/*
* GetXorBitmapInfo - Returns a pointer to a bitmap info structure ... memory
* should be freed with FreeDIBitmapInfo. this is for
* the xor part.
*/
BITMAPINFO2 *GetXorBitmapInfo( img_node *node )
{
long size;
WPI_BITMAPINFO *bmi;
WPI_BITMAPINFOHEADER bmih;
WPI_PRES pres;
WPI_PRES mempres;
HDC memdc;
HBITMAP oldbitmap;
pres = _wpi_getpres( HWND_DESKTOP );
mempres = _wpi_createcompatiblepres( pres, Instance, &memdc );
_wpi_releasepres( HWND_DESKTOP, pres );
size = BMPINFO2_SIZE( node->bitcount );
bmi = MemAlloc( size );
GetBitmapInfoHeader( &bmih, node );
memcpy( bmi, &bmih, sizeof(WPI_BITMAPINFOHEADER) );
oldbitmap = _wpi_selectobject( mempres, node->hxorbitmap );
GpiQueryBitmapBits( mempres, 0, node->height, NULL, bmi );
_wpi_selectobject( mempres, oldbitmap );
_wpi_deletecompatiblepres( mempres, memdc );
return( bmi );
} /* GetXorBitmapInfo */
/*
* DisplayColorBox - display the colors on the given device context
* - PM Note: we assume the presentation space is already in RGB mode
*/
void DisplayColorBox( WPI_PRES pres, palette_box *box )
{
int top;
int bottom;
HBRUSH hcolorbrush;
HBRUSH holdbrush;
HPEN holdpen;
HPEN blackpen;
int height;
blackpen = _wpi_createpen( PS_SOLID, 0, BLACK );
holdpen = _wpi_selectobject( pres, blackpen );
hcolorbrush = _wpi_createsolidbrush( box->color );
holdbrush = _wpi_selectobject( pres, hcolorbrush );
height = 2 * SQR_SIZE + 1;
top = _wpi_cvth_y( box->box.top, height );
bottom = _wpi_cvth_y( box->box.bottom, height );
_wpi_rectangle( pres, box->box.left, top, box->box.right, bottom );
_wpi_selectobject( pres, holdbrush );
_wpi_deleteobject( hcolorbrush );
_wpi_selectobject( pres, holdpen );
_wpi_deleteobject( blackpen );
} /* DisplayColorBox */
/*
* GetAndBitmapInfo - Returns a pointer to a bitmap info structure ... memory
* should be freed with FreeDIBitmapInfo. this is for
* the and part.
*/
BITMAPINFO2 *GetAndBitmapInfo( img_node *node )
{
long size;
WPI_BITMAPINFO *bmi;
WPI_BITMAPINFOHEADER bmih;
WPI_PRES pres;
WPI_PRES mempres;
HDC memdc;
HBITMAP oldbitmap;
pres = _wpi_getpres( HWND_DESKTOP );
mempres = _wpi_createcompatiblepres( pres, Instance, &memdc );
_wpi_releasepres( HWND_DESKTOP, pres );
size = BMPINFO2_SIZE( 1 );
bmi = MemAlloc( size );
GetBitmapInfoHeader( &bmih, node );
// Adjustments for the and mask
bmih.cBitCount = 1;
bmih.cbImage = BITS_TO_BYTES( node->bitcount, node->height );
bmih.cclrUsed = 2;
memcpy( bmi, &bmih, sizeof(WPI_BITMAPINFOHEADER) );
oldbitmap = _wpi_selectobject( mempres, node->handbitmap );
GpiQueryBitmapBits( mempres, 0, node->height, NULL, bmi );
_wpi_selectobject( mempres, oldbitmap );
_wpi_deletecompatiblepres( mempres, memdc );
bmi->cbImage = BITS_TO_BYTES( node->bitcount, 2*node->height );
bmi->cy = node->height * 2;
return( bmi );
} /* GetAndBitmapInfo */
/*
* outlineRect - draw the outline of a rectangle
*/
static void outlineRect( statwnd *sw, WPI_PRES pres, WPI_RECT *r )
{
WPI_POINT pt;
WPI_RECTDIM left;
WPI_RECTDIM right;
WPI_RECTDIM top;
WPI_RECTDIM bottom;
HPEN oldpen;
sw = sw;
_wpi_getrectvalues( *r, &left, &top, &right, &bottom );
_wpi_setpoint( &pt, left, bottom - 1 );
_wpi_cvth_pt( &pt, sw->wndHeight );
_wpi_movetoex( pres, &pt, NULL );
oldpen = _wpi_selectobject( pres, penLight );
pt.x = right - 1;
_wpi_lineto( pres, &pt );
pt.y = _wpi_cvth_y( top, sw->wndHeight );
_wpi_lineto( pres, &pt );
_wpi_selectobject( pres, penShade );
pt.x = left;
_wpi_lineto( pres, &pt );
pt.y = _wpi_cvth_y( bottom - 1, sw->wndHeight );
_wpi_lineto( pres, &pt );
_wpi_selectobject( pres, oldpen );
} /* outlineRect */
/*
* MakeBitmap - Makes the bitmap
*/
void MakeBitmap( img_node *node, BOOL isnew )
{
HDC hdc;
WPI_PRES pres;
WPI_PRES mempres;
HBITMAP oldbitmap;
if (isnew) {
InitXorAndBitmaps( node );
} else {
/*
* The AND bitmap won't really get used, but it should be around
* since some functions are generic (ie for all image types) and
* hence assume an AND bitmap exists.
*/
pres = _wpi_getpres( HWND_DESKTOP );
mempres = _wpi_createcompatiblepres( pres, Instance, &hdc );
node->handbitmap = _wpi_createbitmap(node->width, node->height, 1, 1, NULL );
_wpi_releasepres( HWND_DESKTOP, pres );
_wpi_torgbmode( mempres );
oldbitmap = _wpi_selectobject( mempres, node->handbitmap );
_wpi_patblt( mempres, 0, 0, node->width, node->height, BLACKNESS );
_wpi_selectobject( mempres, oldbitmap );
_wpi_deletecompatiblepres( mempres, hdc );
}
DisplayImageText( node );
} /* MakeBitmap */
/*
* paintPalette - repaint the color palette
*/
static void paintPalette( HWND hwnd )
{
WPI_PRES hdc;
WPI_POINT pt;
HPEN holdpen;
HPEN hgraypen;
HPEN hwhitepen;
PAINTSTRUCT rect;
WPI_RECT client;
int height;
hdc = _wpi_beginpaint( hwnd, NULL, &rect );
#ifdef __OS2_PM__
WinFillRect( hdc, &rect, CLR_PALEGRAY );
#endif
_wpi_torgbmode( hdc );
GetClientRect( hwnd, &client );
height = _wpi_getheightrect( client );
#if defined( __NT__ )
FillRect( (HDC)hdc, (CONST RECT*)&client, hbrush );
#endif
#if defined( __NT__ )
hgraypen = _wpi_createpen( PS_SOLID, 0, GetSysColor( COLOR_BTNSHADOW ) );
#else
hgraypen = _wpi_createpen( PS_SOLID, 0, DKGRAY );
#endif
holdpen = _wpi_selectobject( hdc, hgraypen );
pt.x = 2;
pt.y = 50;
_wpi_cvth_pt( &pt, height );
_wpi_movetoex( hdc, &pt, NULL );
pt.y = 6;
_wpi_cvth_pt( &pt, height );
_wpi_lineto( hdc, &pt );
pt.x = 90;
_wpi_lineto( hdc, &pt );
_wpi_selectobject( hdc, holdpen );
_wpi_deleteobject( hgraypen );
#if defined( __NT__ )
hwhitepen = _wpi_createpen( PS_SOLID, 0, GetSysColor( COLOR_BTNHIGHLIGHT ) );
#else
hwhitepen = _wpi_createpen( PS_SOLID, 0, WHITE );
#endif
holdpen = _wpi_selectobject( hdc, hwhitepen );
pt.y = 50;
_wpi_cvth_pt( &pt, height );
_wpi_lineto( hdc, &pt );
pt.x = 2;
_wpi_lineto( hdc, &pt );
_wpi_selectobject( hdc, holdpen );
_wpi_deleteobject( hwhitepen );
_wpi_endpaint( hwnd, hdc, &rect );
} /* paintPalette */
/*
* ShowNewColor - replace the color of the color box and redisplay the boxes
*/
void ShowNewColor( int index, COLORREF newcolor, BOOL repaint )
{
WPI_POINT topleft;
WPI_POINT bottomright;
WPI_PRES pres;
WPI_PRES mempres;
HDC hdc;
HBITMAP oldbitmap;
HBRUSH brush;
HBRUSH oldbrush;
HPEN blackpen;
HPEN oldpen;
pres = _wpi_getpres( HWND_DESKTOP );
_wpi_torgbmode( pres );
paletteBox[index].color = newcolor;
paletteBox[index].solid_color = _wpi_getnearestcolor( pres, newcolor );
_wpi_releasepres( HWND_DESKTOP, pres );
if( numberOfColors != 2 ) {
topleft.x = (index / 2) * SQR_SIZE;
bottomright.x = topleft.x + SQR_SIZE + 1;
if( index / 2 == (index + 1) / 2 ) {
topleft.y = 0;
bottomright.y = SQR_SIZE + 1;
} else {
topleft.y = SQR_SIZE;
bottomright.y = 2 * SQR_SIZE + 1;
}
pres = _wpi_getpres( HWND_DESKTOP );
mempres = _wpi_createcompatiblepres( pres, Instance, &hdc );
_wpi_releasepres( HWND_DESKTOP, pres );
_wpi_torgbmode( mempres );
brush = _wpi_createsolidbrush( newcolor );
oldbrush = _wpi_selectobject( mempres, brush );
blackpen = _wpi_createpen( PS_SOLID, 0, BLACK );
oldpen = _wpi_selectobject( mempres, blackpen );
oldbitmap = _wpi_selectbitmap( mempres, hColorBitmap );
_wpi_cvth_pt( &topleft, colorsHeight );
_wpi_cvth_pt( &bottomright, colorsHeight );
_wpi_rectangle( mempres, topleft.x, topleft.y, bottomright.x, bottomright.y );
_wpi_selectobject( mempres, oldpen );
_wpi_selectobject( mempres, oldbrush );
_wpi_deleteobject( blackpen );
_wpi_deleteobject( brush );
_wpi_getoldbitmap( mempres, oldbitmap );
_wpi_deletecompatiblepres( mempres, hdc );
}
if( repaint ) {
_wpi_invalidaterect( hColorsWnd, NULL, FALSE );
}
} /* ShowNewColor */
/*
* ClearImage - clear the XOR and the AND bitmaps
*/
void ClearImage( void )
{
WPI_PRES pres;
WPI_PRES xorpres;
WPI_PRES andpres;
HDC xormemdc;
HDC andmemdc;
HBITMAP oldxor;
HBITMAP oldand;
img_node *node;
WPI_RECT clear_area;
IMGED_DIM left;
IMGED_DIM top;
IMGED_DIM right;
IMGED_DIM bottom;
int width;
int height;
node = GetCurrentNode();
if( node == NULL ) {
return;
}
if( DoesRectExist( &clear_area ) ) {
SetRectExists( FALSE );
} else {
_wpi_setwrectvalues( &clear_area, 0, 0, node->width, node->height );
}
pres = _wpi_getpres( HWND_DESKTOP );
xorpres = _wpi_createcompatiblepres( pres, Instance, &xormemdc );
andpres = _wpi_createcompatiblepres( pres, Instance, &andmemdc );
_wpi_releasepres( HWND_DESKTOP, pres );
oldxor = _wpi_selectobject( xorpres, node->hxorbitmap );
oldand = _wpi_selectobject( andpres, node->handbitmap );
_wpi_getwrectvalues( clear_area, &left, &top, &right, &bottom );
width = _wpi_getwidthrect( clear_area );
height = _wpi_getheightrect( clear_area );
_wpi_patblt( xorpres, left, top, width, height, WHITENESS );
_wpi_patblt( andpres, left, top, width, height, BLACKNESS );
_wpi_selectobject( xorpres, oldxor );
_wpi_selectobject( andpres, oldand );
_wpi_deletecompatiblepres( xorpres, xormemdc );
_wpi_deletecompatiblepres( andpres, andmemdc );
InvalidateRect( node->viewhwnd, NULL, TRUE );
RecordImage( node->hwnd );
BlowupImage( node->hwnd, NULL );
PrintHintTextByID( WIE_AREACLEARED, NULL );
} /* ClearImage */
/*
* BlowupImage - stretch the view window into the window given by hwnd
*/
void BlowupImage( HWND hmdiwnd, WPI_PRES pres )
{
HDC memdc;
WPI_PRES mempres;
WPI_RECT client;
HBITMAP oldbitmap;
HBITMAP newbitmap;
HWND hwnd;
img_node *node;
BOOL new_pres;
if( hmdiwnd != NULL ) {
hwnd = hmdiwnd;
} else {
node = GetCurrentNode();
if( node == NULL ) {
return;
}
hwnd = node->hwnd;
}
newbitmap = EnlargeImage( hwnd );
if( newbitmap == NULL ) {
return;
}
new_pres = FALSE;
if( pres == (WPI_PRES)NULL ) {
pres = _wpi_getpres( hwnd );
new_pres = TRUE;
}
mempres = _wpi_createcompatiblepres( pres, Instance, &memdc );
oldbitmap = _wpi_selectobject( mempres, newbitmap );
if( ImgedConfigInfo.grid_on ) {
showGrid( hwnd, mempres );
} else {
GetClientRect( hwnd, &client );
_wpi_bitblt( pres, 0, 0, _wpi_getwidthrect( client ),
_wpi_getheightrect( client ), mempres, 0, 0, SRCCOPY );
RedrawPrevClip( hwnd ); // Redraw if there was a clip region specified.
}
_wpi_selectobject( mempres, oldbitmap );
_wpi_deletebitmap( newbitmap );
_wpi_deletecompatiblepres( mempres, memdc );
if( new_pres ) {
_wpi_releasepres( hwnd, pres );
}
} /* BlowupImage */
/*
* SetCurrentNumColors - set the number of colors for this module
*/
void SetCurrentNumColors( int color_count )
{
WPI_PRES pres;
WPI_PRES mempres;
HDC memdc;
HBITMAP oldbitmap;
numberOfColors = color_count;
pres = _wpi_getpres( HWND_DESKTOP );
_wpi_torgbmode( pres );
if( lButton.bitmap != NULL ) {
_wpi_deletebitmap( lButton.bitmap );
}
if( rButton.bitmap != NULL ) {
_wpi_deletebitmap( rButton.bitmap );
}
if( color_count == 2 ) {
lButton.bitmap = _wpi_createbitmap( CUR_SQR_SIZE + 1, 2 * CUR_SQR_SIZE + 1,
1, 1, NULL );
rButton.bitmap = _wpi_createbitmap( CUR_SQR_SIZE + 1, 2 * CUR_SQR_SIZE + 1,
1, 1, NULL );
//} else if( color_count == 16 ) {
} else {
lButton.bitmap = _wpi_createcompatiblebitmap( pres, CUR_SQR_SIZE + 1,
2 * CUR_SQR_SIZE + 1 );
rButton.bitmap = _wpi_createcompatiblebitmap( pres, CUR_SQR_SIZE + 1,
2 * CUR_SQR_SIZE + 1 );
if( firstTime ) {
mempres = _wpi_createcompatiblepres( pres, Instance, &memdc );
_wpi_torgbmode( mempres );
oldbitmap = _wpi_selectobject( mempres, lButton.bitmap );
_wpi_patblt( mempres, 0, 0, CUR_SQR_SIZE + 1, 2 * CUR_SQR_SIZE + 1, BLACKNESS );
_wpi_selectobject( mempres, oldbitmap );
oldbitmap = _wpi_selectobject( mempres, rButton.bitmap );
_wpi_patblt( mempres, 0, 0, CUR_SQR_SIZE + 1, 2 * CUR_SQR_SIZE + 1, WHITENESS );
_wpi_selectobject( mempres, oldbitmap );
_wpi_deletecompatiblepres( mempres, memdc );
firstTime = false;
}
}
_wpi_releasepres( HWND_DESKTOP, pres );
} /* SetCurrentNumColors */
/*
* RedrawPrevClip - redraw the area if a region has been selected and copied to the
* clipboard OR if a region has been selected and then another is
* selected (without a cut or copy in between)
* - the hwnd parameter indicates which window to draw the clip rect on
* - if the hwnd does not match the one associated with clipRect, we return
*/
void RedrawPrevClip( HWND hwnd )
{
WPI_POINT pointsize;
int prevROP2;
HBRUSH blackbrush;
HBRUSH oldbrush;
HPEN whitepen;
HPEN oldpen;
WPI_PRES pres;
WPI_RECTDIM left;
WPI_RECTDIM top;
WPI_RECTDIM right;
WPI_RECTDIM bottom;
img_node *node;
if( !fEnableCutCopy || !_wpi_iswindow( Instance, hwnd ) || clipRect.hwnd != hwnd ) {
return;
}
pointsize = GetPointSize( hwnd );
pres = _wpi_getpres( hwnd );
_wpi_torgbmode( pres );
prevROP2 = _wpi_setrop2( pres, R2_XORPEN );
blackbrush = _wpi_createsolidbrush( BLACK );
oldbrush = _wpi_selectobject( pres, blackbrush );
whitepen = _wpi_createpen( PS_SOLID, 0, WHITE );
oldpen = _wpi_selectobject( pres, whitepen );
_wpi_getrectvalues( clipRect.rect, &left, &top, &right, &bottom );
node = SelectImage( hwnd );
#ifdef __OS2_PM__
_wpi_rectangle( pres, left * pointsize.x + 1, bottom * pointsize.y + 1,
right * pointsize.x, top * pointsize.y );
#else
_wpi_rectangle( pres, left * pointsize.x, top * pointsize.y,
right * pointsize.x, bottom * pointsize.y );
#endif
_wpi_selectobject( pres, oldpen );
_wpi_selectobject( pres, oldbrush );
_wpi_setrop2( pres, prevROP2 );
_wpi_releasepres( hwnd, pres );
_wpi_deleteobject( whitepen );
_wpi_deleteobject( blackbrush );
} /* RedrawPrevClip */
/*
* StatusWndDraw3DBox - called by StatusWndDrawLine or externally
* if StatusWndDrawLine is not used.
*/
void StatusWndDraw3DBox( statwnd *sw, WPI_PRES pres )
{
HPEN old_pen;
int i;
WPI_RECT r;
old_pen = _wpi_selectobject( pres, penLight );
for( i = 0; i <= sw->numSections; i++ ) {
getRect( sw, &r, i );
outlineRect( sw, pres, &r );
makeInsideRect( &r );
_wpi_fillrect( pres, &r, colorButtonFace, brushButtonFace );
}
_wpi_selectobject( pres, old_pen );
} /* StatusWndDraw3DBox */
/*
* paintCurrent - paint the current window (process WM_PAINT)
*/
static void paintCurrent( HWND hwnd )
{
WPI_PRES pres;
WPI_PRES mempres;
HDC hdc;
PAINTSTRUCT ps;
WPI_RECT rect;
HBITMAP oldbitmap;
int top;
int bottom;
pres = _wpi_beginpaint( hwnd, NULL, &ps );
#ifdef __OS2_PM__
WinFillRect( pres, &ps, CLR_PALEGRAY );
#endif
mempres = _wpi_createcompatiblepres( pres, Instance, &hdc );
_wpi_torgbmode( pres );
_wpi_torgbmode( mempres );
oldbitmap = _wpi_selectobject( mempres, lButton.bitmap );
_wpi_bitblt( pres, 0, 0, CUR_SQR_SIZE + 1, 2 * CUR_SQR_SIZE + 1, mempres,
0, 0, SRCCOPY );
_wpi_selectobject( mempres, oldbitmap );
oldbitmap = _wpi_selectobject( mempres, rButton.bitmap );
_wpi_bitblt( pres, CUR_RCOL_X - 1, 0, CUR_SQR_SIZE + 1, 2 * CUR_SQR_SIZE + 1,
mempres, 0, 0, SRCCOPY );
_wpi_selectobject( mempres, oldbitmap );
_wpi_deletecompatiblepres( mempres, hdc );
_wpi_setbackmode( pres, TRANSPARENT );
_wpi_settextcolor( pres, GetInverseColor( lButton.solid ) );
top = _wpi_cvth_y( CUR_COL_Y, currentHeight );
bottom = _wpi_cvth_y( CUR_COL_Y + CUR_SQR_SIZE, currentHeight );
_wpi_setintwrectvalues( &rect, CUR_LCOL_X, top, CUR_LCOL_X + CUR_SQR_SIZE, bottom );
_wpi_drawtext( pres, "L", 1, &rect, DT_CENTER | DT_SINGLELINE | DT_VCENTER );
_wpi_settextcolor( pres, GetInverseColor( rButton.solid ) );
_wpi_setintwrectvalues( &rect, CUR_RCOL_X, top, CUR_RCOL_X + CUR_SQR_SIZE, bottom );
_wpi_drawtext( pres, "R", 1, &rect, DT_CENTER | DT_SINGLELINE | DT_VCENTER );
_wpi_endpaint( hwnd, pres, &ps );
} /* paintCurrent */
/*
* writeDataInPieces - writes the xor data for the bitmap in chunks
*/
static bool writeDataInPieces( BITMAPINFO2 *bmi, FILE *fp, img_node *node )
{
WPI_PRES pres;
WPI_PRES mempres;
HDC memdc;
int scanline_count;
int one_scanline_size;
long chunk_size;
int start;
int num_lines;
long byte_count;
BYTE *buffer;
HBITMAP oldbitmap;
pres = _wpi_getpres( HWND_DESKTOP );
mempres = _wpi_createcompatiblepres( pres, Instance, &memdc );
_wpi_releasepres( HWND_DESKTOP, pres );
oldbitmap = _wpi_selectobject( mempres, node->hxorbitmap );
byte_count = BITS_TO_BYTES( node->bitcount * node->width, node->height );
start = 0;
num_lines = SCANLINE_SIZE;
one_scanline_size = BITS_TO_BYTES( node->width*node->bitcount, 1 );
scanline_count = node->height;
chunk_size = one_scanline_size * num_lines;
while( chunk_size > MAX_CHUNK ) {
chunk_size >>= 1;
num_lines = chunk_size / one_scanline_size;
}
buffer = calloc( chunk_size, sizeof( BYTE ) );
while( scanline_count > num_lines ) {
GpiQueryBitmapBits( mempres, start, num_lines, buffer, bmi );
fwrite( buffer, sizeof( BYTE ), chunk_size, fp );
scanline_count -= num_lines;
start += num_lines;
byte_count -= chunk_size;
}
GpiQueryBitmapBits( mempres, start, scanline_count, buffer, bmi );
fwrite( buffer, sizeof( BYTE ), one_scanline_size * scanline_count, fp );
free( buffer );
_wpi_selectobject( mempres, oldbitmap );
_wpi_deletecompatiblepres( mempres, memdc );
return( true );
} /* writeDataInPieces */
/*
* OutlineLine - outline the line before it is drawn
*/
void OutlineLine( HWND hwnd, WPI_POINT *start_pt, WPI_POINT *end_pt,
WPI_POINT *prev_pt, BOOL firsttime )
{
WPI_POINT startpt;
WPI_POINT endpt;
WPI_POINT prevpt;
int prevROP2;
HPEN holdpen;
HPEN hwhitepen;
WPI_PRES pres;
CheckBounds( hwnd, start_pt );
CheckBounds( hwnd, end_pt );
startpt.x = MAKELOGPTX( start_pt->x ) + pointSize.x / 2;
startpt.y = MAKELOGPTY( start_pt->y ) + pointSize.y / 2;
endpt.x = MAKELOGPTX( end_pt->x ) + pointSize.x / 2;
endpt.y = MAKELOGPTY( end_pt->y ) + pointSize.y / 2;
pres = _wpi_getpres( hwnd );
_wpi_torgbmode( pres );
hwhitepen = _wpi_createpen( PS_SOLID, 0, WHITE );
holdpen = _wpi_selectobject( pres, hwhitepen );
prevROP2 = _wpi_setrop2( pres, R2_XORPEN );
if( !firsttime ) {
CheckBounds( hwnd, prev_pt );
prevpt.x = MAKELOGPTX( prev_pt->x ) + pointSize.x / 2;
prevpt.y = MAKELOGPTY( prev_pt->y ) + pointSize.y / 2;
_wpi_movetoex( pres, &startpt, NULL );
_wpi_lineto( pres, &prevpt );
}
_wpi_movetoex( pres, &startpt, NULL );
_wpi_lineto( pres, &endpt );
_wpi_setrop2( pres, prevROP2 );
_wpi_selectobject( pres, holdpen );
_wpi_deleteobject( hwhitepen );
_wpi_releasepres( hwnd, pres );
} /* OutlineLine */
/*
* DragClipBitmap - routine to show the clipped bitmap
*/
void DragClipBitmap( HWND hwnd, WPI_POINT *newpt, WPI_POINT pointsize )
{
int prevROP2;
HBRUSH hbrush;
HBRUSH holdbrush;
HPEN hwhitepen;
HPEN holdpen;
WPI_PRES pres;
pres = _wpi_getpres( hwnd );
if( pres == (HDC)NULL ) {
return;
}
prevROP2 = _wpi_setrop2( pres, R2_XORPEN );
hbrush = _wpi_createsolidbrush( CLR_BLACK );
holdbrush = _wpi_selectobject( pres, hbrush );
hwhitepen = _wpi_createpen( PS_SOLID, 0, CLR_WHITE );
holdpen = _wpi_selectobject( pres, hwhitepen );
if( !firstTime ) {
_wpi_rectangle( pres, prevPoint.x * pointsize.x, prevPoint.y * pointsize.y,
prevPoint.x * pointsize.x + dragWidth,
prevPoint.y * pointsize.y + dragHeight );
}
_wpi_rectangle( pres, newpt->x * pointsize.x, newpt->y * pointsize.y,
newpt->x * pointsize.x + dragWidth,
newpt->y * pointsize.y + dragHeight );
_wpi_selectobject( pres, holdpen );
_wpi_selectobject( pres, holdbrush );
_wpi_deleteobject( hwhitepen );
_wpi_deleteobject( hbrush );
_wpi_setrop2( pres, prevROP2 );
_wpi_releasepres( hwnd, pres );
memcpy( &prevPoint, newpt, sizeof( WPI_POINT ) );
firstTime = false;
} /* DragClipBitmap */
/*
* LineXorAnd - draw the line on the XOR and the AND bitmaps
*/
void LineXorAnd( COLORREF xorcolor, COLORREF andcolor,
WPI_POINT *startpt, WPI_POINT *endpt )
{
HPEN oldpen;
HPEN hpen;
HDC memdc;
WPI_PRES pres;
WPI_PRES mempres;
HBITMAP oldbitmap;
HDC anddc;
anddc = anddc;
pres = _wpi_getpres( HWND_DESKTOP );
mempres = _wpi_createcompatiblepres( pres, Instance, &memdc );
_wpi_releasepres( HWND_DESKTOP, pres );
_wpi_torgbmode( mempres );
hpen = _wpi_createpen( PS_SOLID, 0, xorcolor );
oldpen = _wpi_selectobject( mempres, hpen );
oldbitmap = _wpi_selectobject( mempres, activeImage->hxorbitmap );
_wpi_movetoex( mempres, startpt, NULL );
_wpi_lineto( mempres, endpt );
_wpi_setpixel( mempres, endpt->x, endpt->y, xorcolor );
_wpi_selectobject( mempres, oldpen );
_wpi_deleteobject( hpen );
_wpi_selectobject( mempres, oldbitmap );
if( activeImage->imgtype == BITMAP_IMG ) {
_wpi_deletecompatiblepres( mempres, memdc );
return;
}
hpen = _wpi_createpen( PS_SOLID, 0, andcolor );
oldpen = _wpi_selectobject( mempres, hpen );
oldbitmap = _wpi_selectobject( mempres, activeImage->handbitmap );
_wpi_movetoex( mempres, startpt, NULL );
_wpi_lineto( mempres, endpt );
_wpi_setpixel( mempres, endpt->x, endpt->y, andcolor );
_wpi_selectobject( mempres, oldpen );
_wpi_deleteobject( hpen );
_wpi_selectobject( mempres, oldbitmap );
_wpi_deletecompatiblepres( mempres, anddc );
} /* LineXorAnd */
/*
* OutlineRectangle - outline a rectangle with the XOR pen
*/
void OutlineRectangle( bool firsttime, WPI_PRES pres, WPI_RECT *prevrc, WPI_RECT *newrc )
{
int prevrop2;
HBRUSH holdbrush;
HBRUSH nullbrush;
HPEN holdpen;
HPEN whitepen;
int left, top, right, bottom;
_wpi_torgbmode( pres );
nullbrush = _wpi_createnullbrush();
whitepen = _wpi_createpen( PS_SOLID, 0, WHITE );
holdbrush = _wpi_selectobject( pres, nullbrush );
holdpen = _wpi_selectobject( pres, whitepen );
prevrop2 = _wpi_setrop2( pres, R2_XORPEN );
if( !firsttime ) {
_wpi_getintrectvalues( *prevrc, &left, &top, &right, &bottom );
/*
* In this case don't call _wpi_convertheight because of the
* way the rectangle values are set in iedraw.c
*/
_wpi_rectangle( pres, left, top, right, bottom );
}
_wpi_getintrectvalues( *newrc, &left, &top, &right, &bottom );
_wpi_rectangle( pres, left, top, right, bottom );
_wpi_selectobject( pres, holdbrush );
_wpi_selectobject( pres, holdpen );
_wpi_setrop2( pres, prevrop2 );
_wpi_deleteobject( whitepen );
_wpi_deletenullbrush( nullbrush );
} /* OutlineRectangle */
/*
* DuplicateBitmap - produces a duplicate of the bitmap
*/
HBITMAP DuplicateBitmap( HBITMAP hbitmap )
{
HDC srcdc;
WPI_PRES srcpres;
HDC destdc;
WPI_PRES destpres;
WPI_PRES pres;
int width;
int height;
int planes;
int bitspixel;
HBITMAP newbitmap;
HBITMAP oldbitmap;
HBITMAP oldnewbitmap;
_wpi_getbitmapparms( hbitmap, &width, &height, &planes, NULL, &bitspixel );
pres = _wpi_getpres( HWND_DESKTOP );
srcpres = _wpi_createcompatiblepres( pres, Instance, &srcdc );
destpres = _wpi_createcompatiblepres( pres, Instance, &destdc );
_wpi_releasepres( HWND_DESKTOP, pres );
newbitmap = _wpi_createbitmap( width, height, planes, bitspixel, NULL );
oldbitmap = _wpi_selectobject( srcpres, hbitmap );
oldnewbitmap = _wpi_selectobject( destpres, newbitmap );
_wpi_bitblt( destpres, 0, 0, width, height, srcpres, 0, 0, SRCCOPY );
_wpi_selectobject( srcpres, oldbitmap );
_wpi_selectobject( destpres, oldnewbitmap );
_wpi_deletecompatiblepres( srcpres, srcdc );
_wpi_deletecompatiblepres( destpres, destdc );
return( newbitmap );
} /* DuplicateBitmap */
/*
* showGrid - Display the grid on the draw area.
*/
static void showGrid( HWND hwnd, WPI_PRES mempres )
{
short i;
short psx;
short psy;
WPI_RECT rcclient;
HPEN hblackpen;
HPEN holdpen;
img_node *node;
short width;
short height;
IMGED_DIM left;
IMGED_DIM right;
IMGED_DIM top;
IMGED_DIM bottom;
WPI_PRES pres;
WPI_POINT startpt;
WPI_POINT endpt;
node = SelectImage( hwnd );
_wpi_torgbmode( mempres );
GetClientRect( hwnd, &rcclient );
width = (short)( _wpi_getwidthrect(rcclient) );
height = (short)( _wpi_getheightrect(rcclient) );
if (((width / node->width) < POINTSIZE_MIN) ||
((height / node->height) < POINTSIZE_MIN)) {
psx = 0;
psy = 0;
} else {
psx = width / node->width;
psy = height / node->height;
hblackpen = _wpi_createpen( PS_SOLID, 0, BLACK );
holdpen = _wpi_selectobject( mempres, hblackpen );
_wpi_getrectvalues( rcclient, &left, &top, &right, &bottom );
for (i=0; i < width; i = i + psx) {
_wpi_setpoint( &startpt, i, top );
_wpi_setpoint( &endpt, i, bottom );
_wpi_movetoex( mempres, &startpt, NULL );
_wpi_lineto( mempres, &endpt );
}
for (i=0; i <= height; i = i + psy) {
_wpi_setpoint( &startpt, left, i );
_wpi_setpoint( &endpt, right, i );
_wpi_movetoex( mempres, &startpt, NULL );
_wpi_lineto( mempres, &endpt );
}
_wpi_selectobject( mempres, holdpen );
_wpi_deleteobject( hblackpen );
}
pres = _wpi_getpres( hwnd );
_wpi_bitblt( pres, 0, 0, width, height, mempres, 0, 0, SRCCOPY );
_wpi_releasepres( hwnd, pres );
RedrawPrevClip(hwnd); // Redraws if there was a clip region specified.
} /* showGrid */
/*
* CreateViewBitmap - create the bitmap on the screen (with the background
* color as it should be, etc.)
* - the caller is responsible for deleting the bitmap
*/
HBITMAP CreateViewBitmap( img_node *mdi_node )
{
WPI_PRES pres;
WPI_PRES xorandpres;
WPI_PRES mempres;
WPI_PRES freehandpres;
HDC xoranddc;
HDC memdc;
HBITMAP newbitmap;
HBITMAP oldxorandbitmap;
HBITMAP oldbitmap;
HBRUSH brush;
HBRUSH oldbrush;
img_node *node;
COLORREF bkcolor;
if( mdi_node != NULL ) {
node = mdi_node;
} else {
node = GetCurrentNode();
if( node == NULL ) {
return( NULL );
}
}
pres = _wpi_getpres( HWND_DESKTOP );
xorandpres = _wpi_createcompatiblepres( pres, Instance, &xoranddc );
mempres = _wpi_createcompatiblepres( pres, Instance, &memdc );
newbitmap = _wpi_createcompatiblebitmap( pres, node->width, node->height );
_wpi_releasepres( HWND_DESKTOP, pres );
_wpi_torgbmode( mempres );
_wpi_torgbmode( xorandpres );
bkcolor = GetViewBkColor();
#ifdef __OS2_PM__
_wpi_preparemono( mempres, BLACK, bkcolor );
#endif
oldbitmap = _wpi_selectobject( mempres, newbitmap );
brush = _wpi_createsolidbrush( bkcolor );
oldbrush = _wpi_selectobject( mempres, brush );
_wpi_patblt( mempres, 0, 0, node->width, node->height, PATCOPY );
_wpi_selectobject( mempres, oldbrush );
_wpi_deletebrush( brush );
GetFreeHandPresentationSpaces( NULL, &freehandpres, NULL );
if( freehandpres == (WPI_PRES)NULL ) {
oldxorandbitmap = _wpi_selectobject( xorandpres, node->handbitmap );
_wpi_bitblt( mempres, 0, 0, node->width, node->height,
xorandpres, 0, 0, SRCAND );
_wpi_selectobject( xorandpres, oldxorandbitmap );
} else {
_wpi_bitblt( mempres, 0, 0, node->width, node->height,
freehandpres, 0, 0, SRCAND );
}
GetFreeHandPresentationSpaces( NULL, NULL, &freehandpres );
if( freehandpres == (WPI_PRES)NULL ) {
oldxorandbitmap = _wpi_selectobject( xorandpres, node->hxorbitmap );
_wpi_bitblt( mempres, 0, 0, node->width, node->height,
xorandpres, 0, 0, SRCINVERT );
_wpi_selectobject( xorandpres, oldxorandbitmap );
} else {
_wpi_bitblt( mempres, 0, 0, node->width, node->height,
freehandpres, 0, 0, SRCINVERT );
}
_wpi_deletecompatiblepres( xorandpres, xoranddc );
_wpi_selectobject( mempres, oldbitmap );
_wpi_deletecompatiblepres( mempres, memdc );
return( newbitmap );
} /* CreateViewBitmap */
/*
* EnlargeImage - take an MDI window handle and enlarge the view bitmap
* that goes with it
* - returns a handle to the bitmap
* - the bitmap must be deleted by the calling routine
*/
HBITMAP EnlargeImage( HWND hwnd )
{
WPI_PRES pres;
WPI_PRES srcpres;
WPI_PRES destpres;
HDC srcdc;
HDC destdc;
HBITMAP oldbitmap;
HBITMAP newbitmap;
HBITMAP olddestbitmap;
HBITMAP viewbitmap;
img_node *node;
WPI_RECT rc;
short width;
short height;
int window_width;
int window_height;
BITMAP bm;
node = SelectImage( hwnd );
if( node == NULL ) {
return( NULL );
}
viewbitmap = CreateViewBitmap( node );
_wpi_getclientrect( hwnd, &rc );
/*
* I add this so that if the window's client rect doesn't fit on the
* screen, it will still enlarge to the right size.
*/
window_width = _wpi_getwidthrect( rc );
window_height = _wpi_getheightrect( rc );
if( window_width < node->width ) {
window_width = node->width;
}
if( window_height < node->height ) {
window_height = node->height;
}
pres = _wpi_getpres( HWND_DESKTOP );
srcpres = _wpi_createcompatiblepres( pres, Instance, &srcdc );
destpres = _wpi_createcompatiblepres( pres, Instance, &destdc );
newbitmap = _wpi_createcompatiblebitmap( pres, _wpi_getwidthrect( rc ),
_wpi_getheightrect( rc ) );
_wpi_releasepres( HWND_DESKTOP, pres );
GetObject( newbitmap, sizeof( BITMAP ), &bm );
_wpi_torgbmode( destpres );
_wpi_torgbmode( srcpres );
olddestbitmap = _wpi_selectobject( destpres, newbitmap );
oldbitmap = _wpi_selectobject( srcpres, viewbitmap );
height = node->height;
width = node->width;
IEStretchBlt( destpres, 0, 0, _wpi_getwidthrect( rc ),
_wpi_getheightrect( rc ), srcpres, 0, 0, width, height,
SRCCOPY, bm.bmBitsPixel );
_wpi_selectobject( srcpres, oldbitmap );
_wpi_deletecompatiblepres( srcpres, srcdc );
_wpi_deleteobject( viewbitmap );
_wpi_selectobject( destpres, olddestbitmap );
_wpi_deletecompatiblepres( destpres, destdc );
return( newbitmap );
} /* EnlargeImage */
/*
* IEStretchBlt
*/
static BOOL IEStretchBlt( WPI_PRES hdcDest, int nXOriginDest, int nYOriginDest,
int nWidthDest, int nHeightDest,
WPI_PRES hdcSrc, int nXOriginSrc, int nYOriginSrc,
int nWidthSrc, int nHeightSrc,
DWORD fdwRop, int bitcount )
{
POINT slines;
POINT dlines;
POINT num_strips;
unsigned long linesize;
int x, y;
int sw, sh, dw, dh;
WPI_PRES srcpres;
HDC srcdc;
HBITMAP oldbitmap;
HBITMAP newbitmap;
num_strips.x = nWidthDest / 256;
num_strips.x++;
#if 0
if( nWidthDest > 32 ) {
/* use the version that returns exact bytes needed for bits */
linesize = BITS_INTO_BYTES( (unsigned long)(nWidthDest * bitcount), 1 );
} else {
/* use the version that rounds up to 32 bits */
linesize = BITS_TO_BYTES( (unsigned long)(nWidthDest * bitcount), 1 );
}
#else
/* use the version that rounds up to 32 bits */
linesize = BITS_TO_BYTES( (unsigned long)(nWidthDest * bitcount), 1 );
#endif
num_strips.y = ((unsigned long)nHeightDest * linesize) / (16 * 1024);
num_strips.y++;
if( num_strips.x > nWidthSrc ) {
num_strips.x = nWidthSrc;
} else if( num_strips.x < nWidthSrc ) {
num_strips.x += num_strips.x % 2;
}
if( num_strips.y > nHeightSrc ) {
num_strips.y = nHeightSrc;
} else if( num_strips.y < nHeightSrc ) {
num_strips.y += num_strips.y % 2;
}
slines.x = nWidthSrc / num_strips.x;
dlines.x = ((unsigned long)slines.x * (unsigned long)nWidthDest) /
(unsigned long)nWidthSrc;
slines.y = nHeightSrc / num_strips.y;
dlines.y = ((unsigned long)slines.y * (unsigned long)nHeightDest) /
(unsigned long)nHeightSrc;
srcpres = _wpi_createcompatiblepres( hdcDest, Instance, &srcdc );
newbitmap = _wpi_createcompatiblebitmap( hdcDest, dlines.x, dlines.y );
oldbitmap = _wpi_selectobject( srcpres, newbitmap );
sw = slines.x;
dw = dlines.x;
for( x = 0; slines.x * x <= nWidthSrc; x++ ) {
if( slines.x * x + sw > nWidthSrc ) {
sw = nWidthSrc - x * slines.x;
dw = nWidthDest - x * dlines.x;
}
sh = slines.y;
dh = dlines.y;
for( y = 0; slines.y * y <= nHeightSrc; y++ ) {
if( slines.y * y + sh > nHeightSrc ) {
sh = nHeightSrc - y * slines.y;
dh = nHeightDest - y * dlines.y;
}
_wpi_stretchblt( srcpres, 0, 0, dw, dh, hdcSrc,
nXOriginSrc + slines.x * x, nYOriginSrc + slines.y * y,
sw, sh, fdwRop );
_wpi_bitblt( hdcDest, nXOriginDest + dlines.x * x,
nYOriginDest + dlines.y * y, dw, dh, srcpres, 0, 0, SRCCOPY );
}
}
_wpi_selectobject( srcpres, oldbitmap );
_wpi_deleteobject( newbitmap );
_wpi_deletecompatiblepres( srcpres, srcdc );
return( TRUE );
} /* IEStretchBlt */
/*
* rotateTheImage - create the rotated bitmaps
*/
static void rotateTheImage( img_node *node, int whichway, WPI_RECT *rect,
HBITMAP rotxorbmp, HBITMAP rotandbmp )
{
WPI_PRES pres;
WPI_PRES rotxorpres;
HDC rotxordc;
WPI_PRES xorpres;
HDC xordc;
WPI_PRES rotandpres;
HDC rotanddc;
HBITMAP oldandrot;
HBITMAP oldxorrot;
HBITMAP oldxor;
short new_height;
short new_width;
long i;
long amt_done;
long prev_amt;
long total_amt;
long temp;
IMGED_DIM left;
IMGED_DIM top;
IMGED_DIM right;
IMGED_DIM bottom;
int x;
int y;
COLORREF color;
bitmap_bits *xorbits;
bitmap_bits *andbits;
bitmap_bits *rotxorbits;
bitmap_bits *rotandbits;
new_height = (short)_wpi_getwidthrect( *rect );
new_width = (short)_wpi_getheightrect( *rect );
oldxor = NULL;
amt_done = prev_amt = 0L;
total_amt = (long)new_height * (long)new_width;
i = 0L;
_wpi_getwrectvalues( *rect, &left, &top, &right, &bottom );
if( node->imgtype == BITMAP_IMG ) {
pres = _wpi_getpres( HWND_DESKTOP );
xorpres = _wpi_createcompatiblepres( pres, Instance, &xordc );
rotxorpres = _wpi_createcompatiblepres( pres, Instance, &rotxordc );
rotandpres = _wpi_createcompatiblepres( pres, Instance, &rotanddc );
_wpi_releasepres( HWND_DESKTOP, pres );
_wpi_torgbmode( rotxorpres );
_wpi_torgbmode( rotandpres );
oldxorrot = _wpi_selectobject( rotxorpres, rotxorbmp );
oldandrot = _wpi_selectobject( rotandpres, rotandbmp );
_wpi_patblt( rotxorpres, 0, 0, new_width, new_height, WHITENESS );
_wpi_patblt( rotandpres, 0, 0, new_width, new_height, BLACKNESS );
_wpi_selectobject( rotxorpres, oldxorrot );
_wpi_selectobject( rotandpres, oldandrot );
_wpi_deletecompatiblepres( rotandpres, rotanddc );
_imged_getthebits( xorbits, xorpres, node->hxorbitmap, oldxor );
_imged_getthebits( rotxorbits, rotxorpres, rotxorbmp, oldxorrot );
if( whichway == ROTATE_COUNTERCLOCKWISE ) {
for( y = 0; y < new_height; y++ ) {
for( x = 0; x < new_width; x++ ) {
color = _imged_getpixel( xorbits, xorpres, right - y - 1, top + x );
_imged_setpixel( rotxorbits, rotxorpres, x, y, color );
i++;
temp = i * 100;
amt_done = temp / total_amt;
if( amt_done - prev_amt >= 2 ) {
IEPrintRotateAmt( amt_done );
prev_amt = amt_done;
}
}
}
} else {
for( y = 0; y < new_height; y++ ) {
for( x = 0; x < new_width; x++ ) {
color = _imged_getpixel( xorbits, xorpres, left + y, bottom - x - 1 );
_imged_setpixel( rotxorbits, rotxorpres, x, y, color );
i++;
temp = i * 100;
amt_done = temp / total_amt;
if( amt_done - prev_amt >= 2 ) {
IEPrintRotateAmt( amt_done );
prev_amt = amt_done;
}
}
}
}
_imged_freethebits( xorbits, xorpres, node->hxorbitmap, FALSE, oldxor );
_imged_freethebits( rotxorbits, rotxorpres, rotxorbmp, TRUE, oldxorrot );
_wpi_deletecompatiblepres( xorpres, xordc );
_wpi_deletecompatiblepres( rotxorpres, rotxordc );
} else {
// We can use the bits.c routines for icons and cursors.
xorbits = GetTheBits( node->hxorbitmap );
andbits = GetTheBits( node->handbitmap );
rotxorbits = GetTheBits( rotxorbmp );
rotandbits = GetTheBits( rotandbmp );
if( whichway != IMGED_ROTATECC ) {
for( y = 0; y < new_height; y++ ) {
for( x = 0; x < new_width; x++ ) {
color = MyGetPixel( xorbits, right - y - 1, top + x );
MySetPixel( rotxorbits, x, y, color );
color = MyGetPixel( andbits, right - y - 1, top + x );
MySetPixel( rotandbits, x, y, color );
i++;
temp = i * 100;
amt_done = temp / total_amt;
if( amt_done - prev_amt >= 2 ) {
IEPrintRotateAmt( amt_done );
prev_amt = amt_done;
}
}
}
} else {
for( y = 0; y < new_height; y++ ) {
for( x = 0; x < new_width; x++ ) {
color = MyGetPixel( xorbits, left + y, bottom - x - 1 );
MySetPixel( rotxorbits, x, y, color );
color = MyGetPixel( andbits, left + y, bottom - x - 1 );
MySetPixel( rotandbits, x, y, color );
i++;
temp = i * 100;
amt_done = temp / total_amt;
if( amt_done - prev_amt >= 2 ) {
IEPrintRotateAmt( amt_done );
prev_amt = amt_done;
}
}
}
}
FreeTheBits( xorbits, node->hxorbitmap, FALSE );
FreeTheBits( andbits, node->handbitmap, FALSE );
FreeTheBits( rotxorbits, rotxorbmp, TRUE );
FreeTheBits( rotandbits, rotandbmp, TRUE );
}
} /* rotateTheImage */
/*
* OutlineRegion - displays the potential region (rectangle or ellipse)
* on the draw area.
*/
void OutlineRegion( HWND hwnd, WPI_POINT *start_pt, WPI_POINT *end_pt,
WPI_POINT *prev_pt, BOOL firsttime )
{
WPI_POINT topleft;
WPI_POINT bottomright;
WPI_POINT prevtl; // previous top left point
WPI_POINT prevbr; // previous bottom right point
int prevROP2;
HBRUSH hbrush;
HBRUSH holdbrush;
HPEN hwhitepen;
HPEN holdpen;
int temp;
WPI_PRES pres;
CheckBounds( hwnd, start_pt );
CheckBounds( hwnd, end_pt );
CheckBounds( hwnd, prev_pt );
_wpi_setpoint(&topleft, MAKELOGPTX(start_pt->x), MAKELOGPTY(start_pt->y));
_wpi_setpoint(&bottomright, MAKELOGPTX(end_pt->x), MAKELOGPTY(end_pt->y));
if (topleft.x > bottomright.x) {
temp = (short)bottomright.x;
bottomright.x = topleft.x + pointSize.x;
topleft.x = temp;
} else {
bottomright.x += pointSize.x;
}
if (topleft.y > bottomright.y) {
temp = (int)bottomright.y;
bottomright.y = topleft.y + pointSize.y;
topleft.y = temp;
} else {
bottomright.y += pointSize.y;
}
prevtl.x = MAKELOGPTX( start_pt->x );
prevtl.y = MAKELOGPTY( start_pt->y );
prevbr.x = MAKELOGPTX( prev_pt->x );
prevbr.y = MAKELOGPTY( prev_pt->y );
if (prevtl.x > prevbr.x) {
temp = (int)prevbr.x;
prevbr.x = prevtl.x + pointSize.x;
prevtl.x = temp;
} else {
prevbr.x += pointSize.x;
}
if (prevtl.y > prevbr.y) {
temp = (int)prevbr.y;
prevbr.y = prevtl.y + pointSize.y;
prevtl.y = temp;
} else {
prevbr.y += pointSize.y;
}
++prevtl.x;
++prevtl.y;
++topleft.x;
++topleft.y;
pres = _wpi_getpres( hwnd );
_wpi_torgbmode( pres );
prevROP2 = _wpi_setrop2( pres, R2_XORPEN );
hbrush = _wpi_createsolidbrush( BLACK );
hwhitepen = _wpi_createpen( PS_SOLID, 0, WHITE );
holdbrush = _wpi_selectobject( pres, hbrush );
holdpen = _wpi_selectobject( pres, hwhitepen );
if (!firsttime) {
if ((toolType == IMGED_CIRCLEO) || (toolType == IMGED_CIRCLEF)) {
_wpi_ellipse( pres, prevtl.x, prevtl.y, prevbr.x, prevbr.y );
} else {
_wpi_rectangle( pres, prevtl.x, prevtl.y, prevbr.x, prevbr.y );
}
}
if ((toolType == IMGED_CIRCLEO) || (toolType == IMGED_CIRCLEF)) {
_wpi_ellipse( pres, topleft.x, topleft.y, bottomright.x, bottomright.y );
} else {
_wpi_rectangle( pres, topleft.x, topleft.y, bottomright.x, bottomright.y );
}
_wpi_selectobject( pres, holdpen );
_wpi_selectobject( pres, holdbrush );
_wpi_deleteobject( hwhitepen );
_wpi_deleteobject( hbrush );
_wpi_setrop2( pres, prevROP2 );
_wpi_releasepres( hwnd, pres );
} /* OutlineRegion */
/*
* DrawSinglePoint - needed for when the mouse button is initially pressed.
*/
void DrawSinglePoint( HWND hwnd, WPI_POINT *pt, short mousebutton )
{
HBRUSH colourbrush;
HBRUSH oldbrush;
HPEN colourpen;
HPEN oldpen;
COLORREF selected_colour;
COLORREF dithered;
short truncated_x;
short truncated_y;
short i;
short j;
WPI_POINT logical_pt;
WPI_RECT rcclient;
short width;
short height;
short wndwidth;
short wndheight;
wie_clrtype type;
WPI_PRES pres;
int brushsize;
BOOL gridvisible;
GetClientRect( hwnd, &rcclient );
wndwidth = _wpi_getwidthrect( rcclient );
wndheight = _wpi_getheightrect( rcclient );
brushsize = ImgedConfigInfo.brush_size;
CheckBounds( hwnd, pt );
gridvisible = ImgedConfigInfo.grid_on && (pointSize.x >= POINTSIZE_MIN &&
pointSize.y >= POINTSIZE_MIN);
if (gridvisible) {
if (toolType == IMGED_BRUSH) {
truncated_x = max(0, (pt->x/pointSize.x - brushsize/2)) * pointSize.x+1;
truncated_y = max(0, (pt->y/pointSize.y - brushsize/2)) * pointSize.y+1;
width = (short)(pointSize.x - 1);
height = (short)(pointSize.y - 1);
/*
* We just have to check that we don't spill over the image dimensions
*/
truncated_x = min(truncated_x, wndwidth-pointSize.x*brushsize+1);
truncated_y = min(truncated_y, wndheight-pointSize.y*brushsize+1);
} else {
truncated_x = ( pt->x / pointSize.x) * pointSize.x + 1;
truncated_y = ( pt->y / pointSize.y) * pointSize.y + 1;
width = (short)(pointSize.x - 1);
height = (short)(pointSize.y - 1);
}
} else {
if (toolType == IMGED_BRUSH) {
truncated_x = max(0, (pt->x / pointSize.x - brushsize/2)) * pointSize.x;
truncated_y = max(0, (pt->y / pointSize.y - brushsize/2)) * pointSize.y;
width = (short)(pointSize.x * brushsize);
height = (short)(pointSize.y * brushsize);
/*
* We just have to check that we don't spill over the image dimensions
*/
truncated_x = min( truncated_x, wndwidth-width );
truncated_y = min( truncated_y, wndheight-width );
} else {
truncated_x = ( pt->x / pointSize.x) * pointSize.x;
truncated_y = ( pt->y / pointSize.y) * pointSize.y;
width = (short)pointSize.x;
height = (short)pointSize.y;
}
}
logical_pt.x = truncated_x / pointSize.x;
logical_pt.y = truncated_y / pointSize.y;
pres = _wpi_getpres( hwnd );
_wpi_torgbmode( pres );
dithered = GetSelectedColour(mousebutton, &selected_colour, &type);
colourbrush = _wpi_createsolidbrush( selected_colour );
oldbrush = _wpi_selectobject( pres, colourbrush );
colourpen = _wpi_createpen( PS_SOLID, 0, selected_colour );
oldpen = _wpi_selectobject( pres, colourpen );
if (gridvisible && (toolType == IMGED_BRUSH)) {
for (i=0; i < brushsize; ++i) {
for (j=0; j < brushsize; ++j) {
_wpi_patblt(pres, truncated_x+i*pointSize.x,
truncated_y+j*pointSize.y,
width, height, PATCOPY);
}
}
} else {
_wpi_patblt(pres, truncated_x, truncated_y, width, height, PATCOPY);
}
_wpi_selectobject( pres, oldbrush );
_wpi_selectobject( pres, oldpen );
_wpi_releasepres( hwnd, pres );
_wpi_deleteobject( colourbrush );
_wpi_deleteobject( colourpen );
/*
* draws the points in the view window
*/
if (toolType == IMGED_BRUSH) {
if (type == SCREEN_CLR) {
BrushThePoints(selected_colour, BLACK, WHITE, &logical_pt,
brushsize);
} else if (type == INVERSE_CLR) {
BrushThePoints(selected_colour, WHITE, WHITE, &logical_pt,
brushsize);
} else {
BrushThePoints(selected_colour, selected_colour, BLACK,
&logical_pt, brushsize);
}
} else {
if (type == SCREEN_CLR) {
DrawThePoints(selected_colour, BLACK, WHITE, &logical_pt);
} else if (type == INVERSE_CLR) {
DrawThePoints(selected_colour, WHITE, WHITE, &logical_pt);
} else {
DrawThePoints(selected_colour, selected_colour, BLACK, &logical_pt);
}
}
} /* DrawSinglePoint */
/*
* drawPt - Actually draws the point on the drawing region. (uses LineDDA)
*/
void CALLBACK drawPt( int xpos, int ypos, WPI_PARAM2 lparam )
{
HBRUSH colourbrush;
HBRUSH oldbrush;
HPEN colourpen;
HPEN oldpen;
COLORREF selected_colour;
COLORREF dithered;
short mousebutton;
WPI_PRES pres;
HWND hwnd;
short area_x;
short area_y;
short width;
short height;
short i;
short j;
WPI_POINT pt;
WPI_RECT rcclient;
wie_clrtype type;
int brushsize;
BOOL gridvisible;
hwnd = (HWND)GET_HWND_PARAM2( lparam );
mousebutton = currentMouseButton;
_wpi_getclientrect( hwnd, &rcclient );
brushsize = ImgedConfigInfo.brush_size;
gridvisible = ImgedConfigInfo.grid_on && (pointSize.x >= POINTSIZE_MIN &&
pointSize.y >= POINTSIZE_MIN);
if ((!gridvisible) && (toolType == IMGED_FREEHAND)) {
area_x = xpos * pointSize.x;
area_y = ypos * pointSize.y;
width = (short)pointSize.x;
height = (short)pointSize.y;
} else if ((!gridvisible) && (toolType == IMGED_BRUSH)) {
area_x = max(0, xpos-brushsize/2) * pointSize.x;
area_y = max(0, ypos-brushsize/2) * pointSize.y;
width = (short)(brushsize * pointSize.x);
height = (short)(brushsize * pointSize.y);
/*
* We just have to check that we don't spill over the image dimensions
*/
area_x = min( area_x, _wpi_getwidthrect(rcclient)-width );
area_y = min( area_y, _wpi_getheightrect(rcclient)-width );
} else if ((gridvisible) && (toolType == IMGED_FREEHAND)) {
area_x = xpos * pointSize.x+1;
area_y = ypos * pointSize.y+1;
width = (short)(pointSize.x-1);
height = (short)(pointSize.y-1);
} else {
area_x = max(0, xpos-brushsize/2) * pointSize.x+1;
area_y = max(0, ypos-brushsize/2) * pointSize.y+1;
width = (short)(pointSize.x - 1);
height = (short)(pointSize.y - 1);
/*
* We just have to check that we don't spill over the image dimensions
*/
area_x = min( area_x, _wpi_getwidthrect(rcclient) - pointSize.x *
brushsize+1 );
area_y = min( area_y, _wpi_getheightrect(rcclient) - pointSize.y *
brushsize+1 );
}
pres = _wpi_getpres( hwnd );
_wpi_torgbmode( pres );
dithered = GetSelectedColour( mousebutton, &selected_colour, &type );
colourbrush = _wpi_createsolidbrush( selected_colour );
oldbrush = _wpi_selectobject(pres, colourbrush);
colourpen = _wpi_createpen(PS_SOLID, 0, selected_colour);
oldpen = _wpi_selectobject(pres, colourpen);
if (gridvisible && (toolType == IMGED_BRUSH)) {
for (i=0; i < brushsize; ++i) {
for (j=0; j < brushsize; ++j) {
_wpi_patblt(pres, area_x+i*pointSize.x, area_y+j*pointSize.y,
width, height, PATCOPY);
}
}
} else {
_wpi_patblt(pres, area_x, area_y, width, height, PATCOPY);
}
_wpi_selectobject(pres, oldbrush);
_wpi_selectobject(pres, oldpen);
_wpi_releasepres( hwnd, pres );
_wpi_deleteobject( colourbrush );
_wpi_deleteobject( colourpen );
pt.x = area_x / pointSize.x;
pt.y = area_y / pointSize.y;
if (toolType == IMGED_BRUSH) {
if (type == SCREEN_CLR) {
BrushThePoints(selected_colour, BLACK, WHITE, &pt, brushsize);
} else if (type == INVERSE_CLR) {
BrushThePoints(selected_colour, WHITE, WHITE, &pt, brushsize);
} else {
BrushThePoints(selected_colour, selected_colour, BLACK, &pt,
brushsize);
}
} else {
if (type == SCREEN_CLR) {
DrawThePoints(selected_colour, BLACK, WHITE, &pt);
} else if (type == INVERSE_CLR) {
DrawThePoints(selected_colour, WHITE, WHITE, &pt);
} else {
DrawThePoints(selected_colour, selected_colour, BLACK, &pt);
}
}
} /* drawPt */
/*
* ShiftImage - shift the image in the given direction
*/
void ShiftImage( WORD shiftdirection )
{
HBITMAP dup_and;
HBITMAP dup_xor;
HBITMAP oldbitmap;
HBITMAP oldsrcbitmap;
WPI_PRES pres;
HDC memdc;
WPI_PRES mempres;
HDC srcdc;
WPI_PRES srcpres;
short x_src;
short y_src;
short x_dest;
short y_dest;
short width;
short height;
short min_width;
short min_height;
short rgn_width;
short rgn_height;
img_node *node;
WPI_RECT rect;
IMGED_DIM left;
IMGED_DIM right;
IMGED_DIM top;
IMGED_DIM bottom;
DWORD message;
node = GetCurrentNode();
if( node == NULL ) {
return;
}
dup_and = DuplicateBitmap( node->handbitmap );
dup_xor = DuplicateBitmap( node->hxorbitmap );
pres = _wpi_getpres( HWND_DESKTOP );
mempres = _wpi_createcompatiblepres( pres, Instance, &memdc );
srcpres = _wpi_createcompatiblepres( pres, Instance, &srcdc );
_wpi_releasepres( HWND_DESKTOP, pres );
_wpi_torgbmode( mempres );
_wpi_torgbmode( srcpres );
if( DoesRectExist( &rect ) ) {
width = (short)_wpi_getwidthrect( rect );
height = (short)_wpi_getheightrect( rect );
} else {
_wpi_setwrectvalues( &rect, 0, 0, node->width, node->height );
width = node->width;
height = node->height;
}
_wpi_getwrectvalues( rect, &left, &top, &right, &bottom );
oldbitmap = _wpi_selectobject( mempres, node->handbitmap );
_wpi_patblt( mempres, left, top, width, height, BLACKNESS );
_wpi_selectobject( mempres, oldbitmap );
oldbitmap = _wpi_selectobject( mempres, node->hxorbitmap );
_wpi_patblt( mempres, left, top, width, height, WHITENESS );
oldsrcbitmap = _wpi_selectobject( srcpres, dup_xor );
x_src = (short)left;
y_src = (short)top;
x_dest =(short)left;
y_dest = (short)top;
min_width = (short)min( ImgedConfigInfo.shift, width );
min_height = (short)min( ImgedConfigInfo.shift, height );
rgn_width = width;
rgn_height = height;
switch( shiftdirection ) {
case IMGED_LEFT:
width -= min_width;
x_src = x_src + min_width;
message = WIE_IMAGESHIFTEDLEFT;
break;
case IMGED_RIGHT:
width -= min_width;
x_dest = x_dest + min_width;
message = WIE_IMAGESHIFTEDRIGHT;
break;
case IMGED_UP:
#ifndef __OS2_PM__
height -= min_height;
y_src = y_src + min_height;
#else
height += min_height;
y_src = y_src - min_height;
#endif
message = WIE_IMAGESHIFTEDUP;
break;
case IMGED_DOWN:
#ifndef __OS2_PM__
height -= min_height;
y_dest = y_dest + min_height;
#else
height += min_height;
y_dest = y_dest - min_height;
#endif
message = WIE_IMAGESHIFTEDDOWN;
break;
default:
break;
}
_wpi_bitblt( mempres, x_dest, y_dest, width, height, srcpres, x_src, y_src, SRCCOPY );
_wpi_selectobject( srcpres, oldsrcbitmap );
oldsrcbitmap = _wpi_selectobject( srcpres, dup_and );
_wpi_selectobject( mempres, oldbitmap );
oldbitmap = _wpi_selectobject( mempres, node->handbitmap );
_wpi_bitblt( mempres, x_dest, y_dest, width, height, srcpres, x_src, y_src, SRCCOPY );
if( IsShiftWrap() ) {
switch( shiftdirection ) {
case IMGED_LEFT:
width = min_width;
x_src = (short)left;
x_dest = (short)(right - width);
break;
case IMGED_RIGHT:
width = min_width;
x_dest = (short)left;
x_src = (short)(right - width);
break;
case SHIFT_UP:
height = min_height;
y_src = (short)top;
y_dest = (short)(bottom - height);
break;
case SHIFT_DOWN:
height = min_height;
y_dest = (short)top;
y_src = (short)(bottom - height);
break;
default:
break;
}
_wpi_bitblt( mempres, x_dest, y_dest, width, height, srcpres,
x_src, y_src, SRCCOPY );
_wpi_selectobject( srcpres, oldsrcbitmap );
_wpi_selectobject( mempres, oldbitmap );
oldsrcbitmap = _wpi_selectobject( srcpres, dup_xor );
oldbitmap = _wpi_selectobject( mempres, node->hxorbitmap );
_wpi_bitblt( mempres, x_dest, y_dest, width, height, srcpres,
x_src, y_src, SRCCOPY );
}
_wpi_selectobject( srcpres, oldsrcbitmap );
_wpi_selectobject( mempres, oldbitmap );
_wpi_deletecompatiblepres( srcpres, srcdc );
_wpi_deletecompatiblepres( mempres, memdc );
_wpi_deleteobject( dup_xor );
_wpi_deleteobject( dup_and );
RecordImage( node->hwnd );
BlowupImage( node->hwnd, NULL );
InvalidateRect( node->viewhwnd, NULL, FALSE );
IEPrintAmtText( message, ImgedConfigInfo.shift );
} /* ShiftImage */
/*
* drawBorder - draw the border for the view window
*/
static void drawBorder( img_node *node )
{
WPI_PRES presborder;
HPEN hgraypen;
HPEN hwhitepen;
HPEN hblackpen;
HPEN holdpen;
WPI_RECT rcclient;
HBRUSH hnewbrush;
HBRUSH holdbrush;
HBRUSH nullbrush;
int width;
int height;
#ifndef __NT__
WPI_POINT pt;
#endif
int top;
int bottom;
presborder = _wpi_getpres( node->viewhwnd );
#if defined( __NT__ )
hwhitepen = _wpi_createpen( PS_SOLID, 0, GetSysColor( COLOR_BTNHIGHLIGHT ) );
hblackpen = _wpi_createpen( PS_SOLID, 0, GetSysColor( COLOR_BTNTEXT ) );
#else
hwhitepen = _wpi_createpen( PS_SOLID, 0, CLR_WHITE );
hblackpen = _wpi_createpen( PS_SOLID, 0, CLR_BLACK );
#endif
GetClientRect( node->viewhwnd, &rcclient );
width = _wpi_getwidthrect( rcclient );
height = _wpi_getheightrect( rcclient );
if( node->imgtype != BITMAP_IMG ) {
#if defined( __NT__ )
hgraypen = _wpi_createpen( PS_SOLID, 0, GetSysColor( COLOR_BTNSHADOW ) );
#else
hgraypen = _wpi_createpen( PS_SOLID, 0, CLR_DARKGRAY );
#endif
holdpen = _wpi_selectobject( presborder, hgraypen );
#if defined( __NT__ )
hnewbrush = _wpi_createsolidbrush( GetSysColor( COLOR_BTNFACE ) );
#else
hnewbrush = _wpi_createsolidbrush( CLR_PALEGRAY );
#endif
holdbrush = _wpi_selectobject( presborder, hnewbrush );
top = 0;
bottom = height;
top = _wpi_cvth_y( top, height );
bottom = _wpi_cvth_y( bottom, height );
_wpi_rectangle( presborder, 0, top, width, bottom );
/*
* Draw black border and selected background color in the view window.
*/
_wpi_selectobject( presborder, hblackpen );
_wpi_selectobject( presborder, holdbrush );
_wpi_deleteobject( hnewbrush );
hnewbrush = _wpi_createsolidbrush( bkgroundColor );
_wpi_selectobject( presborder, hnewbrush );
top = BORDER_WIDTH - 1;
bottom = height - BORDER_WIDTH + 1;
top = _wpi_cvth_y( top, height );
bottom = _wpi_cvth_y( bottom, height );
#ifndef __NT__
/*
* Draw the border relative to the size of the object being displayed,
* not the window containing it.
*/
_wpi_rectangle( presborder, BORDER_WIDTH - 1, top,
node->width + BORDER_WIDTH + 1, top + node->height + 2 );
#endif
_wpi_selectobject( presborder, holdbrush );
_wpi_selectobject( presborder, holdpen );
_wpi_deleteobject( hnewbrush );
} else {
#ifdef __OS2_PM__
// I can't seem to get the thick pen to work so I'm using this
// method.
hgraypen = _wpi_createpen( PS_SOLID, 0, CLR_PALEGRAY );
holdpen = _wpi_selectobject( presborder, hgraypen );
hnewbrush = _wpi_createsolidbrush( CLR_PALEGRAY );
holdbrush = _wpi_selectobject( presborder, hnewbrush );
_wpi_rectangle( presborder, 0, 0, width + 1, BORDER_WIDTH + 1 );
_wpi_rectangle( presborder, 0, 0, BORDER_WIDTH + 1, height + 1 );
_wpi_rectangle( presborder, 0, height - BORDER_WIDTH, width + 1, height + 1 );
_wpi_rectangle( presborder, width - BORDER_WIDTH, 0, width + 1, height + 1 );
_wpi_selectobject( presborder, holdbrush );
_wpi_deleteobject( hnewbrush );
_wpi_selectobject( presborder, holdpen );
_wpi_deleteobject( hgraypen );
#else
#if defined( __NT__ )
hgraypen = _wpi_createpen( PS_INSIDEFRAME, BORDER_WIDTH,
GetSysColor( COLOR_BTNFACE ) );
#else
hgraypen = _wpi_createpen( PS_INSIDEFRAME, BORDER_WIDTH, CLR_PALEGRAY );
#endif
holdpen = _wpi_selectobject( presborder, hgraypen );
nullbrush = _wpi_createnullbrush();
holdbrush = _wpi_selectbrush( presborder, nullbrush );
_wpi_rectangle( presborder, 0, 0, rcclient.right, rcclient.bottom );
_wpi_getoldbrush( presborder, holdbrush );
_wpi_selectobject( presborder, holdpen );
_wpi_deleteobject( hgraypen );
_wpi_deletenullbrush( nullbrush );
#endif
nullbrush = _wpi_createnullbrush();
#if defined( __NT__ )
hgraypen = _wpi_createpen( PS_SOLID, 0, GetSysColor( COLOR_BTNSHADOW ) );
#else
hgraypen = _wpi_createpen( PS_SOLID, 0, CLR_DARKGRAY );
#endif
holdbrush = _wpi_selectbrush( presborder, nullbrush );
holdpen = _wpi_selectobject( presborder, hgraypen );
top = 0;
bottom = height;
top = _wpi_cvth_y( top, height );
bottom = _wpi_cvth_y( bottom, height );
_wpi_rectangle( presborder, 0, top, width, bottom );
_wpi_selectobject( presborder, hblackpen );
top = BORDER_WIDTH - 1;
bottom = height - BORDER_WIDTH + 1;
top = _wpi_cvth_y( top, height );
bottom = _wpi_cvth_y( bottom, height );
#ifndef __NT__
/*
* Draw the border relative to the size of the object being displayed,
* not the window containing it.
*/
_wpi_rectangle( presborder, BORDER_WIDTH - 1, top,
node->width + BORDER_WIDTH + 1, top + node->height + 2 );
#endif
_wpi_selectobject( presborder, holdpen );
_wpi_selectbrush( presborder, holdbrush );
_wpi_deletenullbrush( nullbrush );
}
/*
* Give the view window the 3D effect.
*/
#ifndef __NT__
holdpen = _wpi_selectobject( presborder, hwhitepen );
_wpi_setpoint( &pt, 0, height - 1 );
_wpi_cvth_pt( &pt, height );
_wpi_movetoex( presborder, &pt, NULL );
_wpi_setpoint( &pt, 0, 0 );
_wpi_cvth_pt( &pt, height );
_wpi_lineto( presborder, &pt );
pt.x = width;
_wpi_lineto( presborder, &pt );
_wpi_setpoint( &pt, width - BORDER_WIDTH + 1, BORDER_WIDTH - 2 );
_wpi_cvth_pt( &pt, height );
_wpi_movetoex( presborder, &pt, NULL );
pt.y = height - BORDER_WIDTH + 1;
_wpi_cvth_pt( &pt, height );
_wpi_lineto( presborder, &pt );
pt.x = BORDER_WIDTH - 2;
_wpi_lineto( presborder, &pt );
_wpi_selectobject( presborder, hgraypen );
_wpi_setpoint( &pt, BORDER_WIDTH - 2, BORDER_WIDTH - 2 );
_wpi_cvth_pt( &pt, height );
_wpi_lineto( presborder, &pt );
pt.x = width - BORDER_WIDTH + 1;
_wpi_lineto( presborder, &pt );
_wpi_selectobject( presborder, holdpen );
#endif
_wpi_deleteobject( hgraypen );
_wpi_deleteobject( hwhitepen );
_wpi_deleteobject( hblackpen );
_wpi_releasepres( node->viewhwnd, presborder );
} /* drawBorder */
/*
* SetColor - set the current colors
*/
void SetColor( int mousebutton, COLORREF color, COLORREF solid, wie_clrtype type )
{
HDC hdc;
WPI_PRES pres;
WPI_PRES mempres;
HBITMAP oldbitmap;
HPEN blackpen;
HPEN oldpen;
HBRUSH brush;
HBRUSH oldbrush;
int top;
int bottom;
blackpen = _wpi_createpen( PS_SOLID, 0, BLACK );
if( mousebutton == LMOUSEBUTTON ) {
lButton.color = color;
lButton.solid = solid;
lButton.type = type;
if( lButton.bitmap != NULL ) {
_wpi_deletebitmap( lButton.bitmap );
pres = _wpi_getpres( HWND_DESKTOP );
if( numberOfColors == 2 && type == NORMAL_CLR ) {
lButton.bitmap = _wpi_createbitmap( CUR_SQR_SIZE + 1, 2 * CUR_SQR_SIZE + 1,
1, 1, NULL );
} else {
lButton.bitmap = _wpi_createcompatiblebitmap( pres, CUR_SQR_SIZE + 1,
2 * CUR_SQR_SIZE + 1 );
}
mempres = _wpi_createcompatiblepres( pres, Instance, &hdc );
_wpi_torgbmode( mempres );
oldbitmap = _wpi_selectobject( mempres, lButton.bitmap );
_wpi_releasepres( HWND_DESKTOP, pres );
oldpen = _wpi_selectobject( mempres, blackpen );
brush = _wpi_createsolidbrush( solid );
oldbrush = _wpi_selectobject( mempres, brush );
top = _wpi_cvth_y( 0, currentHeight );
bottom = _wpi_cvth_y( CUR_SQR_SIZE + 1, currentHeight );
_wpi_rectangle( mempres, 0, top, CUR_SQR_SIZE + 1, bottom );
_wpi_selectobject( mempres, oldbrush );
_wpi_deleteobject( brush );
brush = _wpi_createsolidbrush( color );
oldbrush = _wpi_selectobject( mempres, brush );
top = _wpi_cvth_y( CUR_SQR_SIZE, currentHeight );
bottom = _wpi_cvth_y( 2 * CUR_SQR_SIZE + 1, currentHeight );
_wpi_rectangle( mempres, 0, top, CUR_SQR_SIZE + 1, bottom );
_wpi_selectobject( mempres, oldbrush );
_wpi_deleteobject( brush );
_wpi_selectobject( mempres, oldbitmap );
_wpi_selectobject( mempres, oldpen );
_wpi_deletecompatiblepres( mempres, hdc );
}
} else {
rButton.color = color;
rButton.solid = solid;
rButton.type = type;
if( rButton.bitmap != NULL ) {
_wpi_deletebitmap( rButton.bitmap );
pres = _wpi_getpres( HWND_DESKTOP );
if( numberOfColors == 2 && type == NORMAL_CLR ) {
rButton.bitmap = _wpi_createbitmap( CUR_SQR_SIZE + 1, 2 * CUR_SQR_SIZE + 1,
1, 1, NULL );
} else {
rButton.bitmap = _wpi_createcompatiblebitmap( pres, CUR_SQR_SIZE + 1,
2 * CUR_SQR_SIZE + 1 );
}
mempres = _wpi_createcompatiblepres( pres, Instance, &hdc );
_wpi_torgbmode( mempres );
oldbitmap = _wpi_selectobject( mempres, rButton.bitmap );
_wpi_releasepres( HWND_DESKTOP, pres );
oldpen = _wpi_selectobject( mempres, blackpen );
brush = _wpi_createsolidbrush( solid );
oldbrush = _wpi_selectobject( mempres, brush );
top = _wpi_cvth_y( 0, currentHeight );
bottom = _wpi_cvth_y( CUR_SQR_SIZE + 1, currentHeight );
_wpi_rectangle( mempres, 0, top, CUR_SQR_SIZE + 1, bottom );
_wpi_selectobject( mempres, oldbrush );
_wpi_deleteobject( brush );
brush = _wpi_createsolidbrush( color );
oldbrush = _wpi_selectobject( mempres, brush );
top = _wpi_cvth_y( CUR_SQR_SIZE, currentHeight );
bottom = _wpi_cvth_y( 2 * CUR_SQR_SIZE + 1, currentHeight );
_wpi_rectangle( mempres, 0, top, CUR_SQR_SIZE + 1, bottom );
_wpi_selectobject( mempres, oldbrush );
_wpi_deleteobject( brush );
_wpi_selectobject( mempres, oldbitmap );
_wpi_selectobject( mempres, oldpen );
_wpi_deletecompatiblepres( mempres, hdc );
}
}
_wpi_deleteobject( blackpen );
InvalidateRect( hCurrentWnd, NULL, TRUE );
} /* SetColor */