/*
* 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 */
/*
* 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 */
void SetBKBrush( gui_window *wnd )
{
if (!init_rgb) {
InitSystemRGB();
init_rgb = 1;
}
GUIGetRGB( wnd->colours[GUI_BACKGROUND].back, &wnd->bk_rgb );
wnd->bk_brush = _wpi_createsolidbrush(GUIGetBack( wnd, GUI_BACKGROUND ));
}
/*
* 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 */
/*
* 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 */
/*
* StatusWndChangeSysColors - fiddle with what StatusWnd believes
* are the system colors
*/
void StatusWndChangeSysColors( COLORREF btnFace, COLORREF btnText,
COLORREF btnHighlight, COLORREF btnShadow )
{
#ifdef __NT__
if( !IsCommCtrlLoaded() ) {
#endif
if( hasGDIObjects ) {
_wpi_deleteobject( penLight );
_wpi_deleteobject( penShade );
_wpi_deleteobject( brushButtonFace );
}
colorButtonFace = btnFace;
colorTextFace = btnText;
brushButtonFace = _wpi_createsolidbrush( btnFace );
penLight = _wpi_createpen( PS_SOLID, 1, btnHighlight );
penShade = _wpi_createpen( PS_SOLID, 1, btnShadow );
hasGDIObjects = true;
#ifdef __NT__
}
#endif
}
/*
* 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 */
/*
* 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 */
/*
* 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 */
/*
* 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 */
/*
* 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 */
static bool DrawRect( gui_window *wnd, gui_rect *rect, WPI_COLOUR colour,
bool fill, bool outline )
{
WPI_RECT wnd_rect;
gui_coord pos;
gui_coord size;
HBRUSH brush;
int hscroll;
int vscroll;
int win_height;
if( ( rect->width == 0 ) || ( rect->height == 0 ) ) {
return( false );
}
if( GUI_DO_VSCROLL( wnd ) ) {
vscroll = GUIGetScrollPos( wnd, SB_VERT );
} else {
vscroll = 0;
}
if( GUI_DO_HSCROLL( wnd ) ) {
hscroll = GUIGetScrollPos( wnd, SB_HORZ );
} else {
hscroll = 0;
}
win_height = _wpi_getheightrect( wnd->hwnd_client_rect );
pos.x = rect->x;
pos.y = rect->y;
size.x = rect->width;
if( rect->width < 0 ) {
pos.x += rect->width;
size.x *= -1;
}
size.y = rect->height;
if( rect->height < 0 ) {
pos.y += rect->height;
size.y *= -1;
}
GUIScaleToScreenR( &pos );
GUIScaleToScreenR( &size );
pos.x -= hscroll;
pos.y -= vscroll;
pos.y = _wpi_cvth_y_size_plus1( pos.y, win_height, size.y );
_wpi_setrectvalues( &wnd_rect, pos.x, pos.y, pos.x + size.x, pos.y + size.y );
if( GUIIsRectInUpdateRect( wnd, &wnd_rect ) ) {
brush = _wpi_createsolidbrush( colour );
if( fill ) {
_wpi_fillrect( wnd->hdc, &wnd_rect, colour, brush );
}
if( outline ) {
_wpi_borderrect( wnd->hdc, &wnd_rect, brush, colour, colour );
}
_wpi_deletebrush( brush );
}
return( true );
}
/*
* RegionXorAnd - Draws a filled or framed region (ellipse or rectangle) in
* the View window.
*/
void RegionXorAnd( COLORREF xorcolour, COLORREF andcolour, BOOL fFillRgn,
WPI_RECT *r, BOOL is_rect )
{
HBRUSH oldbrush;
HBRUSH hbrush;
HPEN oldpen;
HPEN hpen;
WPI_PRES mempres;
HDC memdc;
WPI_PRES pres;
HBITMAP oldbitmap;
int left;
int top;
int right;
int bottom;
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, xorcolour );
oldpen = _wpi_selectobject( mempres, hpen );
oldbitmap = _wpi_selectobject( mempres, activeImage->hxorbitmap );
if ( fFillRgn ) {
hbrush = _wpi_createsolidbrush( xorcolour );
} else {
hbrush = _wpi_createnullbrush();
}
oldbrush = _wpi_selectobject( mempres, hbrush );
_wpi_getintrectvalues( *r, &left, &top, &right, &bottom );
if (is_rect) {
_wpi_rectangle( mempres, left, top, right, bottom );
} else {
_wpi_ellipse( mempres, left, top, right, bottom );
}
_wpi_selectobject( mempres, oldpen );
_wpi_deletepen( hpen );
_wpi_selectobject( mempres, oldbrush );
_wpi_selectobject( mempres, oldbitmap );
if (fFillRgn) {
_wpi_deleteobject( hbrush );
} else {
_wpi_deletenullbrush( hbrush );
}
if( activeImage->imgtype == BITMAP_IMG ) {
_wpi_deletecompatiblepres( mempres, memdc );
return;
}
hpen = _wpi_createpen( PS_SOLID, 0, andcolour );
oldpen = _wpi_selectobject( mempres, hpen );
oldbitmap = _wpi_selectobject( mempres, activeImage->handbitmap );
if ( fFillRgn ) {
hbrush = _wpi_createsolidbrush( andcolour );
} else {
hbrush = _wpi_createnullbrush();
}
oldbrush = _wpi_selectobject( mempres, hbrush );
if (is_rect) {
_wpi_rectangle( mempres, left, top, right, bottom );
} else {
_wpi_ellipse( mempres, left, top, right, bottom );
}
_wpi_selectobject( mempres, oldpen );
_wpi_deletepen( hpen );
_wpi_selectobject( mempres, oldbrush );
_wpi_selectobject( mempres, oldbitmap );
if (fFillRgn) {
_wpi_deleteobject( hbrush );
} else {
_wpi_deletenullbrush( hbrush );
}
_wpi_deletecompatiblepres( mempres, memdc );
} /* RegionXorAnd */
/*
* InitPaletteBitmaps - initialize the available color bitmaps
*/
void InitPaletteBitmaps( HWND hwnd, HBITMAP *colorbitmap, HBITMAP *monobitmap )
{
WPI_PRES pres;
WPI_PRES mempres;
HDC hdc;
HBITMAP oldbitmap;
COLORREF color;
int i;
int left_sqr;
HBRUSH colorbrush;
HBRUSH oldbrush;
HPEN blackpen;
HPEN oldpen;
int top;
int bottom;
int height;
pres = _wpi_getpres( hwnd );
*colorbitmap = _wpi_createcompatiblebitmap( pres, CUR_BMP_WIDTH, CUR_BMP_HEIGHT );
*monobitmap = _wpi_createbitmap( CUR_BMP_WIDTH, CUR_BMP_HEIGHT, 1, 1, NULL );
mempres = _wpi_createcompatiblepres( pres, Instance, &hdc );
_wpi_releasepres( hwnd, pres );
_wpi_torgbmode( mempres );
blackpen = _wpi_createpen( PS_SOLID, 0, BLACK );
oldpen = _wpi_selectobject( mempres, blackpen );
oldbitmap = _wpi_selectobject( mempres, *colorbitmap );
/*
* PM NOTE: All box coordinates are relative to the window's origin
* of top left. So we convert the height for PM.
*/
left_sqr = 0;
height = 2 * SQR_SIZE + 1;
for( i = 0; i < PALETTE_SIZE; i += 2 ) {
color = RGB( palette[COLOR_16][i].rgbRed, palette[COLOR_16][i].rgbGreen,
palette[COLOR_16][i].rgbBlue );
colorbrush = _wpi_createsolidbrush( color );
oldbrush = _wpi_selectobject( mempres, colorbrush );
top = _wpi_cvth_y( 0, height );
bottom = _wpi_cvth_y( SQR_SIZE + 1, height );
_wpi_rectangle( mempres, left_sqr, top, left_sqr + SQR_SIZE + 1, bottom );
_wpi_selectobject( mempres, oldbrush );
_wpi_deleteobject( colorbrush );
color = RGB( palette[COLOR_16][i + 1].rgbRed, palette[COLOR_16][i + 1].rgbGreen,
palette[COLOR_16][i + 1].rgbBlue );
colorbrush = _wpi_createsolidbrush( color );
oldbrush = _wpi_selectobject( mempres, colorbrush );
top = _wpi_cvth_y( SQR_SIZE, height );
bottom = _wpi_cvth_y( 2 * SQR_SIZE + 1, height );
_wpi_rectangle( mempres, left_sqr, top, left_sqr + SQR_SIZE + 1, bottom );
_wpi_selectobject( mempres, oldbrush );
_wpi_deleteobject( colorbrush );
left_sqr += SQR_SIZE;
}
_wpi_selectobject( mempres, oldbitmap );
oldbitmap = _wpi_selectobject( mempres, *monobitmap );
left_sqr = 0;
for( i = 0; i < PALETTE_SIZE; i += 2 ) {
color = RGB( palette[COLOR_2][i].rgbRed, palette[COLOR_2][i].rgbGreen,
palette[COLOR_2][i].rgbBlue );
colorbrush = _wpi_createsolidbrush( color );
oldbrush = _wpi_selectobject( mempres, colorbrush );
top = _wpi_cvth_y( 0, height );
bottom = _wpi_cvth_y( SQR_SIZE + 1, height );
_wpi_rectangle( mempres, left_sqr, top, left_sqr + SQR_SIZE + 1, bottom );
_wpi_selectobject( mempres, oldbrush );
_wpi_deleteobject( colorbrush );
color = RGB( palette[COLOR_2][i + 1].rgbRed, palette[COLOR_2][i + 1].rgbGreen,
palette[COLOR_2][i + 1].rgbBlue );
colorbrush = _wpi_createsolidbrush( color );
oldbrush = _wpi_selectobject( mempres, colorbrush );
top = _wpi_cvth_y( SQR_SIZE, height );
bottom = _wpi_cvth_y( 2 * SQR_SIZE + 1, height );
_wpi_rectangle( mempres, left_sqr, top, left_sqr + SQR_SIZE + 1, bottom );
_wpi_selectobject( mempres, oldbrush );
_wpi_deleteobject( colorbrush );
left_sqr += SQR_SIZE;
}
_wpi_selectobject( mempres, oldbitmap );
_wpi_selectobject( mempres, oldpen );
_wpi_deletecompatiblepres( mempres, hdc );
_wpi_deleteobject( blackpen );
} /* InitPaletteBitmaps */
/*
* StatusWndInit - initialize for using the status window
*/
bool StatusWndInit( WPI_INST hinstance, statushook hook, int extra, HCURSOR hDefaultCursor )
{
bool rc;
#ifdef __OS2_PM__
/* OS/2 PM version of the initialization */
colorButtonFace = CLR_PALEGRAY;
if( !hasGDIObjects ) {
brushButtonFace = _wpi_createsolidbrush( colorButtonFace );
penLight = _wpi_createpen( PS_SOLID, 1, CLR_WHITE );
penShade = _wpi_createpen( PS_SOLID, 1, CLR_DARKGRAY );
hasGDIObjects = true;
}
statusWndHookFunc = hook;
rc = true;
if( !classRegistered ) {
memcpy( &classHandle, &hinstance, sizeof( WPI_INST ) );
rc = WinRegisterClass( hinstance.hab, className, (PFNWP)StatusWndCallback,
CS_SIZEREDRAW | CS_CLIPSIBLINGS,
extra + sizeof( statwnd * ) );
classWinExtra = extra;
classRegistered = true;
}
#else
/* Win16 and Win32 version of the initialization */
WNDCLASS wc;
#ifdef __NT__
if( LoadCommCtrl() ) {
rc = true;
} else {
#endif
if( !hasGDIObjects ) {
colorButtonFace = GetSysColor( COLOR_BTNFACE );
colorTextFace = GetSysColor( COLOR_BTNTEXT );
brushButtonFace = CreateSolidBrush( colorButtonFace );
penLight = CreatePen( PS_SOLID, 1, GetSysColor( COLOR_BTNHIGHLIGHT ) );
penShade = CreatePen( PS_SOLID, 1, GetSysColor( COLOR_BTNSHADOW ) );
hasGDIObjects = true;
}
statusWndHookFunc = hook;
rc = true;
if( !GetClassInfo( hinstance, className, &wc ) ) {
classHandle = hinstance;
classWinExtra = extra;
wc.style = CS_HREDRAW | CS_VREDRAW;
wc.lpfnWndProc = GetWndProc( StatusWndCallback );
wc.cbClsExtra = 0;
wc.cbWndExtra = extra + sizeof( statwnd * );
wc.hInstance = hinstance;
wc.hIcon = LoadIcon( (HINSTANCE)NULL, IDI_APPLICATION );
wc.hCursor = hDefaultCursor;
if( wc.hCursor == NULL ) {
wc.hCursor = LoadCursor( (HINSTANCE)NULL, IDC_ARROW );
}
wc.hbrBackground = (HBRUSH)0;
wc.lpszMenuName = NULL;
wc.lpszClassName = className;
rc = ( RegisterClass( &wc ) != 0 );
classRegistered = true;
}
#ifdef __NT__
}
#endif
#endif
return( rc );
} /* StatusWndInit */
/*
* 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 */
void GUIDrawTextBitmapRGB( gui_window *wnd, const char *text,
size_t length, int height, gui_coord *pos,
WPI_COLOUR fore, WPI_COLOUR back, gui_ord extentx,
bool draw_extent, int bitmap )
{
int nDrawX, nDrawY;
UINT lenx;
HBRUSH brush;
HBRUSH old_brush;
HPEN pen;
HPEN old_pen;
int old_rop;
size_t num_chars;
WPI_RECT rect;
gui_coord indent;
int hscroll_pos;
gui_coord extent;
WPI_COLOUR colour;
GUI_RECTDIM left, top, right, bottom;
GUI_RECTDIM paint_left, paint_top, paint_right, paint_bottom;
WPI_RECT paint_rect;
WPI_RECT draw_rect;
//draw_cache dcache;
if( ( wnd->hdc == NULLHANDLE ) || ( wnd->ps == NULL ) ||
( ( text == NULL ) && ( bitmap == 0 ) ) ||
( ( bitmap != 0 ) && ( height == 0 ) ) ) {
return;
}
old_rop = 0;
old_brush = (HBRUSH)NULL;
brush = (HBRUSH)NULL;
old_pen = (HPEN)NULL;
pen = (HPEN)NULL;
GUIGetMetrics( wnd );
if( !bitmap ) {
height = AVGYCHAR(GUItm);
}
rect = wnd->hwnd_client;
_wpi_getrectvalues( rect, &left, &top, &right, &bottom);
_wpi_getpaintrect( wnd->ps, &paint_rect );
_wpi_getwrectvalues( paint_rect, &paint_left, &paint_top, &paint_right,
&paint_bottom );
top = paint_top / height * height;
bottom = ( paint_bottom + height - 1) / height * height;
if( GUI_DO_HSCROLL( wnd ) ) {
hscroll_pos = GUIGetScrollPos( wnd, SB_HORZ );
} else {
hscroll_pos = 0;
}
if( bitmap == 0 ) {
num_chars = strlen( text );
if( num_chars > length ) {
num_chars = length;
}
}
indent.x = pos->x;
indent.y = pos->y;
GUIScaleToScreenR( &indent );
nDrawY = indent.y;
if( GUI_DO_VSCROLL( wnd ) ) {
nDrawY -= GUIGetScrollPos( wnd, SB_VERT );
}
nDrawX = left;
nDrawX += ( indent.x - hscroll_pos );
if( bitmap > 0 ) {
lenx = length ;
} else {
lenx = GUIGetTextExtentX( wnd, text, num_chars );
}
if( draw_extent ) {
/* blanks out some portion of rest of the line */
if( extentx != GUI_NO_COLUMN ) {
extent.x = extentx;
GUIScaleToScreen( &extent );
right = nDrawX + extent.x;
}
} else {
right = nDrawX + lenx;
}
nDrawY = _wpi_cvth_y_size( nDrawY, _wpi_getheightrect(wnd->hwnd_client), height );
_wpi_setrectvalues( &draw_rect, nDrawX, nDrawY, right, nDrawY+height );
if( GUIIsRectInUpdateRect( wnd, &draw_rect ) ) {
colour = _wpi_getnearestcolor( wnd->hdc, back );
brush = _wpi_createsolidbrush( colour );
pen = _wpi_createpen( PS_SOLID, 1, colour );
if( pen == NULLHANDLE ) {
GUIError(LIT( Pen_Failed ));
}
old_brush = _wpi_selectbrush( wnd->hdc, brush );
old_pen = _wpi_selectpen( wnd->hdc, pen );
#ifdef __OS2_PM__
_wpi_rectangle( wnd->hdc, nDrawX, nDrawY+1, right, nDrawY + height - 1 );
#else
_wpi_rectangle( wnd->hdc, nDrawX, nDrawY, right, nDrawY + height);
#endif
/* if visible even with scrolling */
if( nDrawX < ( paint_right + hscroll_pos ) ) {
if( bitmap > 0 ) {
GUIDrawBitmap( bitmap, wnd->hdc, nDrawX, nDrawY, colour);
} else {
#ifdef __OS2_PM__
nDrawY += _wpi_metricdescent( GUItm );
#endif
old_rop = _wpi_setrop2( wnd->hdc, R2_COPYPEN );
SetText( wnd, fore, back );
_wpi_textout( wnd->hdc, nDrawX, nDrawY, text, num_chars );
}
}
/* restore old resources */
if( old_rop != 0 ) {
_wpi_setrop2( wnd->hdc, old_rop );
}
if( old_brush != (HBRUSH)NULL ) {
_wpi_getoldbrush( wnd->hdc, old_brush );
}
if( brush != (HBRUSH)NULL ) {
_wpi_deletebrush( brush );
}
if( old_pen != (HPEN)NULL ) {
_wpi_getoldpen( wnd->hdc, old_pen );
}
if( pen != (HPEN)NULL ) {
_wpi_deletepen( pen );
}
}
}
/*
* ColorPalWinProc - handle messages for the color palette
*/
WPI_MRESULT CALLBACK ColorPalWinProc( HWND hwnd, WPI_MSG msg, WPI_PARAM1 mp1, WPI_PARAM2 mp2 )
{
HMENU sysmenu;
WPI_RECT rcpal;
WPI_RECTDIM left;
WPI_RECTDIM right;
WPI_RECTDIM top;
WPI_RECTDIM bottom;
static HMENU menu;
static HWND hframe;
switch( msg ) {
case WM_CREATE:
hframe = _wpi_getframe( hwnd );
sysmenu = _wpi_getcurrentsysmenu( hframe );
_wpi_deletemenu( sysmenu, SC_RESTORE, FALSE );
_wpi_deletemenu( sysmenu, SC_SIZE, FALSE );
_wpi_deletemenu( sysmenu, SC_MINIMIZE, FALSE );
_wpi_deletemenu( sysmenu, SC_MAXIMIZE, FALSE );
_wpi_deletemenu( sysmenu, SC_TASKLIST, FALSE );
#ifdef __OS2_PM__
_wpi_deletemenu( sysmenu, SC_HIDE, FALSE );
#endif
_wpi_deletesysmenupos( sysmenu, 1 );
_wpi_deletesysmenupos( sysmenu, 2 );
hbrush = _wpi_createsolidbrush( LTGRAY );
menu = GetMenu( _wpi_getframe( HMainWindow ) );
break;
case WM_PAINT:
_wpi_deleteobject( hbrush );
SetBkColor( (HDC)mp1, GetSysColor( COLOR_BTNFACE ) );
SetTextColor( (HDC)mp1, GetSysColor( COLOR_BTNTEXT ) );
hbrush = _wpi_createsolidbrush( GetSysColor( COLOR_BTNFACE ) );
paintPalette( hwnd );
break;
#ifndef __OS2_PM__
#ifdef __NT__
case WM_SYSCOLORCHANGE:
case WM_CTLCOLORSTATIC:
case WM_CTLCOLORBTN:
_wpi_deleteobject( hbrush );
hbrush = _wpi_createsolidbrush( GetSysColor( COLOR_BTNFACE ) );
SetBkColor( (HDC)mp1, GetSysColor( COLOR_BTNFACE ) );
SetTextColor( (HDC)mp1, GetSysColor( COLOR_BTNTEXT ) );
return( (WPI_MRESULT)hbrush );
#else
case WM_CTLCOLOR:
if( HIWORD( mp2 ) == CTLCOLOR_STATIC || HIWORD( mp2 ) == CTLCOLOR_BTN ) {
SetBkColor( (HDC)LOWORD( mp1 ), LTGRAY );
SetTextColor( (HDC)LOWORD( mp1 ), BLACK );
return( (WPI_MRESULT)hbrush );
}
break;
#endif
#endif
case WM_MOVE:
_wpi_getwindowrect( _wpi_getframe( hwnd ), &rcpal );
_wpi_getrectvalues( rcpal, &left, &top, &right, &bottom );
ImgedConfigInfo.pal_xpos = (short)left;
ImgedConfigInfo.pal_ypos = (short)top;
break;
case WM_CLOSE:
CheckPaletteItem( menu );
break;
case WM_DESTROY:
_wpi_deleteobject( hbrush );
break;
default:
return( DefWindowProc( hwnd, msg, mp1, mp2 ) );
}
return( 0 );
} /* ColorPalWinProc */
