/*
* IECopyImage - copy the current clipping rectangle to the clipboard
*
* 1) Copy the bitmap to the clipboard (so other apps can use it).
* 2) Make a copy of the XOR bitmap and the AND bitmaps so that if
* screen colors are involved, they will be preserved.
* Later, we check the owner of the clipboard to see if we really
* want to use the XOR/AND bitmaps or not.
*/
void IECopyImage( void )
{
short width;
short height;
img_node *node;
node = GetCurrentNode();
if( node == NULL ) {
return;
}
if( !fEnableCutCopy ) {
_wpi_setwrectvalues( &clipRect.rect, 0, 0, node->width, node->height );
width = node->width;
height = node->height;
} else {
width = _wpi_getwidthrect( clipRect.rect );
height = _wpi_getheightrect( clipRect.rect );
}
copyImageToClipboard( width, height, node );
if( !fEnableCutCopy ) {
PrintHintTextByID( WIE_ENTIREIMAGECOPIED, NULL );
} else {
PrintHintTextByID( WIE_AREACOPIED, NULL );
RedrawPrevClip( node->hwnd );
fEnableCutCopy = FALSE;
}
} /* IECopyImage */
/*
* CheckGridItem - Check the grid item and display the grid if necessary.
* First we check if an item has been created or not, if not
* we just check some flags so that when it is created, a
* grid will (not) be displayed.
*/
void CheckGridItem( HMENU hmenu )
{
WPI_ENUMPROC fp_enum;
HCURSOR prevcursor;
prevcursor = _wpi_setcursor( _wpi_getsyscursor(IDC_WAIT) );
if ( _wpi_isitemchecked(hmenu, IMGED_GRID) ) {
_wpi_checkmenuitem( hmenu, IMGED_GRID, MF_UNCHECKED, FALSE );
ImgedConfigInfo.grid_on = FALSE;
BlowupImage( NULL, NULL );
PrintHintTextByID( WIE_GRIDTURNEDOFF, NULL );
} else {
_wpi_checkmenuitem( hmenu, IMGED_GRID, MF_CHECKED, FALSE );
ImgedConfigInfo.grid_on = TRUE;
BlowupImage( NULL, NULL );
PrintHintTextByID( WIE_GRIDTURNEDON, NULL );
}
PressGridButton();
if( DoImagesExist() ) {
fp_enum = _wpi_makeenumprocinstance( GridEnumProc, Instance );
_wpi_enumchildwindows( ClientWindow, fp_enum, 0L );
_wpi_freeprocinstance( fp_enum );
}
_wpi_setcursor( prevcursor );
} /* CheckGridItem */
/*
* CutImage - cuts the current clipping rectangle to the clipboard
*/
void CutImage( void )
{
WPI_PRES pres;
WPI_PRES mempres;
HDC memdc;
HBITMAP oldbitmap;
short width;
short height;
img_node *node;
WPI_RECTDIM left;
WPI_RECTDIM right;
WPI_RECTDIM top;
WPI_RECTDIM bottom;
node = GetCurrentNode();
if( node == NULL ) {
return;
}
if( !fEnableCutCopy ) {
_wpi_setwrectvalues( &clipRect.rect, 0, 0, node->width, node->height );
width = node->width;
height = node->height;
} else {
width = (short)_wpi_getwidthrect( clipRect.rect );
height = (short)_wpi_getheightrect( clipRect.rect );
}
copyImageToClipboard( width, height, node );
pres = _wpi_getpres( node->viewhwnd );
mempres = _wpi_createcompatiblepres( pres, Instance, &memdc );
_wpi_releasepres( node->viewhwnd, pres );
oldbitmap = _wpi_selectbitmap( mempres, node->hxorbitmap );
_wpi_getrectvalues( clipRect.rect, &left, &top, &right, &bottom );
_wpi_patblt( mempres, left, top, width, height, WHITENESS );
_wpi_getoldbitmap( mempres, oldbitmap );
oldbitmap = _wpi_selectbitmap( mempres, node->handbitmap );
_wpi_patblt( mempres, left, top, width, height, BLACKNESS );
_wpi_getoldbitmap( mempres, oldbitmap );
_wpi_deletecompatiblepres( mempres, memdc );
InvalidateRect( node->viewhwnd, NULL, FALSE );
RecordImage( node->hwnd );
if( !fEnableCutCopy ) {
PrintHintTextByID( WIE_ENTIREIMAGECUT, NULL );
} else {
PrintHintTextByID( WIE_AREACUT, NULL );
fEnableCutCopy = FALSE;
}
BlowupImage( node->hwnd, NULL );
} /* CutImage */
/*
* CheckSquareGrid - checks the square grid item
*/
void CheckSquareGrid( HMENU hmenu )
{
if ( _wpi_isitemchecked(hmenu, IMGED_SQUARE) ) {
_wpi_checkmenuitem(hmenu, IMGED_SQUARE, MF_UNCHECKED, FALSE);
ImgedConfigInfo.square_grid = FALSE;
PrintHintTextByID( WIE_SQUAREGRIDOFF, NULL );
} else {
_wpi_checkmenuitem( hmenu, IMGED_SQUARE, MF_CHECKED, FALSE );
ImgedConfigInfo.square_grid = TRUE;
PrintHintTextByID( WIE_SQUAREGRIDON, NULL );
}
} /* CheckSquareGrid */
/*
* CloseCurrentImage - Gets the current image the user is editing and deletes
* the node from the linked list and sends a message to
* destroy the mdi child (this will activate another
* child then).
*/
void CloseCurrentImage( HWND hwnd )
{
img_node *node;
char file_name[ _MAX_PATH ];
BOOL ret;
node = SelectImage( hwnd );
if (!node) return;
ret = DestroyWindow( _wpi_getframe(node->viewhwnd) );
GetFnameFromPath( node->fname, file_name );
DeleteUndoStack( hwnd );
if ( !DeleteNode(hwnd) ) {
WImgEditError( WIE_ERR_BAD_HWND, WIE_INTERNAL_002 );
return;
}
DeleteActiveImage();
ClearImageText();
GrayEditOptions();
PrintHintTextByID( WIE_FILEHASBEENCLOSED, file_name );
SetWindowText( _wpi_getframe(HMainWindow), IEAppTitle );
#ifdef __OS2_PM__
ret = DestroyWindow( _wpi_getframe(hwnd) );
#else
SendMessage(ClientWindow, WM_MDIDESTROY, (WPARAM)hwnd, 0L);
#endif
} /* CloseCurrentImage */
/*
* ViewWindowProc - window procedure for the view window
*/
WPI_MRESULT CALLBACK ViewWindowProc( HWND hwnd, WPI_MSG msg,
WPI_PARAM1 wparam, WPI_PARAM2 lparam )
{
static HMENU sysmenu;
static HWND hframe;
HMENU hmenu;
WPI_RECT rcview;
WPI_RECTDIM left;
WPI_RECTDIM top;
WPI_RECTDIM right;
WPI_RECTDIM bottom;
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 );
break;
case WM_PAINT:
redrawViewWnd( hwnd );
return( 0 );
case WM_MOVE:
_wpi_getwindowrect( _wpi_getframe( hwnd ), &rcview );
_wpi_getrectvalues( rcview, &left, &top, &right, &bottom );
ImgedConfigInfo.view_xpos = (short)left;
ImgedConfigInfo.view_ypos = (short)top;
break;
case WM_CLOSE:
hmenu = GetMenu( _wpi_getframe( HMainWindow ) );
if( fOneViewWindow ) {
CheckViewItem( hmenu );
} else {
PrintHintTextByID( WIE_USEOPTIONSTOHIDEALL, NULL );
}
break;
case WM_DESTROY:
hViewWindow = NULL;
break;
default:
return( DefWindowProc( hwnd, msg, wparam, lparam ) );
}
return( 0 );
} /* ViewWindowProc */
/*
* CloseAllImages - used in the close all menu option
*/
void CloseAllImages( void )
{
img_node *head;
img_node *current;
WPI_PARAM1 p1;
HWND parent;
head = GetHeadNode();
if( !head ) {
PrintHintTextByID( WIE_NOIMAGESTOCLOSE, NULL );
return;
}
current = head;
while( current ) {
if( !(current->issaved) ) {
p1 = WPI_MAKEP1( current->hwnd, 0 );
parent = _wpi_getparent( current->hwnd );
#ifdef __OS2_PM__
_wpi_sendmessage(parent, WM_ACTIVATE, (WPI_PARAM1)p1, 0L);
#else
_wpi_sendmessage( parent, WM_MDIRESTORE, (WPI_PARAM1)p1, 0L );
_wpi_sendmessage(ClientWindow, WM_MDIACTIVATE, (WPI_PARAM1)p1, 0L);
#endif
if( !(lastChanceSave(current)) ) {
return;
}
}
current = current->next;
}
DeleteActiveImage();
while( head ) {
closeTheImage( head );
head = GetHeadNode();
}
ClearImageText();
GrayEditOptions();
PrintHintTextByID( WIE_ALLIMAGESCLOSED, NULL );
_wpi_setwindowtext( _wpi_getframe(HMainWindow), IEAppTitle );
} /* CloseAllImages */
/*
* 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 */
/*
* DontPaste - when escape is hit while dragging the image to paste
*/
void DontPaste( HWND hwnd, WPI_POINT *topleft, WPI_POINT pointsize )
{
firstTime = true;
DragClipBitmap( hwnd, topleft, pointsize );
_wpi_setcursor( prevCursor );
_wpi_destroycursor( pointCursor );
ReleaseCapture();
SetToolType( prevToolType );
PrintHintTextByID( WIE_PASTECANCELLED, NULL );
} /* DontPaste */
/*
* PlaceAndPaste - find out where the image is to be placed and then paste it there
*/
void PlaceAndPaste( void )
{
HBITMAP hbitmap;
WPI_POINT pointsize;
img_node *node;
WPI_POINT pt;
unsigned long format;
int bm_width;
int bm_height;
format = 0;
node = GetCurrentNode();
if( node == NULL ) {
return;
}
if( !_wpi_isclipboardformatavailable( Instance, CF_BITMAP, &format ) ) {
PrintHintTextByID( WIE_NOBITMAPINCLIPBOARD, NULL );
return;
}
pointsize = GetPointSize( node->hwnd );
if( fEnableCutCopy ) {
RedrawPrevClip( node->hwnd );
PasteImage( NULL, pointsize, node->hwnd );
fEnableCutCopy = FALSE;
return;
}
prevToolType = SetToolType( IMGED_PASTE );
pointCursor = _wpi_loadcursor( Instance, POINT_CUR );
prevCursor = _wpi_setcursor( pointCursor );
_wpi_openclipboard( Instance, HMainWindow );
hbitmap = _wpi_getclipboarddata( Instance, CF_BITMAP );
_wpi_getbitmapdim( hbitmap, &bm_width, &bm_height );
_wpi_closeclipboard( Instance );
dragWidth = (short)(bm_width * pointsize.x);
dragHeight = (short)(bm_height * pointsize.y);
WriteSetSizeText( WIE_CLIPBOARDBITMAPSIZE, bm_width, bm_height);
_wpi_getcursorpos( &pt );
_wpi_screentoclient( node->hwnd, &pt );
pt.x = pt.x / pointsize.x;
pt.y = pt.y / pointsize.y;
_wpi_setcapture( node->hwnd );
firstTime = true;
DragClipBitmap( node->hwnd, &pt, pointsize );
} /* PlaceAndPaste */
/*
* TransferImage - transfer the image in the outlined box to the view window
*/
void TransferImage( HWND hwnd )
{
POINT topleft_desk;
HDC hdc;
HDC memdc;
HBITMAP oldbitmap;
img_node *node;
#ifdef __NT__
SetDeskTopHook( NULL );
#endif
redrawPrevRegion();
GetCursorPos( &topleft_desk );
node = SelectImage( hwnd );
hdc = GetDC( NULL );
memdc = CreateCompatibleDC( hdc );
oldbitmap = SelectObject( memdc, node->handbitmap );
PatBlt( memdc, topLeft.x, topLeft.y, snapWidth, snapHeight, BLACKNESS );
SelectObject( memdc, node->hxorbitmap );
BitBlt( memdc, topLeft.x, topLeft.y, snapWidth, snapHeight, hdc,
topleft_desk.x, topleft_desk.y, SRCCOPY );
ReleaseDC( NULL, hdc );
SelectObject( memdc, oldbitmap );
DeleteDC( memdc );
ReleaseCapture();
ShowWindow( HMainWindow, previousState );
#ifdef __NT__
DestroyWindow( deskTopWindow );
#else
InvalidateRect( node->viewhwnd, NULL, FALSE );
#endif
RecordImage( hwnd );
SetToolType( prevToolType );
if( !DoKeepRect() ) {
SetRectExists( FALSE );
} else {
SetRectExists( rectExists );
}
#ifndef __NT__
BlowupImage( node->hwnd, NULL );
#endif
SetCursor( prevCursor );
PrintHintTextByID( WIE_BMPSNAPPEDFROMDSKTOP, NULL );
} /* TransferImage */
/*
* doReadCursor
*/
BOOL doReadCursor( char *fname, an_img_file *cursorfile, an_img *cursor,
WRInfo *info, WResLangNode *lnode )
{
img_node node;
HDC hdc;
char filename[_MAX_FNAME + _MAX_EXT];
if( cursorfile == NULL || cursor == NULL ) {
return( FALSE );
}
GetFnameFromPath( fname, filename );
node.imgtype = CURSOR_IMG;
node.width = cursor->bm->bmiHeader.biWidth;
node.height = cursor->bm->bmiHeader.biHeight;
if( node.height == 0 ) {
node.height = node.width;
}
node.bitcount = cursor->bm->bmiHeader.biBitCount;
node.hotspot.x = cursorfile->resources->xhotspot;
node.hotspot.y = cursorfile->resources->yhotspot;
node.issaved = TRUE;
node.num_of_images = 1;
node.next = NULL;
node.nexticon = NULL;
node.wrinfo = info;
node.lnode = lnode;
hdc = GetDC( NULL );
node.handbitmap = ImgToAndBitmap( hdc, cursor );
node.hxorbitmap = ImgToXorBitmap( hdc, cursor );
ReleaseDC( NULL, hdc );
strcpy( node.fname, strupr( fname ) );
ImageFini( cursor );
ImageClose( cursorfile );
PrintHintTextByID( WIE_OPENEDTEXT, filename );
MakeIcon( &node, FALSE ); // also makes cursors
CreateNewDrawPad( &node );
return( TRUE );
} /* doReadCursor */
/*
* LoadColorPalette - load a palette
*/
BOOL LoadColorPalette( void )
{
char fname[_MAX_PATH];
char filename[_MAX_FNAME + _MAX_EXT];
a_pal_file *pal_file;
FILE *fp;
WORD file_type;
if( !getOpenPalName( fname ) ) {
if( CommDlgExtendedError() == FNERR_INVALIDFILENAME ) {
WImgEditError( WIE_ERR_BAD_FILENAME, fname );
return( FALSE );
}
return( TRUE );
}
pal_file = MemAlloc( sizeof( a_pal_file ) );
fp = fopen( fname, "rb" );
if( fp == NULL ) {
WImgEditError( WIE_ERR_FILE_NOT_OPENED, fname );
return( FALSE );
}
GetFnameFromPath( fname, filename );
fseek( fp, 0L, SEEK_SET );
fread( &file_type, sizeof( WORD ), 1, fp );
if( file_type != PALETTE_FILE ) {
WImgEditError( WIE_ERR_BAD_PALFILE, filename );
fclose( fp );
return( FALSE );
}
fseek( fp, 0L, SEEK_SET );
fread( pal_file, sizeof( a_pal_file ), 1, fp );
fclose( fp );
SetNewPalette( pal_file );
PrintHintTextByID( WIE_PALETTELOADEDFROM, filename );
MemFree( pal_file );
return( TRUE );
} /* LoadColorPalette */
/*
* ChooseBkColor - choose the color to represent the background
*/
void ChooseBkColor( void )
{
WPI_DLGPROC dlgproc;
WPI_DLGRESULT button_type;
screenColor.color = GetViewBkColor();
dlgproc = _wpi_makedlgprocinstance( SelColorDlgProc, Instance );
button_type = _wpi_dialogbox( HMainWindow, dlgproc, Instance, SELBKCOLOR, 0L );
_wpi_freedlgprocinstance( dlgproc );
if( button_type == IDCANCEL ) {
return;
}
SetViewBkColor( screenColor.color );
SetScreenClr( screenColor.color );
PrintHintTextByID( WIE_NEWBKCOLORSELECTED, NULL );
} /* ChooseBkColor */
/*
* EditColors - edit the current color selection
*/
void EditColors( void )
{
static CHOOSECOLOR choosecolor;
BOOL setcolor = FALSE;
wie_clrtype type;
COLORREF current_color;
HMENU hmenu;
HWND parent;
if( ImgedConfigInfo.show_state & SET_SHOW_CLR ) {
parent = HColorPalette;
} else {
parent = HMainWindow;
}
current_color = GetSelectedColor( LMOUSEBUTTON, NULL, &type );
choosecolor.lStructSize = sizeof( CHOOSECOLOR );
choosecolor.hwndOwner = parent;
choosecolor.hInstance = NULL;
choosecolor.rgbResult = current_color;
choosecolor.lpCustColors = (LPDWORD)customcolors;
choosecolor.Flags = CC_RGBINIT | CC_FULLOPEN;
choosecolor.lCustData = 0l;
choosecolor.lpfnHook = 0;
choosecolor.lpTemplateName = (LPSTR)NULL;
setcolor = ChooseColor( &choosecolor );
if( !setcolor ) {
return;
}
ReplacePaletteEntry( choosecolor.rgbResult );
fRestEnabled = TRUE;
hmenu = GetMenu( HMainWindow );
EnableMenuItem( hmenu, IMGED_CRESET, MF_ENABLED );
PrintHintTextByID( WIE_COLORPALETTEMODIFIED, NULL );
} /* EditColors */
/*
* AbortSnap - abort the snapping of an image
*/
void AbortSnap( HWND hwnd )
{
img_node *node;
#ifdef __NT__
SetDeskTopHook( NULL );
#endif
node = SelectImage( hwnd );
ReleaseCapture();
ShowWindow( HMainWindow, previousState );
#ifdef __NT__
DestroyWindow( deskTopWindow );
#else
InvalidateRect( node->viewhwnd, NULL, FALSE );
#endif
SetToolType( prevToolType );
SetCursor( prevCursor );
PrintHintTextByID( WIE_BMPSNAPABORTED, NULL );
} /* AbortSnap */
/*
* FlipImage - flip the image along either the x-axis or the y-axis
*/
void FlipImage( WORD whichway )
{
img_node *node;
short width;
short height;
short destwidth;
short destheight;
short new_left;
short new_top;
WPI_RECT dims;
HBITMAP xorflip;
HBITMAP oldflip;
HBITMAP oldbitmap;
HBITMAP andflip;
WPI_PRES pres;
WPI_PRES mempres;
HDC memdc;
WPI_PRES flippres;
HDC flipdc;
HCURSOR prevcursor;
IMGED_DIM bottom;
IMGED_DIM left;
IMGED_DIM right;
IMGED_DIM top;
node = GetCurrentNode();
if( node == NULL ) {
return;
}
PrintHintTextByID( WIE_FLIPPINGIMAGE, NULL );
prevcursor = _wpi_setcursor( _wpi_getsyscursor( IDC_WAIT ) );
if( !DoesRectExist( &dims ) ) {
_wpi_setwrectvalues( &dims, 0, 0, (IMGED_DIM)node->width, (IMGED_DIM)node->height );
}
width = (short)_wpi_getwidthrect( dims );
height = (short)_wpi_getheightrect( dims );
pres = _wpi_getpres( HWND_DESKTOP );
if( node->bitcount == 1 ) {
xorflip = _wpi_createbitmap( width, height, 1, 1, NULL );
} else {
#if 1
xorflip = _wpi_createcompatiblebitmap( pres, width, height );
#else
xorflip = _wpi_createbitmap( width, height, ColorPlanes, BitsPerPixel, NULL );
#endif
}
andflip = _wpi_createbitmap( width, height, 1, 1, NULL );
mempres = _wpi_createcompatiblepres( pres, Instance, &memdc );
flippres = _wpi_createcompatiblepres( pres, Instance, &flipdc );
_wpi_releasepres( HWND_DESKTOP, pres );
_wpi_getrectvalues( dims, &left, &top, &right, &bottom );
_wpi_preparemono( flippres, BLACK, WHITE );
oldbitmap = _wpi_selectobject( mempres, node->hxorbitmap );
oldflip = _wpi_selectobject( flippres, xorflip );
_wpi_bitblt( flippres, 0, 0, width, height, mempres, left, top, SRCCOPY );
_wpi_selectobject( mempres, oldbitmap );
_wpi_selectobject( flippres, oldflip );
oldbitmap = _wpi_selectobject( mempres, node->handbitmap );
oldflip = _wpi_selectobject( flippres, andflip );
_wpi_bitblt( flippres, 0, 0, width, height, mempres, left, top, SRCCOPY );
if( whichway == IMGED_FLIPVERT ) {
destwidth = -1 * width;
new_left = right - 1;
new_top = top;
destheight = height;
} else {
destwidth = width;
new_left = left;
new_top = bottom - 1;
destheight = -1 * height;
}
_wpi_stretchblt( mempres, new_left, new_top, destwidth, destheight,
flippres, 0, 0, width, height, SRCCOPY );
_wpi_selectobject( mempres, oldbitmap );
oldbitmap = _wpi_selectobject( mempres, node->hxorbitmap );
_wpi_selectobject( flippres, oldflip );
oldflip = _wpi_selectobject( flippres, xorflip );
_wpi_stretchblt( mempres, new_left, new_top, destwidth, destheight,
flippres, 0, 0, width, height, SRCCOPY );
_wpi_selectobject( mempres, oldbitmap );
_wpi_selectobject( flippres, oldflip );
_wpi_deleteobject( xorflip );
_wpi_deleteobject( andflip );
_wpi_deletecompatiblepres( mempres, memdc );
_wpi_deletecompatiblepres( flippres, flipdc );
InvalidateRect( node->viewhwnd, NULL, TRUE );
if( !DoKeepRect() ) {
SetRectExists( FALSE );
}
RecordImage( node->hwnd );
BlowupImage( node->hwnd, NULL );
if( whichway == IMGED_FLIPHORZ ) {
PrintHintTextByID( WIE_IMAGEREFLECTEDH, NULL );
} else {
PrintHintTextByID( WIE_IMAGEREFLECTEDV, NULL );
}
_wpi_setcursor( prevcursor );
} /* FlipImage */
/*
* ChangeImageSize - changes the size of the current image being edited
*/
void ChangeImageSize( void )
{
img_node *node;
WPI_DLGPROC dlgproc;
WPI_DLGRESULT button_type;
img_node new_node;
WPI_PRES pres;
HDC srcdc;
WPI_PRES srcpres;
HDC destdc;
WPI_PRES destpres;
HBITMAP oldsrc;
HBITMAP olddest;
int retcode;
WPI_PARAM2 lparam;
WPI_RECT rc;
short new_width;
short new_height;
int y_src;
int y_dest;
char *title;
char *text;
node = GetCurrentNode();
if( node == NULL ) {
return;
}
if( node->imgtype != BITMAP_IMG ) {
return;
}
imgHeight = node->height;
imgWidth = node->width;
dlgproc = _wpi_makedlgprocinstance( ChangeSizeDlgProc, Instance );
button_type = _wpi_dialogbox( HMainWindow, dlgproc, Instance, IMAGESIZE, 0L );
_wpi_freedlgprocinstance( dlgproc );
if( button_type == DLGID_CANCEL ) {
return;
}
if( imgWidth == node->width && imgHeight == node->height ) {
PrintHintTextByID( WIE_IMAGESIZEUNCHANGED, NULL );
return;
}
title = IEAllocRCString( WIE_INFORMATIONTEXT );
text = IEAllocRCString( WIE_RESETUNDOSTACKWARNING );
retcode = _wpi_messagebox( HMainWindow, text, title, MB_YESNO | MB_ICONINFORMATION );
if( text != NULL ) {
IEFreeRCString( text );
}
if( title != NULL ) {
IEFreeRCString( title );
}
if( retcode == WPI_IDNO ) {
return;
}
new_node.width = (short)imgWidth;
new_node.height = (short)imgHeight;
new_node.bitcount = node->bitcount;
new_node.imgtype = BITMAP_IMG;
MakeBitmap( &new_node, TRUE );
pres = _wpi_getpres( HWND_DESKTOP );
srcpres = _wpi_createcompatiblepres( pres, Instance, &srcdc );
destpres = _wpi_createcompatiblepres( pres, Instance, &destdc );
_wpi_releasepres( HWND_DESKTOP, pres );
oldsrc = _wpi_selectbitmap( srcpres, node->hxorbitmap );
olddest = _wpi_selectbitmap( destpres, new_node.hxorbitmap );
if( stretchImage ) {
_wpi_stretchblt( destpres, 0, 0, imgWidth, imgHeight,
srcpres, 0, 0, node->width, node->height, SRCCOPY );
} else {
#ifdef __OS2_PM__
y_src = node->height - imgHeight;
if( y_src < 0 ) {
y_src = 0;
y_dest = imgHeight - node->height;
} else {
y_dest = 0;
}
#else
y_src = 0;
y_dest = 0;
#endif
_wpi_bitblt( destpres, 0, y_dest, node->width, node->height,
srcpres, 0, y_src, SRCCOPY );
}
_wpi_getoldbitmap( srcpres, oldsrc );
oldsrc = _wpi_selectbitmap( srcpres, node->handbitmap );
_wpi_getoldbitmap( destpres, olddest );
olddest = _wpi_selectbitmap( destpres, new_node.handbitmap );
if( stretchImage ) {
_wpi_stretchblt( destpres, 0, 0, imgWidth, imgHeight,
srcpres, 0, 0, node->width, node->height, SRCCOPY );
} else {
_wpi_bitblt( destpres, 0, 0, node->width, node->height, srcpres, 0, 0, SRCCOPY );
}
_wpi_getoldbitmap( srcpres, oldsrc );
_wpi_getoldbitmap( destpres, olddest );
_wpi_deletebitmap( node->hxorbitmap );
_wpi_deletebitmap( node->handbitmap );
_wpi_deletecompatiblepres( srcpres, srcdc );
_wpi_deletecompatiblepres( destpres, destdc );
node->hxorbitmap = new_node.hxorbitmap;
node->handbitmap = new_node.handbitmap;
node->width = (short)imgWidth;
node->height = (short)imgHeight;
SetIsSaved( node->hwnd, FALSE );
ResetUndoStack( node );
RePositionViewWnd( node );
_wpi_getclientrect( node->hwnd, &rc );
new_width = (short)_wpi_getwidthrect( rc );
new_height = (short)_wpi_getheightrect( rc );
lparam = WPI_MAKEP2( new_width, new_height );
ResizeChild( lparam, node->hwnd, false );
DisplayImageText( node );
WriteSetSizeText( WIE_NEWIMAGESIZE, imgWidth, imgHeight );
} /* ChangeImageSize */
/*
* PasteImage - paste the image in the clipboard at the current point
* - first check to see if the image was cut/copied from our program
* - if it was, then we use the hXorClipped and hAndClipped bitmaps
* we created in order to preserve the screen colors if ther were used
* - otherwise, just copy from the clipboard
*/
void PasteImage( WPI_POINT *pt, WPI_POINT pointsize, HWND hwnd )
{
HBITMAP hbitmap;
HBITMAP hbitmapdup;
HBITMAP holddup;
HBITMAP oldbitmap;
HBITMAP oldbitmap2;
WPI_PRES pres;
WPI_PRES mempres;
HDC memdc;
WPI_PRES clippres;
HDC clipdc;
WPI_RECT client;
WPI_POINT truept;
short width;
short height;
short clipwidth;
short clipheight;
img_node *node;
int fstretchbmp;
int bm_width, bm_height;
WPI_RECTDIM left;
WPI_RECTDIM right;
WPI_RECTDIM top;
WPI_RECTDIM bottom;
WPI_RECTDIM client_l;
WPI_RECTDIM client_r;
WPI_RECTDIM client_t;
WPI_RECTDIM client_b;
#ifdef __OS2_PM__
int src_y, dest_y;
#endif
if( fEnableCutCopy ) {
_wpi_getwrectvalues( clipRect.rect, &left, &top, &right, &bottom );
truept.x = left;
truept.y = top;
fstretchbmp = StretchPastedImage();
} else {
truept.x = pt->x / pointsize.x;
truept.y = pt->y / pointsize.y;
fstretchbmp = -1;
}
node = SelectImage( hwnd );
pres = _wpi_getpres( node->viewhwnd );
if( _wpi_getclipboardowner( Instance ) == HMainWindow && node->imgtype != BITMAP_IMG ) {
_wpi_getbitmapdim( hAndClipped, &bm_width, &bm_height );
GetClientRect( node->hwnd, &client );
if( fEnableCutCopy ) {
width = (short)_wpi_getwidthrect( clipRect.rect );
height = (short)_wpi_getheightrect( clipRect.rect );
} else {
_wpi_getrectvalues( client, &client_l, &client_t, &client_r, &client_b );
width = (short)( client_r / pointsize.x - truept.x );
if( width > (short)bm_width )
width = (short)bm_width;
height = (short)( client_b / pointsize.y - truept.y );
if( height > (short)bm_height ) {
height = (short)bm_height;
}
}
mempres = _wpi_createcompatiblepres( pres, Instance, &memdc );
_wpi_setstretchbltmode( mempres, COLORONCOLOR );
clippres = _wpi_createcompatiblepres( pres, Instance, &clipdc );
oldbitmap = _wpi_selectbitmap( mempres, node->handbitmap );
oldbitmap2 = _wpi_selectbitmap( clippres, hAndClipped );
if( fstretchbmp == FALSE ) {
clipwidth = (short)bm_width;
if( clipwidth > (short)width )
clipwidth = (short)width;
clipheight = (short)bm_height;
if( clipheight > (short)height )
clipheight = (short)height;
_wpi_patblt( mempres, truept.x, truept.y, width, height, BLACKNESS );
_wpi_bitblt( mempres, truept.x, truept.y, clipwidth, clipheight,
clippres, 0, 0, SRCCOPY );
} else if( fstretchbmp == TRUE ) {
_wpi_stretchblt( mempres, truept.x, truept.y, width, height,
clippres, 0, 0, bm_width, bm_height, SRCCOPY);
} else {
_wpi_bitblt( mempres, truept.x, truept.y, width, height, clippres,
0, 0, SRCCOPY );
}
_wpi_getoldbitmap( mempres, oldbitmap );
oldbitmap = _wpi_selectbitmap( mempres, node->hxorbitmap );
hbitmapdup = DuplicateBitmap( hXorClipped );
_wpi_getoldbitmap( clippres, oldbitmap2 );
oldbitmap2 = _wpi_selectbitmap( clippres, hbitmapdup );
if( fstretchbmp == FALSE ) {
clipwidth = (short)bm_width;
if( clipwidth > (short)width )
clipwidth = (short)width;
clipheight = (short)bm_height;
if( clipheight > (short)height )
clipheight = (short)height;
_wpi_patblt( mempres, truept.x, truept.y, width, height, WHITENESS );
#ifdef __OS2_PM__
if( bm_height > height ) {
src_y = bm_height - height;
dest_y = truept.y;
} else {
src_y = 0;
dest_y = truept.y + (height - bm_height);
}
_wpi_bitblt( mempres, truept.x, dest_y, clipwidth, clipheight,
clippres, 0, src_y, SRCCOPY );
#else
_wpi_bitblt( mempres, truept.x, truept.y, clipwidth, clipheight,
clippres, 0, 0, SRCCOPY );
#endif
} else if( fstretchbmp == TRUE ) {
_wpi_stretchblt( mempres, truept.x, truept.y, width, height,
clippres, 0, 0, bm_width, bm_height, SRCCOPY );
} else {
_wpi_bitblt( mempres, truept.x, truept.y, width, height, clippres,
0, 0, SRCCOPY );
}
_wpi_getoldbitmap( mempres, oldbitmap );
_wpi_getoldbitmap( clippres, oldbitmap2 );
_wpi_deletebitmap( hbitmapdup );
_wpi_deletecompatiblepres( mempres, memdc );
_wpi_deletecompatiblepres( clippres, clipdc );
} else {
if( node->imgtype != BITMAP_IMG ) {
CleanupClipboard();
}
_wpi_openclipboard( Instance, HMainWindow );
hbitmap = _wpi_getclipboarddata( Instance, CF_BITMAP );
hbitmapdup = DuplicateBitmap( hbitmap );
_wpi_closeclipboard( Instance );
_wpi_getbitmapdim( hbitmapdup, &bm_width, &bm_height );
GetClientRect( node->hwnd, &client );
if( fEnableCutCopy ) {
width = (short)_wpi_getwidthrect( clipRect.rect );
height = (short)_wpi_getheightrect( clipRect.rect );
} else {
_wpi_getrectvalues( client, &client_l, &client_t, &client_r, &client_b );
width = (short)( client_r / pointsize.x - truept.x );
if( width > (short)bm_width )
width = (short)bm_width;
height = (short)( client_b / pointsize.y - truept.y );
if( height > (short)bm_height ) {
height = (short)bm_height;
}
}
clippres = _wpi_createcompatiblepres( pres, Instance, &clipdc );
mempres = _wpi_createcompatiblepres( pres, Instance, &memdc );
_wpi_setstretchbltmode( mempres, COLORONCOLOR );
holddup = _wpi_selectbitmap( clippres, hbitmapdup );
oldbitmap = _wpi_selectbitmap( mempres, node->hxorbitmap );
if( fstretchbmp == FALSE ) {
clipwidth = (short)bm_width;
if( clipwidth > (short)width )
clipwidth = (short)width;
clipheight = (short)bm_height;
if( clipheight > (short)height )
clipheight = (short)height;
_wpi_patblt( mempres, truept.x, truept.y, width, height, WHITENESS );
#ifdef __OS2_PM__
if( bm_height > height ) {
src_y = bm_height - height;
dest_y = truept.y;
} else {
src_y = 0;
dest_y = truept.y + (height - bm_height);
}
_wpi_bitblt( mempres, truept.x, dest_y, clipwidth, clipheight,
clippres, 0, src_y, SRCCOPY );
#else
_wpi_bitblt( mempres, truept.x, truept.y, clipwidth, clipheight,
clippres, 0, 0, SRCCOPY );
#endif
} else if( fstretchbmp == TRUE ) {
_wpi_stretchblt( mempres, truept.x, truept.y, width, height,
clippres, 0, 0, bm_width, bm_height, SRCCOPY );
} else {
_wpi_bitblt( mempres, truept.x, truept.y, width, height, clippres,
0, 0, SRCCOPY );
}
_wpi_getoldbitmap( clippres, holddup );
_wpi_deletebitmap( hbitmapdup );
_wpi_deletecompatiblepres( clippres, clipdc );
_wpi_getoldbitmap( mempres, oldbitmap );
oldbitmap = _wpi_selectbitmap( mempres, node->handbitmap );
_wpi_patblt( mempres, truept.x, truept.y, width, height, BLACKNESS );
_wpi_getoldbitmap( mempres, oldbitmap );
_wpi_deletecompatiblepres( mempres, memdc );
}
ReleaseCapture();
_wpi_releasepres( node->viewhwnd, pres );
InvalidateRect( node->viewhwnd, NULL, TRUE );
if( !fEnableCutCopy ) {
_wpi_setcursor( prevCursor );
_wpi_destroycursor( pointCursor );
SetToolType( prevToolType );
}
fEnableCutCopy = FALSE;
RecordImage( hwnd );
BlowupImage( NULL, NULL );
PrintHintTextByID( WIE_BITMAPPASTED, NULL );
} /* PasteImage */
/*
* lastChanceSave - is called when the user quits and the current image
* is not yet saved. Returns FALSE if CANCEL
* is selected, otherwise, it returns TRUE.
*/
static BOOL lastChanceSave( img_node *node )
{
int retcode;
int how;
HMENU hmenu;
char *title;
char *text;
char *msg_text;
char filename[ _MAX_PATH ];
if( !node ) return( TRUE );
IECheckIfActiveWindow();
if( strnicmp( node->fname, IEImageUntitled, strlen( IEImageUntitled ) ) != 0 ) {
GetFnameFromPath( node->fname, filename );
how = SB_SAVE;
} else {
strcpy( filename, node->fname );
how = SB_SAVE_AS;
}
retcode = IDCANCEL;
title = IEAllocRCString( WIE_EXITTITLE );
if( ImgedIsDDE ) {
text = IEAllocRCString( WIE_QUERYIMAGEUPDATE );
} else {
text = IEAllocRCString( WIE_QUERYIMAGESAVE );
}
if( text ) {
msg_text = (char *)MemAlloc( strlen( text ) + strlen( filename ) + 1 );
if( msg_text ) {
sprintf( msg_text, text, filename );
retcode = _wpi_messagebox( HMainWindow, msg_text, title,
MB_YESNOCANCEL | MB_ICONQUESTION );
MemFree( msg_text );
}
IEFreeRCString( text );
}
if( title ) {
IEFreeRCString( title );
}
if (retcode == IDYES) {
if( ImgedIsDDE ) {
#ifndef __OS2_PM__
if( IEUpdateDDEEditSession() ) {
SetIsSaved( node->hwnd, TRUE );
} else {
PrintHintTextByID( WIE_FILENOTSAVED, NULL );
return( FALSE );
}
#else
PrintHintTextByID( WIE_FILENOTSAVED, NULL );
return( FALSE );
#endif
} else {
if (!SaveFile( how )) {
PrintHintTextByID( WIE_FILENOTSAVED, NULL );
return( FALSE );
} else {
hmenu = _wpi_getmenu( HMainWindow );
_wpi_enablemenuitem( hmenu, IMGED_SAVE, FALSE, FALSE );
SetIsSaved( node->hwnd, TRUE );
}
}
} else if (retcode == IDCANCEL) {
return (FALSE);
}
return (TRUE);
} /* lastChanceSave */
/*
* RestoreColors - restore the original color palette
*/
void RestoreColors( void )
{
ResetColorPalette();
PrintHintTextByID( WIE_COLORPALETTERESTORED, NULL );
} /* RestoreColors */
/*
* ImgEdFrameProc - handle messages for the image editor application
*/
WPI_MRESULT CALLBACK ImgEdFrameProc( HWND hwnd, WPI_MSG msg,
WPI_PARAM1 wparam, WPI_PARAM2 lparam )
{
static BOOL window_destroyed = FALSE;
static HMENU hmenu;
ctl_id cmdid;
img_node *node;
WPI_RECT rcmain;
#ifndef __OS2_PM__
about_info ai;
#endif
WPI_RECTDIM left, top;
if( !window_destroyed ) {
enableMainItems( hmenu );
}
switch( msg ) {
case UM_EXIT:
_wpi_sendmessage( hwnd, WM_COMMAND, IMGED_CLOSEALL, 0L );
/* fall through */
case UM_EXIT_NO_SAVE:
if( _wpi_getfirstchild( _wpi_getclient( ClientWindow ) ) != NULL ) {
break;
}
#ifndef __OS2_PM__
_wpi_destroywindow( _wpi_getframe( hwnd ) );
#else
_wpi_sendmessage( hwnd, WM_CLOSE, 0, 0 );
#endif
break;
case UM_SAVE_ALL:
SaveAllImages();
break;
case WM_CREATE:
hmenu = _wpi_getmenu( _wpi_getframe( hwnd ) );
#ifndef __OS2_PM__
createClientWindow( hwnd );
#endif
if( !InitStatusLine( hwnd ) ) {
return( -1 );
}
InitFunctionBar( hwnd );
InitIconInfo();
InitializeCursors();
/*
* Set values from profile information ...
*/
if( ImgedConfigInfo.brush_size <= 5 && ImgedConfigInfo.brush_size >= 2 ) {
checkBrushItem( hmenu, IMGED_2x2 - 2 + ImgedConfigInfo.brush_size );
}
if( ImgedConfigInfo.grid_on ) {
CheckGridItem( hmenu );
}
if( ImgedConfigInfo.square_grid ) {
CheckSquareGrid( hmenu );
}
if( ImgedConfigInfo.show_state & SET_SHOW_VIEW ) {
CheckViewItem( hmenu );
}
_wpi_enablemenuitem( hmenu, IMGED_CRESET, FALSE, FALSE );
_wpi_enablemenuitem( hmenu, IMGED_RCOLOR, FALSE, FALSE );
#ifndef __OS2_PM__
// not necessary for PM
InitMenus( hmenu );
#endif
SetHintText( IEAppTitle );
return( 0 );
#ifdef __NT__
case WM_DROPFILES:
OpenImage( (HANDLE)wparam );
break;
#endif
case WM_MOVE:
_wpi_getwindowrect( hwnd, &rcmain );
if( !ImgedConfigInfo.ismaximized ) {
ImgedConfigInfo.last_xpos = ImgedConfigInfo.x_pos;
ImgedConfigInfo.last_ypos = ImgedConfigInfo.y_pos;
_wpi_getrectvalues( rcmain, &left, &top, NULL, NULL );
ImgedConfigInfo.x_pos = (short)left;
ImgedConfigInfo.y_pos = (short)top;
}
return( 0 );
case WM_SIZE:
ResizeFunctionBar( lparam );
ResizeStatusBar( lparam );
#ifndef __OS2_PM__
if( ClientWindow != NULL ) {
setClientSize( hwnd );
}
#else
resizeClientArea( lparam );
#endif
if( !_imgwpi_issizeminimized( wparam ) && !_imgwpi_issizemaximized( wparam ) ) {
_wpi_getwindowrect( hwnd, &rcmain );
ImgedConfigInfo.width = (short)_wpi_getwidthrect( rcmain );
ImgedConfigInfo.height = (short)_wpi_getheightrect( rcmain );
ImgedConfigInfo.ismaximized = FALSE;
} else {
ImgedConfigInfo.x_pos = ImgedConfigInfo.last_xpos;
ImgedConfigInfo.y_pos = ImgedConfigInfo.last_ypos;
ImgedConfigInfo.ismaximized = _imgwpi_issizemaximized( wparam );
}
return( FALSE );
case WM_MENUSELECT:
#ifndef __OS2_PM__
if( GET_WM_MENUSELECT_FLAGS( wparam, lparam ) & MF_SEPARATOR ) {
break;
}
if( GET_WM_MENUSELECT_FLAGS( wparam, lparam ) & MF_SYSMENU ) {
PrintHintTextByID( WIE_SYSMENUOPERATIONS, NULL );
break;
}
#endif
ShowHintText( LOWORD( wparam ) );
break;
case WM_COMMAND:
cmdid = LOWORD( wparam );
if( !IEIsMenuIDValid( hmenu, cmdid ) ) {
break;
}
switch( cmdid ) {
case IMGED_NEW:
if( !ImgedIsDDE ) {
if( !NewImage( UNDEF_IMG, NULL ) ) {
PrintHintTextByID( WIE_NEIMAGENOTCREATED, NULL );
}
}
break;
case IMGED_CLOSE:
node = GetCurrentNode();
if( node != NULL ) {
_wpi_sendmessage( node->hwnd, WM_CLOSE, 0, 0L );
}
break;
case IMGED_CLOSEALL:
CloseAllImages();
break;
case IMGED_HELP:
IEHelpRoutine();
break;
case IMGED_HELP_SEARCH:
IEHelpSearchRoutine();
break;
case IMGED_HELP_ON_HELP:
IEHelpOnHelpRoutine();
break;
case IMGED_ABOUT:
#ifndef __OS2_PM__
ai.owner = hwnd;
ai.inst = Instance;
ai.name = IEAllocRCString( WIE_ABOUTTEXT );
ai.version = IEAllocRCString( WIE_ABOUTVERSION );
ai.title = IEAllocRCString( WIE_ABOUTTITLE );
DoAbout( &ai );
if( ai.name != NULL ) {
IEFreeRCString( ai.name );
}
if( ai.version != NULL ) {
IEFreeRCString( ai.version );
}
if( ai.title != NULL ) {
IEFreeRCString( ai.title );
}
#endif
break;
#ifndef __OS2_PM__
case IMGED_DDE_UPDATE_PRJ:
IEUpdateDDEEditSession();
break;
#endif
case IMGED_SAVE_AS:
SaveFile( SB_SAVE_AS );
break;
case IMGED_SAVE:
SaveFile( SB_SAVE );
break;
case IMGED_OPEN:
if( !ImgedIsDDE ) {
OpenImage( NULL );
}
break;
case IMGED_CLEAR:
ClearImage();
break;
case IMGED_NEWIMG:
AddNewIcon();
break;
case IMGED_SELIMG:
SelectIconImg();
break;
case IMGED_DELIMG:
DeleteIconImg();
break;
case IMGED_UNDO:
UndoOp();
break;
case IMGED_REDO:
RedoOp();
break;
case IMGED_REST:
RestoreImage();
break;
case IMGED_SNAP:
#ifndef __OS2_PM__
SnapPicture();
#endif
break;
case IMGED_RIGHT:
case IMGED_LEFT:
case IMGED_UP:
case IMGED_DOWN:
ShiftImage( cmdid );
break;
case IMGED_FLIPHORZ:
case IMGED_FLIPVERT:
FlipImage( cmdid );
break;
case IMGED_ROTATECC:
case IMGED_ROTATECL:
RotateImage( cmdid );
break;
case IMGED_PASTE:
PlaceAndPaste();
break;
case IMGED_COPY:
IECopyImage();
break;
case IMGED_CUT:
CutImage();
break;
case IMGED_COLOR:
CheckPaletteItem( hmenu );
break;
case IMGED_VIEW:
CheckViewItem( hmenu );
break;
case IMGED_TOOLBAR:
CheckToolbarItem( hmenu );
break;
case IMGED_SQUARE:
CheckSquareGrid( hmenu );
break;
case IMGED_SIZE:
ChangeImageSize();
break;
case IMGED_GRID:
CheckGridItem( hmenu );
break;
case IMGED_MAXIMIZE:
MaximizeCurrentChild();
break;
case IMGED_SETTINGS:
SelectOptions();
break;
case IMGED_2x2:
case IMGED_3x3:
case IMGED_4x4:
case IMGED_5x5:
checkBrushItem( hmenu, cmdid );
break;
case IMGED_CEDIT:
#ifndef __OS2_PM__
EditColors();
#endif
break;
case IMGED_CRESET:
#ifndef __OS2_PM__
RestoreColors();
#endif
break;
case IMGED_CSCREEN:
ChooseBkColor();
break;
case IMGED_SCOLOR:
#ifndef __OS2_PM__
SaveColorPalette();
#endif
break;
case IMGED_LCOLOR:
#ifndef __OS2_PM__
if( LoadColorPalette() ) {
_wpi_enablemenuitem( hmenu, IMGED_RCOLOR, TRUE, FALSE );
}
#endif
break;
case IMGED_RCOLOR:
RestoreColorPalette();
break;
case IMGED_FREEHAND:
case IMGED_LINE:
case IMGED_RECTO:
case IMGED_RECTF:
case IMGED_CIRCLEO:
case IMGED_CIRCLEF:
case IMGED_FILL:
case IMGED_BRUSH:
case IMGED_CLIP:
case IMGED_HOTSPOT:
SetToolType( cmdid );
PushToolButton( cmdid );
break;
case IMGED_ARRANGE:
#ifndef __OS2_PM__
SendMessage( ClientWindow, WM_MDIICONARRANGE, 0, 0L );
#endif
break;
case IMGED_TILE:
#ifndef __OS2_PM__
SendMessage( ClientWindow, WM_MDITILE, MDITILE_VERTICAL, 0L );
#endif
break;
case IMGED_CASCADE:
#ifndef __OS2_PM__
SendMessage( ClientWindow, WM_MDICASCADE, MDITILE_SKIPDISABLED, 0L );
#endif
break;
case IMGED_EXIT:
_wpi_sendmessage( hwnd, WM_COMMAND, IMGED_CLOSEALL, 0L );
if( _wpi_getfirstchild( _wpi_getclient( ClientWindow ) ) != NULL ) {
break;
}
#ifndef __OS2_PM__
_wpi_destroywindow( _wpi_getframe( hwnd ) );
#else
_wpi_sendmessage( hwnd, WM_CLOSE, 0, 0 );
#endif
break;
default:
#if 1
return( _imgwpi_defframeproc( hwnd, ClientWindow, msg, wparam, lparam ) );
#else
return( 0 );
#endif
}
return( 0 );
#ifndef __OS2_PM__
case WM_COMPACTING:
RelieveUndos();
return 0;
#endif
case WM_QUERYENDSESSION:
if( _wpi_isiconic( _wpi_getframe( hwnd ) ) ) {
if( ImgedConfigInfo.ismaximized ) {
_wpi_maximizewindow( _wpi_getframe( hwnd ) );
} else {
_wpi_showwindow( _wpi_getframe( hwnd ), SW_SHOWNORMAL );
}
}
_wpi_sendmessage( hwnd, WM_COMMAND, IMGED_CLOSEALL, 0L );
if( _wpi_getfirstchild( _wpi_getclient( ClientWindow ) ) != NULL ) {
return( 0 );
}
return( (WPI_MRESULT)1 );
case WM_CLOSE:
// wParam is non-zero if the DDE connection died
if( !wparam && !ImgEdEnableMenuInput ) {
// this prevents the user from closing the editor during
// DDE initialization
return( 0 );
}
_wpi_sendmessage( hwnd, WM_COMMAND, IMGED_CLOSEALL, 0L );
#ifdef __OS2_PM__
return( _wpi_defwindowproc( hwnd, msg, wparam, lparam ) );
#else
if( _wpi_getfirstchild( _wpi_getclient( ClientWindow ) ) != NULL ) {
return( 0 );
}
window_destroyed = TRUE;
_wpi_destroywindow( _wpi_getframe( hwnd ) );
return( 0 );
#endif
case WM_DESTROY:
#ifndef __OS2_PM__
WWinHelp( HMainWindow, "resimg.hlp", HELP_QUIT, 0 );
#endif
FiniStatusLine();
CleanupClipboard();
CleanupCursors();
CloseToolBar();
CloseFunctionBar();
_wpi_deletefont( SmallFont );
_wpi_postquitmessage( 0 );
return( 0 );
default:
break;
}
return( _imgwpi_defframeproc( hwnd, ClientWindow, msg, wparam, lparam ) );
} /* ImgEdFrameProc */
/*
* doReadInBitmapFile
*/
static BOOL doReadInBitmapFile( HBITMAP hbitmap, bitmap_info *bmi, char *fullname,
WRInfo *info, WResLangNode *lnode )
{
HBITMAP oldbmp1;
HBITMAP oldbmp2;
img_node node;
char filename[_MAX_FNAME + _MAX_EXT];
BITMAPINFOHEADER *h;
HDC hdc;
HDC srcdc;
HDC destdc;
GetFnameFromPath( fullname, filename );
if( hbitmap != NULL ) {
h = &bmi->u.bm_info->bmiHeader;
if( h->biWidth > MAX_DIM || h->biHeight > MAX_DIM ) {
WImgEditError( WIE_ERR_BITMAP_TOO_BIG, filename );
MemFree( bmi->u.bm_info );
DeleteObject( hbitmap );
return( FALSE );
}
#if 0
/* Should not be an error... */
else if( h->biBitCount > 8 ) {
WImgEditError( WIE_ERR_TOO_MANY_COLOURS, filename );
MemFree( bmi->u.bm_info );
DeleteObject( hbitmap );
return( FALSE );
}
#endif
node.imgtype = BITMAP_IMG;
node.width = bmi->u.bm_info->bmiHeader.biWidth;
node.height = bmi->u.bm_info->bmiHeader.biHeight;
node.bitcount = bmi->u.bm_info->bmiHeader.biBitCount;
node.hotspot.x = 0;
node.hotspot.y = 0;
node.num_of_images = 1;
node.nexticon = NULL;
node.issaved = TRUE;
if( node.bitcount == 1 ) {
hdc = GetDC( NULL );
srcdc = CreateCompatibleDC( hdc );
destdc = CreateCompatibleDC( hdc );
ReleaseDC( NULL, hdc );
node.hxorbitmap = CreateCompatibleBitmap( destdc, node.width, node.height );
oldbmp1 = SelectObject( srcdc, hbitmap );
oldbmp2 = SelectObject( destdc, node.hxorbitmap );
BitBlt( destdc, 0, 0, node.width, node.height, srcdc, 0, 0, SRCCOPY );
SelectObject( srcdc, oldbmp1 );
SelectObject( destdc, oldbmp2 );
DeleteDC( srcdc );
DeleteDC( destdc );
DeleteObject( hbitmap );
} else {
node.hxorbitmap = hbitmap;
}
strcpy( node.fname, fullname );
PrintHintTextByID( WIE_OPENEDTEXT, filename );
node.wrinfo = info;
node.lnode = lnode;
MakeBitmap( &node, FALSE );
CreateNewDrawPad( &node );
MemFree( bmi->u.bm_info );
return( TRUE );
}
return( FALSE );
} /* doReadInBitmapFile */
/*
* RestoreColorPalette - restore the color palette to the hard-coded colors
* in the initialization routine
*/
void RestoreColorPalette( void )
{
int i;
COLORREF leftcolor;
COLORREF rightcolor;
COLORREF color;
WPI_PRES pres;
int leftindex;
int rightindex;
wie_clrtype lefttype;
wie_clrtype righttype;
HMENU hmenu;
HWND frame;
if( currentPalIndex != COLOR_16 && currentPalIndex != COLOR_256 ) {
return;
}
leftcolor = GetSelectedColor( LMOUSEBUTTON, NULL, &lefttype );
rightcolor = GetSelectedColor( RMOUSEBUTTON, NULL, &righttype );
leftindex = getColorIndex( leftcolor );
rightindex = getColorIndex( rightcolor );
InitPalette();
for( i = 0; i < PALETTE_SIZE - 1; i++ ) {
ShowNewColor( i, RGB( palette[currentPalIndex][i].rgbRed,
palette[currentPalIndex][i].rgbGreen,
palette[currentPalIndex][i].rgbBlue ), FALSE );
}
/*
* We do the last one separately to invalidate the window.
*/
ShowNewColor( i, RGB( palette[currentPalIndex][i].rgbRed,
palette[currentPalIndex][i].rgbGreen,
palette[currentPalIndex][i].rgbBlue ), TRUE );
if( lefttype == NORMAL_CLR ) {
color = RGB( palette[currentPalIndex][leftindex].rgbRed,
palette[currentPalIndex][leftindex].rgbGreen,
palette[currentPalIndex][leftindex].rgbBlue );
pres = _wpi_getpres( HWND_DESKTOP );
_wpi_torgbmode( pres );
SetColor( LMOUSEBUTTON, color, _wpi_getnearestcolor( pres, color ), NORMAL_CLR );
_wpi_releasepres( HWND_DESKTOP, pres );
}
if( righttype == NORMAL_CLR ) {
color = RGB( palette[currentPalIndex][rightindex].rgbRed,
palette[currentPalIndex][rightindex].rgbGreen,
palette[currentPalIndex][rightindex].rgbBlue );
pres = _wpi_getpres( HWND_DESKTOP );
_wpi_torgbmode( pres );
SetColor( RMOUSEBUTTON, color, _wpi_getnearestcolor( pres, color ), NORMAL_CLR );
_wpi_releasepres( HWND_DESKTOP, pres );
}
PrintHintTextByID( WIE_PALETTERESTORED, NULL );
if( HMainWindow != NULL ) {
frame = _wpi_getframe( _wpi_getframe( HMainWindow ) );
hmenu = GetMenu( frame );
_wpi_enablemenuitem( hmenu, IMGED_RCOLOR, FALSE, FALSE );
}
} /* RestoreColorPalette */
/*
* RotateImage - rotate the image either clockwise or counterclockwise
*/
void RotateImage( WORD whichway )
{
img_node *node;
HBITMAP rotxorbmp;
HBITMAP rotandbmp;
HCURSOR prevcursor;
int rotate_type;
WPI_RECT rotate_rect;
BOOL rectexists;
short new_width;
short new_height;
WPI_PRES pres;
node = GetCurrentNode();
if( node == NULL ) {
return;
}
prevcursor = _wpi_setcursor( _wpi_getsyscursor( IDC_WAIT ) );
PrintHintTextByID( WIE_ROTATINGIMAGE, NULL );
if( DoesRectExist( &rotate_rect ) ) {
rectexists = TRUE;
new_width = (short)_wpi_getheightrect( rotate_rect );
new_height = (short)_wpi_getwidthrect( rotate_rect );
} else {
rectexists = FALSE;
_wpi_setwrectvalues( &rotate_rect, 0, 0,
(IMGED_DIM)node->width, (IMGED_DIM)node->height );
new_width = node->height;
new_height = node->width;
}
if( node->bitcount == 1 ) {
rotxorbmp = _wpi_createbitmap( new_width, new_height, 1, 1, NULL );
} else {
#if 1
pres = _wpi_getpres( HWND_DESKTOP );
rotxorbmp = _wpi_createcompatiblebitmap( pres, new_width, new_height );
_wpi_releasepres( HWND_DESKTOP, pres );
#else
rotxorbmp = _wpi_createbitmap( new_width, new_height, ColorPlanes,
BitsPerPixel, NULL );
#endif
}
rotandbmp = _wpi_createbitmap( new_width, new_height, 1, 1, NULL );
rotateTheImage( node, whichway, &rotate_rect, rotxorbmp, rotandbmp );
rotate_type = GetRotateType();
if( rotate_type == SIMPLE_ROTATE ) {
simpleRotate( node, &rotate_rect, rotxorbmp, rotandbmp, rectexists );
} else if( rotate_type == CLIP_ROTATE ) {
clipIntoArea( node, &rotate_rect, rotxorbmp, rotandbmp );
} else {
stretchIntoArea( node, &rotate_rect, rotxorbmp, rotandbmp );
}
_wpi_deleteobject( rotxorbmp );
_wpi_deleteobject( rotandbmp );
if( whichway == IMGED_ROTATECC ) {
PrintHintTextByID( WIE_IMAGEROTATEDCCW, NULL );
} else {
PrintHintTextByID( WIE_IMAGEROTATEDCW, NULL );
}
_wpi_setcursor( prevcursor );
} /* RotateImage */
/*
* lastChanceSave - called when the user quits and the current image
* is not yet saved
* - return FALSE if CANCEL is selected
* - otherwise, it return TRUE
*/
static BOOL lastChanceSave( HWND hwnd )
{
int retcode;
int how;
HMENU hmenu;
img_node *node;
img_node *icon;
char *title;
char *text;
char *msg_text;
char filename[_MAX_PATH];
if( !DoImagesExist() ) {
return( TRUE );
}
node = SelectImage( hwnd );
if( node == NULL ) {
return( TRUE );
}
icon = GetImageNode( hwnd );
while( icon != NULL ) {
if( icon->issaved ) {
return( TRUE );
}
icon = icon->nexticon;
}
if( strnicmp( node->fname, IEImageUntitled, strlen( IEImageUntitled ) ) != 0 ) {
GetFnameFromPath( node->fname, filename );
how = SB_SAVE;
} else {
strcpy( filename, node->fname );
how = SB_SAVE_AS;
}
retcode = WPI_IDCANCEL;
title = IEAllocRCString( WIE_CLOSETITLE );
text = IEAllocRCString( WIE_QUERYIMAGESAVE );
if( text != NULL ) {
msg_text = (char *)MemAlloc( strlen( text ) + strlen( filename ) + 1 );
if( msg_text != NULL ) {
sprintf( msg_text, text, filename );
retcode = _wpi_messagebox( HMainWindow, msg_text, title,
MB_YESNOCANCEL | MB_ICONQUESTION );
MemFree( msg_text );
}
IEFreeRCString( text );
}
if( title != NULL ) {
IEFreeRCString( title );
}
if( retcode == WPI_IDYES ) {
if( !SaveFile( how ) ) {
PrintHintTextByID( WIE_FILENOTSAVED, NULL );
return( FALSE );
} else {
hmenu = _wpi_getmenu( _wpi_getframe( HMainWindow ) );
_wpi_enablemenuitem( hmenu, IMGED_SAVE, FALSE, FALSE );
SetIsSaved( hwnd, TRUE );
}
} else if( retcode == WPI_IDCANCEL ) {
return( FALSE );
}
return( TRUE );
} /* lastChanceSave */