/*[]=====================================================================[]*/ /*[] LeadTools Run Time Library - Version 14 []*/ /*[] []*/ /*[] []*/ /*[] Copyright (c)1991-2004 LEAD Technologies, Inc. []*/ /*[] All Rights Reserved. []*/ /*[]=====================================================================[]*/ #include "ImgPF.h" /*--------------------Handle Message function decleration ---------------------*/ static L_BOOL Child_OnCreate (HWND hWnd, CREATESTRUCT FAR * lpCreateStruct); static L_VOID Child_OnPaint (HWND hWnd); static L_VOID Child_OnCommand (HWND hWnd, L_INT nID, HWND hWndCtl, L_UINT uCodeNotify); L_VOID Child_OnSize (HWND hWnd, L_UINT nState, L_INT nCx, L_INT nCy); static L_VOID Child_OnMDIActivate (HWND hWnd, L_BOOL fActive, HWND hWndActivate, HWND hWndDeactivate); static L_VOID Child_OnClose (HWND hWnd); static L_VOID Child_OnDestroy (HWND hWnd); static L_VOID Child_OnHScroll (HWND hWnd, HWND hWndCtl, L_UINT nCode, L_INT nPos); static L_VOID Child_OnVScroll (HWND hWnd, HWND hWndCtl, L_UINT nCode, L_INT nPos); static L_BOOL Child_OnEraseBkgnd (HWND hWnd, HDC hDC); static L_VOID Child_OnPaletteChanged (HWND hWnd, HWND hWndPaletteChange); static L_BOOL Child_OnQueryNewPalette (HWND hWnd); static L_VOID Child_OnTimer (HWND hWnd, L_UINT nID); static L_VOID Child_OnLButtonDown (HWND hWnd, L_BOOL bDoubleClick, L_INT nX, L_INT nY, L_UINT uKeyFlags); static L_VOID Child_OnMouseMove (HWND hWnd, L_INT nX, L_INT nY, L_UINT uKeyFlags); static L_VOID Child_OnRButtonup (HWND hWnd, L_INT nX, L_INT nY, L_UINT uKeyFlags); static L_VOID Child_OnLButtonUp (HWND hWnd, L_INT nX, L_INT nY, L_UINT uKeyFlags); static L_VOID Child_OnSetFocus (HWND hWnd, HWND hWndOldFocus); static L_VOID Child_OnKillFocus (HWND hWnd, HWND hWndNewFocus); static L_VOID Child_OnKey (HWND hWnd, L_UINT vk, L_BOOL bDown, L_INT nRepeat, L_UINT uFlags); /*-----------------------functions decleration---------------------------------*/ L_INT L_FAR L_EXPORT StatusBarProgressCallBack (L_INT nPercent, L_VOID L_FAR * pUserData); L_INT PasteBitmapRgn (HWND hWnd); L_INT SaveBitmapFile (HWND hWnd); L_INT CancelRgn (HWND hWnd, L_BOOL bAddUndoBitmap); L_VOID OutlineBitmapRgn (HWND hWnd, HDC hdc); L_INT L_FAR L_EXPORT BrowseBitmapsCB (pBITMAPHANDLE pBitmap, L_TCHAR L_FAR *pszFile, pFILEINFO pInfo, L_INT nStatusCode, L_INT nPercent, L_VOID L_FAR *pUserData); L_VOID SetStatusBarText (LPTSTR pTitle, pBITMAPHANDLE pBitmap, LPTSTR szPos, LPTSTR szColor); L_INT OpenBitmapChild (LPSTR szFileName); L_VOID TransToStatusBar (pBITMAPHANDLE pTempBitmap, pBITMAPHANDLE pLeadBitmap); L_VOID TransBack (pBITMAPHANDLE pTempBitmap, pBITMAPHANDLE pLeadBitmap, L_INT nRet); L_VOID SetStatusColorAndPixel (HWND hWnd); L_INT SafeCopyBitmapRect (pBITMAPHANDLE pBitmapDst, pBITMAPHANDLE pBitmapSrc, L_INT L_FAR * nXSrc, L_INT L_FAR * nYSrc, L_INT L_FAR * nWidth, L_INT L_FAR * nHeight); L_INT GetProcPixel (pBITMAPHANDLE pBitmap); L_VOID CleanOpenDlgParam (LPOPENDLGPARAMS pFOParam); L_VOID UpdatePlanes (HWND hWnd); L_VOID L_PlaneUndoList_AddBitmap (HWND hWnd); L_VOID L_PlaneUndoList_Undo (HWND hWnd); L_VOID L_PlaneUndoList_Redo (HWND hWnd); /*--------global variable -----*/ #define IMAGES_COUNT 30 #define MAX_CHILDS_COUNT 30 static L_INT nBitmapsCount; COLORREF crColor; L_BOOL bInScroll = FALSE; BOOL bStartLineHistogram; POINT StartPoint, EndPoint; static L_INT nCount = 0; static LPPOINT pptRegion; static L_INT nNextPt; #define MAXPOINTS 0x4000 /* maximum number of points allowed in freehand */ static ADDFRAMEDLGPARAMS AddframeParams; static ADDBORDERDLGPARAMS AddborderParams; static BALANCECOLORSDLGPARAMS BalanceColorsParams; static COLOREDGRAYDLGPARAMS ColoredGrayParams; static GRAYSCALEDLGPARAMS GrayScaleParams; static HALFTONEDLGPARAMS HalgToneParams; static PICTURIZEDLGPARAMS PicturizeParams; static UNSHARPMASKDLGPARAMS UnsharpMaskParams; static ANTIALIASDLGPARAMS AntiAliasParams; static MINFILTERDLGPARAMS MinFilterParams; static MAXFILTERDLGPARAMS MaxFilterParams; static MEDIANDLGPARAMS MedianParams; static EDGEDETECTORDLGPARAMS EdgeDetectorParams; static MOTIONBLURDLGPARAMS MotionBlurParams; static GAUSSIANBLURDLGPARAMS GaussianBlurParams; static REMAPINTENSITYDLGPARAMS RemapIntensityParams; static HISTOGRAMDLGPARAMS HistogramParams; static MULTIPLYDLGPARAMS MultiplyParams; static REMAPHUEDLGPARAMS RemapHueParams; static LPFTDATA pFFTData; static LPFTDATA pDFTData; /*-----------------------------*/ /*====(ChildWindowProc)==================================================== Description: Processes child window messages. Syntax : LRESULT CALLBACK L_EXPORT ChildWindowProc(HWND hWnd, L_UINT Msg, WPARAM wParam, LPARAM lParam) Prototype : demo.h Parameters : hWnd Handle of a window. Msg Message to be processed. wParam First uMessage parameter. lParam Second uMessage parameter. Return Value: Depends on the uMessage. ==========================================================================*/ LRESULT CALLBACK ChildWndProc (HWND hWnd, L_UINT uMessage, WPARAM wParam, LPARAM lParam) { switch(uMessage) { HANDLE_MSG (hWnd, WM_CREATE, Child_OnCreate); HANDLE_MSG (hWnd, WM_PAINT, Child_OnPaint); HANDLE_MSG (hWnd, WM_COMMAND, Child_OnCommand); HANDLE_MSG (hWnd, WM_SIZE, Child_OnSize); HANDLE_MSG (hWnd, WM_MDIACTIVATE, Child_OnMDIActivate); HANDLE_MSG (hWnd, WM_CLOSE, Child_OnClose); HANDLE_MSG (hWnd, WM_DESTROY, Child_OnDestroy); HANDLE_MSG (hWnd, WM_HSCROLL, Child_OnHScroll); HANDLE_MSG (hWnd, WM_VSCROLL, Child_OnVScroll); HANDLE_MSG (hWnd, WM_ERASEBKGND, Child_OnEraseBkgnd); HANDLE_MSG (hWnd, WM_PALETTECHANGED, Child_OnPaletteChanged); HANDLE_MSG (hWnd, WM_QUERYNEWPALETTE, Child_OnQueryNewPalette); HANDLE_MSG (hWnd, WM_TIMER, Child_OnTimer); HANDLE_MSG (hWnd, WM_LBUTTONDOWN, Child_OnLButtonDown); HANDLE_MSG (hWnd, WM_MOUSEMOVE, Child_OnMouseMove); HANDLE_MSG (hWnd, WM_LBUTTONUP, Child_OnLButtonUp); HANDLE_MSG (hWnd, WM_SETFOCUS, Child_OnSetFocus); HANDLE_MSG (hWnd, WM_KILLFOCUS, Child_OnKillFocus); HANDLE_MSG (hWnd, WM_RBUTTONUP, Child_OnRButtonup); HANDLE_MSG (hWnd, WM_KEYUP, Child_OnKey); HANDLE_MSG (hWnd, WM_KEYDOWN, Child_OnKey); case WM_USER_CHANGECURSOR: SetCursor(LoadCursor((HINSTANCE)wParam, (LPTSTR)lParam)); break; } return DefMDIChildProc(hWnd, uMessage, wParam, lParam); } /*====(Child_OnCreate)===================================================== Description: Creates an MDI child window. The image can come from a file or the clipboard. Syntax : BOOL Child_OnCreate(HWND hWnd, CREATESTRUCT FAR* lpCreateStruct) Parameters : hWnd Handle of a window. lpCreateStruct Pointer to CREATESTRUCT Return Value: TRUE The function was successful. FALSE The function was not successful. ==========================================================================*/ COLORREF gMask[]={RGB(255,0,0)}; L_INT gMaskCount = 1; static L_BOOL Child_OnCreate (HWND hWnd, CREATESTRUCT FAR * lpCreateStruct) { HANDLE hMem; HDC hdcCompatibile; pCHILDDATA pData; LPCREATEDATA pCreateData; //Allocate memory for window private data pCreateData = (LPCREATEDATA)CHILDCREATELPARAM(lpCreateStruct); if(!pCreateData) return FALSE; hMem = GlobalAlloc (GHND, sizeof (CHILDDATA)); SETCHILDDATA (hWnd, hMem); if(!hMem) return(FALSE); pData = LOCKCHILDDATA (hWnd); memset(pData, 0, sizeof(CHILDDATA)); pData->pszTitle = GlobalAllocPtr(GHND, ( (lstrlen(pCreateData->pszTitle) + 1) * sizeof(L_TCHAR))); pData->hBitmapWnd = hWnd; pData->uCombineMode = L_RGN_SET; pData->hPlaneWnd = NULL; IsDecimal = 1; if(pData->pszTitle) lstrcpy(pData->pszTitle, pCreateData->pszTitle); L_CopyBitmapHandle(&pData->LeadBitmap, pCreateData->pBitmap, sizeof(BITMAPHANDLE)); pData->nBitmapFormat = pCreateData->nBitmapFormat; L_InitBitmap(&pData->bmFloater, sizeof(BITMAPHANDLE), 0, 0, 0); L_InitBitmap(&pData->bmSave, sizeof(BITMAPHANDLE), 0, 0, 0); hdcCompatibile = GetDC(hWnd); pData->hPalette = L_CreatePaintPalette(hdcCompatibile, &pData->LeadBitmap); ReleaseDC(hWnd, hdcCompatibile); SetRect(&pData->rcView, 0, 0, BITMAPWIDTH(&pData->LeadBitmap), BITMAPHEIGHT(&pData->LeadBitmap)); SetWindowLong(hWnd, GWL_USERDATA, (long)pData); if(L_BitmapHasRgn(&pData->LeadBitmap)) L_GetBitmapRgnHandle(&pData->LeadBitmap, NULL, &pData->hrgnRegion); // Save some window handles hWndClient = GetParent(hWnd); hWndFrame = GetParent(hWndClient); uColorSpace = 0; memset(szColor, 0, 20); memset(szPos, 0, 20); pData->hbmSave = (HBITMAP)NULL; pData->hbmFloater = (HBITMAP)NULL; pData->uThreshold = 25; FileInit(hWnd); Child_OnQueryNewPalette(hWnd); UNLOCKCHILDDATA(hWnd); //UNDOLIST// L_UndoList_Init (hWnd, FreeFun, 20); return TRUE; } /*====(Child_OnPaint)====================================================== Description: Paints the child window. Syntax : VOID Child_OnPaint(HWND hWnd) Parameters : hWnd Handle of the child window. Return Value: None. ==========================================================================*/ static L_VOID Child_OnPaint (HWND hWnd) { HDC hdc; HPALETTE hSavedPalette = NULL; HPALETTE hPalette = NULL; PAINTSTRUCT ps; pCHILDDATA pData; BITMAPHANDLE TmpBitmapHandle; RECT rcView; HBITMAP hBitmap; L_INT Rop; L_INT nAngle; L_DOUBLE dTheta; RECT rcClipRect; pData = LOCKCHILDDATA (hWnd); if (!pData->LeadBitmap.Flags.Allocated) return; GetClientRect(hWnd, &rcClipRect); hdc = BeginPaint(hWnd, &ps); hPalette = L_CreatePaintPalette(hdc, &pData->LeadBitmap); if (hPalette) { hSavedPalette = SelectPalette (hdc, hPalette, FALSE); RealizePalette (hdc); } if(StatusProc.bStillWork) { if((abs(StatusProc.nStatusCnt - StatusProc.nOldStatusCnt) > StatusProc.nPercent)) { L_PaintDC(hdc, &pData->LeadBitmap, NULL, NULL, &pData->rcView, &rcClipRect, SRCCOPY); StatusProc.nOldStatusCnt = StatusProc.nStatusCnt; } } else { L_PaintDC(hdc, &pData->LeadBitmap, NULL, NULL, &pData->rcView, &rcClipRect, SRCCOPY); } if (pData->bCross) { hBitmap = LoadBitmap(hInst, MAKEINTRESOURCE(IDB_CROSS)); L_ConvertFromDDB(hdc, &TmpBitmapHandle, sizeof(BITMAPHANDLE), hBitmap, NULL); rcView.left = pData->ptCenter.x + pData->rcView.left - 15; rcView.top = pData->ptCenter.y + pData->rcView.top - 15; rcView.right = pData->ptCenter.x + pData->rcView.left + 15; rcView.bottom = pData->ptCenter.y + pData->rcView.top + 15; L_PaintDC(hdc, &TmpBitmapHandle, NULL, NULL, &rcView, NULL, SRCINVERT); L_FreeBitmap(&TmpBitmapHandle); DeleteBitmap(hBitmap); } if (pData->bLineHistogram) { Rop = SetROP2(hdc, R2_NOT); MoveToEx(hdc, pData->ptBegLn.x + pData->rcView.left, pData->ptBegLn.y + pData->rcView.top, NULL); LineTo(hdc, pData->ptEndLn.x + pData->rcView.left, pData->ptEndLn.y + pData->rcView.top); SetROP2(hdc, Rop); if (pData->bDetails) { dTheta = atan2(((pData->ptBegLn.y + pData->rcView.top ) - (pData->ptEndLn.y + pData->rcView.top)), ((pData->ptBegLn.x + pData->rcView.left) - (pData->ptEndLn.x + pData->rcView.left))); nAngle = (360 - (L_INT)((180 * dTheta)/3.14))% 360; hBitmap = LoadBitmap(hInst, MAKEINTRESOURCE(IDB_CROSS)); L_ConvertFromDDB(hdc, &TmpBitmapHandle, sizeof(BITMAPHANDLE), hBitmap, NULL); rcView.left = pData->ptBegLn.x + pData->rcView.left - 15; rcView.top = pData->ptBegLn.y + pData->rcView.top - 15; rcView.right = pData->ptBegLn.x + pData->rcView.left + 15; rcView.bottom = pData->ptBegLn.y + pData->rcView.top + 15; L_RotateBitmap(&TmpBitmapHandle, 4500 - nAngle * 100, ROTATE_RESAMPLE, RGB(0, 0, 0)); L_PaintDC(hdc, &TmpBitmapHandle, NULL, NULL, &rcView, &pData->rcView, SRCINVERT); rcView.left = pData->ptEndLn.x + pData->rcView.left - 15; rcView.top = pData->ptEndLn.y + pData->rcView.top - 15; rcView.right = pData->ptEndLn.x + pData->rcView.left + 15; rcView.bottom = pData->ptEndLn.y + pData->rcView.top + 15; L_PaintDC(hdc, &TmpBitmapHandle, NULL, NULL, &rcView, &pData->rcView, SRCINVERT); L_FreeBitmap(&TmpBitmapHandle); DeleteBitmap(hBitmap); } } if (pData->bDrawColoredFrame) DrawColoredFrame(hGlobalWnd, hdc); if (hSavedPalette) SelectPalette (hdc, hSavedPalette, FALSE); if(hPalette) DeleteObject (hPalette); EndPaint(hWnd, &ps); UNLOCKCHILDDATA(hWnd); } /*====(Child_OnPaletteChanged)============================================== Description: Processes WM_PALETTECHANGED uMessage for a child window. Syntax : VOID Child_OnPaletteChanged(HWND hWnd, HWND hWndPaletteChange) Parameters : hWnd Handle of a window. hWndPaletteChange Handle of the window that has the palette realized. Return Value: None. ==========================================================================*/ static L_VOID Child_OnPaletteChanged (HWND hWnd, HWND hWndPaletteChange) { HDC hDC; HPALETTE hOldPal; pCHILDDATA pData; if(hWnd == hWndPaletteChange) return; pData = LOCKCHILDDATA (hWnd); if(pData->hPalette) { hDC = GetDC(hWnd); hOldPal = SelectPalette(hDC, pData->hPalette, TRUE); RealizePalette(hDC); InvalidateRect(hWnd, NULL, FALSE); SelectPalette(hDC, hOldPal, TRUE); ReleaseDC(hWnd, hDC); } UNLOCKCHILDDATA(hWnd); } /*====(BmpWnd_OnVScroll)==================================================== Description: Scrolls the child window vertically. Syntax : VOID BmpWnd_OnVScroll(HWND hWnd, HWND hWndCtl, L_UINT nCode, L_INT nPos) Parameters : hWnd Handle of a window. hWndCtl Not used. nCode Amount/Direction to be scrolled. npos The new position of the thumb. Return Value: None. ==========================================================================*/ static L_VOID Child_OnVScroll (HWND hWnd, HWND hWndCtl, L_UINT nCode, L_INT nPos) { L_INT nScrollInc; pCHILDDATA pData; UNREFERENCED_PARAMETER(hWndCtl); pData = LOCKCHILDDATA (hWnd); bInScroll = TRUE; switch (nCode) { case SB_BOTTOM: nScrollInc = pData->nVScrollMax - pData->nVScrollPos; break; case SB_TOP: nScrollInc = -pData->nVScrollPos; break; case SB_LINEDOWN: nScrollInc = pData->nVScrollStep; break; case SB_LINEUP: nScrollInc = -pData->nVScrollStep; break; case SB_PAGEDOWN: nScrollInc = max (pData->nVScrollStep, (pData->cyClient - pData->nVScrollStep)); break; case SB_PAGEUP: nScrollInc = -max (pData->nVScrollStep, (pData->cyClient - pData->nVScrollStep)); break; case SB_THUMBTRACK: case SB_THUMBPOSITION: nScrollInc = nPos - pData->nVScrollPos; break; default: nScrollInc = 0; break; } nScrollInc = max(-pData->nVScrollPos, min(nScrollInc, (pData->nVScrollMax - pData->nVScrollPos))); if(nScrollInc) { pData->nVScrollPos += nScrollInc; OffsetRect(&pData->rcView, 0, -nScrollInc); ScrollWindow(hWnd, 0, -nScrollInc, NULL, NULL); SetScrollPos(hWnd, SB_VERT, pData->nVScrollPos, TRUE); UpdateWindow(hWnd); } bInScroll = FALSE; UNLOCKCHILDDATA(hWnd); } /*====(BmpWnd_OnHScroll)==================================================== Description: Scrolls the child window horizontally. Syntax : VOID BmpWnd_OnHScroll(HWND hWnd, HWND hWndCtl, L_UINT nCode, L_INT npos) Parameters : hWnd Handle of a window. hWndCtl Not used. nCode Amount/Direction to be scrolled. npos The new position of the thumb. Return Value: None. ==========================================================================*/ static L_VOID Child_OnHScroll (HWND hWnd, HWND hWndCtl, L_UINT nCode, L_INT nPos) { L_INT nHScrollInc; pCHILDDATA pData; UNREFERENCED_PARAMETER(hWndCtl); pData = LOCKCHILDDATA (hWnd); if(!pData) return; bInScroll = TRUE; switch (nCode) { case SB_LEFT: nHScrollInc = -pData->nHScrollPos; break; case SB_RIGHT: nHScrollInc = pData->nHScrollMax - pData->nHScrollPos; break; case SB_LINELEFT: nHScrollInc = -pData->nHScrollStep; break; case SB_LINERIGHT: nHScrollInc = pData->nHScrollStep; break; case SB_PAGELEFT: nHScrollInc = -max(pData->nHScrollStep, (pData->cxClient - pData->nHScrollStep)); break; case SB_PAGERIGHT: nHScrollInc = max(pData->nHScrollStep, (pData->cxClient - pData->nHScrollStep)); break; case SB_THUMBPOSITION: case SB_THUMBTRACK: nHScrollInc = nPos - pData->nHScrollPos; break; default: nHScrollInc = 0; break; } nHScrollInc = max (-pData->nHScrollPos, min (nHScrollInc, (pData->nHScrollMax - pData->nHScrollPos))); if (nHScrollInc) { pData->nHScrollPos += nHScrollInc; OffsetRect(&pData->rcView, -nHScrollInc, 0); ScrollWindow(hWnd, -nHScrollInc, 0, NULL, NULL); SetScrollPos(hWnd, SB_HORZ, pData->nHScrollPos, TRUE); UpdateWindow(hWnd); } bInScroll = FALSE; UNLOCKCHILDDATA(hWnd); } /*====(BmpWnd_OnEraseBkgnd)================================================= Description: Erases the background of a child window. Syntax : BOOL BmpWnd_OnEraseBkgnd(HWND hWnd, HDC hDC) Parameters : hWnd Handle to the child window. hDC Handle to the device context. Return Value: TRUE The function was successful. ==========================================================================*/ static L_BOOL Child_OnEraseBkgnd (HWND hWnd, HDC hDC) { HRGN hClientRgn, hFillRgn; RECT rcView, rcClient; HGDIOBJ hBrush; pCHILDDATA pData; pData = LOCKCHILDDATA (hWnd); if(IsIconic(hWnd)) hBrush = GetStockObject(BLACK_BRUSH); else hBrush = GETHBRBACKGROUND(hWnd); GetClientRect(hWnd, &rcClient); GetUpdateRect(hWnd, &rcView, 0); if(bInScroll || pData->LeadBitmap.Flags.Allocated) { IntersectRect(&rcView, &pData->rcView, &rcClient); hClientRgn = CreateRectRgnIndirect(&rcClient); hFillRgn = CreateRectRgnIndirect(&rcView); CombineRgn(hFillRgn, hClientRgn, hFillRgn, RGN_DIFF); FillRgn(hDC, hFillRgn, hBrush); DeleteObject(hFillRgn); DeleteObject(hClientRgn); } else FillRect(hDC, &rcClient, hBrush); UNLOCKCHILDDATA(hWnd); return TRUE; } L_VOID MySetScrollRange(HWND hwnd, L_INT nBar, L_INT32 nMinPos, L_INT32 nMaxPos, L_INT32 lStep, BOOL bRedraw) { #ifdef WIN32 SCROLLINFO ScrollInfo; ScrollInfo.cbSize = sizeof(SCROLLINFO); ScrollInfo.fMask = SIF_RANGE|SIF_PAGE; ScrollInfo.nPage = lStep; ScrollInfo.nMin = nMinPos; ScrollInfo.nMax = nMaxPos + ScrollInfo.nPage - 1; SetScrollInfo (hwnd, nBar, &ScrollInfo, bRedraw); #else SetScrollRange(hwnd, nBar, (int)nMinPos, (int)nMaxPos, bRedraw); #endif } /*====(Child_OnSize)======================================================= Description: Responds to WM_SIZE uMessage and sets the internal data accordingly. Also forwards the uMessage to DefMDIChildProc. Syntax : VOID Child_OnSize(HWND hWnd, L_UINT nState, L_INT nCx, L_INT nCy) Parameters : hWnd Handle to the child window. nState State of resizing requested. nCx Size to be used for the "x" direction. nCy Size to be used for the "y" direction. Return Value: None. ==========================================================================*/ L_VOID Child_OnSize (HWND hWnd, L_UINT nState, L_INT nCx, L_INT nCy) { static L_BOOL fSizeInUse = FALSE; L_INT nWidth; L_INT nHeight; L_INT nVScroll; L_INT nHScroll; DWORD dwStyle; pCHILDDATA pData; L_INT nHScrollFactor; L_INT nVScrollFactor; pData = LOCKCHILDDATA (hWnd); if(!pData) return; if (!fSizeInUse) { fSizeInUse = TRUE; if (!IsIconic(hWnd))// if window is normal { if (!pData->LeadBitmap.Flags.Allocated) { /* if bitmap is not allocated then set width and height to ZERO */ nWidth = 0; nHeight = 0; } else // if bitmap is allocated, then set the width and height to bitmap width and height { nWidth = BITMAPWIDTH(&pData->LeadBitmap); nHeight= BITMAPHEIGHT(&pData->LeadBitmap); } // Set client dimensions to current width and height pData->cxClient = nCx; pData->cyClient = nCy; dwStyle = GetWindowLong (hWnd, GWL_STYLE); nVScroll = GetSystemMetrics (SM_CXVSCROLL); // Get Vertical scroll arrow width nHScroll = GetSystemMetrics (SM_CXHSCROLL); // Get Horizontal scroll arrow width if (WS_VSCROLL & dwStyle)// if Vertical scroll pData->cxClient += nVScroll; if (WS_HSCROLL & dwStyle)// if Horizontal scroll pData->cyClient += nHScroll; if (pData->cxClient <= nWidth)// if client width < current width { pData->cyClient -= nHScroll; if (pData->cyClient <= nHeight) pData->cxClient -= nVScroll; } else if (pData->cyClient <= nHeight)// if client height < current height { pData->cxClient -= nVScroll; if (pData->cxClient <= nWidth) pData->cyClient -= nHScroll; } pData->nVScrollStep = max (1, pData->cyClient / SCROLL_RATIO); pData->nHScrollStep = max (1, pData->cxClient / SCROLL_RATIO); pData->nVScrollMax = max (0, (nHeight - pData->cyClient)); pData->nHScrollMax = max (0, (nWidth - pData->cxClient)); pData->nVScrollPos = max (0, min (pData->nVScrollPos, pData->nVScrollMax)); pData->nHScrollPos = max (0, min (pData->nHScrollPos, pData->nHScrollMax)); if (pData->LeadBitmap.Flags.Allocated) { SetRect (&pData->rcView, 0, 0, nWidth, nHeight); OffsetRect (&pData->rcView, -pData->nHScrollPos, -pData->nVScrollPos); } nHScrollFactor = 0; while((pData->nHScrollMax >> nHScrollFactor) > 0x7FFF) nHScrollFactor++; MySetScrollRange (pData->hBitmapWnd, SB_HORZ, 0, pData->nHScrollMax >> nHScrollFactor, max (pData->nHScrollStep, (pData->cxClient - pData->nHScrollStep)), FALSE); SetScrollPos (pData->hBitmapWnd, SB_HORZ, pData->nHScrollPos >> nHScrollFactor, TRUE); nVScrollFactor = 0; while((pData->nVScrollMax >> nVScrollFactor) > 0x7FFF) nVScrollFactor++; MySetScrollRange (pData->hBitmapWnd, SB_VERT, 0, pData->nVScrollMax >> nVScrollFactor, max (pData->nVScrollStep, (pData->cyClient - pData->nVScrollStep)), FALSE); SetScrollPos (pData->hBitmapWnd, SB_VERT, pData->nVScrollPos >> nVScrollFactor, TRUE); } else // if window is iconized { // Retain the x-client and y-client area pData->cxClient = nCx; pData->cyClient = nCy; // set client area SetRect (&pData->rcView, 0, 0, pData->cxClient, pData->cyClient); } fSizeInUse = FALSE; } UNLOCKCHILDDATA(hWnd); FORWARD_WM_SIZE(hWnd, nState, nCx, nCy, DefMDIChildProc); } /*====(Child_OnQueryNewPalette)============================================ Description: Processes WM_QUERYNEWPALETTE uMessage for a child window. Syntax : BOOL Child_OnQueryNewPalette(HWND hWnd) Parameters : hWnd Handle of a window. Return Value: nNoColors Number of colors changed in the palette. ==========================================================================*/ static L_BOOL Child_OnQueryNewPalette (HWND hWnd) { HDC hDC; L_INT nNoColors = 0; HPALETTE hOldPal; pCHILDDATA pData; pData = LOCKCHILDDATA (hWnd); if(pData->hPalette) { DeleteObject(pData->hPalette); pData->hPalette = NULL; } if(pData->LeadBitmap.Flags.Allocated) { hDC = GetDC(hWnd); pData->hPalette = L_CreatePaintPalette(hDC, &pData->LeadBitmap); if(pData->hPalette) { hOldPal = SelectPalette(hDC, pData->hPalette, FALSE); nNoColors = RealizePalette(hDC); if(nNoColors) InvalidateRect(hWnd, NULL, FALSE); SelectPalette(hDC, hOldPal, TRUE); } ReleaseDC(hWnd, hDC); } UNLOCKCHILDDATA(hWnd); return nNoColors; } L_VOID ShowStatusWindow(L_BOOL bStatus) { ShowWindow(GetDlgItem(hStatusWnd, IDC_STATUS_PROG), bStatus ? SW_HIDE : SW_SHOW); ShowWindow(GetDlgItem(hStatusWnd, IDC_STATUS_BITSPIXEL), bStatus ? SW_SHOW : SW_HIDE); ShowWindow(GetDlgItem(hStatusWnd, IDC_STATUS_INK), bStatus ? SW_SHOW : SW_HIDE); ShowWindow(GetDlgItem(hStatusWnd, IDC_STATUS_COLOR), bStatus ? SW_SHOW : SW_HIDE); ShowWindow(GetDlgItem(hStatusWnd, IDC_STATUS_DIMENSION), bStatus ? SW_SHOW : SW_HIDE); ShowWindow(GetDlgItem(hStatusWnd, IDC_STATUS_MEMORY), bStatus ? SW_SHOW : SW_HIDE); ShowWindow(GetDlgItem(hStatusWnd, IDC_STATUS_MOUSEPOS), bStatus ? SW_SHOW : SW_HIDE); ShowWindow(GetDlgItem(hStatusWnd, IDC_STATUS_REGIONBOUNDS), bStatus ? SW_SHOW : SW_HIDE); ShowWindow(GetDlgItem(hStatusWnd, IDC_STATUS_SPC), bStatus ? SW_SHOW : SW_HIDE); ShowWindow(GetDlgItem(hStatusWnd, IDC_STATUS_ESCAPE), bStatus ? SW_HIDE : SW_SHOW); ShowWindow(GetDlgItem(hStatusWnd, IDC_STATUS_PROG), bStatus ? SW_HIDE : SW_SHOW); } L_VOID InitDataAfterDlg(HWND hWnd, L_VOID L_FAR * pStructDlgData, pBITMAPHANDLE pLeadBitmap, pBITMAPHANDLE pBitmap, L_INT nDlgRet) { HWND hWndParent; pCHILDDATA pData; L_INT nMin, nMax; hWndParent = FORWARD_WM_MDIGETACTIVE(hWndClient,SendMessage); pData = LOCKCHILDDATA (hWndParent); if(StatusProc.ProgressValue != 100 || !nDlgRet) { L_FreeBitmap(pLeadBitmap); L_CopyBitmap(pLeadBitmap, pBitmap, sizeof(BITMAPHANDLE)); L_FreeBitmap(pBitmap); } else { L_FreeBitmap(pBitmap); if (pData->hPlaneWnd) L_PlaneUndoList_AddBitmap(pData->hPlaneWnd); else L_UndoList_AddBitmap (hWnd); } if(pStructDlgData) GlobalFreePtr(pStructDlgData); hGlobalWnd = NULL; ShowStatusWindow(TRUE); StatusProc.bStillWork = FALSE; StatusProc.bProgress = FALSE; StatusProc.bKillProgress = TRUE ; StatusProc.ProgressValue = 100; InvalidateRect(hWnd, NULL, TRUE); InvalidateRect(hStatusWnd, NULL, FALSE); SetStatusColorAndPixel(hWnd); if(L_IsGrayScaleBitmap(pLeadBitmap) && (pLeadBitmap->BitsPerPixel == 12 || pLeadBitmap->BitsPerPixel == 16)) { if (!pLeadBitmap->Flags.UseLUT) { L_GetMinMaxBits(pLeadBitmap, &nMin, &nMax); pLeadBitmap->LowBit = nMin; pLeadBitmap->HighBit = nMax; } else { pLeadBitmap->LowBit = 0; pLeadBitmap->HighBit = (pLeadBitmap->BitsPerPixel) - 1; } } } L_VOID InitDataBeforDlg(L_INT nPercent) { ShowStatusWindow(TRUE); StatusProc.bStillWork = FALSE; StatusProc.nStatusCnt = 0; StatusProc.nOldStatusCnt = 0; StatusProc.nPercent = nPercent; StatusProc.bOneTick = FALSE; } L_VOID InitOneTikeDataBefor(HWND hWnd, pBITMAPHANDLE pStatusBitmap, pBITMAPHANDLE pLeadBitmap, L_INT nPercent) { SetCursor (LoadCursor(NULL, IDC_WAIT)); MemorizeBitmap (hWnd); //MEMDISK TransToStatusBar(pStatusBitmap, pLeadBitmap); StatusProc.bStillWork = TRUE; StatusProc.nStatusCnt = 0; StatusProc.nOldStatusCnt = 0; StatusProc.nPercent = nPercent; StatusProc.bInvalidate = TRUE; StatusProc.bProgress = TRUE; StatusProc.bOneTick = TRUE; StatusProc.bKillProgress = FALSE ; } L_VOID InitOneTikeDataAfter(HWND hWnd, pBITMAPHANDLE pStatusBitmap, pBITMAPHANDLE pLeadBitmap, L_INT nPercent, L_INT nDlgRet) { L_INT nMin, nMax; if (nDlgRet == SUCCESS) L_UndoList_AddBitmap (hWnd); TransBack(pStatusBitmap, pLeadBitmap, nDlgRet); StatusProc.bStillWork = FALSE; StatusProc.bProgress = FALSE; StatusProc.bOneTick = FALSE; StatusProc.bKillProgress = FALSE ; StatusProc.ProgressValue = 100; InvalidateRect(hWnd, NULL, FALSE); InvalidateRect(hStatusWnd, NULL, FALSE); SetStatusColorAndPixel(hWnd); if(L_IsGrayScaleBitmap(pLeadBitmap) && (pLeadBitmap->BitsPerPixel == 12 || pLeadBitmap->BitsPerPixel == 16)) { if (!pLeadBitmap->Flags.UseLUT) { L_GetMinMaxBits(pLeadBitmap, &nMin, &nMax); pLeadBitmap->LowBit = nMin; pLeadBitmap->HighBit = nMax; } else { pLeadBitmap->LowBit = 0; pLeadBitmap->HighBit = (pLeadBitmap->BitsPerPixel) - 1; } } } /*L_INT GetDialogFilter(L_INT ID) { switch(ID) { case IDM_IMAGE_POSTERIZE: return DLG_IMG_POSTERIZE ; case IDM_IMAGE_AVERAGE: return DLG_IMG_AVERAGE; case IDM_IMAGE_MOSAIC: return DLG_IMG_MOSAIC; case IDM_IMAGE_OILIFY: return DLG_IMG_OILIFY; case IDM_IMAGE_HUE: return DLG_IMG_HUE; case IDM_IMAGE_SHARPEN: return DLG_IMG_SHARPEN; case IDM_IMAGE_SOLARIZE: return DLG_IMG_SOLARIZE; case IDM_IMAGE_MAX: return DLG_IMG_MAX; case IDM_IMAGE_MIN: return DLG_IMG_MIN; case IDM_IMAGE_MEDIAN: return DLG_IMG_MEDIAN; case IDM_IMAGE_CONTRAST: return DLG_IMG_CONTRAST; case IDM_IMAGE_BRIGHTNESS: return DLG_IMG_BRIGHTNESS; case IDM_IMAGE_SATURATION: return DLG_IMG_SATURATION; case IDM_IMAGE_HISTOCONTRAST: return DLG_IMG_HISTOCONTRAST; } return 0; } */ /*====(Child_OnCommand)==================================================== Description: Processes the WM_COMMAND for a child window. Syntax : VOID Child_OnCommand(HWND hWnd, L_INT nID, HWND hWndCtl, L_UINT codeNotify) Parameters : hWnd Handle to the child window. nID Value of the command to be processed. hWndCtl Not used. codeNotify Not used. Return Value: None. ==========================================================================*/ static L_VOID Child_OnCommand (HWND hWnd, L_INT nID, HWND hwndCtl, L_UINT codeNotify) { pCHILDDATA pData; LPBINSGDATA pBSgData; LPCHMIXDATA pChMixData; LPDTNDLGDATA pDtnDlgData; LPBMPDLGDATA pBmpDlgData; LPSKLDLGDATA pSklDlgData; LPEDGSMTHDLGDATA pEdgsmthDlgData; LPLNSDLGDATA pLnsDlgData; LPGLWDLGDATA pGlwDlgData; LPSTSDLGDATA pStsDlgData; LPCSTDLGDATA pCstDlgData; LPGLASSEFFECTDATA pGlassData; LPLIGHTCTRLDATA pDlgData; LPCUBISMDATA pCubData; LPSAMPTRDATA pSampleData; LPCONVDATA pConvDlgData; LPSCLRDLGDATA pSClrDlgData; LPLVLDLGDATA pLvlDlgData; LPLCLEQLDATA pLclEqlData; LPSEGDLGDATA pSegDlgData; LPBNDDLGDATA pBndDlgData; LPCYLDLGDATA pCylDlgData; LPHNDDLGDATA pHndDlgData; LPIMPDLGDATA pImpDlgData; LPMRADDLGDATA pMRadDlgData; LPMZOMDLGDATA pMZomDlgData; LPPINDLGDATA pPinDlgData; LPPIXDLGDATA pPixDlgData; LPPLRDLGDATA pPlrDlgData; LPRADWAVDLGDATA pRadWavDlgData; LPWAVDLGDATA pWavDlgData; LPWNDDLGDATA pWndDlgData; LPRIPDLGDATA pRipDlgData; LPSHRDLGDATA pShrDlgData; LPSPHDLGDATA pSphDlgData; LPSWRDLGDATA pSwrDlgData; LPZOMWAVDLGDATA pZomWavDlgData; LPHSEQDLGDATA pHsEqDlgData; LPADDDLGDATA pAddDlgData; LPREDEYEDATA pRedEyeData; LPOPCDLGDATA pOpctyDlgData; LPCOMBDLGDATA pCombDlgData; LPFDMSKDLGDATA pFdMskDlgData; LPFEATHERDLGDATA pFeatherData; LPLNPROFDLGDATA pLnProfDlgData; LPSWPDLGDATA pSwpDlgData; LPPICDLGDATA pPicDlgData; LPADDMESGDLGDATA pAddMesgDlgData; LPADDWDLGDATA pAddWDlgData; LPHTONEDLGDATA pHalfToneData; LPDEINTERDATA pDeIntData; LPDISFTDLGDATA pDisFTDlgData; LPCLRTHRDLGDATA pClThDlgData; LPREVEFTDLGDATA pRevDlgData; LPSBGDATA pSBGData; LPFNDEDGDLGDATA pFndEdgDlgData; LPSHADOWDLGDATA pShadowDlgData; LPRSZRGNDLGDATA pRszRgnDlgData; LPADDNOISDLGDATA pAddNoisDlgData; LPAFNDLGDATA pAfnDlgData; LPTVDICEDLGDATA pTVDiceDlgData; LPTVPUZZLEDLGDATA pPzlDlgData; LPMATHFUNCDLGDATA pMathDlgData; LPFREHNDNOISDLGDATA pFhnDlgData; LPTVSPIRALDLGDATA pSpiralDlgData; LPGRYDLGDATA pGryDlgData; LPBCIDLGDATA pBciDlgData; LPDSADLGDATA pDsaDlgData; LPRADDLGDATA pRadDlgData; LPSHIDLGDATA pShiDlgData; LPSELDLGDATA pSelDlgData; LPTUNDLGDATA pTunDlgData; LPPLBDLGDATA pPlbDlgData; LPPLNDLGDATA pPlnDlgData; LPLGTDLGDATA pLgtDlgData; LPINFDLGDATA pInfoDlgData; LPDRYDLGDATA pDryDlgData; LPOCEDLGDATA pOceDlgData; LPFRBDLGDATA pFrbDlgData; LPFPBDLGDATA pFpbDlgData; LPSTRDLGDATA pStrDlgData; LPDYTHDLGDATA pDythDlgData; LPAGEDLGDATA pAgeDlgData; LPBALDLGDATA pBalDlgData; LPCONDLGDATA pConDlgData; LPREPDLGDATA pRepDlgData; LPHSBDLGDATA pHsiDlgData; LPNUMDLGDATA pNumDlgData; LPCHSCLRDLGDATA pChsClrDlgData; L_BOOL bOldMoveFloater; L_INT bOldRgnType; L_INT nRet; BITMAPHANDLE StatusBitmap; OPENDLGPARAMS foParm; OPENFILENAME OpenFileName; L_TCHAR szFileName[MAX_PATH] = TEXT("\0"); L_TCHAR szImageDir[1024] = TEXT("\0"); RESIZEDLGPARAMS ResizeParams; COLORRESDLGPARAMS ColorResParams; LPACEDLGDATA pAceDlgData; LPCLOUDSDLGDATA pCloudsDlgData; LPVIGNTDLGDATA pVignnetDlgData; LPMSCTLSDLGDATA pMosiacTilesDlgData; LPFRAGMENTDLGDATA pFragmentDlgData; LPRMNMSCDLGDATA pRomanDlgData; LPGAMMADATA pGammaData; LPEMBOSSDATA pEmbossData; LPPLASMADATA pPlasmaData; LPPERSDLGDATA pPersDlgData; LPPOINTLIZEDLGDATA pPntDlgData; LPHTPATTERNDLGDATA pHtpDlgData; LPCOLORHTDLGDATA pHtcDlgData; LPCOLORBALLDLGDATA pClrBDlgData; LPZIGZAGDLGDATA pZigZagDlgData; LPHPFDLGDATA pHpfDlgData; LPDISPDLGDATA pDispDlgData; LPDFGDLGDATA pDfgDlgData; LPDSKWDLGDATA pDskDlgData; LPOFFSETDLGDATA pOffsetDlgData; LPBRICKSDLGDATA pBricksDlgData; LPTINTDLGDATA pTintDlgData; LPSPENCILDLGDATA pSPencilDlgData; LPCANVASDLGDATA pCanvasDlgData; LPPRLNDLGDATA pPrlnDlgData; LPKFNRGNDLGDATA pKfnRgnDlgData; StatusProc.hwndCtl = hwndCtl; pData = LOCKCHILDDATA (hWnd); switch(nID) { case IDM_FILE_SAVE: SaveBitmapFile (hWnd); break; case IDM_EDIT_REDO://UNDOLIST// if (pData->hPlaneWnd) L_PlaneUndoList_Redo(pData->hPlaneWnd); else { L_UndoList_Redo (hWnd); MemorizeBitmap(hWnd); } SetStatusColorAndPixel(hWnd); SetStatusBarText(TEXT(""), &pData->LeadBitmap, szPos, szColor); break; case IDM_EDIT_UNDO://UNDOLIST// if (pData->hPlaneWnd) L_PlaneUndoList_Undo(pData->hPlaneWnd); else { L_UndoList_Undo (hWnd); MemorizeBitmap(hWnd); } SetStatusColorAndPixel(hWnd); SetStatusBarText(TEXT(""), &pData->LeadBitmap, szPos, szColor); break; case IDM_EDIT_COPY: L_CopyToClipboard(hWnd, &pData->LeadBitmap, 0x1f); break; case IDM_EDIT_COPYRGN: { RECT rcRgn; BITMAPHANDLE bmpRgn; HRGN hRgn = NULL; pData = LOCKCHILDDATA (hWnd); L_GetBitmapRgnBounds(&pData->LeadBitmap, NULL, &rcRgn); L_InitBitmap(&bmpRgn, sizeof(BITMAPHANDLE), 0, 0, 0); L_CopyBitmapRect(&bmpRgn, &pData->LeadBitmap, sizeof(BITMAPHANDLE), rcRgn.left, rcRgn.top, RECTWIDTH(&rcRgn), RECTHEIGHT(&rcRgn)); L_GetBitmapRgnHandle(&bmpRgn, NULL, &hRgn); L_SetBitmapRgnHandle(&bmpRgn, NULL, hRgn, L_RGN_SETNOT); L_FillBitmap(&bmpRgn, RGB(0, 0, 0)); L_SetBitmapRgnHandle(&bmpRgn, NULL, hRgn, L_RGN_SET); DeleteObject(hRgn); L_CopyToClipboard (hWnd, &bmpRgn, 0x1f); L_FreeBitmap(&bmpRgn); UNLOCKCHILDDATA (hWnd); } SetStatusColorAndPixel(hWnd); SetStatusBarText(TEXT(""), &pData->LeadBitmap, szPos, szColor); break; case IDM_EDIT_PASTE: PasteBitmap(hWnd); SetStatusColorAndPixel(hWnd); break; case IDM_EDIT_SETREGION_NONE: if (pData->nRgnType == 5) { pData->bMagWnd = FALSE; EndDialog(pData->hMagicWand, FALSE); } pData->nRgnType = 0; SetStatusColorAndPixel(hWnd); SetStatusBarText(TEXT(""), &pData->LeadBitmap, szPos, szColor); break; case IDM_EDIT_SETREGION_RECTANGLE: if (pData->nRgnType == 5) { pData->bMagWnd = FALSE; EndDialog(pData->hMagicWand, FALSE); } pData->nRgnType = 1; SetStatusColorAndPixel(hWnd); SetStatusBarText(TEXT(""), &pData->LeadBitmap, szPos, szColor); break; case IDM_EDIT_SETREGION_ROUNDEDRECTANGLE: if (pData->nRgnType == 5) { pData->bMagWnd = FALSE; EndDialog(pData->hMagicWand, FALSE); } pData->nRgnType = 2; SetStatusColorAndPixel(hWnd); SetStatusBarText(TEXT(""), &pData->LeadBitmap, szPos, szColor); break; case IDM_EDIT_SETREGION_ELLIPSE: if (pData->nRgnType == 5) { pData->bMagWnd = FALSE; EndDialog(pData->hMagicWand, FALSE); } pData->nRgnType = 3; SetStatusColorAndPixel(hWnd); SetStatusBarText(TEXT(""), &pData->LeadBitmap, szPos, szColor); break; case IDM_EDIT_SETREGION_FREEHAND: if (pData->nRgnType == 5) { pData->bMagWnd = FALSE; EndDialog(pData->hMagicWand, FALSE); } pData->nRgnType = 4; SetStatusColorAndPixel(hWnd); SetStatusBarText(TEXT(""), &pData->LeadBitmap, szPos, szColor); break; case IDM_EDIT_SETREGION_MAGICWAND: if (pData->nRgnType == 5) break; pData->nRgnType = 5; pData->bMagWnd = FALSE; case IDM_WINDOW_MGCDLG: pData->bMagWnd ^= TRUE; if (pData->bMagWnd) CreateDialog(hInst, MAKEINTRESOURCE(IDD_MGC_DLG), hWnd, MagicWandDlgProc); else EndDialog(pData->hMagicWand, FALSE); SetStatusColorAndPixel(hWnd); SetStatusBarText(TEXT(""), &pData->LeadBitmap, szPos, szColor); break; case IDM_EDIT_CANCELREGION: nRgn =0; CancelRgn(hWnd, TRUE); SetCursor(LoadCursor(NULL, IDC_ARROW)); InvalidateRect(hWnd, NULL, FALSE); SetStatusColorAndPixel(hWnd); SetStatusBarText(TEXT(""), &pData->LeadBitmap, szPos, szColor); break; case IDM_EDIT_SINGLE: pData->uCombineMode = L_RGN_SET; SetStatusColorAndPixel(hWnd); SetStatusBarText(TEXT(""), &pData->LeadBitmap, szPos, szColor); break; case IDM_EDIT_MULTI: pData->uCombineMode = L_RGN_OR; SetStatusColorAndPixel(hWnd); SetStatusBarText(TEXT(""), &pData->LeadBitmap, szPos, szColor); break; case IDM_EDIT_INTERSECT: pData->uCombineMode = L_RGN_AND; SetStatusColorAndPixel(hWnd); SetStatusBarText(TEXT(""), &pData->LeadBitmap, szPos, szColor); break; case IDM_EDIT_INVERT: pData->uCombineMode = L_RGN_SETNOT; SetStatusColorAndPixel(hWnd); SetStatusBarText(TEXT(""), &pData->LeadBitmap, szPos, szColor); break; case IDM_EDIT_OLDANDNOTNEW: pData->uCombineMode = L_RGN_ANDNOTRGN; SetStatusColorAndPixel(hWnd); SetStatusBarText(TEXT(""), &pData->LeadBitmap, szPos, szColor); break; case IDM_EDIT_NEWANDNOTOLD: pData->uCombineMode = L_RGN_ANDNOTBITMAP; SetStatusColorAndPixel(hWnd); SetStatusBarText(TEXT(""), &pData->LeadBitmap, szPos, szColor); break; case IDM_EDIT_OLDXORNEW: pData->uCombineMode = L_RGN_XOR; SetStatusColorAndPixel(hWnd); SetStatusBarText(TEXT(""), &pData->LeadBitmap, szPos, szColor); break; case IDM_IMAGE_BINARYSEGMENT: pBSgData = (LPBINSGDATA)GlobalAllocPtr(GHND, sizeof(BINSGDATA)); if (!pBSgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_BIN_DLG, hWnd, (DLGPROC)BinSgDlgProc, (long)pBSgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pBSgData, &pData->LeadBitmap, &pBSgData->LeadBitmap, nRet); break; case IDM_IMAGE_SMOOTH: pEdgsmthDlgData = (LPEDGSMTHDLGDATA)GlobalAllocPtr(GHND, sizeof(EDGSMTHDLGDATA)); if(!pEdgsmthDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_SMTH_DLG, hWnd, (DLGPROC)SmoothDlgProc, (LONG)pEdgsmthDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pEdgsmthDlgData, &pData->LeadBitmap, &pEdgsmthDlgData->Bitmap, nRet); break; case IDM_IMAGE_SHADOW: pShadowDlgData = (LPSHADOWDLGDATA)GlobalAllocPtr(GHND, sizeof(SHADOWDLGDATA)); if(!pShadowDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_SHDW_DLG, hWnd, (DLGPROC)ShadowDlgProc, (LONG)pShadowDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pShadowDlgData, &pData->LeadBitmap, &pShadowDlgData->LeadBitmap, nRet); break; case IDM_EDIT_RESIZEREGION: pRszRgnDlgData = (LPRSZRGNDLGDATA)GlobalAllocPtr(GHND, sizeof(RSZRGNDLGDATA)); if(!pRszRgnDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_RRGN_DLG, hWnd, (DLGPROC)RszRgnDlgProc, (LONG)pRszRgnDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pRszRgnDlgData, &pData->LeadBitmap, &pRszRgnDlgData->LeadBitmap, nRet); break; case IDM_IMAGE_SUBTRACTBACKGROUND: pSBGData = (LPSBGDATA)GlobalAllocPtr(GHND, sizeof(SBGDATA)); if(!pSBGData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_SBK_DLG, hWnd, (DLGPROC)SBGDlgProc, (LONG)pSBGData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pSBGData, &pData->LeadBitmap, &pSBGData->LeadBitmap, nRet); break; case IDM_IMAGE_COLORTHRESHOLD: pClThDlgData = (LPCLRTHRDLGDATA)GlobalAllocPtr(GHND, sizeof(CLRTHRDLGDATA)); if(!pClThDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_CLTH_DLG, hWnd, (DLGPROC)ClThDlgProc, (LONG)pClThDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pClThDlgData, &pData->LeadBitmap, &pClThDlgData->LeadBitmap, nRet); break; case IDM_IMAGE_REVEFFECT: pRevDlgData = (LPREVEFTDLGDATA)GlobalAllocPtr(GHND, sizeof(REVEFTDLGDATA)); if(!pRevDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_REV_DLG, hWnd, (DLGPROC)RevDlgProc, (LONG)pRevDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pRevDlgData, &pData->LeadBitmap, &pRevDlgData->LeadBitmap, nRet); break; case IDM_IMAGE_FINDEDGES: pFndEdgDlgData = (LPFNDEDGDLGDATA)GlobalAllocPtr(GHND, sizeof(FNDEDGDLGDATA)); if(!pFndEdgDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_FNDEDG_DLG, hWnd, (DLGPROC)FndEdgDlgProc, (LONG)pFndEdgDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pFndEdgDlgData, &pData->LeadBitmap, &pFndEdgDlgData->LeadBitmap, nRet); break; case IDM_IMAGE_DESAT: InitOneTikeDataBefor(hWnd, &StatusBitmap, &pData->LeadBitmap, 10); nRet = L_DesaturateBitmap(&pData->LeadBitmap); InitOneTikeDataAfter(hWnd, &StatusBitmap, &pData->LeadBitmap, 10, nRet); break; case IDM_IMAGE_LENS: bOldMoveFloater = pData->bMovingFloater; pData->bMovingFloater = FALSE; bOldRgnType = pData->nRgnType; if (pData->bMagWnd) EndDialog(pData->hMagicWand, FALSE); pData->nRgnType = 0; pLnsDlgData = (LPLNSDLGDATA)GlobalAllocPtr(GHND, sizeof(LNSDLGDATA)); if(!pLnsDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_LNS_DLG, hWnd, (DLGPROC)LensDlgProc, (LONG)pLnsDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pLnsDlgData, &pData->LeadBitmap, &pLnsDlgData->Bitmap, nRet); if (pData->bMagWnd) CreateDialog(hInst, MAKEINTRESOURCE(IDD_MGC_DLG), hWnd, MagicWandDlgProc); pData->bMovingFloater = bOldMoveFloater; pData->nRgnType = bOldRgnType; break; case IDM_IMAGE_SEG: pSegDlgData = (LPSEGDLGDATA)GlobalAllocPtr(GHND, sizeof(SEGDLGDATA)); if(!pSegDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_SEG_DLG, hWnd, (DLGPROC)SegDlgProc, (LONG)pSegDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pSegDlgData, &pData->LeadBitmap, &pSegDlgData->Bitmap, nRet); break; case IDM_IMAGE_GLOW: pGlwDlgData = (LPGLWDLGDATA)GlobalAllocPtr(GHND, sizeof(GLWDLGDATA)); if(!pGlwDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_GLW_DLG, hWnd, (DLGPROC)GlowDlgProc, (LONG)pGlwDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pGlwDlgData, &pData->LeadBitmap, &pGlwDlgData->Bitmap, nRet); break; case IDM_IMAGE_POLAR: pPlrDlgData = (LPPLRDLGDATA)GlobalAllocPtr(GHND, sizeof(PLRDLGDATA)); if(!pPlrDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_PLR_DLG, hWnd, (DLGPROC)PolarDlgProc, (LONG)pPlrDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pPlrDlgData, &pData->LeadBitmap, &pPlrDlgData->Bitmap, nRet); break; case IDM_IMAGE_STATIS: pStsDlgData = (LPSTSDLGDATA)GlobalAllocPtr(GHND, sizeof(STSDLGDATA)); if(!pStsDlgData) return; InitDataBeforDlg(10); nRet = nRet = DoDialogBoxParam(IDD_STS_DLG, hWnd, (DLGPROC)StatsDlgProc, (LONG)pStsDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pStsDlgData, &pData->LeadBitmap, &pStsDlgData->Bitmap, nRet); break; case IDM_IMAGE_COMSTS: pCstDlgData = (LPCSTDLGDATA)GlobalAllocPtr(GHND, sizeof(CSTDLGDATA)); if(!pCstDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_CST_DLG, hWnd, (DLGPROC)ComStDlgProc, (LONG)pCstDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pCstDlgData, &pData->LeadBitmap, &pCstDlgData->Bitmap, nRet); break; case IDM_IMAGE_SKELTON: pSklDlgData = (LPSKLDLGDATA)GlobalAllocPtr(GHND, sizeof(SKLDLGDATA)); if(!pSklDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_SKL_DLG, hWnd, (DLGPROC)SkeltonDlgProc, (LONG)pSklDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pSklDlgData, &pData->LeadBitmap, &pSklDlgData->Bitmap, nRet); break; case IDM_IMAGE_CHANNELMIXER: pChMixData = (LPCHMIXDATA)GlobalAllocPtr(GHND, sizeof(CHMIXDATA)); if (!pChMixData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_CHM_DLG, hWnd, (DLGPROC)ChMixWndProc, (long)pChMixData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pChMixData, &pData->LeadBitmap, &pChMixData->LeadBitmap, nRet); break; case IDM_IMAGE_LOCALHISTO: pLclEqlData = (LPLCLEQLDATA)GlobalAllocPtr(GHND, sizeof(LCLEQLDATA)); if (!pLclEqlData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_LEQ_DLG, hWnd, (DLGPROC)LclEqlWndProc, (long)pLclEqlData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pLclEqlData, &pData->LeadBitmap, &pLclEqlData->LeadBitmap, nRet); break; case IDM_IMAGE_DUOTONE: pDtnDlgData = (LPDTNDLGDATA)GlobalAllocPtr(GHND, sizeof(DTNDLGDATA)); if(!pDtnDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_DTN_DLG, hWnd, (DLGPROC)LkDialog, (LONG)pDtnDlgData); if(pDtnDlgData->pCurveTable) free(pDtnDlgData->pCurveTable); if(pDtnDlgData->uLut) { for(nCount=0;nCount<=3;nCount++) free(pDtnDlgData->uLut[nCount]); } if(pDtnDlgData->aptCurve) { for(nCount=0;nCount<=3;nCount++) free(pDtnDlgData->aptCurve[nCount]); } for (nCount = 0; nCount < 4; nCount++) { free(pDtnDlgData->pRGBArray[nCount]); } L_FreeBitmap(&pDtnDlgData->BackUpGray); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pDtnDlgData, &pData->LeadBitmap, &pDtnDlgData->Bitmap, nRet); break; case IDM_IMAGE_AUTOBINARYSEGMENT: InitOneTikeDataBefor(hWnd, &StatusBitmap, &pData->LeadBitmap, 10); nRet = L_AutoBinaryBitmap(&pData->LeadBitmap); InitOneTikeDataAfter(hWnd, &StatusBitmap, &pData->LeadBitmap, 10, nRet); break; case IDM_IMAGE_BUMP: pBmpDlgData = (LPBMPDLGDATA)GlobalAllocPtr(GHND, sizeof(BMPDLGDATA)); if(!pBmpDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_BMP_DLG, hWnd, (DLGPROC)BumpDlgProc, (LONG)pBmpDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pBmpDlgData, &pData->LeadBitmap, &pBmpDlgData->Bitmap, nRet); break; case IDM_IMAGE_GLASS_EFFECT: pGlassData = (LPGLASSEFFECTDATA)GlobalAllocPtr(GHND, sizeof(GLASSEFFECTDATA)); if(!pGlassData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_GLS_DLG, hWnd, (DLGPROC)GlassEffectDlgProc, (LONG)pGlassData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pGlassData, &pData->LeadBitmap, &pGlassData->Bitmap, nRet); break; case IDM_IMAGE_LIGHT_CONTROL: pDlgData = (LPLIGHTCTRLDATA)GlobalAllocPtr(GHND, sizeof(LIGHTCTRLDATA)); if(!pDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_LGT_DLG, hWnd, (DLGPROC)LightDialogProc, (LONG)pDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pDlgData, &pData->LeadBitmap, &pDlgData->Bitmap, nRet); break; case IDM_IMAGE_CUBISM_EFFECT: pCubData = (LPCUBISMDATA)GlobalAllocPtr(GHND, sizeof(CUBISMDATA)); if(!pCubData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_CBS_DLG, hWnd, (DLGPROC)CubismDlgProc, (LONG)pCubData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pCubData, &pData->LeadBitmap, &pCubData->Bitmap, nRet); break; case IDM_IMAGE_SAMPLE_TARGET: pSampleData = (LPSAMPTRDATA)GlobalAllocPtr(GHND, sizeof(SAMPTRDATA)); if(!pSampleData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_ST_DLG, hWnd, (DLGPROC)SAMTRDialogProc, (LONG)pSampleData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pSampleData, &pData->LeadBitmap, &pSampleData->Bitmap, nRet); break; case IDM_IMAGE_WR: InitOneTikeDataBefor(hWnd, &StatusBitmap, &pData->LeadBitmap, 10); nRet = L_HolesRemovalBitmapRgn(&pData->LeadBitmap); InitOneTikeDataAfter(hWnd, &StatusBitmap, &pData->LeadBitmap, 10, nRet); break; case IDM_IMAGE_CONV: pConvDlgData = (LPCONVDATA)GlobalAllocPtr(GHND, sizeof(CONVDATA)); if(!pConvDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_CONV_DLG, hWnd, (DLGPROC)ConvDlgProc, (LONG)pConvDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pConvDlgData, &pData->LeadBitmap, &pConvDlgData->Bitmap, nRet); break; case IDM_IMAGE_AUTOLEVEL: InitOneTikeDataBefor(hWnd, &StatusBitmap, &pData->LeadBitmap, 10); nRet = L_AutoColorLevelBitmap (&pData->LeadBitmap, NULL, DEFAULT_BLACK_CLIP, DEFAULT_WHITE_CLIP, AUTO_LEVEL); InitOneTikeDataAfter(hWnd, &StatusBitmap, &pData->LeadBitmap, 10, nRet); break; case IDM_IMAGE_AUTOCONTRAST: InitOneTikeDataBefor(hWnd, &StatusBitmap, &pData->LeadBitmap, 10); nRet = L_AutoColorLevelBitmap (&pData->LeadBitmap, NULL, DEFAULT_BLACK_CLIP, DEFAULT_WHITE_CLIP, AUTO_CONTRAST); InitOneTikeDataAfter(hWnd, &StatusBitmap, &pData->LeadBitmap, 10, nRet); break; case IDM_IMAGE_AUTOLUMINOSITY: InitOneTikeDataBefor(hWnd, &StatusBitmap, &pData->LeadBitmap, 10); nRet = L_AutoColorLevelBitmap (&pData->LeadBitmap, NULL, DEFAULT_BLACK_CLIP, DEFAULT_WHITE_CLIP, AUTO_INTENSITY); InitOneTikeDataAfter(hWnd, &StatusBitmap, &pData->LeadBitmap, 10, nRet); break; case IDM_IMAGE_LEVELING: pLvlDlgData = (LPLVLDLGDATA)GlobalAllocPtr(GHND, sizeof(LVLDLGDATA)); if(!pLvlDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_LVL_DLG, hWnd, (DLGPROC)LevelingDlgProc, (LONG)pLvlDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pLvlDlgData, &pData->LeadBitmap, &pLvlDlgData->Bitmap, nRet); break; case IDM_IMAGE_SELECTIVECOLOR: pSClrDlgData = (LPSCLRDLGDATA)GlobalAllocPtr(GHND, sizeof(SCLRDLGDATA)); if(!pSClrDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_SCL_DLG, hWnd, (DLGPROC)SelectiveColorDlgProc, (LONG)pSClrDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pSClrDlgData, &pData->LeadBitmap, &pSClrDlgData->Bitmap, nRet); break; case IDM_IMAGE_BND: bOldMoveFloater = pData->bMovingFloater; pData->bMovingFloater = FALSE; bOldRgnType = pData->nRgnType; if (pData->bMagWnd) EndDialog(pData->hMagicWand, FALSE); pData->nRgnType = 0; pBndDlgData = (LPBNDDLGDATA)GlobalAllocPtr(GHND, sizeof(BNDDLGDATA)); if (!pBndDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_BND_DLG, hWnd, (DLGPROC)BendDlgProc, (long)pBndDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pBndDlgData, &pData->LeadBitmap, &pBndDlgData->Bitmap, nRet); if (pData->bMagWnd) CreateDialog(hInst, MAKEINTRESOURCE(IDD_MGC_DLG), hWnd, MagicWandDlgProc); pData->bMovingFloater = bOldMoveFloater; pData->nRgnType = bOldRgnType; break; case IDM_IMAGE_CYLENDER: pCylDlgData = (LPCYLDLGDATA)GlobalAllocPtr(GHND, sizeof(CYLDLGDATA)); if(!pCylDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_CYL_DLG, hWnd, (DLGPROC)CylndDlgProc, (LONG)pCylDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pCylDlgData, &pData->LeadBitmap, &pCylDlgData->Bitmap, nRet); break; case IDM_IMAGE_HANDWAVE: pHndDlgData = (LPHNDDLGDATA)GlobalAllocPtr(GHND, sizeof(HNDDLGDATA)); if(!pHndDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_HND_DLG, hWnd, (DLGPROC)HandWavDlgProc, (LONG)pHndDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pHndDlgData, &pData->LeadBitmap, &pHndDlgData->Bitmap, nRet); break; case IDM_IMAGE_PIXELATE: bOldMoveFloater = pData->bMovingFloater; pData->bMovingFloater = FALSE; bOldRgnType = pData->nRgnType; if (pData->bMagWnd) EndDialog(pData->hMagicWand, FALSE); pData->nRgnType = 0; pPixDlgData = (LPPIXDLGDATA)GlobalAllocPtr(GHND, sizeof(PIXDLGDATA)); if(!pPixDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_PIX_DLG, hWnd, (DLGPROC)PixelateDlgProc, (LONG)pPixDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pPixDlgData, &pData->LeadBitmap, &pPixDlgData->Bitmap, nRet); if (pData->bMagWnd) CreateDialog(hInst, MAKEINTRESOURCE(IDD_MGC_DLG), hWnd, MagicWandDlgProc); pData->bMovingFloater = bOldMoveFloater; pData->nRgnType = bOldRgnType; break; case IDM_IMAGE_MRAD: bOldMoveFloater = pData->bMovingFloater; pData->bMovingFloater = FALSE; bOldRgnType = pData->nRgnType; if (pData->bMagWnd) EndDialog(pData->hMagicWand, FALSE); pData->nRgnType = 0; pMRadDlgData = (LPMRADDLGDATA)GlobalAllocPtr(GHND, sizeof(MRADDLGDATA)); if(!pMRadDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_MRAD_DLG, hWnd, (DLGPROC)RdlMotnDlgProc, (LONG)pMRadDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pMRadDlgData, &pData->LeadBitmap, &pMRadDlgData->Bitmap, nRet); if (pData->bMagWnd) CreateDialog(hInst, MAKEINTRESOURCE(IDD_MGC_DLG), hWnd, MagicWandDlgProc); pData->bMovingFloater = bOldMoveFloater; pData->nRgnType = bOldRgnType; break; case IDM_IMAGE_PINCH: bOldMoveFloater = pData->bMovingFloater; pData->bMovingFloater = FALSE; bOldRgnType = pData->nRgnType; if (pData->bMagWnd) EndDialog(pData->hMagicWand, FALSE); pData->nRgnType = 0; pPinDlgData = (LPPINDLGDATA)GlobalAllocPtr(GHND, sizeof(PINDLGDATA)); if(!pPinDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_PIN_DLG, hWnd, (DLGPROC)PinchDlgProc, (LONG)pPinDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pPinDlgData, &pData->LeadBitmap, &pPinDlgData->Bitmap, nRet); if (pData->bMagWnd) CreateDialog(hInst, MAKEINTRESOURCE(IDD_MGC_DLG), hWnd, MagicWandDlgProc); pData->bMovingFloater = bOldMoveFloater; pData->nRgnType = bOldRgnType; break; case IDM_IMAGE_WVRAD: bOldMoveFloater = pData->bMovingFloater; pData->bMovingFloater = FALSE; bOldRgnType = pData->nRgnType; if (pData->bMagWnd) EndDialog(pData->hMagicWand, FALSE); pData->nRgnType = 0; pRadWavDlgData = (LPRADWAVDLGDATA)GlobalAllocPtr(GHND, sizeof(RADWAVDLGDATA)); if(!pRadWavDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_RADWAV_DLG, hWnd, (DLGPROC)RadWaveDlgProc, (LONG)pRadWavDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pRadWavDlgData, &pData->LeadBitmap, &pRadWavDlgData->Bitmap, nRet); if (pData->bMagWnd) CreateDialog(hInst, MAKEINTRESOURCE(IDD_MGC_DLG), hWnd, MagicWandDlgProc); pData->bMovingFloater = bOldMoveFloater; pData->nRgnType = bOldRgnType; break; case IDM_IMAGE_WIND: pWndDlgData = (LPWNDDLGDATA)GlobalAllocPtr(GHND, sizeof(WNDDLGDATA)); if(!pWndDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_WND_DLG, hWnd, (DLGPROC)WindDlgProc, (LONG)pWndDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pWndDlgData, &pData->LeadBitmap, &pWndDlgData->Bitmap, nRet); break; case IDM_IMAGE_WAVE: pWavDlgData = (LPWAVDLGDATA)GlobalAllocPtr(GHND, sizeof(WAVDLGDATA)); if(!pWavDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_WAV_DLG, hWnd, (DLGPROC)WaveDlgProc, (LONG)pWavDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pWavDlgData, &pData->LeadBitmap, &pWavDlgData->Bitmap, nRet); break; case IDM_IMAGE_MZOOM: bOldMoveFloater = pData->bMovingFloater; pData->bMovingFloater = FALSE; bOldRgnType = pData->nRgnType; if (pData->bMagWnd) EndDialog(pData->hMagicWand, FALSE); pData->nRgnType = 0; pMZomDlgData = (LPMZOMDLGDATA)GlobalAllocPtr(GHND, sizeof(MZOMDLGDATA)); if(!pMZomDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_MZOM_DLG, hWnd, (DLGPROC)MZomMotnDlgProc, (LONG)pMZomDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pMZomDlgData, &pData->LeadBitmap, &pMZomDlgData->Bitmap, nRet); if (pData->bMagWnd) CreateDialog(hInst, MAKEINTRESOURCE(IDD_MGC_DLG), hWnd, MagicWandDlgProc); pData->bMovingFloater = bOldMoveFloater; pData->nRgnType = bOldRgnType; break; case IDM_IMAGE_WAVEZOOM: bOldMoveFloater = pData->bMovingFloater; pData->bMovingFloater = FALSE; bOldRgnType = pData->nRgnType; if (pData->bMagWnd) EndDialog(pData->hMagicWand, FALSE); pData->nRgnType = 0; pZomWavDlgData = (LPZOMWAVDLGDATA)GlobalAllocPtr(GHND, sizeof(ZOMWAVDLGDATA)); if(!pZomWavDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_WVZOM_DLG, hWnd, (DLGPROC)ZomWaveDlgProc, (LONG)pZomWavDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pZomWavDlgData, &pData->LeadBitmap, &pZomWavDlgData->Bitmap, nRet); if (pData->bMagWnd) CreateDialog(hInst, MAKEINTRESOURCE(IDD_MGC_DLG), hWnd, MagicWandDlgProc); pData->bMovingFloater = bOldMoveFloater; pData->nRgnType = bOldRgnType; break; case IDM_IMAGE_IMPRESS: pImpDlgData = (LPIMPDLGDATA)GlobalAllocPtr(GHND, sizeof(IMPDLGDATA)); if(!pImpDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_IMP_DLG, hWnd, (DLGPROC)ImpresDlgProc, (LONG)pImpDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pImpDlgData, &pData->LeadBitmap, &pImpDlgData->Bitmap, nRet); break; case IDM_IMAGE_SHEAR: pShrDlgData = (LPSHRDLGDATA)GlobalAllocPtr(GHND, sizeof(SHRDLGDATA)); if(!pShrDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_SHR_DLG, hWnd, (DLGPROC)ShearDlgProc, (LONG)pShrDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pShrDlgData, &pData->LeadBitmap, &pShrDlgData->Bitmap, nRet); break; case IDM_IMAGE_SPHERE: bOldMoveFloater = pData->bMovingFloater; pData->bMovingFloater = FALSE; bOldRgnType = pData->nRgnType; if (pData->bMagWnd) EndDialog(pData->hMagicWand, FALSE); pData->nRgnType = 0; pSphDlgData = (LPSPHDLGDATA)GlobalAllocPtr(GHND, sizeof(SPHDLGDATA)); if(!pSphDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_SPH_DLG, hWnd, (DLGPROC)SpherDlgProc, (LONG)pSphDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pSphDlgData, &pData->LeadBitmap, &pSphDlgData->Bitmap, nRet); if (pData->bMagWnd) CreateDialog(hInst, MAKEINTRESOURCE(IDD_MGC_DLG), hWnd, MagicWandDlgProc); pData->bMovingFloater = bOldMoveFloater; pData->nRgnType = bOldRgnType; break; case IDM_IMAGE_SWIRL: bOldMoveFloater = pData->bMovingFloater; pData->bMovingFloater = FALSE; bOldRgnType = pData->nRgnType; if (pData->bMagWnd) EndDialog(pData->hMagicWand, FALSE); pData->nRgnType = 0; pSwrDlgData = (LPSWRDLGDATA)GlobalAllocPtr(GHND, sizeof(SWRDLGDATA)); if(!pSwrDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_SWR_DLG, hWnd, (DLGPROC)SwirlDlgProc, (LONG)pSwrDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pSwrDlgData, &pData->LeadBitmap, &pSwrDlgData->Bitmap, nRet); if (pData->bMagWnd) CreateDialog(hInst, MAKEINTRESOURCE(IDD_MGC_DLG), hWnd, MagicWandDlgProc); pData->bMovingFloater = bOldMoveFloater; pData->nRgnType = bOldRgnType; break; case IDM_IMAGE_RIPPEL: bOldMoveFloater = pData->bMovingFloater; pData->bMovingFloater = FALSE; bOldRgnType = pData->nRgnType; if (pData->bMagWnd) EndDialog(pData->hMagicWand, FALSE); pData->nRgnType = 0; pRipDlgData = (LPRIPDLGDATA)GlobalAllocPtr(GHND, sizeof(RIPDLGDATA)); if(!pRipDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_RIP_DLG, hWnd, (DLGPROC)RippleDlgProc, (LONG)pRipDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pRipDlgData, &pData->LeadBitmap, &pRipDlgData->Bitmap, nRet); if (pData->bMagWnd) CreateDialog(hInst, MAKEINTRESOURCE(IDD_MGC_DLG), hWnd, MagicWandDlgProc); pData->bMovingFloater = bOldMoveFloater; pData->nRgnType = bOldRgnType; break; case IDM_IMAGE_HISTOGRAMEQUALIZE: pHsEqDlgData = (LPHSEQDLGDATA)GlobalAllocPtr(GHND, sizeof(HSEQDLGDATA)); if(!pHsEqDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_HSEQ_DLG, hWnd, (DLGPROC)HsEqDlgProc, (LONG)pHsEqDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pHsEqDlgData, &pData->LeadBitmap, &pHsEqDlgData->Bitmap, nRet); break; case IDM_IMAGE_ADDBITMAP: pAddDlgData= (LPADDDLGDATA)GlobalAllocPtr(GHND, sizeof(ADDDLGDATA)); if(!pAddDlgData) return; nRet = DoDialogBoxParam(IDD_ADBM_DLG, hWnd, (DLGPROC)AddDialog, (LONG)pAddDlgData); StatusProc.bProgress = FALSE; StatusProc.bKillProgress = TRUE ; StatusProc.ProgressValue = 100; InvalidateRect(hWnd, NULL, FALSE); SetStatusColorAndPixel(hWnd); break; case IDM_IMAGE_REDEYEREMOVE: pRedEyeData = (LPREDEYEDATA)GlobalAllocPtr(GHND, sizeof(REDEYEDATA)); if (!pRedEyeData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_REYE_DLG, hWnd, (DLGPROC)RedEyeWndProc, (long)pRedEyeData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pRedEyeData, &pData->LeadBitmap, &pRedEyeData->LeadBitmap, nRet); break; case IDM_IMAGE_OPACITY: pOpctyDlgData = (LPOPCDLGDATA)GlobalAllocPtr(GHND, sizeof(OPCDLGDATA)); if (!pOpctyDlgData) return; nRet = DoDialogBoxParam(IDD_OPCT_DLG, hWnd, (DLGPROC)OpacityWndProc, (long)pOpctyDlgData); if(pOpctyDlgData) GlobalFreePtr(pOpctyDlgData); StatusProc.bProgress = FALSE; StatusProc.bKillProgress = TRUE; StatusProc.ProgressValue = 100; InvalidateRect(hWnd, NULL, FALSE); break; case IDM_IMAGE_COMBINE: pCombDlgData = (LPCOMBDLGDATA)GlobalAllocPtr(GHND, sizeof(COMBDLGDATA)); if (!pCombDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_COMB_DLG, hWnd, (DLGPROC)CombineWndProc, (long)pCombDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pCombDlgData, &pData->LeadBitmap, &pCombDlgData->DstBitmap, nRet); break; case IDM_IMAGE_LINEHISTOGRAM: pLnProfDlgData = (LPLNPROFDLGDATA)GlobalAllocPtr(GHND, sizeof(LNPROFDLGDATA)); if (!pLnProfDlgData) return; nRet = DoDialogBoxParam(IDD_LHS_DLG, hWnd, (DLGPROC)LnProfDlgProc, (long)pLnProfDlgData); break; case IDM_IMAGE_FADEMASK: pFdMskDlgData = (LPFDMSKDLGDATA)GlobalAllocPtr(GHND, sizeof(FDMSKDLGDATA)); if (!pFdMskDlgData) return; nRet = DoDialogBoxParam(IDD_FADE_DLG, hWnd, (DLGPROC)FdMskWndProc, (long)pFdMskDlgData); StatusProc.bProgress = FALSE; StatusProc.bKillProgress = TRUE; StatusProc.ProgressValue = 100; InvalidateRect(hWnd, NULL, FALSE); break; case IDM_IMAGE_FEATHER: pFeatherData = (LPFEATHERDLGDATA)GlobalAllocPtr(GHND, sizeof(FEATHERDLGDATA)); if (!pFeatherData) return; nRet = DoDialogBoxParam(IDD_FTHR_DLG, hWnd, (DLGPROC)FeatherWndProc, (long)pFeatherData); StatusProc.bProgress = FALSE; StatusProc.bKillProgress = TRUE; StatusProc.ProgressValue = 100; InvalidateRect(hWnd, NULL, FALSE); break; case IDM_VIEW_ADDBORDER: { L_TCHAR szTitle [ 50 ] = TEXT("Browse For Border Tiles:") ; GETDIRECTORYDLGPARAMS DirectoryDlgParams ; ZeroMemory (&DirectoryDlgParams, sizeof(GETDIRECTORYDLGPARAMS)); DirectoryDlgParams.uStructSize = sizeof (GETDIRECTORYDLGPARAMS); DirectoryDlgParams.pszDirectory = malloc ( L_MAXPATH * 2 ) ; DirectoryDlgParams.pszTitle = TEXT("Select Border Images Folder") ; DirectoryDlgParams.nBuffSize = L_MAXPATH * sizeof(L_TCHAR) ; DirectoryDlgParams.pszFilter = NULL ; DirectoryDlgParams.nFilterIndex = 1 ; nRet = L_DlgGetDirectory ( hWnd, &DirectoryDlgParams ) ; // Get the Border directory if ( nRet == SUCCESS_DLG_OK ) { DLGBITMAPLIST BitmapList ; DLGBITMAPLISTITEM BitmapListItem [IMAGES_COUNT] ; THUMBOPTIONS ThumbOption; L_INT nI; //SHGetPathFromIDList ( pResult, szPath ) ; ZeroMemory ( &BitmapList, sizeof(DLGBITMAPLIST)); nBitmapsCount = -1 ; for ( nI = 0; nI < IMAGES_COUNT; nI++ ) { BitmapListItem[nI].pszFileName = malloc ( _MAX_PATH + 1 ); BitmapListItem[nI].pBitmap = malloc (sizeof (BITMAPHANDLE)); } ThumbOption.nWidth = 115; ThumbOption.nHeight = 115; ThumbOption.bResample = TRUE; ThumbOption.bMaintainAspect = TRUE; ThumbOption.bLoadStamp = FALSE; ThumbOption.nBits = 24; ThumbOption.crBackColor = RGB(0,0,0); ThumbOption.uCRFlags = 0; ThumbOption.uStructSize = sizeof(THUMBOPTIONS); nRet = L_BrowseDir(DirectoryDlgParams.pszDirectory, TEXT("*.*"), &ThumbOption, 0, TRUE, FALSE, 0, 4000*1024, (BROWSEDIRCALLBACK)BrowseBitmapsCB, &BitmapListItem ); if ( nBitmapsCount < 0 ) { MessageBox ( NULL, TEXT("There are file(s)cannot be loaded"), TEXT("Error"), 0 ); } else { BitmapList.nCount = nBitmapsCount + 1 ; BitmapList.pBitmapList = (DLGBITMAPLISTITEM*)&BitmapListItem ; } pData = LOCKCHILDDATA (hWnd); AddborderParams.pBitmapList = &BitmapList ; AddborderParams.pBitmap = &pData->LeadBitmap; AddborderParams.pfnHelpCallback = NULL; AddborderParams.pHelpCallBackUserData = NULL; AddborderParams.uStructSize = sizeof(ADDBORDERDLGPARAMS); AddborderParams.uDlgFlags = DLG_ADDBORDER_SHOW_PREVIEW |DLG_ADDBORDER_SHOW_TOOL_ZOOMLEVEL; nRet = L_DlgAddBorder ( hWnd, &AddborderParams); if ( SUCCESS_DLG_OK == nRet ) { ADDBORDERINFO AddBorderInfo; ZeroMemory ( &AddBorderInfo, sizeof (ADDBORDERINFO)); // Load the bitmap in its original size (NOT THUMBNAIL ) if ( L_LoadBitmap (BitmapList.pBitmapList [ AddborderParams.nTileBitmapIndex ].pszFileName, BitmapList.pBitmapList [ AddborderParams.nTileBitmapIndex ].pBitmap, sizeof(BITMAPHANDLE), 24, ORDER_BGR, NULL, NULL )== SUCCESS ) { AddBorderInfo.nLeftThickness = AddborderParams.nLeftThickness ; AddBorderInfo.nTopThickness = AddborderParams.nTopThickness ; AddBorderInfo.nRightThickness = AddborderParams.nRightThickness ; AddBorderInfo.nBottomThickness = AddborderParams.nBottomThickness; AddBorderInfo.nLocation = AddborderParams.nLocation ; AddBorderInfo.nStyle = AddborderParams.nStyle ; AddBorderInfo.nEffectStyle = AddborderParams.nEffectStyle ; AddBorderInfo.nGradientStyle = AddborderParams.nGradientStyle ; AddBorderInfo.crGradientStart = (AddborderParams.nStyle & BORDER_STYLE_OPAQUE) ? AddborderParams.crOpaque : AddborderParams.crGradientStart; AddBorderInfo.crGradientEnd = AddborderParams.crGradientEnd ; AddBorderInfo.nCurveIntensity = AddborderParams.nCurveIntensity ; AddBorderInfo.bSoftCurve = AddborderParams.bSoftCurve ; AddBorderInfo.bShadow = AddborderParams.bShadow ; AddBorderInfo.nShadowSize = AddborderParams.nShadowSize ; AddBorderInfo.nShadowDirection = AddborderParams.nShadowDirection; AddBorderInfo.bBumpyShadow = AddborderParams.bBumpyShadow ; AddBorderInfo.uStructSize = sizeof(ADDBORDERINFO); AddBorderInfo.pTileBitmap = BitmapList.pBitmapList [AddborderParams.nTileBitmapIndex].pBitmap; // Status Progress InitOneTikeDataBefor(hWnd, &StatusBitmap, &pData->LeadBitmap, 10); nRet = L_AddBorder (&pData->LeadBitmap, &AddBorderInfo); InitOneTikeDataAfter(hWnd, &StatusBitmap, &pData->LeadBitmap, 10, nRet); if (pData->bmSave.Flags.Allocated) // my addition L_FreeBitmap(&pData->bmSave); } } //Free the bitmap list if ( NULL != BitmapList.pBitmapList ) { //Free the list items for ( nI = 0 ; nI <= nBitmapsCount; nI++ ) { L_FreeBitmap ( BitmapListItem[nI].pBitmap ); free (BitmapListItem[nI].pBitmap); free (BitmapListItem[nI].pszFileName); } BitmapList.pBitmapList = NULL ; } UNLOCKCHILDDATA (hWnd); } pData->uTimerID = SetTimer(hWnd, 1, 100, NULL); } break; case IDM_VIEW_ADDFRAME: { //BROWSEINFO BrowseInfo ; //LPITEMIDLIST pResult ; //TCHAR szPath [ MAX_PATH ] = "" ; L_TCHAR szTitle [ 50 ] = TEXT("Browse For Frame Tiles:") ; GETDIRECTORYDLGPARAMS DirectoryDlgParams ; ZeroMemory (&DirectoryDlgParams, sizeof(GETDIRECTORYDLGPARAMS)); DirectoryDlgParams.uStructSize = sizeof (GETDIRECTORYDLGPARAMS); DirectoryDlgParams.pszDirectory = malloc ( L_MAXPATH * 2 ) ; DirectoryDlgParams.pszTitle = TEXT("Select Border Images Folder") ; DirectoryDlgParams.nBuffSize = L_MAXPATH * sizeof(L_TCHAR) ; DirectoryDlgParams.pszFilter = NULL ; DirectoryDlgParams.nFilterIndex = 1 ; nRet = L_DlgGetDirectory ( hWnd, &DirectoryDlgParams ) ; // Get the Border directory if ( nRet == SUCCESS_DLG_OK ) { DLGBITMAPLIST BitmapList ; DLGBITMAPLISTITEM BitmapListItem [IMAGES_COUNT] ; THUMBOPTIONS ThumbOption; L_INT nI; // SHGetPathFromIDList ( pResult, szPath ) ; ZeroMemory ( &BitmapList, sizeof(DLGBITMAPLIST)); nBitmapsCount = -1 ; for ( nI = 0; nI < IMAGES_COUNT; nI++ ) { BitmapListItem[nI].pszFileName = malloc ( _MAX_PATH + 1 ); BitmapListItem[nI].pBitmap = malloc (sizeof (BITMAPHANDLE)); } ThumbOption.nWidth = 115; ThumbOption.nHeight = 115; ThumbOption.bResample = TRUE; ThumbOption.bMaintainAspect = TRUE; ThumbOption.bLoadStamp = FALSE; ThumbOption.nBits = 24; ThumbOption.crBackColor = RGB(0,0,0); ThumbOption.uCRFlags = 0; ThumbOption.uStructSize = sizeof(THUMBOPTIONS); SetCursor(LoadCursor(NULL, IDC_WAIT)); nRet = L_BrowseDir(DirectoryDlgParams.pszDirectory, TEXT("*.*"), &ThumbOption, 0, TRUE, FALSE, 0, 4000*1024, (BROWSEDIRCALLBACK)BrowseBitmapsCB, &BitmapListItem ); if ( nBitmapsCount < 0 ) { MessageBox ( NULL, TEXT("There are file(s)cannot be loaded"), TEXT("Error"), 0 ); } else { BitmapList.nCount = nBitmapsCount + 1 ; BitmapList.pBitmapList = (DLGBITMAPLISTITEM*)&BitmapListItem ; } AddframeParams.pBitmapList = &BitmapList ; pData = LOCKCHILDDATA (hWnd); AddframeParams.pBitmap = &pData->LeadBitmap; AddframeParams.pfnHelpCallback = NULL; AddframeParams.pHelpCallBackUserData = NULL; AddframeParams.uStructSize = sizeof(ADDFRAMEDLGPARAMS); AddframeParams.uDlgFlags = DLG_ADDFRAME_SHOW_PREVIEW |DLG_ADDFRAME_SHOW_TOOL_ZOOMLEVEL; nRet = L_DlgAddFrame ( hWnd, &AddframeParams ); SetCursor(LoadCursor(NULL, IDC_ARROW)); if (nRet == SUCCESS_DLG_OK) { ADDFRAMEINFO AddFrameInfo ; ZeroMemory ( &AddFrameInfo, sizeof ( ADDFRAMEINFO )); // Load the bitmap in its original size (NOT THUMBNAIL ) if ( L_LoadBitmap ( BitmapList.pBitmapList[AddframeParams.nFrameBitmapIndex].pszFileName, BitmapList.pBitmapList[AddframeParams.nFrameBitmapIndex].pBitmap, sizeof(BITMAPHANDLE), 24, ORDER_BGR, NULL, NULL) == SUCCESS) { AddFrameInfo.pBitmapFrame = BitmapList.pBitmapList [ AddframeParams.nFrameBitmapIndex ].pBitmap ; AddFrameInfo.bKeepFrameState = FALSE ; AddFrameInfo.bUseMask = AddframeParams.bUseMask; AddFrameInfo.nLocation = AddframeParams.nLocation; AddFrameInfo.nQuality = FRAME_QUALITY_HIGH; AddFrameInfo.SmoothEdge = AddframeParams.SmoothEdge; AddFrameInfo.crMask = AddframeParams.crMask; AddFrameInfo.uStructSize = sizeof(ADDFRAMEINFO); InitOneTikeDataBefor(hWnd, &StatusBitmap, &pData->LeadBitmap, 10); nRet = L_AddFrame(&pData->LeadBitmap, &AddFrameInfo); InitOneTikeDataAfter(hWnd, &StatusBitmap, &pData->LeadBitmap, 10, nRet); if (pData->bmSave.Flags.Allocated) L_FreeBitmap(&pData->bmSave); } } //Free the bitmap list if ( NULL != BitmapList.pBitmapList) { //Free the list items for ( nI = 0 ; nI < IMAGES_COUNT ; nI++ ) { if ( nI < ( nBitmapsCount + 1)) { L_FreeBitmap ( BitmapListItem[nI].pBitmap ); } free (BitmapListItem[nI].pBitmap); free (BitmapListItem[nI].pszFileName); } BitmapList.pBitmapList = NULL ; } UNLOCKCHILDDATA (hWnd); } pData->uTimerID = SetTimer(hWnd, 1, 100, NULL); } break; case IDM_COLOR_BALANCECOLOR: { SetCursor (LoadCursor(NULL, IDC_WAIT)); MemorizeBitmap (hWnd); //MEMDISK memset(&BalanceColorsParams, 0, sizeof(BALANCECOLORSDLGPARAMS)); BalanceColorsParams.pBitmap = &pData->LeadBitmap; BalanceColorsParams.RedFactor.toRed = 1; BalanceColorsParams.GreenFactor.toGreen = 1; BalanceColorsParams.BlueFactor.toBlue = 1; BalanceColorsParams.pHelpCallBackUserData = NULL ; BalanceColorsParams.RedFactor.uStructSize = sizeof(BALANCING); BalanceColorsParams.GreenFactor.uStructSize = sizeof(BALANCING); BalanceColorsParams.BlueFactor.uStructSize = sizeof(BALANCING); BalanceColorsParams.uStructSize = sizeof(BALANCECOLORSDLGPARAMS); BalanceColorsParams.uDlgFlags = DLG_BALANCECOLORS_SHOW_PREVIEW |DLG_BALANCECOLORS_SHOW_TOOL_ZOOMLEVEL; if (L_DlgBalanceColors (hWnd, &BalanceColorsParams)== SUCCESS_DLG_OK) { InitOneTikeDataBefor(hWnd, &StatusBitmap, &pData->LeadBitmap, 10); nRet = L_BalanceColors (&pData->LeadBitmap, &BalanceColorsParams.RedFactor, &BalanceColorsParams.GreenFactor, &BalanceColorsParams.BlueFactor); InitOneTikeDataAfter(hWnd, &StatusBitmap, &pData->LeadBitmap, 10, nRet); } } pData->uTimerID = SetTimer(hWnd, 1, 100, NULL); break; case IDM_IMAGE_RESIZE: memset(&ResizeParams, 0, sizeof(RESIZEDLGPARAMS)); MemorizeBitmap (hWnd); //MEMDISK ResizeParams.pBitmap = &pData->LeadBitmap; ResizeParams.uStructSize = sizeof(RESIZEDLGPARAMS); ResizeParams.uOriginalBitsPerPixel = pData->LeadBitmap.BitsPerPixel; ResizeParams.uNewHeight = pData->LeadBitmap.Height; ResizeParams.uNewWidth = pData->LeadBitmap.Width; ResizeParams.uResize = SIZE_BICUBIC; ResizeParams.uNewResolutionX = 150; ResizeParams.uNewResolutionY = 150; ResizeParams.uOriginalWidth = pData->LeadBitmap.Width; ResizeParams.uOriginalHeight = pData->LeadBitmap.Height; ResizeParams.uOriginalResolutionX = 150; ResizeParams.uOriginalResolutionY = 150; ResizeParams.uDlgFlags = DLG_RESIZE_SHOW_IDENTICALVALUE |DLG_RESIZE_SHOW_MAINTAINASPECT |DLG_RESIZE_SHOW_PERCENTAGE |DLG_RESIZE_SHOW_RESOLUTIONGRP |DLG_RESIZE_MAINTAINASPECT; nRet = L_DlgResize (hWnd, &ResizeParams) ; if (nRet == SUCCESS_DLG_OK) { RECT rcClient; InitOneTikeDataBefor(hWnd, &StatusBitmap, &pData->LeadBitmap, 10); nRet = L_SizeBitmap( &pData->LeadBitmap, ResizeParams.uNewWidth, ResizeParams.uNewHeight, ResizeParams.uResize); InitOneTikeDataAfter(hWnd, &StatusBitmap, &pData->LeadBitmap, 10, nRet); if (pData->bmSave.Flags.Allocated) L_FreeBitmap(&pData->bmSave); GetClientRect (pData->hBitmapWnd, &rcClient); Child_OnSize (hWnd, IsIconic (hWnd) ? SIZEICONIC : IsZoomed(hWnd) ? SIZEFULLSCREEN : SIZENORMAL, RECTWIDTH (&rcClient), RECTHEIGHT(&rcClient)); } pData->uTimerID = SetTimer(hWnd, 1, 100, NULL); InvalidateRect(hWnd, NULL, TRUE); break; case IDM_IMAGE_CLRRES: memset(&ColorResParams, 0, sizeof(COLORRESDLGPARAMS)); MemorizeBitmap(hWnd); ColorResParams.pBitmap = &pData->LeadBitmap; ColorResParams.nBitsPerPixel = pData->LeadBitmap.BitsPerPixel; ColorResParams.uStructSize = sizeof(COLORRESDLGPARAMS); ColorResParams.uColorResFlags = 0; ColorResParams.uDlgFlagsEx = DLG_COLORRES_SHOW_DITHER_ALL | DLG_COLORRES_SHOW_BITALL | DLG_COLORRES_SHOW_DITHER_ALL | DLG_COLORRES_SHOW_PAL_ALL; // check later ColorResParams.uDlgFlags = DLG_COLORRES_SHOW_PREVIEW | DLG_COLORRES_SHOW_ORDER | DLG_COLORRES_SHOW_OPENPALFILE| DLG_COLORRES_SHOW_PREVIEW | DLG_COLORRES_SHOW_TOOL_ZOOMLEVEL; nRet = L_DlgColorRes(hWnd, &ColorResParams); if (nRet == SUCCESS_DLG_OK) { InitOneTikeDataBefor(hWnd, &StatusBitmap, &pData->LeadBitmap, 10); nRet = L_ColorResBitmap(&pData->LeadBitmap, &pData->LeadBitmap, sizeof(BITMAPHANDLE), ColorResParams.nBitsPerPixel, ColorResParams.uColorResFlags, NULL, ColorResParams.hpalCustom, pData->LeadBitmap.nColors, NULL, NULL); InitOneTikeDataAfter(hWnd, &StatusBitmap, &pData->LeadBitmap, 10, nRet); } pData->uTimerID = SetTimer(hWnd, 1, 100, NULL); break; case IDM_IMAGE_GRAY8: InitOneTikeDataBefor(hWnd, &StatusBitmap, &pData->LeadBitmap, 10); nRet = L_GrayScaleBitmap(&pData->LeadBitmap, 8); InitOneTikeDataAfter(hWnd, &StatusBitmap, &pData->LeadBitmap, 10, nRet); break; case IDM_IMAGE_GRAY12: InitOneTikeDataBefor(hWnd, &StatusBitmap, &pData->LeadBitmap, 10); nRet = L_GrayScaleBitmap(&pData->LeadBitmap, 12); InitOneTikeDataAfter(hWnd, &StatusBitmap, &pData->LeadBitmap, 10, nRet); break; case IDM_IMAGE_GRAY16: InitOneTikeDataBefor(hWnd, &StatusBitmap, &pData->LeadBitmap, 10); nRet = L_GrayScaleBitmap(&pData->LeadBitmap, 16); InitOneTikeDataAfter(hWnd, &StatusBitmap, &pData->LeadBitmap, 10, nRet); break; case IDM_COLOR_COLOREDGRAY: SetCursor (LoadCursor(NULL, IDC_WAIT)); MemorizeBitmap (hWnd); //MEMDISK ColoredGrayParams.pBitmap = &pData->LeadBitmap; ColoredGrayParams.uStructSize = sizeof(COLOREDGRAYDLGPARAMS); ColoredGrayParams.uDlgFlags = DLG_COLOREDGRAY_SHOW_PREVIEW |DLG_COLOREDGRAY_SHOW_TOOL_ZOOMLEVEL; nRet = L_DlgColoredGray (hWnd, &ColoredGrayParams); if (nRet == SUCCESS_DLG_OK) { InitOneTikeDataBefor(hWnd, &StatusBitmap, &pData->LeadBitmap, 10); nRet = L_ConvertToColoredGray (&pData->LeadBitmap, ColoredGrayParams.nRedFactor, ColoredGrayParams.nGreenFactor, ColoredGrayParams.nBlueFactor, ColoredGrayParams.nRedGrayFactor, ColoredGrayParams.nGreenGrayFactor, ColoredGrayParams.nBlueGrayFactor); InitOneTikeDataAfter(hWnd, &StatusBitmap, &pData->LeadBitmap, 10, nRet); } pData->uTimerID = SetTimer(hWnd, 1, 100, NULL); break; case IDM_COLOR_CONVERTTOGRAY: SetCursor (LoadCursor(NULL, IDC_WAIT)); MemorizeBitmap (hWnd); //MEMDISK GrayScaleParams.pBitmap = &pData->LeadBitmap ; GrayScaleParams.pHelpCallBackUserData = NULL ; GrayScaleParams.uStructSize = sizeof(GRAYSCALEDLGPARAMS); GrayScaleParams.uDlgFlags = DLG_GRAYSCALE_SHOW_PREVIEW |DLG_GRAYSCALE_SHOW_TOOL_ZOOMLEVEL; if ( L_DlgGrayScale ( hWnd, &GrayScaleParams )== SUCCESS_DLG_OK) { InitOneTikeDataBefor(hWnd, &StatusBitmap, &pData->LeadBitmap, 10); nRet = L_GrayScaleBitmapExt(&pData->LeadBitmap, GrayScaleParams.nRedFactor, GrayScaleParams.nGreenFactor, GrayScaleParams.nBlueFactor); InitOneTikeDataAfter(hWnd, &StatusBitmap, &pData->LeadBitmap, 10, nRet); } pData->uTimerID = SetTimer(hWnd, 1, 100, NULL); break; case IDM_COLOR_HALFTONE: pHalfToneData = (LPHTONEDLGDATA)GlobalAllocPtr(GHND, sizeof(HTONEDLGDATA)); if (!pHalfToneData) return; InitDataBeforDlg(10); { L_UINT nIndex; nRet = DoDialogBoxParam(IDD_HTONE_DLG, hWnd, (DLGPROC)HToneWndProc, (long)pHalfToneData); L_GetBitmapListCount(pHalfToneData->hListDirectory, &nIndex); L_DeleteBitmapListItems(pHalfToneData->hListDirectory, 0, nIndex); for (nIndex = 0; nIndex < pHalfToneData->uListCount; nIndex++) L_RemoveBitmapListItem(pHalfToneData->hListMultiple, 0, NULL); L_DestroyBitmapList(pHalfToneData->hListDirectory); L_DestroyBitmapList(pHalfToneData->hListMultiple); } InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pHalfToneData, &pData->LeadBitmap, &pHalfToneData->LeadBitmap, nRet); break; case IDM_COLOR_PICTURIZE: pPicDlgData = (LPPICDLGDATA)GlobalAllocPtr(GHND, sizeof(PICDLGDATA)); if (!pPicDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_PIC_DLG, hWnd, (DLGPROC)PictzWndProc, (long)pPicDlgData); { L_UINT nIndex; L_GetBitmapListCount(pPicDlgData->hListDirectory, &nIndex); L_DeleteBitmapListItems(pPicDlgData->hListDirectory, 0, nIndex); for (nIndex = 0; nIndex < pPicDlgData->uListCount; nIndex++) L_RemoveBitmapListItem(pPicDlgData->hListMultiple, 0, NULL); L_DestroyBitmapList(pPicDlgData->hListDirectory); L_DestroyBitmapList(pPicDlgData->hListMultiple); } InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pPicDlgData, &pData->LeadBitmap, &pPicDlgData->LeadBitmap, nRet); break; case IDM_IMAGE_DEINTERLACE: pDeIntData = (LPDEINTERDATA)GlobalAllocPtr(GHND, sizeof(DEINTERDATA)); if (!pDeIntData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_DEINT_DLG, hWnd, (DLGPROC)DeInterlaceBitmap, (long)pDeIntData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pDeIntData, &pData->LeadBitmap, &pDeIntData->Bitmap, nRet); break; case IDM_COLOR_SWAPCOLOR: pSwpDlgData = (LPSWPDLGDATA)GlobalAllocPtr(GHND, sizeof(SWPDLGDATA)); if (!pSwpDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_SWP_DLG, hWnd, (DLGPROC)SwapDlgProc, (long)pSwpDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pSwpDlgData, &pData->LeadBitmap, &pSwpDlgData->Bitmap, nRet); break; case IDM_IMAGE_UNSHARP: SetCursor (LoadCursor(NULL, IDC_WAIT)); MemorizeBitmap (hWnd); //MEMDISK UnsharpMaskParams.pBitmap = &pData->LeadBitmap; UnsharpMaskParams.pfnHelpCallback = NULL; UnsharpMaskParams.pHelpCallBackUserData = NULL; UnsharpMaskParams.uStructSize = sizeof(UNSHARPMASKDLGPARAMS); UnsharpMaskParams.uDlgFlags = DLG_UNSHARPMASK_SHOW_PREVIEW |DLG_UNSHARPMASK_SHOW_TOOL_ZOOMLEVEL; if(L_DlgUnsharpMask(hWnd, &UnsharpMaskParams) == SUCCESS_DLG_OK) { InitOneTikeDataBefor(hWnd, &StatusBitmap, &pData->LeadBitmap, 10); StatusProc.bInvalidate = FALSE; nRet = L_UnsharpMaskBitmap (&pData->LeadBitmap, UnsharpMaskParams.nAmount, UnsharpMaskParams.nRadius, UnsharpMaskParams.nThreshold, UnsharpMaskParams.uUnshrpMaskFlags); InitOneTikeDataAfter(hWnd, &StatusBitmap, &pData->LeadBitmap, 10, nRet); } pData->uTimerID = SetTimer(hWnd, 1, 100, NULL); break; case IDM_IMAGE_ANTIALIAS: SetCursor (LoadCursor(NULL, IDC_WAIT)); MemorizeBitmap (hWnd); //MEMDISK AntiAliasParams.pBitmap = &pData->LeadBitmap; AntiAliasParams.uStructSize = sizeof(ANTIALIASDLGPARAMS); AntiAliasParams.pfnHelpCallback = NULL; AntiAliasParams.pHelpCallBackUserData = NULL; AntiAliasParams.uDlgFlags = DLG_ANTIALIAS_SHOW_PREVIEW |DLG_ANTIALIAS_SHOW_TOOL_ZOOMLEVEL; if(L_DlgAntiAlias (hWnd, &AntiAliasParams) == SUCCESS_DLG_OK) { InitOneTikeDataBefor(hWnd, &StatusBitmap, &pData->LeadBitmap, 10); nRet = L_AntiAliasBitmap (&pData->LeadBitmap, AntiAliasParams.uThreshold, AntiAliasParams.uDim, AntiAliasParams.uFilter); InitOneTikeDataAfter(hWnd, &StatusBitmap, &pData->LeadBitmap, 10, nRet); } pData->uTimerID = SetTimer(hWnd, 1, 100, NULL); break; case IDM_IMAGE_REMAPINTENSITY: SetCursor (LoadCursor(NULL, IDC_WAIT)); MemorizeBitmap (hWnd); //MEMDISK RemapIntensityParams.pBitmap = &pData->LeadBitmap ; RemapIntensityParams.pfnHelpCallback = NULL; RemapIntensityParams.pHelpCallBackUserData = NULL; RemapIntensityParams.uStructSize = sizeof(REMAPINTENSITYDLGPARAMS); RemapIntensityParams.uDlgFlags = DLG_REMAPINTENSITY_SHOW_PREVIEW |DLG_REMAPINTENSITY_SHOW_TOOL_ZOOMLEVEL; if ( (nRet = L_DlgRemapIntensity ( hWnd, &RemapIntensityParams))== SUCCESS_DLG_OK) { InitOneTikeDataBefor(hWnd, &StatusBitmap, &pData->LeadBitmap, 10); nRet = L_RemapBitmapIntensity(&pData->LeadBitmap, RemapIntensityParams.puRGBLookup, RemapIntensityParams.uLookupLen, CHANNEL_MASTER); if (nRet == SUCCESS) nRet = L_RemapBitmapIntensity(&pData->LeadBitmap, RemapIntensityParams.puRedLookup, RemapIntensityParams.uLookupLen, CHANNEL_RED); if (nRet == SUCCESS) nRet = L_RemapBitmapIntensity(&pData->LeadBitmap, RemapIntensityParams.puGreenLookup, RemapIntensityParams.uLookupLen, CHANNEL_GREEN); if (nRet== SUCCESS) nRet = L_RemapBitmapIntensity(&pData->LeadBitmap, RemapIntensityParams.puBlueLookup, RemapIntensityParams.uLookupLen, CHANNEL_BLUE); if (RemapIntensityParams.puRGBLookup) GlobalFree ((HGLOBAL)RemapIntensityParams.puRGBLookup ); if (RemapIntensityParams.puRedLookup) GlobalFree ((HGLOBAL)RemapIntensityParams.puRedLookup ); if (RemapIntensityParams.puGreenLookup) GlobalFree ((HGLOBAL)RemapIntensityParams.puGreenLookup ); if (RemapIntensityParams.puBlueLookup) GlobalFree ((HGLOBAL)RemapIntensityParams.puBlueLookup ); InitOneTikeDataAfter(hWnd, &StatusBitmap, &pData->LeadBitmap, 10, nRet); } pData->uTimerID = SetTimer(hWnd, 1, 100, NULL); break; case IDM_IMAGE_GAUSSIANBLUR: SetCursor (LoadCursor(NULL, IDC_WAIT)); MemorizeBitmap (hWnd); //MEMDISK GaussianBlurParams.pBitmap = &pData->LeadBitmap; GaussianBlurParams.pfnHelpCallback = NULL; GaussianBlurParams.pHelpCallBackUserData = NULL; GaussianBlurParams.uStructSize = sizeof(GAUSSIANBLURDLGPARAMS); GaussianBlurParams.uDlgFlags = DLG_GAUSSIANBLUR_SHOW_PREVIEW |DLG_GAUSSIANBLUR_SHOW_TOOL_ZOOMLEVEL; if(L_DlgGaussianBlur(hWnd, &GaussianBlurParams ) == SUCCESS_DLG_OK) { InitOneTikeDataBefor(hWnd, &StatusBitmap, &pData->LeadBitmap, 10); StatusProc.bInvalidate = FALSE; nRet = L_GaussianFilterBitmap ( &pData->LeadBitmap, GaussianBlurParams.nRadius ); InitOneTikeDataAfter(hWnd, &StatusBitmap, &pData->LeadBitmap, 10, nRet); } pData->uTimerID = SetTimer(hWnd, 1, 100, NULL); break; case IDM_IMAGE_MOTIONBLUR: SetCursor (LoadCursor(NULL, IDC_WAIT)); MemorizeBitmap (hWnd); //MEMDISK MotionBlurParams.pBitmap = &pData->LeadBitmap; MotionBlurParams.pfnHelpCallback = NULL; MotionBlurParams.pHelpCallBackUserData = NULL; MotionBlurParams.uStructSize = sizeof(MOTIONBLURDLGPARAMS); MotionBlurParams.uDlgFlags = DLG_EDGEDETECTOR_SHOW_PREVIEW |DLG_EDGEDETECTOR_SHOW_TOOL_ZOOMLEVEL; if ( L_DlgMotionBlur ( hWnd, &MotionBlurParams )== SUCCESS_DLG_OK) { InitOneTikeDataBefor(hWnd, &StatusBitmap, &pData->LeadBitmap, 10); nRet = L_MotionBlurBitmap ( &pData->LeadBitmap, MotionBlurParams.uDim, MotionBlurParams.nAngle, MotionBlurParams.bUnidirectional ); InitOneTikeDataAfter(hWnd, &StatusBitmap, &pData->LeadBitmap, 10, nRet); } pData->uTimerID = SetTimer(hWnd, 1, 100, NULL); break; case IDM_IMAGE_MIN: SetCursor (LoadCursor(NULL, IDC_WAIT)); MemorizeBitmap (hWnd); //MEMDISK MinFilterParams.pBitmap = &pData->LeadBitmap; MinFilterParams.uDim = 3; MinFilterParams.pfnHelpCallback = NULL; MinFilterParams.pHelpCallBackUserData = NULL; MinFilterParams.uStructSize = sizeof(MINFILTERDLGPARAMS); MinFilterParams.uDlgFlags = DLG_MINFILTER_SHOW_PREVIEW |DLG_MINFILTER_SHOW_TOOL_ZOOMLEVEL; if (L_DlgMinFilter(hWnd, &MinFilterParams) == SUCCESS_DLG_OK) { InitOneTikeDataBefor(hWnd, &StatusBitmap, &pData->LeadBitmap, 10); nRet = L_MinFilterBitmap(&pData->LeadBitmap, MinFilterParams.uDim); InitOneTikeDataAfter(hWnd, &StatusBitmap, &pData->LeadBitmap, 10, nRet); } pData->uTimerID = SetTimer(hWnd, 1, 100, NULL); break; case IDM_IMAGE_MAX: SetCursor (LoadCursor(NULL, IDC_WAIT)); MemorizeBitmap (hWnd); //MEMDISK MaxFilterParams.pBitmap = &pData->LeadBitmap; MaxFilterParams.uDim = 3; MaxFilterParams.pfnHelpCallback = NULL; MaxFilterParams.pHelpCallBackUserData = NULL; MaxFilterParams.uStructSize = sizeof(MAXFILTERDLGPARAMS); MaxFilterParams.uDlgFlags = DLG_MAXFILTER_SHOW_PREVIEW |DLG_MAXFILTER_SHOW_TOOL_ZOOMLEVEL; if (L_DlgMaxFilter(hWnd, &MaxFilterParams) == SUCCESS_DLG_OK) { InitOneTikeDataBefor(hWnd, &StatusBitmap, &pData->LeadBitmap, 10); nRet = L_MaxFilterBitmap(&pData->LeadBitmap, MaxFilterParams.uDim); InitOneTikeDataAfter(hWnd, &StatusBitmap, &pData->LeadBitmap, 10, nRet); } pData->uTimerID = SetTimer(hWnd, 1, 100, NULL); break; case IDM_IMAGE_MEDIAN: SetCursor (LoadCursor(NULL, IDC_WAIT)); MemorizeBitmap (hWnd); //MEMDISK MedianParams.pBitmap = &pData->LeadBitmap; MedianParams.uDim = 3; MedianParams.pfnHelpCallback = NULL; MedianParams.pHelpCallBackUserData = NULL; MedianParams.uStructSize = sizeof(MEDIANDLGPARAMS); MedianParams.uDlgFlags = DLG_MEDIAN_SHOW_PREVIEW |DLG_MEDIAN_SHOW_TOOL_ZOOMLEVEL; if (L_DlgMedian (hWnd, &MedianParams) == SUCCESS_DLG_OK) { InitOneTikeDataBefor(hWnd, &StatusBitmap, &pData->LeadBitmap, 10); nRet = L_MedianFilterBitmap(&pData->LeadBitmap, MedianParams.uDim); InitOneTikeDataAfter(hWnd, &StatusBitmap, &pData->LeadBitmap, 10, nRet); } pData->uTimerID = SetTimer(hWnd, 1, 100, NULL); break; case IDM_IMAGE_EDGEDETECTION: SetCursor (LoadCursor(NULL, IDC_WAIT)); MemorizeBitmap (hWnd); //MEMDISK EdgeDetectorParams.pBitmap = &pData->LeadBitmap; EdgeDetectorParams.pfnHelpCallback = NULL; EdgeDetectorParams.pHelpCallBackUserData = NULL; EdgeDetectorParams.uStructSize = sizeof(EDGEDETECTORDLGPARAMS); EdgeDetectorParams.uDlgFlags = DLG_EDGEDETECTOR_SHOW_PREVIEW |DLG_EDGEDETECTOR_SHOW_TOOL_ZOOMLEVEL; if ( L_DlgEdgeDetector ( hWnd, &EdgeDetectorParams ) == SUCCESS_DLG_OK) { InitOneTikeDataBefor(hWnd, &StatusBitmap, &pData->LeadBitmap, 10); nRet = L_EdgeDetectorBitmap (&pData->LeadBitmap, EdgeDetectorParams.uThreshold, EdgeDetectorParams.uFilter); InitOneTikeDataAfter(hWnd, &StatusBitmap, &pData->LeadBitmap, 10, nRet); } pData->uTimerID = SetTimer(hWnd, 1, 100, NULL); break; case IDM_IMAGE_HISTOGRAM: { L_INT nLowBits, nHighBits; L_GetMinMaxBits (&pData->LeadBitmap, &nLowBits, &nHighBits); pData->LeadBitmap.LowBit = nLowBits ; pData->LeadBitmap.HighBit = nHighBits ; memset(&HistogramParams, 0, sizeof(HISTOGRAMDLGPARAMS)); HistogramParams.pBitmap = &pData->LeadBitmap; HistogramParams.crMasterPen = RGB(0, 0, 0); HistogramParams.crRedChannelPen = RGB(255, 0, 0); HistogramParams.crGreenChannelPen = RGB(0, 255, 0); HistogramParams.crBlueChannelPen = RGB(0, 0, 255); HistogramParams.uHistogramFlags = HIST_LOWHIGH_BITS; HistogramParams.uDlgFlags = DLG_HISTOGRAM_SHOW_VIEWSTYLE |DLG_HISTOGRAM_USERPENCOLORS; HistogramParams.uStructSize = sizeof(HISTOGRAMDLGPARAMS); nRet = L_DlgHistogram (hWnd, &HistogramParams); } pData->uTimerID = SetTimer(hWnd, 1, 100, NULL); break; case IDM_IMAGE_ADDMESSAGE: pAddMesgDlgData = (LPADDMESGDLGDATA)GlobalAllocPtr(GHND, sizeof(ADDMESGDLGDATA)); if (!pAddMesgDlgData) return; pAddMesgDlgData->pAddMesgInfo = (LPADDMESGINFO)GlobalAllocPtr(GHND, sizeof(ADDMESGINFO)); if(!pAddMesgDlgData->pAddMesgInfo) return; nRet = DoDialogBoxParam(IDD_ADMSG_DLG, hWnd, (DLGPROC)AddMesgDlgProc, (LONG)pAddMesgDlgData); if(nRet) { pAddMesgDlgData->pAddMesgInfo->uStructSize = sizeof(ADDMESGINFO); nRet = L_AddMessageToBitmap(&pData->LeadBitmap, pAddMesgDlgData->pAddMesgInfo); if(nRet != SUCCESS) { MessageBox(hWnd, TEXT("Cannot Add Message... !!!\n wrong Position\n or\n Invalid Directory"), TEXT("Error"), MB_OK | MB_ICONERROR); } } if(pAddMesgDlgData) { if(pAddMesgDlgData->pAddMesgInfo->pStrMsg) { GlobalFreePtr(pAddMesgDlgData->pAddMesgInfo->pStrMsg); pAddMesgDlgData->pAddMesgInfo->pStrMsg = NULL; } if(pAddMesgDlgData->pAddMesgInfo->pPassword) { GlobalFreePtr(pAddMesgDlgData->pAddMesgInfo->pPassword); pAddMesgDlgData->pAddMesgInfo->pPassword = NULL; } if(pAddMesgDlgData->pAddMesgInfo->pStart) { GlobalFreePtr(pAddMesgDlgData->pAddMesgInfo->pStart); pAddMesgDlgData->pAddMesgInfo->pStart = NULL; } if(pAddMesgDlgData->pAddMesgInfo->pFileName) { GlobalFreePtr(pAddMesgDlgData->pAddMesgInfo->pFileName); pAddMesgDlgData->pAddMesgInfo->pFileName = NULL; } if(pAddMesgDlgData->pAddMesgInfo) { GlobalFreePtr(pAddMesgDlgData->pAddMesgInfo); pAddMesgDlgData->pAddMesgInfo = NULL; } GlobalFreePtr(pAddMesgDlgData); pAddMesgDlgData = NULL; } SetStatusColorAndPixel(hWnd); break; case IDM_IMAGE_EXTRACTMESSAGE: pAddMesgDlgData = (LPADDMESGDLGDATA)GlobalAllocPtr(GHND, sizeof(ADDMESGDLGDATA)); if(!pAddMesgDlgData) return; memset(pAddMesgDlgData, 0, sizeof(ADDMESGDLGDATA)); pAddMesgDlgData->pAddMesgInfo = (LPADDMESGINFO)GlobalAllocPtr(GHND, sizeof(ADDMESGINFO)); if(!pAddMesgDlgData->pAddMesgInfo) return; memset(pAddMesgDlgData->pAddMesgInfo, 0, sizeof(ADDMESGINFO)); nRet = DoDialogBoxParam(IDD_EXMSG_DLG, hWnd, (DLGPROC)ExtMesgDlgProc, (LONG)pAddMesgDlgData); if(nRet) { pAddMesgDlgData->pAddMesgInfo->uStructSize = sizeof(ADDMESGINFO); nRet = L_ExtractMessageFromBitmap(&pData->LeadBitmap, pAddMesgDlgData->pAddMesgInfo); if(nRet == SUCCESS) { if(pAddMesgDlgData->pAddMesgInfo->pStrMsg != NULL) MessageBox(hWnd, (L_TCHAR*) pAddMesgDlgData->pAddMesgInfo->pStrMsg, TEXT("Extracted Message"), MB_OK); else if(pAddMesgDlgData->pAddMesgInfo->pFileName != NULL) MessageBox(hWnd, (L_TCHAR*) pAddMesgDlgData->pAddMesgInfo->pFileName, TEXT("Extracted File"), MB_OK); else MessageBox(hWnd, TEXT("There is no Message!"), TEXT("Error"), MB_OK); } else { MessageBox(hWnd, TEXT("Cannot Extract Message... !!!\n Either Invalid password\n or\n wrong Position\n or\n Invalid Directory\n or\n or there is no uMessage to extract.."), TEXT("Error"), MB_OK | MB_ICONERROR); } } if(pAddMesgDlgData) { if(pAddMesgDlgData->pAddMesgInfo->pStrMsg) { GlobalFreePtr(pAddMesgDlgData->pAddMesgInfo->pStrMsg); pAddMesgDlgData->pAddMesgInfo->pStrMsg = NULL; } if(pAddMesgDlgData->pAddMesgInfo->pDirectory) { GlobalFreePtr(pAddMesgDlgData->pAddMesgInfo->pDirectory); pAddMesgDlgData->pAddMesgInfo->pDirectory = NULL; } if(pAddMesgDlgData->pAddMesgInfo->pPassword) { GlobalFreePtr(pAddMesgDlgData->pAddMesgInfo->pPassword); pAddMesgDlgData->pAddMesgInfo->pPassword = NULL; } if(pAddMesgDlgData->pAddMesgInfo->pStart) { GlobalFreePtr(pAddMesgDlgData->pAddMesgInfo->pStart); pAddMesgDlgData->pAddMesgInfo->pStart = NULL; } if(pAddMesgDlgData->pAddMesgInfo) { GlobalFreePtr(pAddMesgDlgData->pAddMesgInfo); pAddMesgDlgData->pAddMesgInfo = NULL; } GlobalFreePtr(pAddMesgDlgData); pAddMesgDlgData = NULL; } break; case IDM_IMAGE_ADDWEIGHTEDBITMAP: pAddWDlgData = (LPADDWDLGDATA)GlobalAllocPtr(GHND, sizeof(ADDWDLGDATA)); if(!pAddWDlgData) return; nRet = DoDialogBoxParam(IDD_ADDW_DLG, hWnd, (DLGPROC)AddWeightDialog, (LONG)pAddWDlgData); StatusProc.bProgress = FALSE; StatusProc.bKillProgress = TRUE ; StatusProc.ProgressValue = 100; InvalidateRect(hWnd, NULL, FALSE); SetStatusColorAndPixel(hWnd); break; case IDM_IMAGE_MULTIPLY: SetCursor (LoadCursor(NULL, IDC_WAIT)); MemorizeBitmap (hWnd); //MEMDISK MultiplyParams.pBitmap = &pData->LeadBitmap; MultiplyParams.uFactor = 100; MultiplyParams.pfnHelpCallback = NULL; MultiplyParams.pHelpCallBackUserData = NULL; MultiplyParams.uStructSize = sizeof(MULTIPLYDLGPARAMS); MultiplyParams.uDlgFlags = DLG_MULTIPLY_SHOW_PREVIEW |DLG_MULTIPLY_SHOW_TOOL_ZOOMLEVEL; if ( L_DlgMultiply ( hWnd, &MultiplyParams ) == SUCCESS_DLG_OK) { InitOneTikeDataBefor(hWnd, &StatusBitmap, &pData->LeadBitmap, 10); nRet = L_MultiplyBitmap ( &pData->LeadBitmap, MultiplyParams.uFactor ); InitOneTikeDataAfter(hWnd, &StatusBitmap, &pData->LeadBitmap, 10, nRet); } pData->uTimerID = SetTimer(hWnd, 1, 100, NULL); break; case IDM_IMAGE_REMAPHUE: SetCursor (LoadCursor(NULL, IDC_WAIT)); MemorizeBitmap (hWnd); //MEMDISK RemapHueParams.pBitmap = &pData->LeadBitmap ; RemapHueParams.pfnHelpCallback = NULL; RemapHueParams.pHelpCallBackUserData = NULL; RemapHueParams.uStructSize = sizeof(REMAPHUEDLGPARAMS); RemapHueParams.uDlgFlags = DLG_REMAPHUE_SHOW_PREVIEW |DLG_REMAPHUE_SHOW_TOOL_ZOOMLEVEL; if ( L_DlgRemapHue ( hWnd, &RemapHueParams )== SUCCESS_DLG_OK) { InitOneTikeDataBefor(hWnd, &StatusBitmap, &pData->LeadBitmap, 10); nRet = L_RemapBitmapHue (&pData->LeadBitmap, //check later RemapHueParams.puMaskLookup, RemapHueParams.puHueLookup, RemapHueParams.puSaturationLookup, RemapHueParams.puValueLookup, RemapHueParams.uLookupLen); InitOneTikeDataAfter(hWnd, &StatusBitmap, &pData->LeadBitmap, 10, nRet); } pData->uTimerID = SetTimer(hWnd, 1, 100, NULL); break; case IDM_IMAGE_FFT: pFFTData = (LPFTDATA)GlobalAllocPtr(GHND, sizeof(FTDATA)); if (!pFFTData) GlobalFree(pFFTData); L_AllocFTArray(&pData->LeadBitmap, &pFFTData->pFtArray, sizeof(FTARRAY)); if (!DoDialogBoxParam(IDD_FFTST_DLG, hWnd, (DLGPROC)FFTstDlgProc, (LONG)pFFTData)) { L_FreeFTArray(pFFTData->pFtArray); if (pFFTData) GlobalFree(pFFTData); } else { InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_FFTND_DLG, hWnd, (DLGPROC)FFTndDlgProc, (LONG)pFFTData); L_FreeFTArray(pFFTData->pFtArray); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pFFTData, &pData->LeadBitmap, &pFFTData->Bitmap, nRet); } StatusProc.bProgress = FALSE; StatusProc.bKillProgress = TRUE; StatusProc.ProgressValue = 100; SetStatusColorAndPixel(hWnd); break; case IDM_IMAGE_DFT: pDFTData = (LPFTDATA)GlobalAllocPtr(GHND, sizeof(FTDATA)); if (!pDFTData) GlobalFree(pDFTData); L_AllocFTArray(&pData->LeadBitmap, &pDFTData->pFtArray, sizeof(FTARRAY)); if (!DoDialogBoxParam(IDD_DFTST_DLG, hWnd, (DLGPROC)DFTstDlgProc, (LONG)pDFTData)) { L_FreeFTArray(pDFTData->pFtArray); if (pDFTData) GlobalFree(pDFTData); } else { InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_DFTND_DLG, hWnd, (DLGPROC)DFTndDlgProc, (LONG)pDFTData); L_FreeFTArray(pDFTData->pFtArray); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pDFTData, &pData->LeadBitmap, &pDFTData->Bitmap, nRet); } StatusProc.bProgress = FALSE; StatusProc.bKillProgress = TRUE; StatusProc.ProgressValue = 100; SetStatusColorAndPixel(hWnd); break; case IDM_IMAGE_DISPLAYFOURIER: pDisFTDlgData = (LPDISFTDLGDATA)GlobalAllocPtr(GHND, sizeof(DISFTDLGDATA)); if (!pDisFTDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_DISFT_DLG, hWnd, (DLGPROC)FourierDispaly, (long)pDisFTDlgData); L_FreeFTArray(pDisFTDlgData->pFtArray); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pDisFTDlgData, &pData->LeadBitmap, &pDisFTDlgData->Bitmap, nRet); break; case IDM_IMAGE_ONOFFMASK: case IDM_IMAGE_SCALEMASK: memset(szFileName, 0, MAX_PATH); memset(&foParm, 0, sizeof(OPENDLGPARAMS)); memset(&OpenFileName, 0, sizeof(OPENFILENAME)); OpenFileName.lpstrInitialDir = NULL; OpenFileName.lStructSize = sizeof(OPENFILENAME); OpenFileName.hwndOwner = hWnd; OpenFileName.lpstrFilter = TEXT("Popular Media Types\0 *.CMP;*.jpg;*.jpeg;*.cmw;*.j2k;*.tif;*.tiff;*.gif;*.png;*.ani;*.bmp;*.cur;*.ico;*.icon;*.wmf;*.dic\0All Files(*.*)\0*.*"); OpenFileName.lpstrCustomFilter = NULL; OpenFileName.lpstrFile = szFileName; OpenFileName.nMaxFile = MAX_PATH; OpenFileName.lpstrFileTitle = NULL; OpenFileName.lpstrTitle = TEXT("Open a File"); OpenFileName.lpstrDefExt = NULL; OpenFileName.lpfnHook = NULL; foParm.uDlgFlags = DLG_OPEN_SHOW_PROGRESSIVE | DLG_OPEN_SHOW_MULTIPAGE | DLG_OPEN_SHOW_LOADROTATED | DLG_OPEN_SHOW_LOADCOMPRESSED | DLG_OPEN_SHOW_FILEINFO | DLG_OPEN_SHOW_PREVIEW | DLG_OPEN_ENABLESIZING | DLG_OPEN_USEFILESTAMP | DLG_OPEN_LOADBITMAP; foParm.uStructSize = sizeof(OPENDLGPARAMS); nRet = L_DlgOpen(hWnd, &OpenFileName, &foParm); if (nRet == SUCCESS_DLG_OK) { MemorizeBitmap (hWnd); //MEMDISK L_ChangeBitmapViewPerspective(foParm.pFileData[0].pBitmap, foParm.pFileData[0].pBitmap, sizeof(BITMAPHANDLE),TOP_LEFT); pFFTData = (LPFTDATA)GlobalAllocPtr(GHND, sizeof(FTDATA)); if(!pFFTData) return; L_AllocFTArray(&pData->LeadBitmap, &pFFTData->pFtArray, sizeof(FTARRAY)); pFFTData->bFFT = TRUE; pFFTData->rcRange.left = 0; pFFTData->rcRange.right = pData->LeadBitmap.Width - 1; pFFTData->rcRange.top = 0; pFFTData->rcRange.bottom = pData->LeadBitmap.Height - 1; pFFTData->bKeepX = TRUE; pFFTData->bKeepY = TRUE; pFFTData->uFlags = FFT_GRAY; SetCursor(LoadCursor(NULL, IDC_WAIT)); InitOneTikeDataBefor(hWnd, &StatusBitmap, &pData->LeadBitmap, 10); nRet = L_FFTBitmap(&pData->LeadBitmap, pFFTData->pFtArray, FFT_FFT | FFT_GRAY); if(nRet != SUCCESS && nRet != ERROR_USER_ABORT) nRet = L_DFTBitmap(&pData->LeadBitmap, pFFTData->pFtArray, NULL, DFT_DFT | DFT_GRAY | DFT_ALL); if(nRet != SUCCESS) { L_FreeFTArray(pFFTData->pFtArray); L_FreeBitmap(foParm.pFileData[0].pBitmap); foParm.pFileData[0].pBitmap = NULL; InitOneTikeDataAfter(hWnd, &StatusBitmap, &pData->LeadBitmap, 10, nRet); SetStatusColorAndPixel(hWnd); if(pFFTData) GlobalFreePtr(pFFTData); return; } L_SizeBitmap(foParm.pFileData[0].pBitmap, pData->LeadBitmap.Width, pData->LeadBitmap.Height, SIZE_BICUBIC); nRet = L_FrqFilterMaskBitmap(foParm.pFileData[0].pBitmap, pFFTData->pFtArray, (nID == IDM_IMAGE_ONOFFMASK)); if (nRet != ERROR_USER_ABORT) nRet = L_FFTBitmap(&pData->LeadBitmap, pFFTData->pFtArray, pFFTData->uFlags| FFT_IFFT | FFT_IFFT_BOTH | FFT_IFFT_CLIP); if(nRet!= SUCCESS && nRet != ERROR_USER_ABORT) nRet = L_DFTBitmap(&pData->LeadBitmap, pFFTData->pFtArray, &pFFTData->rcRange, pFFTData->uFlags | DFT_IDFT | DFT_IDFT_BOTH | DFT_IDFT_CLIP | DFT_RANGE |(pFFTData->bKeepX ? DFT_INSIDE_X : DFT_OUTSIDE_X)| (pFFTData->bKeepY ? DFT_INSIDE_Y : DFT_OUTSIDE_Y)); L_FreeBitmap(&pFFTData->Bitmap); L_FreeFTArray(pFFTData->pFtArray); if(pFFTData) GlobalFreePtr(pFFTData); InitOneTikeDataAfter(hWnd, &StatusBitmap, &pData->LeadBitmap, 10, nRet); L_FreeBitmap(foParm.pFileData[0].pBitmap); foParm.pFileData[0].pBitmap = NULL; CleanOpenDlgParam(&foParm); } SetStatusColorAndPixel(hWnd); break; case IDM_IMAGE_ADDNOISE: bOldMoveFloater = pData->bMovingFloater; pData->bMovingFloater = FALSE; bOldRgnType = pData->nRgnType; if (pData->bMagWnd) EndDialog(pData->hMagicWand, FALSE); pData->nRgnType = 0; pAddNoisDlgData = (LPADDNOISDLGDATA)GlobalAllocPtr(GHND, sizeof(ADDNOISDLGDATA)); if (!pAddNoisDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_NOIS_DLG, hWnd, (DLGPROC)AddNoisDlgProc, (long)pAddNoisDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pAddNoisDlgData, &pData->LeadBitmap, &pAddNoisDlgData->LeadBitmap, nRet); if (pData->bMagWnd) CreateDialog(hInst, MAKEINTRESOURCE(IDD_MGC_DLG), hWnd, MagicWandDlgProc); pData->bMovingFloater = bOldMoveFloater; pData->nRgnType = bOldRgnType; break; case IDM_IMAGE_ADDFUNCNOISE: bOldMoveFloater = pData->bMovingFloater; pData->bMovingFloater = FALSE; bOldRgnType = pData->nRgnType; if (pData->bMagWnd) EndDialog(pData->hMagicWand, FALSE); pData->nRgnType = 0; pAfnDlgData = (LPAFNDLGDATA)GlobalAllocPtr(GHND, sizeof(AFNDLGDATA)); if (!pAfnDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_AFN_DLG, hWnd, (DLGPROC)AfnEfctDlgProc, (long)pAfnDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pAfnDlgData, &pData->LeadBitmap, &pAfnDlgData->LeadBitmap, nRet); if (pData->bMagWnd) CreateDialog(hInst, MAKEINTRESOURCE(IDD_MGC_DLG), hWnd, MagicWandDlgProc); pData->bMovingFloater = bOldMoveFloater; pData->nRgnType = bOldRgnType; break; case IDM_IMAGE_DICE: pTVDiceDlgData = (LPTVDICEDLGDATA)GlobalAllocPtr(GHND, sizeof(TVDICEDLGDATA)); if (!pTVDiceDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_DICE_DLG, hWnd, (DLGPROC)TVDiceDlgProc, (LONG)pTVDiceDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pTVDiceDlgData, &pData->LeadBitmap, &pTVDiceDlgData->LeadBitmap, nRet); break; case IDM_IMAGE_PUZZLE: pPzlDlgData = (LPTVPUZZLEDLGDATA)GlobalAllocPtr(GHND, sizeof(TVPUZZLEDLGDATA)); if (!pPzlDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_PZL_DLG, hWnd, (DLGPROC)TVPuzzleDlgProc, (LONG)pPzlDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pPzlDlgData, &pData->LeadBitmap, &pPzlDlgData->LeadBitmap, nRet); break; case IDM_IMAGE_MATH: pMathDlgData = (LPMATHFUNCDLGDATA)GlobalAllocPtr(GHND, sizeof(MATHFUNCDLGDATA)); if (!pMathDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_MATH_DLG, hWnd, (DLGPROC)MathFuncDlgProc, (LONG)pMathDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pMathDlgData, &pData->LeadBitmap, &pMathDlgData->LeadBitmap, nRet); break; case IDM_IMAGE_FREEHANDNOISE: pFhnDlgData = (LPFREHNDNOISDLGDATA)GlobalAllocPtr(GHND, sizeof(FREHNDNOISDLGDATA)); if (!pFhnDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_HNOIS_DLG, hWnd, (DLGPROC)AddFreHndNoisDlgProc, (LONG)pFhnDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pFhnDlgData, &pData->LeadBitmap, &pFhnDlgData->LeadBitmap, nRet); break; case IDM_IMAGE_SPIRAL: bOldMoveFloater = pData->bMovingFloater; pData->bMovingFloater = FALSE; bOldRgnType = pData->nRgnType; if (pData->bMagWnd) EndDialog(pData->hMagicWand, FALSE); pData->nRgnType = 0; pSpiralDlgData = (LPTVSPIRALDLGDATA)GlobalAllocPtr(GHND, sizeof(TVSPIRALDLGDATA)); if (!pSpiralDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_SPRL_DLG, hWnd, (DLGPROC)TVSpiralDlgProc, (LONG)pSpiralDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pSpiralDlgData, &pData->LeadBitmap, &pSpiralDlgData->LeadBitmap, nRet); if (pData->bMagWnd) CreateDialog(hInst, MAKEINTRESOURCE(IDD_MGC_DLG), hWnd, MagicWandDlgProc); pData->bMovingFloater = bOldMoveFloater; pData->nRgnType = bOldRgnType; break; case IDM_IMAGE_BCI: pBciDlgData = (LPBCIDLGDATA)GlobalAllocPtr(GHND, sizeof(BCIDLGDATA)); if (!pBciDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_BCI_DLG, hWnd, (DLGPROC)BCIDlgProc, (LONG)pBciDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pBciDlgData, &pData->LeadBitmap, &pBciDlgData->LeadBitmap, nRet); break; case IDM_IMAGE_DSA: pDsaDlgData = (LPDSADLGDATA)GlobalAllocPtr(GHND, sizeof(DSADLGDATA)); if (!pDsaDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_DSA_DLG, hWnd, (DLGPROC)DSADlgProc, (LONG)pDsaDlgData); StatusProc.bProgress = FALSE; StatusProc.bKillProgress = TRUE ; StatusProc.ProgressValue = 100; InvalidateRect(hWnd, NULL, FALSE); SetStatusColorAndPixel(hWnd); break; case IDM_IMAGE_CR: pRadDlgData = (LPRADDLGDATA)GlobalAllocPtr(GHND, sizeof(RADDLGDATA)); if (!pRadDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_RAD_DLG, hWnd, (DLGPROC)RadDlgProc, (LONG)pRadDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pRadDlgData, &pData->LeadBitmap, &pRadDlgData->LeadBitmap, nRet); break; case IDM_IMAGE_SHIFTBITMAP: pShiDlgData = (LPSHIDLGDATA)GlobalAllocPtr(GHND, sizeof(SHIDLGDATA)); if (!pShiDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_SHI_DLG, hWnd, (DLGPROC)ShiDlgProc, (LONG)pShiDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pShiDlgData, &pData->LeadBitmap, &pShiDlgData->LeadBitmap, nRet); break; case IDM_IMAGE_BITMAPSELECTOR: pSelDlgData = (LPSELDLGDATA)GlobalAllocPtr(GHND, sizeof(SELDLGDATA)); if (!pSelDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_SEL_DLG, hWnd, (DLGPROC)SelDlgProc, (LONG)pSelDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pSelDlgData, &pData->LeadBitmap, &pSelDlgData->LeadBitmap, nRet); break; case IDM_IMAGE_GRAYCOLORATION: pGryDlgData = (LPGRYDLGDATA)GlobalAllocPtr(GHND, sizeof(GRYDLGDATA)); if (!pGryDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_GRY_DLG, hWnd, (DLGPROC)GryDlgProc, (LONG)pGryDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pGryDlgData, &pData->LeadBitmap, &pGryDlgData->LeadBitmap, nRet); break; case IDM_IMAGE_DRY: pDryDlgData = (LPDRYDLGDATA)GlobalAllocPtr(GHND, sizeof(DRYDLGDATA)); if (!pDryDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_DRY_DLG, hWnd, (DLGPROC)DryDlgProc, (LONG)pDryDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pDryDlgData, &pData->LeadBitmap, &pDryDlgData->Bitmap, nRet); break; case IDM_IMAGE_STAR: bOldMoveFloater = pData->bMovingFloater; pData->bMovingFloater = FALSE; bOldRgnType = pData->nRgnType; if (pData->bMagWnd) EndDialog(pData->hMagicWand, FALSE); pData->nRgnType = 0; pStrDlgData = (LPSTRDLGDATA)GlobalAllocPtr(GHND, sizeof(STRDLGDATA)); if (!pStrDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_STR_DLG, hWnd, (DLGPROC)StarDlgProc, (LONG)pStrDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pStrDlgData, &pData->LeadBitmap, &pStrDlgData->Bitmap, nRet); if (pData->bMagWnd) CreateDialog(hInst, MAKEINTRESOURCE(IDD_MGC_DLG), hWnd, MagicWandDlgProc); pData->bMovingFloater = bOldMoveFloater; pData->nRgnType = bOldRgnType; break; case IDM_IMAGE_PLANE: bOldMoveFloater = pData->bMovingFloater; pData->bMovingFloater = FALSE; bOldRgnType = pData->nRgnType; if (pData->bMagWnd) EndDialog(pData->hMagicWand, FALSE); pData->nRgnType = 0; pPlnDlgData = (LPPLNDLGDATA)GlobalAllocPtr(GHND, sizeof(PLNDLGDATA)); if (!pPlnDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_PLN_DLG, hWnd, (DLGPROC)PlaneDlgProc, (LONG)pPlnDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pPlnDlgData, &pData->LeadBitmap, &pPlnDlgData->Bitmap, nRet); if (pData->bMagWnd) CreateDialog(hInst, MAKEINTRESOURCE(IDD_MGC_DLG), hWnd, MagicWandDlgProc); pData->bMovingFloater = bOldMoveFloater; pData->nRgnType = bOldRgnType; break; case IDM_IMAGE_TUNNEL: bOldMoveFloater = pData->bMovingFloater; pData->bMovingFloater = FALSE; bOldRgnType = pData->nRgnType; if (pData->bMagWnd) EndDialog(pData->hMagicWand, FALSE); pData->nRgnType = 0; pTunDlgData = (LPTUNDLGDATA)GlobalAllocPtr(GHND, sizeof(TUNDLGDATA)); if (!pTunDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_TUN_DLG, hWnd, (DLGPROC)TunnelDlgProc, (LONG)pTunDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pTunDlgData, &pData->LeadBitmap, &pTunDlgData->Bitmap, nRet); if (pData->bMagWnd) CreateDialog(hInst, MAKEINTRESOURCE(IDD_MGC_DLG), hWnd, MagicWandDlgProc); pData->bMovingFloater = bOldMoveFloater; pData->nRgnType = bOldRgnType; break; case IDM_IMAGE_FREE_RAD_BEND: bOldMoveFloater = pData->bMovingFloater; pData->bMovingFloater = FALSE; bOldRgnType = pData->nRgnType; if (pData->bMagWnd) EndDialog(pData->hMagicWand, FALSE); pData->nRgnType = 0; pFrbDlgData = (LPFRBDLGDATA)GlobalAllocPtr(GHND, sizeof(FRBDLGDATA)); if (!pFrbDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_FRB_DLG, hWnd, (DLGPROC)FreeRadBndDlgProc, (LONG)pFrbDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pFrbDlgData, &pData->LeadBitmap, &pFrbDlgData->Bitmap, nRet); if (pData->bMagWnd) CreateDialog(hInst, MAKEINTRESOURCE(IDD_MGC_DLG), hWnd, MagicWandDlgProc); pData->bMovingFloater = bOldMoveFloater; pData->nRgnType = bOldRgnType; break; case IDM_IMAGE_LIGHT: pLgtDlgData = (LPLGTDLGDATA)GlobalAllocPtr(GHND, sizeof(LGTDLGDATA)); if (!pLgtDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_LGTS_DLG, hWnd, (DLGPROC)LightDlgProc, (LONG)pLgtDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pLgtDlgData, &pData->LeadBitmap, &pLgtDlgData->Bitmap, nRet); break; case IDM_IMAGE_OCEAN: pOceDlgData = (LPOCEDLGDATA)GlobalAllocPtr(GHND, sizeof(OCEDLGDATA)); if (!pOceDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_OCE_DLG, hWnd, (DLGPROC)OceanDlgProc, (LONG)pOceDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pOceDlgData, &pData->LeadBitmap, &pOceDlgData->Bitmap, nRet); break; case IDM_IMAGE_FREE_PLANE_BEND: pFpbDlgData = (LPFPBDLGDATA)GlobalAllocPtr(GHND, sizeof(FPBDLGDATA)); if (!pFpbDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_FPB_DLG, hWnd, (DLGPROC)FreePlanBndDlgProc, (LONG)pFpbDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pFpbDlgData, &pData->LeadBitmap, &pFpbDlgData->Bitmap, nRet); break; case IDM_IMAGE_PLANE_BEND: bOldMoveFloater = pData->bMovingFloater; pData->bMovingFloater = FALSE; bOldRgnType = pData->nRgnType; if (pData->bMagWnd) EndDialog(pData->hMagicWand, FALSE); pData->nRgnType = 0; pPlbDlgData = (LPPLBDLGDATA)GlobalAllocPtr(GHND, sizeof(PLBDLGDATA)); if (!pPlbDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_PLB_DLG, hWnd, (DLGPROC)PlaneBendDlgProc, (LONG)pPlbDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pPlbDlgData, &pData->LeadBitmap, &pPlbDlgData->Bitmap, nRet); if (pData->bMagWnd) CreateDialog(hInst, MAKEINTRESOURCE(IDD_MGC_DLG), hWnd, MagicWandDlgProc); pData->bMovingFloater = bOldMoveFloater; pData->nRgnType = bOldRgnType; break; case IDM_IMAGE_DYNAMICTHRESHOLD: pDythDlgData = (LPDYTHDLGDATA)GlobalAllocPtr(GHND, sizeof(DYTHDLGDATA)); if (!pDythDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_DYTH_DLG, hWnd, (DLGPROC)DYTHDlgProc, (LONG)pDythDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pDythDlgData, &pData->LeadBitmap, &pDythDlgData->LeadBitmap, nRet); break; case IDM_IMAGE_AGING: pAgeDlgData = (LPAGEDLGDATA)GlobalAllocPtr(GHND, sizeof(AGEDLGDATA)); if (!pAgeDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_AGE_DLG, hWnd, (DLGPROC)AgingDlgProc, (LONG)pAgeDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pAgeDlgData, &pData->LeadBitmap, &pAgeDlgData->LeadBitmap, nRet); break; case IDM_IMAGE_BALANCECOLORS: pBalDlgData = (LPBALDLGDATA)GlobalAllocPtr(GHND, sizeof(BALDLGDATA)); if (!pBalDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_BAL_DLG, hWnd, (DLGPROC)BalanceDlgProc, (LONG)pBalDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pBalDlgData, &pData->LeadBitmap, &pBalDlgData->LeadBitmap, nRet); break; case IDM_IMAGE_CONVMATRIX: pConDlgData = (LPCONDLGDATA)GlobalAllocPtr(GHND, sizeof(CONDLGDATA)); if (!pConDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_CON_DLG, hWnd, (DLGPROC)ConDlgProc, (LONG)pConDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pConDlgData, &pData->LeadBitmap, &pConDlgData->Bitmap, nRet); break; case IDM_IMAGE_REPCLR: pRepDlgData = (LPREPDLGDATA) GlobalAllocPtr(GHND, sizeof(REPDLGDATA)); if (!pRepDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_REP_DLG, hWnd, (DLGPROC)ReplaceColorDlgProc, (LONG)pRepDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pRepDlgData, &pData->LeadBitmap, &pRepDlgData->Bitmap, nRet); break; case IDM_IMAGE_INFO: pInfoDlgData = (LPINFDLGDATA) GlobalAllocPtr(GHND, sizeof(INFDLGDATA)); if (!pInfoDlgData) return; nRet = DoDialogBoxParam(IDD_INF_DLG, hWnd, (DLGPROC)ImageInfDlgProc, (LONG)pInfoDlgData); break; case IDM_IMAGE_HSB: pHsiDlgData = (LPHSBDLGDATA) GlobalAllocPtr(GHND, sizeof(HSBDLGDATA)); if (!pHsiDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_HSB_DLG, hWnd, (DLGPROC)HSBDlgProc, (LONG)pHsiDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pHsiDlgData, &pData->LeadBitmap, &pHsiDlgData->LeadBitmap, nRet); break; case IDM_IMAGE_NUM: pNumDlgData = (LPNUMDLGDATA) GlobalAllocPtr(GHND, sizeof(NUMDLGDATA)); if (!pNumDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_NUM_DLG, hWnd, (DLGPROC)MathmaticalDlgProc, (LONG)pNumDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pNumDlgData, &pData->LeadBitmap, &pNumDlgData->Bitmap, nRet); break; case IDM_IMAGE_GETOBJECTINFOW: { L_UINT puX; L_UINT puY; L_UINT puAngle; L_UINT puRoundness; L_TCHAR szBuffer[200] = TEXT("\0"); nRet = L_GetObjectInfo(&pData->LeadBitmap, &puX, &puY, &puAngle, &puRoundness, TRUE); wsprintf(szBuffer, TEXT(" X\t\t = %d\n Y\t\t = %d\n Angle\t\t = %d\n Roundness\t = %d"), puX, puY, puAngle, puRoundness); MessageBox(hWnd, szBuffer, TEXT("Get Weighted Object Info"), MB_OK); } break; case IDM_IMAGE_GETOBJECTINFONW: { L_UINT puX; L_UINT puY; L_UINT puAngle; L_UINT puRoundness; L_TCHAR szBuffer[200] = TEXT("\0"); nRet = L_GetObjectInfo(&pData->LeadBitmap, &puX, &puY, &puAngle, &puRoundness, FALSE); wsprintf(szBuffer, TEXT(" X\t\t = %d\n Y\t\t = %d\n Angle\t\t = %d\n Roundness\t = %d"), puX, puY, puAngle, puRoundness); MessageBox(hWnd, szBuffer, TEXT("Get Non Weighted Object Info"), MB_OK); } break; case IDM_IMAGE_GETRGNPERIMETER: { L_UINT puLength; L_TCHAR szBuffer[200] = TEXT("\0"); nRet = L_GetRgnPerimeterLength(&pData->LeadBitmap, NULL, &puLength); wsprintf(szBuffer, TEXT(" Region Perimeter Length = %d\n"), puLength); MessageBox(hWnd, szBuffer, TEXT("Get Region Perimeter Length"), MB_OK); } break; case IDM_IMAGE_GETFERETS: { L_UINT puX; L_UINT puY; L_UINT puAngle; POINT L_FAR * pPoints; L_UINT uSize; L_TCHAR szBuffer[200] = TEXT("\0"); nRet = L_GetRgnContourPoints(&pData->LeadBitmap, NULL, &pPoints,&uSize); nRet = L_GetFeretsDiameter(pPoints,uSize,&puX, &puY, &puAngle); wsprintf(szBuffer, TEXT("The Ferets = %d\n"), puX); MessageBox(hWnd, szBuffer, TEXT("Get Ferets Diameter"), MB_OK); GlobalFree(pPoints); } break; case IDM_IMAGE_ACE: bOldMoveFloater = pData->bMovingFloater; pData->bMovingFloater = FALSE; bOldRgnType = pData->nRgnType; if (pData->bMagWnd) EndDialog(pData->hMagicWand, FALSE); pData->nRgnType = 0; pAceDlgData = (LPACEDLGDATA)GlobalAllocPtr(GHND, sizeof(ACEDLGDATA)); if (!pAceDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_ACE_DLG, hWnd, (DLGPROC)ACEDlgProc, (LONG)pAceDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pAceDlgData, &pData->LeadBitmap, &pAceDlgData->Bitmap, nRet); if (pData->bMagWnd) CreateDialog(hInst, MAKEINTRESOURCE(IDD_MGC_DLG), hWnd, MagicWandDlgProc); pData->bMovingFloater = bOldMoveFloater; pData->nRgnType = bOldRgnType; break; case IDM_COLORSPACEPOPUP_RGB: case IDM_COLORSPACEPOPUP_HSV: case IDM_COLORSPACEPOPUP_HLS: case IDM_COLORSPACEPOPUP_XYZ: case IDM_COLORSPACEPOPUP_YUV: case IDM_COLORSPACEPOPUP_YCRCB: case IDM_COLORSPACEPOPUP_LAB: case IDM_COLORSPACEPOPUP_CMY: uColorSpace = nID - IDM_COLORSPACEPOPUP_RGB; SetStatusBarText(TEXT(""), &pData->LeadBitmap, szPos, szColor); SetStatusColorAndPixel(hWnd); break; case IDC_STATUS_HEX: case IDC_STATUS_DEC: IsDecimal = nID - IDC_STATUS_HEX; SetStatusColorAndPixel(hWnd); break; case IDM_IMAGE_FILLBITMAP: pChsClrDlgData = (LPCHSCLRDLGDATA) GlobalAllocPtr(GHND, sizeof(CHSCLRDLGDATA)); if (!pChsClrDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_CLR_DLG, hWnd, (DLGPROC)ChsClrDlgProc, (LONG)pChsClrDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *)pChsClrDlgData, &pData->LeadBitmap ,&pChsClrDlgData->Bitmap, nRet); break; /************************************** new functions ***********************************/ case IDM_FILTERS_CLOUD: pCloudsDlgData = (LPCLOUDSDLGDATA) GlobalAllocPtr(GHND, sizeof(CLOUDSDLGDATA)); if (!pCloudsDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_CLOD_DLG, hWnd, (DLGPROC)CloudsDlgProc, (LONG)pCloudsDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *)pCloudsDlgData, &pData->LeadBitmap ,&pCloudsDlgData->LeadBitmap, nRet); break; case IDM_FILTERS_MOSAIC: bOldMoveFloater = pData->bMovingFloater; pData->bMovingFloater = FALSE; bOldRgnType = pData->nRgnType; if (pData->bMagWnd) EndDialog(pData->hMagicWand, FALSE); pData->nRgnType = 0; pMosiacTilesDlgData = (LPMSCTLSDLGDATA)GlobalAllocPtr(GHND, sizeof(MSCTLSDLGDATA)); if (!pMosiacTilesDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_MSCTLS_DLG, hWnd, (DLGPROC)MosaicDlgProc, (LONG)pMosiacTilesDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *)pMosiacTilesDlgData, &pData->LeadBitmap ,&pMosiacTilesDlgData->LeadBitmap, nRet); if (pData->bMagWnd) CreateDialog(hInst, MAKEINTRESOURCE(IDD_MGC_DLG), hWnd, MagicWandDlgProc); pData->bMovingFloater = bOldMoveFloater; pData->nRgnType = bOldRgnType; break; case IDM_FILTERS_ROMANMOSAIC: pRomanDlgData = (LPRMNMSCDLGDATA)GlobalAllocPtr(GHND, sizeof(RMNMSCDLGDATA)); if (!pRomanDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_RMNMSC_DLG, hWnd, (DLGPROC)RmnMscDlgProc, (LONG)pRomanDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *)pRomanDlgData, &pData->LeadBitmap ,&pRomanDlgData->LeadBitmap, nRet); break; case IDM_FILTERS_VIGNNET: bOldMoveFloater = pData->bMovingFloater; pData->bMovingFloater = FALSE; bOldRgnType = pData->nRgnType; if (pData->bMagWnd) EndDialog(pData->hMagicWand, FALSE); pData->nRgnType = 0; pVignnetDlgData = (LPVIGNTDLGDATA)GlobalAllocPtr(GHND, sizeof(VIGNTDLGDATA)); if (!pVignnetDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_VGNT_DLG, hWnd, (DLGPROC)VignetteDlgProc, (LONG)pVignnetDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *)pVignnetDlgData, &pData->LeadBitmap ,&pVignnetDlgData->LeadBitmap, nRet); if (pData->bMagWnd) CreateDialog(hInst, MAKEINTRESOURCE(IDD_MGC_DLG), hWnd, MagicWandDlgProc); pData->bMovingFloater = bOldMoveFloater; pData->nRgnType = bOldRgnType; break; case IDM_FILTERS_FRAGMENT: pFragmentDlgData = (LPFRAGMENTDLGDATA)GlobalAllocPtr(GHND, sizeof(FRAGMENTDLGDATA)); if (!pFragmentDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_FRGMT_DLG, hWnd, (DLGPROC)FragmentDlgProc, (LONG)pFragmentDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *)pFragmentDlgData, &pData->LeadBitmap ,&pFragmentDlgData->LeadBitmap, nRet); break; case IDM_FILTERS_YUVGAMMA: pGammaData = (LPGAMMADATA)GlobalAllocPtr(GHND, sizeof(GAMMADATA)); if (!pGammaData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_YUVGAMMA_DLG, hWnd, (DLGPROC)YUVGammaWndProc, (LONG)pGammaData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *)pGammaData, &pData->LeadBitmap ,&pGammaData->hBitmap , nRet); break; case IDM_FILTERS_PLASMAGENERATOR: pPlasmaData = (LPPLASMADATA)GlobalAllocPtr(GHND, sizeof(PLASMADATA)); if (!pPlasmaData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_PLASMAGEN_DLG, hWnd, (DLGPROC)PlasmaWndProc, (LONG)pPlasmaData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *)pPlasmaData, &pData->LeadBitmap ,&pPlasmaData->hBitmap, nRet); break; case IDM_FILTERS_EMBOSS: pEmbossData = (LPEMBOSSDATA)GlobalAllocPtr(GHND, sizeof(EMBOSSDATA)); if (!pEmbossData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_EMBOSS_DLG, hWnd, (DLGPROC)EmbossWndProc, (LONG)pEmbossData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *)pEmbossData, &pData->LeadBitmap ,&pEmbossData->hBitmap, nRet); break; case ID_FILTERS_PERSPECTIVE: pPersDlgData = (LPPERSDLGDATA)GlobalAllocPtr(GHND, sizeof(PERSDLGDATA)); if (!pPersDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_PRSP_DLG, hWnd, (DLGPROC)PerspectiveDlgProc, (LONG)pPersDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *)pPersDlgData, &pData->LeadBitmap ,&pPersDlgData->LeadBitmap, nRet); break; case ID_FILTERS_POINTALIZE: pPntDlgData = (LPPOINTLIZEDLGDATA)GlobalAllocPtr(GHND, sizeof(POINTLIZEDLGDATA)); if (!pPntDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_PNT_DLG, hWnd, (DLGPROC)PointillistDlgProc, (LONG)pPntDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *)pPntDlgData, &pData->LeadBitmap ,&pPntDlgData->LeadBitmap, nRet); break; case ID_FILTERS_HTP: pHtpDlgData = (LPHTPATTERNDLGDATA)GlobalAllocPtr(GHND, sizeof(HTPATTERNDLGDATA)); if (!pHtpDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_HTP_DLG, hWnd, (DLGPROC)HTPatternDlgProc, (LONG)pHtpDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *)pHtpDlgData, &pData->LeadBitmap ,&pHtpDlgData->LeadBitmap, nRet); InvalidateRect(hWnd, NULL, FALSE); break; case ID_FILTERS_HTC: pHtcDlgData = (LPCOLORHTDLGDATA)GlobalAllocPtr(GHND, sizeof(COLORHTDLGDATA)); if (!pHtcDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_HTC_DLG, hWnd, (DLGPROC)ColoredHTDlgProc, (LONG)pHtcDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *)pHtcDlgData, &pData->LeadBitmap ,&pHtcDlgData->LeadBitmap, nRet); InvalidateRect(hWnd, NULL, FALSE); break; case ID_FILTERS_COLOREDBALLS: pClrBDlgData = (LPCOLORBALLDLGDATA)GlobalAllocPtr(GHND, sizeof(COLORBALLDLGDATA)); if (!pClrBDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_CLRB_DLG, hWnd, (DLGPROC)ColoredBallDlgProc, (LONG)pClrBDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *)pClrBDlgData, &pData->LeadBitmap ,&pClrBDlgData->LeadBitmap, nRet); InvalidateRect(hWnd, NULL, FALSE); break; case ID_FILTERS_ZIGZAG: pZigZagDlgData = (LPZIGZAGDLGDATA)GlobalAllocPtr(GHND, sizeof(ZIGZAGDLGDATA)); if (!pZigZagDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_ZIG_DLG, hWnd, (DLGPROC)ZigZagDlgProc, (LONG)pZigZagDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *)pZigZagDlgData, &pData->LeadBitmap ,&pZigZagDlgData->LeadBitmap, nRet); InvalidateRect(hWnd, NULL, FALSE); break; case ID_FILTERS_HIGHPASS: pHpfDlgData = (LPHPFDLGDATA)GlobalAllocPtr(GHND, sizeof(HPFDLGDATA)); if (!pHpfDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_HPS_DLG, hWnd, (DLGPROC)HighPassDlgProc, (LONG)pHpfDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *)pHpfDlgData, &pData->LeadBitmap ,&pHpfDlgData->LeadBitmap, nRet); InvalidateRect(hWnd, NULL, FALSE); break; case ID_FILTERS_DIFFUSEGLOW: pDfgDlgData = (LPDFGDLGDATA)GlobalAllocPtr(GHND, sizeof(DFGDLGDATA)); if (!pDfgDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_DGF_DLG, hWnd, (DLGPROC)DiffuseGlowDlgProc, (LONG)pDfgDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *)pDfgDlgData, &pData->LeadBitmap ,&pDfgDlgData->LeadBitmap, nRet); InvalidateRect(hWnd, NULL, FALSE); break; case ID_FILTERS_DISPLACEMENT: pDispDlgData = (LPDISPDLGDATA)GlobalAllocPtr(GHND, sizeof(DISPDLGDATA)); if (!pDispDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_DISP_DLG, hWnd, (DLGPROC)DisplaceDlgProc, (LONG)pDispDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *)pDispDlgData, &pData->LeadBitmap ,&pDispDlgData->LeadBitmap, nRet); InvalidateRect(hWnd, NULL, FALSE); break; case ID_FILTERS_NEWDESKEW: pDskDlgData = (LPDSKWDLGDATA)GlobalAllocPtr(GHND, sizeof(DSKWDLGDATA)); if (!pDskDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_DSK_DLG, hWnd, (DLGPROC)DeskewDlgProc, (LONG)pDskDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *)pDskDlgData, &pData->LeadBitmap ,&pDskDlgData->LeadBitmap, nRet); InvalidateRect(hWnd, NULL, FALSE); break; case ID_FILTERS_OFFSET: pOffsetDlgData = (LPOFFSETDLGDATA)GlobalAllocPtr(GHND, sizeof(OFFSETDLGDATA)); if(!pOffsetDlgData) return; InitDataBeforDlg(10); pOffsetDlgData->uFlags = 1; nRet = DoDialogBoxParam(IDD_OFFSET_DLG, hWnd, (DLGPROC)OffsetDlgProc, (LONG)pOffsetDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pOffsetDlgData, &pData->LeadBitmap, &pOffsetDlgData->LeadBitmap, nRet); break; case ID_FILTERS_BRICKS: pBricksDlgData = (LPBRICKSDLGDATA)GlobalAllocPtr(GHND, sizeof(BRICKSDLGDATA)); if(!pBricksDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_BRICK_DLG, hWnd, (DLGPROC)BricksDlgProc, (LONG)pBricksDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pBricksDlgData, &pData->LeadBitmap, &pBricksDlgData->LeadBitmap, nRet); break; case IDM_COLOR_PLANES: pData->hPlaneWnd = CreateDialog(hInst, MAKEINTRESOURCE(IDD_PLANE_DLG), hWnd, PlaneCtlDlgProc); ShowWindow(pData->hPlaneWnd, SW_SHOW); EnableWindow(GetDlgItem(hWnd, nID), FALSE); break; case IDM_COLOR_ADJUSTTINT: pTintDlgData = (LPTINTDLGDATA)GlobalAllocPtr(GHND, sizeof(TINTDLGDATA)); if(!pTintDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_TNT_DLG, hWnd, (DLGPROC)TintDlgProc, (LONG)pTintDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pTintDlgData, &pData->LeadBitmap, &pTintDlgData->LeadBitmap, nRet); break; case IDM_ARTISTIC_SPENCIL: pSPencilDlgData = (LPSPENCILDLGDATA)GlobalAllocPtr(GHND, sizeof(SPENCILDLGDATA)); if(!pSPencilDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_SPENCIL_DLG, hWnd, (DLGPROC)SimplePencilDlgProc, (LONG)pSPencilDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pSPencilDlgData, &pData->LeadBitmap, &pSPencilDlgData->LeadBitmap, nRet); break; case IDM_COLOR_PERLIN: bOldMoveFloater = pData->bMovingFloater; pData->bMovingFloater = FALSE; bOldRgnType = pData->nRgnType; if (pData->bMagWnd) EndDialog(pData->hMagicWand, FALSE); pData->nRgnType = 0; pPrlnDlgData = (LPPRLNDLGDATA)GlobalAllocPtr(GHND, sizeof(PRLNDLGDATA)); if(!pPrlnDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_PRLN_DLG, hWnd, (DLGPROC)PerlinDlgProc, (LONG)pPrlnDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pPrlnDlgData, &pData->LeadBitmap, &pPrlnDlgData->LeadBitmap, nRet); if (pData->bMagWnd) CreateDialog(hInst, MAKEINTRESOURCE(IDD_MGC_DLG), hWnd, MagicWandDlgProc); pData->bMovingFloater = bOldMoveFloater; pData->nRgnType = bOldRgnType; break; case IDM_FILTERS_CANVAS: pCanvasDlgData = (LPCANVASDLGDATA)GlobalAllocPtr(GHND, sizeof(CANVASDLGDATA)); if(!pCanvasDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_CNVS_DLG, hWnd, (DLGPROC)CanvasDlgProc, (LONG)pCanvasDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pCanvasDlgData, &pData->LeadBitmap, &pCanvasDlgData->LeadBitmap, nRet); break; case IDM_IMAGE_MEDICALIMAGING_KAUFMANNREGION: bOldMoveFloater = pData->bMovingFloater; pData->bMovingFloater = FALSE; bOldRgnType = pData->nRgnType; if (pData->bMagWnd) EndDialog(pData->hMagicWand, FALSE); pData->nRgnType = 0; pKfnRgnDlgData = (LPKFNRGNDLGDATA)GlobalAllocPtr(GHND, sizeof(KFNRGNDLGDATA)); if (!pKfnRgnDlgData) return; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_KFMN_DLG, hWnd, (DLGPROC)KfmnDlgProc, (long)pKfnRgnDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pKfnRgnDlgData, &pData->LeadBitmap, &pKfnRgnDlgData->LeadBitmap, nRet); if (pData->bMagWnd) CreateDialog(hInst, MAKEINTRESOURCE(IDD_MGC_DLG), hWnd, MagicWandDlgProc); pData->bMovingFloater = bOldMoveFloater; pData->nRgnType = bOldRgnType; break; case IDM_DETECTION_CORRELATIONLIST: { LPCORRLISTDLGDATA pCorrListDlgData = GlobalAllocPtr(GHND, sizeof(CORRLISTDLGDATA)); if (!pCorrListDlgData) return; bOldMoveFloater = pData->bMovingFloater; pData->bMovingFloater = FALSE; bOldRgnType = pData->nRgnType; if (pData->bMagWnd) EndDialog(pData->hMagicWand, FALSE); pData->nRgnType = 0; InitDataBeforDlg(10); nRet = DoDialogBoxParam(IDD_CLST_DLG, hWnd, (DLGPROC)CorrListDlgProc, (long)pCorrListDlgData); InitDataAfterDlg(hWnd, (L_VOID L_FAR *) pCorrListDlgData, &pData->LeadBitmap, &pCorrListDlgData->Bitmap, nRet); if (pData->bMagWnd) CreateDialog(hInst, MAKEINTRESOURCE(IDD_MGC_DLG), hWnd, MagicWandDlgProc); pData->bMovingFloater = bOldMoveFloater; pData->nRgnType = bOldRgnType; } break; case IDM_COLOR_SEPARATE_RGB: case IDM_COLOR_SEPARATE_YUV: case IDM_COLOR_SEPARATE_XYZ: case IDM_COLOR_SEPARATE_LAB: case IDM_COLOR_SEPARATE_HSV: case IDM_COLOR_SEPARATE_HLS: case IDM_COLOR_SEPARATE_YCrCb: case IDM_COLOR_SEPARATE_CMY: case IDM_COLOR_SEPARATE_CMYK: case IDM_COLOR_SEPARATE_LTP: { L_INT nValue; L_INT nIndex; pBITMAPHANDLE pColorPlanes[4]; switch(nID) { case IDM_COLOR_SEPARATE_RGB: nValue = COLORSEP_RGB ; break; case IDM_COLOR_SEPARATE_YUV: nValue = COLORSEP_YUV ; break; case IDM_COLOR_SEPARATE_XYZ: nValue = COLORSEP_XYZ ; break; case IDM_COLOR_SEPARATE_LAB: nValue = COLORSEP_LAB ; break ; case IDM_COLOR_SEPARATE_HSV: nValue = COLORSEP_HSV ; break ; case IDM_COLOR_SEPARATE_HLS: nValue = COLORSEP_HLS ; break ; case IDM_COLOR_SEPARATE_YCrCb: nValue = COLORSEP_YCrCb ; break ; case IDM_COLOR_SEPARATE_CMY: nValue = COLORSEP_CMY ; break ; case IDM_COLOR_SEPARATE_LTP: nValue = COLORSEP_SCT ; break ; case IDM_COLOR_SEPARATE_CMYK: nValue = COLORSEP_CMYK ; break ; } for (nIndex = 0 ; nIndex < 4 ; nIndex++) pColorPlanes[nIndex] = (pBITMAPHANDLE) GlobalAllocPtr(GHND, sizeof(BITMAPHANDLE)) ; nRet = L_ColorSeparateBitmap(&pData->LeadBitmap, pColorPlanes, sizeof(BITMAPHANDLE), nValue) ; switch(nID) { case IDM_COLOR_SEPARATE_RGB: CreateChildWindow (TEXT("Blue Plane"), pColorPlanes[0], NULL, 0, FALSE) ; CreateChildWindow (TEXT("Green Plane"), pColorPlanes[1], NULL, 0, FALSE) ; CreateChildWindow (TEXT("Red Plane"), pColorPlanes[2], NULL, 0, FALSE) ; break; case IDM_COLOR_SEPARATE_YUV: CreateChildWindow (TEXT("Y Plane"), pColorPlanes[0], NULL, 0, FALSE) ; CreateChildWindow (TEXT("U Plane"), pColorPlanes[1], NULL, 0, FALSE) ; CreateChildWindow (TEXT("V Plane"), pColorPlanes[2], NULL, 0, FALSE) ; break ; case IDM_COLOR_SEPARATE_XYZ: CreateChildWindow (TEXT("X Plane"), pColorPlanes[0], NULL, 0, FALSE) ; CreateChildWindow (TEXT("Y Plane"), pColorPlanes[1], NULL, 0, FALSE) ; CreateChildWindow (TEXT("Z Plane"), pColorPlanes[2], NULL, 0, FALSE) ; break; case IDM_COLOR_SEPARATE_LAB: CreateChildWindow (TEXT("L Plane"), pColorPlanes[0], NULL, 0, FALSE) ; CreateChildWindow (TEXT("A Plane"), pColorPlanes[1], NULL, 0, FALSE) ; CreateChildWindow (TEXT("B Plane"), pColorPlanes[2], NULL, 0, FALSE) ; break; case IDM_COLOR_SEPARATE_HSV: CreateChildWindow (TEXT("H Plane"), pColorPlanes[0], NULL, 0, FALSE) ; CreateChildWindow (TEXT("S Plane"), pColorPlanes[1], NULL, 0, FALSE) ; CreateChildWindow (TEXT("V Plane"), pColorPlanes[2], NULL, 0, FALSE) ; break; case IDM_COLOR_SEPARATE_HLS: CreateChildWindow (TEXT("H Plane"), pColorPlanes[0], NULL, 0, FALSE) ; CreateChildWindow (TEXT("L Plane"), pColorPlanes[1], NULL, 0, FALSE) ; CreateChildWindow (TEXT("S Plane"), pColorPlanes[2], NULL, 0, FALSE) ; break; case IDM_COLOR_SEPARATE_YCrCb: CreateChildWindow (TEXT("Y Plane"), pColorPlanes[0], NULL, 0, FALSE) ; CreateChildWindow (TEXT("Cr Plane"), pColorPlanes[1], NULL, 0, FALSE) ; CreateChildWindow (TEXT("Cb Plane"), pColorPlanes[2], NULL, 0, FALSE) ; break; case IDM_COLOR_SEPARATE_CMY: CreateChildWindow (TEXT("C Plane"), pColorPlanes[0], NULL, 0, FALSE) ; CreateChildWindow (TEXT("M Plane"), pColorPlanes[1], NULL, 0, FALSE) ; CreateChildWindow (TEXT("Y Plane"), pColorPlanes[2], NULL, 0, FALSE) ; break; case IDM_COLOR_SEPARATE_LTP: CreateChildWindow (TEXT("L Plane"), pColorPlanes[0], NULL, 0, FALSE) ; CreateChildWindow (TEXT("P Plane"), pColorPlanes[1], NULL, 0, FALSE) ; CreateChildWindow (TEXT("T Plane"), pColorPlanes[2], NULL, 0, FALSE) ; break; case IDM_COLOR_SEPARATE_CMYK: CreateChildWindow (TEXT("C Plane"), pColorPlanes[0], NULL, 0, FALSE) ; CreateChildWindow (TEXT("M Plane"), pColorPlanes[1], NULL, 0, FALSE) ; CreateChildWindow (TEXT("Y Plane"), pColorPlanes[2], NULL, 0, FALSE) ; CreateChildWindow (TEXT("K Plane"), pColorPlanes[3], NULL, 0, FALSE) ; break; } } } UNLOCKCHILDDATA(hWnd); } L_INT GetFileExtentionIndex(LPTSTR szTitle, L_INT nBits) { L_TCHAR L_FAR * ptTitle = szTitle; while (ptTitle[0] != '.' && ptTitle[0] != '\0') ptTitle++; if (!lstrcmp(_tcslwr(ptTitle), TEXT(".cmp"))) { if (nBits == 1 || nBits == 8 || nBits == 24) return 0; else return 4; } if ((!lstrcmp(_tcslwr(ptTitle), TEXT(".jpg"))) || (!lstrcmp(_tcslwr(ptTitle), TEXT(".jpeg")))) { if (nBits == 8 || nBits == 12 || nBits == 16 || nBits == 24) return 1; else return 4; } if (!lstrcmp(_tcslwr(ptTitle), TEXT(".cmw"))) { if (nBits == 8 || nBits == 12 || nBits == 16 || nBits == 24) return 2; else return 4; } if ((!lstrcmp(_tcslwr(ptTitle), TEXT(".tif"))) || (!lstrcmp(_tcslwr(ptTitle), TEXT(".tiff")))) return 4; if (!lstrcmp(_tcslwr(ptTitle), TEXT(".gif"))) { if (nBits <= 8) return 5; else return 4; } if (!lstrcmp(_tcslwr(ptTitle), TEXT(".png"))) { if (nBits == 1 || nBits == 4 || nBits == 8 || nBits == 24 || nBits == 32) return 6; else return 4; } if (!lstrcmp(_tcslwr(ptTitle), TEXT(".ani"))) { if (nBits == 1 || nBits == 4 || nBits == 8 || nBits == 16 || nBits == 24 || nBits == 32) return 7; else return 4; } if (!lstrcmp(_tcslwr(ptTitle), TEXT(".bmp"))) { if (nBits == 1 || nBits == 4 || nBits == 8 || nBits == 24) return 50; else return 4; } if (!lstrcmp(_tcslwr(ptTitle), TEXT(".cur"))) { if (nBits == 1 || nBits == 4 || nBits == 8 || nBits == 24) return 51; else return 4; } if (!lstrcmp(_tcslwr(ptTitle), TEXT(".ico"))) { if (nBits == 1 || nBits == 4 || nBits == 8 || nBits == 24) return 52; else return 4; } if (!lstrcmp(_tcslwr(ptTitle), TEXT(".wmf"))) { if (nBits == 8 || nBits == 24) return 54; else return 4; } return 0; } L_VOID UpdateSaveFileOption(SAVEDLGPARAMS pFSParm, SAVEFILEOPTION L_FAR * SaveFileOption) { L_GetDefaultSaveFileOption(SaveFileOption, sizeof(SAVEFILEOPTION)); SaveFileOption->PageNumber = pFSParm.nPageNumber; SaveFileOption->Flags = 0; switch(pFSParm.uSaveMulti) { case MULTIPAGE_OPERATION_REPLACE: SaveFileOption->Flags|=ESO_REPLACEPAGE; break; case MULTIPAGE_OPERATION_INSERT: SaveFileOption->Flags|=ESO_INSERTPAGE; break; case MULTIPAGE_OPERATION_APPEND: SaveFileOption->PageNumber = 2; break; case MULTIPAGE_OPERATION_OVERWRITE: SaveFileOption->PageNumber = 1; break; } SaveFileOption->Passes = pFSParm.nPasses; if(pFSParm.nFormat == FILE_GIF) { if (!pFSParm.bSaveInterlaced) SaveFileOption->Flags &= ~ESO_INTERLACED; else SaveFileOption->Flags |= ESO_INTERLACED; } } /*====(SaveBitmapFile)========================================================= Description: Save the image to file. Syntax : L_INT SaveBitmapFile (HWND hWnd) Parameters : hWnd Handle of a window. Return Value: None. ==========================================================================*/ L_INT SaveBitmapFile (HWND hWnd) { SAVEDLGPARAMS DlgParams; OPENFILENAME OpenFileName; SAVEFILEOPTION SaveFileOption; FILEJ2KOPTIONS FileJ2KOptions; FILEJBIG2OPTIONS FileJBIG2Options; pCHILDDATA pData; L_INT nRet; L_TCHAR szFile[1024] = TEXT(""); L_TCHAR szBuffer[1024]; pDIMENSION pOldResolutions = NULL; pDIMENSION pJBIGResolutions = NULL; L_UINT uResCount; pData = LOCKCHILDDATA (hWnd); memset(&DlgParams, 0, sizeof(SAVEDLGPARAMS)); memset(&OpenFileName, 0, sizeof(OPENFILENAME)); memset(&SaveFileOption, 0, sizeof(SAVEFILEOPTION)); OpenFileName.lStructSize = sizeof ( OPENFILENAME ) ; OpenFileName.lpstrInitialDir = NULL; OpenFileName.lpstrTitle = TEXT("Save a File"); DlgParams.uFileTypeIndex = GetFileExtentionIndex(pData->pszTitle, pData->LeadBitmap.BitsPerPixel); DlgParams.uStructSize = sizeof ( SAVEDLGPARAMS ) ; DlgParams.nQFactor = 2; DlgParams.nPageNumber = 1; DlgParams.nBitsPerPixel = pData->LeadBitmap.BitsPerPixel; DlgParams.uSaveMulti = MULTIPAGE_OPERATION_APPEND; DlgParams.uDlgFlags = DLG_SAVE_SHOW_FILEOPTIONS_PROGRESSIVE | DLG_SAVE_SHOW_FILEOPTIONS_MULTIPAGE | DLG_SAVE_SHOW_FILEOPTIONS_STAMP | DLG_SAVE_SHOW_FILEOPTIONS_QFACTOR | DLG_SAVE_SHOW_FILEOPTIONS_J2KOPTIONS | DLG_SAVE_SHOW_FILEOPTIONS_BASICJ2KOPTIONS ; nRet = L_DlgSave ( hWnd, &OpenFileName, &DlgParams ); if (nRet == SUCCESS_DLG_OK) { UpdateSaveFileOption(DlgParams, &SaveFileOption); if(DlgParams.bSaveWithStamp) { SaveFileOption.Flags |= ESO_SAVEWITHSTAMP; SaveFileOption.StampWidth = DlgParams.nStampWidth; SaveFileOption.StampHeight = DlgParams.nStampHeight; SaveFileOption.StampBits = DlgParams.nStampBits; } if(DlgParams.nFormat == FILE_JBIG) { /* get current resolutions */ L_GetSaveResolution (&uResCount, NULL); if(uResCount>0) { pOldResolutions = (pDIMENSION)GlobalAllocPtr(GHND, sizeof(DIMENSION)*uResCount); if(pOldResolutions) L_GetSaveResolution (&uResCount, pOldResolutions); } pJBIGResolutions = (pDIMENSION)GlobalAllocPtr(GHND, sizeof(DIMENSION)*DlgParams.nPasses); if(pJBIGResolutions) { /* largest resolution will be actual image size */ pJBIGResolutions[0].nWidth = pData->LeadBitmap.Width; pJBIGResolutions[0].nHeight = pData->LeadBitmap.Height; /* will save nPasses resolution layers */ L_SetSaveResolution (DlgParams.nPasses, pJBIGResolutions); } } if((DlgParams.nFormat == FILE_J2K)|| (DlgParams.nFormat == FILE_JP2)|| (DlgParams.nFormat == FILE_CMW)|| (DlgParams.nFormat == FILE_TIF_J2K)|| (DlgParams.nFormat == FILE_TIF_CMW)) { /*Restore the old J2K Options*/ L_GetJ2KOptions(&FileJ2KOptions,sizeof(FILEJ2KOPTIONS)); L_SetJ2KOptions(&DlgParams.FileJ2KOptions); } if((DlgParams.nFormat == FILE_JBIG2)|| (DlgParams.nFormat == FILE_RAS_PDF_JBIG2)|| (DlgParams.nFormat == FILE_TIF_JBIG2)) { /*Restore the old JBIG2 Options*/ L_GetJBIG2Options(&FileJBIG2Options, sizeof(FILEJBIG2OPTIONS)); L_SetJBIG2Options(&DlgParams.FileJBIG2Options); } if ( DlgParams.nFormat == FILE_GIF ) { if(DlgParams.bSaveInterlaced) { SaveFileOption.Flags |= ESO_INTERLACED ; } else { SaveFileOption.Flags &= ~ESO_INTERLACED ; } } SaveFileOption.Flags |= ESO_JPEGSTAMP; /* force compressed stamps */ nRet = L_SaveBitmap(DlgParams.szFileName, &pData->LeadBitmap, DlgParams.nFormat, DlgParams.nBitsPerPixel, DlgParams.nQFactor, &SaveFileOption ); /* restore the old save dimensions */ if(pOldResolutions) { L_SetSaveResolution (uResCount, pOldResolutions); GlobalFreePtr(pOldResolutions); } if(pJBIGResolutions) GlobalFreePtr(pJBIGResolutions); if((DlgParams.nFormat == FILE_J2K)|| (DlgParams.nFormat == FILE_JP2)|| (DlgParams.nFormat == FILE_CMW)|| (DlgParams.nFormat == FILE_TIF_J2K)|| (DlgParams.nFormat == FILE_TIF_CMW)) { /*Restore the old J2K Options*/ L_SetJ2KOptions(&FileJ2KOptions); } if((DlgParams.nFormat == FILE_JBIG2)|| (DlgParams.nFormat == FILE_RAS_PDF_JBIG2)|| (DlgParams.nFormat == FILE_TIF_JBIG2)) { /*Restore the old JBIG2 Options*/ L_SetJBIG2Options(&FileJBIG2Options); } if (nRet != SUCCESS) { wsprintf (szBuffer, TEXT("ERROR %d saving the file %s."), nRet, (LPSTR)szFile); MessageBox(hWnd, szBuffer, TEXT("ERROR"), MB_OK); } else { UNLOCKCHILDDATA(hWnd); return (TRUE); } } UNLOCKCHILDDATA(hWnd); return (FALSE); } /*====(Child_OnClose)==================================================== Description: Performs cleanup for the child window. Syntax : VOID Child_OnClose(HWND hWnd) Parameters : hWnd Handle of a window. Return Value: None. ==========================================================================*/ static L_VOID Child_OnClose (HWND hWnd) { pCHILDDATA pData = LOCKCHILDDATA(hWnd); FORWARD_WM_CLOSE(hWnd, DefMDIChildProc); if (pData->nRgnType == 5) { pData->bMagWnd = FALSE; EndDialog(pData->hMagicWand, FALSE); } } /*====(Child_OnDestroy)==================================================== Description: Performs cleanup for the child window. Syntax : VOID Child_OnDestroy(HWND hWnd) Parameters : hWnd Handle of a window. Return Value: None. ==========================================================================*/ static L_VOID Child_OnDestroy (HWND hWnd) { pCHILDDATA pData; //MEMDISK...// L_BOOL bDel = TRUE; L_UINT uMem; //...MEMDISK// L_BOOL bBmSaveDel; pData = LOCKCHILDDATA (hWnd); if (pData->hPlaneWnd != NULL) DestroyWindow(pData->hPlaneWnd); //MEMDISK...// L_GetBitmapMemoryInfo (&pData->LeadBitmap, &uMem, NULL, NULL, NULL, NULL, NULL); if (uMem == TYPE_DISK) bDel = FALSE; //...MEMDISK// L_GetBitmapMemoryInfo (&pData->bmSave, &uMem, NULL, NULL, NULL, NULL, NULL); if (uMem == TYPE_DISK) bBmSaveDel = FALSE; //...MEMDISK// L_UndoList_DestroyList (hWnd);//UNDOLIST// if(pData) { nCount--; if(L_BitmapHasRgn(&pData->LeadBitmap)) KillTimer(hWnd, 1); if(pData->LeadBitmap.Flags.Allocated) { if (bDel) L_FreeBitmap(&pData->LeadBitmap); L_InitBitmap(&pData->LeadBitmap, sizeof(BITMAPHANDLE), 0, 0, 0); } if(pData->bmFloater.Flags.Allocated) { L_FreeBitmap(&pData->bmFloater); L_InitBitmap(&pData->bmFloater, sizeof(BITMAPHANDLE), 0, 0, 0); } if(pData->bmSave.Flags.Allocated) { if (bBmSaveDel) L_FreeBitmap(&pData->bmSave); L_InitBitmap(&pData->bmSave, sizeof(BITMAPHANDLE), 0, 0, 0); } if(pData->pszTitle) { GlobalFreePtr(pData->pszTitle); pData->pszTitle = NULL; } if(pData->hPalette) DeletePalette(pData->hPalette); if(pData->hrgnRegion) { DeleteRgn(pData->hrgnRegion); pData->hrgnRegion = NULL; } if(pData->hrgnFloater) { DeleteRgn(pData->hrgnFloater); pData->hrgnFloater = NULL; } UNLOCKCHILDDATA(hWnd); } } /*====(Child_OnMDIActivate)================================================ Description: Informs the child window it is going to receive the focus. Syntax : VOID Child_OnMDIActivate(HWND hWnd, BOOL fActive, HWND hWndActivate, HWND hWndDeactivate) Parameters : hWnd Handle of a window. fActive Truth of "Is the window active". hWndActivate Handle to the window to be activated. hWndDeactivate Handle to the window to be deactivated. Return Value: None. ==========================================================================*/ static L_VOID Child_OnMDIActivate (HWND hWnd, L_BOOL fActive, HWND hWndActivate, HWND hWndDeactivate) { pCHILDDATA pData; pCHILDDATA pPrevData = LOCKCHILDDATA(hWndDeactivate); pData = LOCKCHILDDATA (hWnd); if(hWnd == GetCapture()) ReleaseCapture(); if(hWndActivate) { SetFocus(hWnd); SendMessage(hWndClient, WM_MDISETMENU, (WPARAM)hMenuChild, (LPARAM)hMenuChildWindow); Child_OnQueryNewPalette(hWnd); SetStatusColorAndPixel(hWnd); SetStatusBarText(TEXT("STATUS"), &pData->LeadBitmap, szPos, szColor); if (IsWindow(hWndDeactivate)) if (pPrevData->bMagWnd) ShowWindow(pPrevData->hMagicWand, SW_HIDE); if (pData->bMagWnd) ShowWindow(pData->hMagicWand, SW_SHOW); } else { SetStatusBarText(NULL, 0, szPos, szColor); SendMessage(hWndClient, WM_MDISETMENU, (WPARAM)hMenuInit, (LPARAM)hMenuInitWindow); } DrawMenuBar(hWndFrame); UNLOCKCHILDDATA(hWnd); } static VOID FreeRegionBitmaps (pCHILDDATA pData) { if( pData->bmSave.Flags.Allocated ) L_FreeBitmap( &pData->bmSave ); if( pData->bmFloater.Flags.Allocated ) L_FreeBitmap( &pData->bmFloater ); if( pData->hbmFloater ) { DeleteObject( pData->hbmFloater ); pData->hbmFloater = NULL; } if( pData->hbmSave ) { DeleteObject( pData->hbmSave ); pData->hbmSave = NULL; } if( pData->hrgnRegion ) { DeleteObject( pData->hrgnRegion ); pData->hrgnRegion = NULL; } if( pData->hrgnFloater ) { DeleteObject( pData->hrgnFloater ); pData->hrgnFloater = NULL; } } static HBITMAP ResizeToDDB( pCHILDDATA pData, HDC hDisplay, pBITMAPHANDLE pBitmap, L_INT xSrcLeft, L_INT ySrcTop, L_INT nNewWidth, L_INT nNewHeight, L_INT nClientWidth, L_INT nClientHeight ) { HDC hDisplayMem; HDC hdcDevice; HBITMAP hBitmap; HBITMAP hbmSave; L_UINT32 ulFlags; RECT rcDest, rcDestClip; HPALETTE hpalSave = NULL; hdcDevice = (hDisplay)? hDisplay : GetDC (NULL); hDisplayMem = CreateCompatibleDC (hdcDevice); if ((hBitmap = CreateCompatibleBitmap (hdcDevice, nNewWidth, nNewHeight))== 0) { if (!hDisplay) ReleaseDC (NULL, hdcDevice); return (NULL); } hbmSave = SelectObject(hDisplayMem, hBitmap); if (pData->hPalette) { hpalSave = SelectPalette (hDisplayMem, pData->hPalette, TRUE); RealizePalette(hDisplayMem); } ulFlags = L_GetDisplayMode (); L_SetDisplayMode (DISPLAYMODE_INDEXEDPAINT, 0); SetRect(&rcDestClip, 0, 0, nNewWidth, nNewHeight); SetRect(&rcDest, - xSrcLeft, - ySrcTop, nClientWidth - xSrcLeft, nClientHeight - ySrcTop); L_PaintDC (hDisplayMem, pBitmap, NULL, NULL, &rcDest, &rcDestClip, SRCCOPY); L_SetDisplayMode (DISPLAYMODE_RESETPOSITIONS, ulFlags); if (hpalSave) SelectPalette (hDisplayMem, hpalSave, TRUE); SelectObject(hDisplayMem, hbmSave); DeleteDC(hDisplayMem); if (!hDisplay) ReleaseDC (NULL, hdcDevice); return (hBitmap); } /*====(OutlineBitmapRgn)====================================================== Description: Draws a frame around the current region Syntax : L_VOID OutlineBitmapRgn(HWND hWnd, HDC hdc) Parameters : hWnd Handle of the child window. HDC DC to use for drawing (may be null) Return Value: None. ==========================================================================*/ L_VOID OutlineBitmapRgn(HWND hWnd, HDC hdc) { pCHILDDATA pData; HDC hdcDraw; RGNXFORM XForm; pData = LOCKCHILDDATA(hWnd); if(L_BitmapHasRgn(&pData->LeadBitmap)) { if(hdc) hdcDraw = hdc; else hdcDraw = GetDC(pData->hBitmapWnd); XForm.uViewPerspective = TOP_LEFT; XForm.nXScalarNum = RECTWIDTH(&pData->rcView); XForm.nXScalarDen = BITMAPWIDTH(&pData->LeadBitmap); XForm.nYScalarNum = RECTHEIGHT(&pData->rcView); XForm.nYScalarDen = BITMAPHEIGHT(&pData->LeadBitmap); XForm.nXOffset = pData->rcView.left; XForm.nYOffset = pData->rcView.top; L_FrameBitmapRgn(hdcDraw, &pData->LeadBitmap, &XForm, pData->uFrameType); if(!hdc) ReleaseDC(pData->hBitmapWnd, hdcDraw); } UNLOCKCHILDDATA(hWnd); } static L_INT SafeCopyBitmapRect(pBITMAPHANDLE pBitmapDst, pBITMAPHANDLE pBitmapSrc, L_INT L_FAR * nXSrc, L_INT L_FAR * nYSrc, L_INT L_FAR * nWidth, L_INT L_FAR * nHeight ) { RECT rcRect; /* check the input parameters */ if( *nXSrc < 0 ) { *nWidth += *nXSrc; *nXSrc = 0; } else if(*nXSrc >= pBitmapSrc->Width) { *nXSrc = pBitmapSrc->Width; *nWidth = 0; } if( *nYSrc < 0 ) { *nHeight += *nYSrc; *nYSrc = 0; } else if(*nYSrc >= pBitmapSrc->Height) { *nYSrc = pBitmapSrc->Height; *nHeight = 0; } if( *nXSrc + *nWidth > pBitmapSrc->Width ) *nWidth = pBitmapSrc->Width - *nXSrc; if( *nYSrc + *nHeight > pBitmapSrc->Height ) *nHeight = pBitmapSrc->Height - *nYSrc; if( pBitmapDst->Flags.Allocated ) L_FreeBitmap( pBitmapDst ); L_InitBitmap(pBitmapDst, sizeof(BITMAPHANDLE), *nWidth, *nHeight, pBitmapSrc->BitsPerPixel); pBitmapDst->ViewPerspective = pBitmapSrc->ViewPerspective; pBitmapDst->Order = pBitmapSrc->Order; if( L_AllocateBitmap(pBitmapDst, TYPE_CONV)!= SUCCESS ) return FAILURE; if( pBitmapSrc->BitsPerPixel <= 8 ) L_CopyBitmapPalette(pBitmapDst, pBitmapSrc); SetRect(&rcRect, *nXSrc, *nYSrc, *nXSrc + *nWidth, *nYSrc + *nHeight); L_RectFromBitmap(pBitmapSrc, TOP_LEFT, &rcRect); L_CombineBitmap( pBitmapDst, 0, 0, RECTWIDTH(&rcRect), RECTHEIGHT(&rcRect), pBitmapSrc, rcRect.left, rcRect.top, L_SRCCOPY ); return SUCCESS; } /*====(HiliteMark)====================================================== Description: Performs the inversion of the region being marked Syntax : L_VOID HiliteMark(HWND hWnd, L_BOOL fUpdate) Parameters : hWnd Handle of the child window. fUpdate Hilite the new points only Return Value: None. ==========================================================================*/ static L_VOID HiliteMark(HWND hWnd, L_BOOL fUpdate) { HDC hdc; HBRUSH hBrush; HPEN hPen; L_INT nDrawMode; pCHILDDATA pData; HRGN hRgn; RECT rcScreen; pData = LOCKCHILDDATA(hWnd); if(nNextPt <= 1) return; hdc = GetDC(pData->hBitmapWnd); hBrush = SelectObject (hdc, GetStockObject (NULL_BRUSH)); hPen = SelectObject (hdc, GetStockObject(WHITE_PEN)); // create a region based on the visible area SetRect(&rcScreen, 0, 0, GetDeviceCaps(hdc, HORZRES), GetDeviceCaps(hdc, VERTRES)); IntersectRect(&rcScreen, &rcScreen, &pData->rcView); hRgn = CreateRectRgnIndirect(&rcScreen); SelectObject(hdc, hRgn); DeleteObject(hRgn); nDrawMode = GetROP2 (hdc); SetROP2 (hdc, R2_NOT); switch(pData->nRgnType) { case 1: Rectangle(hdc, min(pptRegion[0].x, pptRegion[1].x), min(pptRegion[0].y, pptRegion[1].y), max(pptRegion[0].x, pptRegion[1].x), max(pptRegion[0].y, pptRegion[1].y)); break; case 2: RoundRect(hdc, pptRegion[0].x, pptRegion[0].y, pptRegion[1].x, pptRegion[1].y, abs(pptRegion[0].x - pptRegion[1].x)/ 4, abs(pptRegion[0].y - pptRegion[1].y)/ 4); break; case 3: Ellipse(hdc, pptRegion[0].x, pptRegion[0].y, pptRegion[1].x, pptRegion[1].y); break; case 4: if(fUpdate) Polyline(hdc, &pptRegion[nNextPt - 2], 2); else Polyline(hdc, pptRegion, nNextPt); break; } SetROP2 (hdc, nDrawMode); SelectObject(hdc, hBrush); SelectObject(hdc, hPen); ReleaseDC(pData->hBitmapWnd, hdc); UNLOCKCHILDDATA(hWnd); } /*====(MoveFloater)======================================================== Description: Moves the floater when you drag it with the mouse. Syntax : VOID MoveFloater(HWND hWnd, LPCHILDDATA pData, L_INT x, L_INT y) Parameters : hWnd Handle of the child window. pData Child MDI window's data. x, y New position of the mouse cursor in client coordinates. Return Value: None. ==========================================================================*/ static VOID MoveFloater(HWND hWnd, pCHILDDATA pData, L_INT x, L_INT y) { HDC hdc; HDC hdcUnion; HDC hdcRegion; HBITMAP hbmUnion = 0, holdUnion, holdRegion; RECT rcSave; RECT rcUnion; RECT rcRegion; L_INT nUnionWidth = 0; L_INT nUnionHeight = 0; hdc = GetDC (pData->hBitmapWnd); /* All the x values are relative to the client window; viewport of the DC matches that already */ IntersectClipRect (hdc, 0, 0, RECTWIDTH(&pData->rcView), RECTHEIGHT(&pData->rcView)); SetRect (&rcSave, 0, 0, pData->nFloaterWidth, pData->nFloaterHeight); rcRegion = rcSave; OffsetRect (&rcSave, pData->xFloaterDest, pData->yFloaterDest); pData->deltaX += x - pData->xAnchor; pData->deltaY += y - pData->yAnchor; pData->xFloaterDest = pData->xFloaterDest + x - pData->xAnchor; pData->yFloaterDest = pData->yFloaterDest + y - pData->yAnchor; pData->xAnchor = x; pData->yAnchor = y; OffsetRect (&rcRegion, pData->xFloaterDest, pData->yFloaterDest); if (IntersectRect (&rcUnion, &rcSave, &rcRegion)) { UnionRect (&rcUnion, &rcSave, &rcRegion); /* create a DDB from the origial bitmap the size of the union */ nUnionWidth = rcUnion.right - rcUnion.left; nUnionHeight = rcUnion.bottom - rcUnion.top; hbmUnion = CreateCompatibleBitmap(hdc, nUnionWidth, nUnionHeight ); OffsetRect (&rcRegion, -rcUnion.left, -rcUnion.top); OffsetRect (&rcSave, -rcUnion.left, -rcUnion.top); hdcUnion = CreateCompatibleDC (hdc); holdUnion = SelectObject (hdcUnion, hbmUnion); hdcRegion = CreateCompatibleDC (hdc); holdRegion = SelectObject (hdcRegion, pData->hbmSave); /* copy to the union DDB what's on the screen */ BitBlt( hdcUnion, 0, 0, nUnionWidth, nUnionHeight, hdc, rcUnion.left, rcUnion.top, SRCCOPY ); /* restore the background into the union. Now the union bitmap should contain what should on the screen without the floating bitmap */ BitBlt( hdcUnion, rcSave.left, rcSave.top, pData->nFloaterWidth, pData->nFloaterHeight, hdcRegion, 0, 0, SRCCOPY ); /* get the new background into hbmSave */ BitBlt (hdcRegion, 0, 0, pData->nFloaterWidth, pData->nFloaterHeight, hdcUnion, rcRegion.left, rcRegion.top, SRCCOPY); /* Paint only what's is inside the region using Windows's ability to do clipping. Select the region into the union DC */ SelectObject( hdcUnion, pData->hrgnFloater ); OffsetClipRgn( hdcUnion, rcRegion.left, rcRegion.top ); /* select the floater DDB */ SelectObject( hdcRegion, pData->hbmFloater ); /* Now the union DDB is what should be on the screen */ BitBlt (hdcUnion, rcRegion.left, rcRegion.top, pData->nFloaterWidth, pData->nFloaterHeight, hdcRegion, 0, 0, SRCCOPY); /* blast the whole thing to the screen */ BitBlt( hdc, rcUnion.left, rcUnion.top, nUnionWidth, nUnionHeight, hdcUnion, 0, 0, SRCCOPY ); SelectObject( hdcUnion, holdUnion ); DeleteDC(hdcUnion); SelectObject( hdcRegion, holdRegion ); DeleteDC(hdcRegion); DeleteObject( hbmUnion ); } else { hdcRegion = CreateCompatibleDC (hdc); holdRegion = SelectObject (hdcRegion, pData->hbmSave); /* restore the background */ BitBlt( hdc, rcSave.left, rcSave.top, pData->nFloaterWidth, pData->nFloaterHeight, hdcRegion, 0, 0, SRCCOPY ); /* save the background */ BitBlt (hdcRegion, 0, 0, pData->nFloaterWidth, pData->nFloaterHeight, hdc, pData->xFloaterDest, pData->yFloaterDest, SRCCOPY); /* Paint only what's is inside the region using Windows's ability to do clipping. Select the floater into the union DC */ SelectObject( hdc, pData->hrgnFloater ); OffsetClipRgn( hdc, pData->xFloaterDest, pData->yFloaterDest ); IntersectClipRect (hdc, 0, 0, RECTWIDTH(&pData->rcView), RECTHEIGHT(&pData->rcView)); /* paint only what's INSIDE the region */ SelectObject( hdcRegion, pData->hbmFloater ); BitBlt (hdc, pData->xFloaterDest, pData->yFloaterDest, pData->nFloaterWidth, pData->nFloaterHeight, hdcRegion, 0, 0, SRCCOPY); SelectObject( hdcRegion, holdRegion ); DeleteDC(hdcRegion); } ReleaseDC (pData->hBitmapWnd, hdc); } /*====(YClientToBitmap)=================================================== Description: Helps find the corresponding pixel in the bitmap for a point on the screen. Syntax : L_INT YClientToBitmap(LPCHILDDATA pData, L_INT y) Parameters : pData Child window's data x X coordinate of a point in the client window y Y coordinate of a point in the client window Return Value: The corresponding Y coordinate in bitmap coordinates ==========================================================================*/ static L_INT YClientToBitmap(pCHILDDATA pData, L_INT x, L_INT y) { x = (L_INT)((L_INT32)(x - pData->rcView.left)*BITMAPWIDTH(&pData->LeadBitmap)/RECTWIDTH(&pData->rcView)); y = (L_INT)((L_INT32)(y - pData->rcView.top)*BITMAPHEIGHT(&pData->LeadBitmap)/RECTHEIGHT(&pData->rcView)); L_PointToBitmap(&pData->LeadBitmap, TOP_LEFT, &x, &y); return y; } /*====(XClientToBitmap)=================================================== Description: Helps find the corresponding pixel in the bitmap for a point on the screen. Syntax : L_INT XClientToBitmap(LPCHILDDATA pData, L_INT x) Parameters : pData Child window's data x X coordinate of a point in the client window y Y coordinate of a point in the client window Return Value: The corresponding X coordinate in bitmap coordinates ==========================================================================*/ static L_INT XClientToBitmap(pCHILDDATA pData, L_INT x, L_INT y) { x = (L_INT)((L_INT32)(x - pData->rcView.left)*BITMAPWIDTH(&pData->LeadBitmap)/RECTWIDTH(&pData->rcView)); y = (L_INT)((L_INT32)(y - pData->rcView.top)*BITMAPHEIGHT(&pData->LeadBitmap)/RECTHEIGHT(&pData->rcView)); L_PointToBitmap(&pData->LeadBitmap, TOP_LEFT, &x, &y); return x; } /*----[CreateRegionBitmaps]------------------------------------------------- Syntax: L_INT CreateRegionBitmaps( HWND hWnd ) Parameters: hWnd The window where the bitmap is drawn. Notes: This function will allocate the bitmaps and DDBs used to move the floater bitmap around. --------------------------------------------------------------------------*/ static L_INT CreateRegionBitmaps( HWND hWnd ) { HDC hdc; RGNXFORM XForm; RECT rcRegion; RECT rcFloater; pCHILDDATA pData; RECT rcRect; pData = LOCKCHILDDATA(hWnd); hdc = GetDC(pData->hBitmapWnd); /* get the position of the region in bitmap coordinates */ XForm.uViewPerspective = pData->LeadBitmap.ViewPerspective; XForm.nXScalarNum = XForm.nXScalarDen = XForm.nYScalarNum = XForm.nYScalarDen = 1; XForm.nXOffset = XForm.nYOffset = 0; L_GetBitmapRgnBounds(&pData->LeadBitmap, &XForm, &rcRegion); pData->xMoveSrc = rcRegion.left; pData->yMoveSrc = rcRegion.top; pData->nMoveWidth = RECTWIDTH(&rcRegion); pData->nMoveHeight = RECTHEIGHT(&rcRegion); /* delete the previous region */ if( pData->hrgnRegion ) DeleteObject( pData->hrgnRegion ); /* get the Windows region handle from original bitmap. Current offset is xMoveSrc, yMoveSrc and I want it at 0, 0 */ XForm.nXOffset = - pData->xMoveSrc; XForm.nYOffset = - pData->yMoveSrc; L_GetBitmapRgnHandle( &pData->LeadBitmap, &XForm, &pData->hrgnRegion ); /* get the position of the region in client coordinates. This is how we find out the size of the floater. We have to to it here in case the zoom factor has changed since the creation of the region. I want these coordinates to be TOP_LEFT, like the screen! */ XForm.uViewPerspective = TOP_LEFT; XForm.nXScalarNum = RECTWIDTH(&pData->rcView); XForm.nYScalarNum = RECTHEIGHT(&pData->rcView); XForm.nXScalarDen = BITMAPWIDTH(&pData->LeadBitmap); XForm.nYScalarDen = BITMAPHEIGHT(&pData->LeadBitmap); XForm.nXOffset = pData->rcView.left; XForm.nYOffset = pData->rcView.top; L_GetBitmapRgnBounds(&pData->LeadBitmap, &XForm, &rcFloater); pData->xFloaterDest = rcFloater.left; pData->yFloaterDest = rcFloater.top; pData->nFloaterWidth = RECTWIDTH(&rcFloater); pData->nFloaterHeight = RECTHEIGHT(&rcFloater); /* delete the previous floater region */ if( pData->hrgnFloater ) DeleteObject( pData->hrgnFloater ); /* get the Windows region handle for the floater. I want it at 0, 0 */ XForm.uViewPerspective = TOP_LEFT; XForm.nXOffset -= rcFloater.left; XForm.nYOffset -= rcFloater.top; L_GetBitmapRgnHandle( &pData->LeadBitmap, &XForm, &pData->hrgnFloater ); /* clear the region from the source bitmap */ L_FreeBitmapRgn(&pData->LeadBitmap); /* --------------- START CREATING THE FLOATING BITMAPS --------- */ /* free the previous floater bitmap */ if( pData->bmFloater.Flags.Allocated ) L_FreeBitmap( &pData->bmFloater ); /* create the floater bitmap */ L_CopyBitmapRect( &pData->bmFloater, &pData->LeadBitmap, sizeof(BITMAPHANDLE), pData->xMoveSrc, pData->yMoveSrc, pData->nMoveWidth, pData->nMoveHeight); /* create the floater DDB */ if( pData->hbmFloater ) DeleteObject( pData->hbmFloater ); pData->hbmFloater = ResizeToDDB( pData, hdc, &pData->LeadBitmap, pData->xFloaterDest - pData->rcView.left, pData->yFloaterDest - pData->rcView.top, pData->nFloaterWidth, pData->nFloaterHeight, RECTWIDTH(&pData->rcView), RECTHEIGHT(&pData->rcView)); /* --------------- the floating bitmaps are created ------------- */ /* ------- START CREATING THE BACKGROUND BITMAPS ------- */ /* create the background bitmap if it doesn't exist already */ if( pData->bmSave.Flags.Allocated ) { //SetRect(&rcRect, pData->xMoveSrc, pData->yMoveSrc, SetRect(&rcRect, pData->xSaveSrc, pData->ySaveSrc, pData->xMoveSrc + pData->nMoveWidth, pData->yMoveSrc + pData->nMoveHeight); L_RectFromBitmap(&pData->LeadBitmap, TOP_LEFT, &rcRect); /* restore the background in the big bitmap */ L_CombineBitmap(&pData->LeadBitmap, rcRect.left, rcRect.top, RECTWIDTH(&rcRect), RECTHEIGHT(&rcRect), &pData->bmSave, 0, 0, L_SRCCOPY ); } else /* create the save bitmap. Now, it is exactly as the floater */ L_CopyBitmap( &pData->bmSave, &pData->bmFloater, sizeof(BITMAPHANDLE)); /* create the save DDB */ if( pData->hbmSave ) DeleteObject( pData->hbmSave ); pData->hbmSave = ResizeToDDB( pData, hdc, &pData->LeadBitmap, pData->xFloaterDest - pData->rcView.left, pData->yFloaterDest - pData->rcView.top, pData->nFloaterWidth, pData->nFloaterHeight, RECTWIDTH(&pData->rcView), RECTHEIGHT(&pData->rcView)); /* ------- the background bitmaps are created --------- */ if( !pData->hbmFloater || !pData->hbmSave || !pData->bmFloater.Flags.Allocated || !pData->bmSave.Flags.Allocated || !pData->hrgnRegion || !pData->hrgnFloater ) MessageBox( hWnd, TEXT("Error allocating bitmaps"), TEXT(""), MB_OK ); /* create the background DDB */ ReleaseDC(pData->hBitmapWnd, hdc ); UNLOCKCHILDDATA(hWnd); return SUCCESS; } L_VOID Child_OnRButtonup (HWND hWnd, L_INT nX, L_INT nY, L_UINT ukeyFlags) { POINT pt; L_BOOL bClipboardReady; pCHILDDATA pData; HMENU hRightClickMenu; L_INT nNum; L_INT nShift; L_BOOL bEnable; L_BOOL bGrayScale; L_BOOL bOneBitImage; pData = LOCKCHILDDATA (hWnd); if(!pData) return; bOneBitImage = pData->LeadBitmap.BitsPerPixel == 1; pt.x = nX; pt.y = nY; ClientToScreen(hWnd, &pt); hRightClickMenu = LoadMenu(hInst, MAKEINTRESOURCE(IDR_RIGHTCLICKMENU)); bClipboardReady = L_ClipboardReady(); bGrayScale = L_IsGrayScaleBitmap(&pData->LeadBitmap); CheckMenuItem(hRightClickMenu, IDM_EDIT_SETREGION_NONE, MF_BYCOMMAND | (pData->nRgnType == 0) ? MF_CHECKED : MF_UNCHECKED); CheckMenuItem(hRightClickMenu, IDM_EDIT_SETREGION_RECTANGLE, MF_BYCOMMAND | (pData->nRgnType == 1) ? MF_CHECKED : MF_UNCHECKED); CheckMenuItem(hRightClickMenu, IDM_EDIT_SETREGION_ROUNDEDRECTANGLE, MF_BYCOMMAND | (pData->nRgnType == 2) ? MF_CHECKED : MF_UNCHECKED); CheckMenuItem(hRightClickMenu, IDM_EDIT_SETREGION_ELLIPSE, MF_BYCOMMAND | (pData->nRgnType == 3) ? MF_CHECKED : MF_UNCHECKED); CheckMenuItem(hRightClickMenu, IDM_EDIT_SETREGION_FREEHAND, MF_BYCOMMAND | (pData->nRgnType == 4) ? MF_CHECKED : MF_UNCHECKED); CheckMenuItem(hRightClickMenu, IDM_EDIT_SETREGION_MAGICWAND, MF_BYCOMMAND | (pData->nRgnType == 5) ? MF_CHECKED : MF_UNCHECKED); CheckMenuItem(hRightClickMenu, IDM_WINDOW_MGCDLG, MF_BYCOMMAND | (pData->bMagWnd) ? MF_CHECKED : MF_UNCHECKED); //CheckMenuItem(hRightClickMenu, IDM_EDIT_MAGICWANDEX, MF_BYCOMMAND | (pData->nRgnType == 6) ? MF_CHECKED : MF_UNCHECKED); CheckMenuItem(hRightClickMenu, IDM_EDIT_SINGLE, MF_BYCOMMAND | (pData->uCombineMode == L_RGN_SET) ? MF_CHECKED : MF_UNCHECKED); CheckMenuItem(hRightClickMenu, IDM_EDIT_MULTI, MF_BYCOMMAND | (pData->uCombineMode == L_RGN_OR) ? MF_CHECKED : MF_UNCHECKED); CheckMenuItem(hRightClickMenu, IDM_EDIT_INTERSECT, MF_BYCOMMAND | (pData->uCombineMode == L_RGN_AND) ? MF_CHECKED : MF_UNCHECKED); CheckMenuItem(hRightClickMenu, IDM_EDIT_INVERT, MF_BYCOMMAND | (pData->uCombineMode == L_RGN_SETNOT) ? MF_CHECKED : MF_UNCHECKED); CheckMenuItem(hRightClickMenu, IDM_EDIT_OLDANDNOTNEW, MF_BYCOMMAND | (pData->uCombineMode == L_RGN_ANDNOTRGN) ? MF_CHECKED : MF_UNCHECKED); CheckMenuItem(hRightClickMenu, IDM_EDIT_NEWANDNOTOLD, MF_BYCOMMAND | (pData->uCombineMode == L_RGN_ANDNOTBITMAP) ? MF_CHECKED : MF_UNCHECKED); CheckMenuItem(hRightClickMenu, IDM_EDIT_OLDXORNEW, MF_BYCOMMAND | (pData->uCombineMode == L_RGN_XOR) ? MF_CHECKED : MF_UNCHECKED); EnableMenuItem(hRightClickMenu, IDM_IMAGE_WR, (L_BitmapHasRgn(&pData->LeadBitmap)) ? MF_ENABLED : MF_GRAYED); EnableMenuItem(hRightClickMenu, IDM_EDIT_COPYRGN, ((L_BitmapHasRgn(&pData->LeadBitmap) ? MF_ENABLED : MF_GRAYED))); EnableMenuItem(hRightClickMenu, IDM_IMAGE_FEATHER, FadeBitmap.Flags.Allocated ? MF_ENABLED : MF_GRAYED); EnableMenuItem(hRightClickMenu, IDM_IMAGE_FADEMASK, L_BitmapHasRgn(&pData->LeadBitmap) ? MF_ENABLED : MF_GRAYED); EnableMenuItem(hRightClickMenu, IDM_IMAGE_SELECTIVECOLOR, bGrayScale ? MF_GRAYED : MF_ENABLED); EnableMenuItem(hRightClickMenu, IDM_IMAGE_DESAT, bGrayScale ? MF_GRAYED : MF_ENABLED); EnableMenuItem(hRightClickMenu, IDM_IMAGE_BALANCECOLORS, bGrayScale ? MF_GRAYED : MF_ENABLED); EnableMenuItem(hRightClickMenu, IDM_COLOR_SWAPCOLOR, bGrayScale ? MF_GRAYED : MF_ENABLED); EnableMenuItem(hRightClickMenu, IDM_COLOR_BALANCECOLOR, bGrayScale ? MF_GRAYED : MF_ENABLED); EnableMenuItem(hRightClickMenu, IDM_COLOR_COLOREDGRAY, bGrayScale ? MF_GRAYED : MF_ENABLED); EnableMenuItem(hRightClickMenu, IDM_COLOR_CONVERTTOGRAY, bGrayScale ? MF_GRAYED : MF_ENABLED); EnableMenuItem(hRightClickMenu, IDM_IMAGE_HSB, bGrayScale ? MF_GRAYED : MF_ENABLED); EnableMenuItem(hRightClickMenu, IDM_IMAGE_CHANNELMIXER, bGrayScale ? MF_GRAYED : MF_ENABLED); EnableMenuItem(hRightClickMenu, IDM_IMAGE_COLORTHRESHOLD, bGrayScale ? MF_GRAYED : MF_ENABLED); EnableMenuItem(hRightClickMenu, IDM_IMAGE_SHIFTBITMAP, !bGrayScale || bOneBitImage ? MF_GRAYED : MF_ENABLED); EnableMenuItem(hRightClickMenu, IDM_IMAGE_BITMAPSELECTOR, !bGrayScale || bOneBitImage ? MF_GRAYED : MF_ENABLED); EnableMenuItem(hRightClickMenu, IDM_IMAGE_GRAYCOLORATION, !bGrayScale || bOneBitImage ? MF_GRAYED : MF_ENABLED); EnableMenuItem(hRightClickMenu, IDM_EDIT_PASTE, MF_BYCOMMAND | (bClipboardReady) ? MF_ENABLED : MF_GRAYED); EnableMenuItem(hRightClickMenu, IDM_EDIT_CANCELREGION, L_BitmapHasRgn(&(pData->LeadBitmap)) ? MF_ENABLED : MF_GRAYED); EnableMenuItem(hRightClickMenu, IDM_EDIT_UNDO, L_UndoList_UndoExists(hWnd) ? MF_ENABLED : MF_GRAYED); EnableMenuItem(hRightClickMenu, IDM_EDIT_REDO, L_UndoList_RedoExists(hWnd) ? MF_ENABLED : MF_GRAYED); EnableMenuItem(hRightClickMenu, IDM_EDIT_COPYRGN, L_BitmapHasRgn(&(pData->LeadBitmap)) ? MF_ENABLED : MF_GRAYED); EnableMenuItem(hRightClickMenu, IDM_IMAGE_GETFERETS, (L_BitmapHasRgn(&pData->LeadBitmap)) ? MF_ENABLED : MF_GRAYED); EnableMenuItem(hRightClickMenu, IDM_IMAGE_GETRGNPERIMETER, (L_BitmapHasRgn(&pData->LeadBitmap)) ? MF_ENABLED : MF_GRAYED); EnableMenuItem(hRightClickMenu, IDM_EDIT_RESIZEREGION, (L_BitmapHasRgn(&pData->LeadBitmap)) ? MF_ENABLED : MF_GRAYED); EnableMenuItem(hRightClickMenu, IDM_WINDOW_MGCDLG, (pData->nRgnType == 5) ? MF_ENABLED : MF_GRAYED); EnableMenuItem(hRightClickMenu, IDM_IMAGE_REDEYEREMOVE, bGrayScale); bEnable = FALSE; nNum = pData->LeadBitmap.Width; nShift = (L_INT)(log10(nNum) / log10(2)); if (((nNum >> nShift) << nShift) == nNum) { nNum = pData->LeadBitmap.Height; nShift = (L_INT)(log10(nNum) / log10(2)); if (((nNum >> nShift) << nShift) == nNum) bEnable = TRUE; } if ((pData->LeadBitmap.Width == 1) || (pData->LeadBitmap.Height == 1)) bEnable = FALSE; EnableMenuItem(hRightClickMenu, IDM_IMAGE_FFT, bEnable ? MF_ENABLED : MF_GRAYED); TrackPopupMenu(GetSubMenu(hRightClickMenu, 0), 0, pt.x, pt.y, 0, hWnd, NULL); UNLOCKCHILDDATA(hWnd); } /*====(Child_OnTimer)====================================================== Description: Called when the timer value expires Syntax : L_VOID Child_OnTimer(HWND hWnd, L_UINT nID) Parameters : hWnd Handle of the child window. nID Timer nID supplied in SetTimr Return Value: None. ==========================================================================*/ static L_VOID Child_OnTimer(HWND hWnd, L_UINT nID) { pCHILDDATA pData; pData = LOCKCHILDDATA(hWnd); switch(nID) { case 1: pData->uFrameType = (pData->uFrameType + 1) % 8; OutlineBitmapRgn(hWnd, NULL); break; } UNLOCKCHILDDATA(hWnd); } /*====(Child_OnSetFocus)====================================================== Description: Indicates when the window is getting the input focus Syntax : VOID Child_OnSetFocus(HWND hWnd) Parameters : hWnd Handle of the child window. hWndOldFocus Previous window that had the focus Return Value: None. ==========================================================================*/ static VOID Child_OnSetFocus(HWND hWnd, HWND hWndOldFocus) { pCHILDDATA pData; pData = LOCKCHILDDATA (hWnd); if (!pData) return; if(L_BitmapHasRgn(&pData->LeadBitmap)) pData->uTimerID = SetTimer(hWnd, 1, 100, NULL); UNLOCKCHILDDATA(hWnd); } /*====(Child_OnSetFocus)====================================================== Description: Indicates when the window is getting the input focus Syntax : VOID Child_OnSetFocus(HWND hWnd) Parameters : hWnd Handle of the child window. hWndOldFocus Previous window that had the focus Return Value: None. ==========================================================================*/ static VOID Child_OnKillFocus(HWND hWnd, HWND hWndNewFocus) { pCHILDDATA pData; pData = LOCKCHILDDATA (hWnd); if (!pData) return; if(L_BitmapHasRgn(&pData->LeadBitmap)) KillTimer(hWnd, 1); UNLOCKCHILDDATA(hWnd); } L_VOID Child_OnKey (HWND hWnd, L_UINT vk, L_BOOL bDown, L_INT nRepeat, L_UINT uFlags) { L_INT nMin, nMax; L_UINT uFlag; POINT pt; RECT rcRect; GetCursorPos(&pt); ScreenToClient(hWnd, &pt); GetClientRect(hWnd, &rcRect); if (!PtInRect(&rcRect, pt)) return; if (vk == VK_SHIFT) { if (bDown) SetCursor(LoadCursor(NULL, IDC_ARROW)); else { GetScrollRange(hWnd, SB_HORZ, &nMin, &nMax); uFlag = (nMin < nMax ? IDC_CURS11 : (L_UINT)IDC_ARROW); GetScrollRange(hWnd, SB_VERT, &nMin, &nMax); uFlag = (nMin < nMax ? IDC_CURS11 : uFlag); SetCursor(LoadCursor((uFlag == IDC_CURS11) ? hInst : NULL, MAKEINTRESOURCE(uFlag))); } } } L_VOID FitImageToWindow(RECT rcImage, pBITMAPHANDLE pBitmap, LPRECT Rect) { L_INT Dy, Dx; L_INT nOffsetx, nOffsety; if(pBitmap->Height >= pBitmap->Width) { Dy = rcImage.bottom - rcImage.top; Dx = MulDiv ( Dy, pBitmap->Width, pBitmap->Height ); nOffsety = 0; nOffsetx = (rcImage.right - rcImage.left - Dx)/2; } else { Dx = rcImage.right- rcImage.left; Dy = MulDiv ( Dx, pBitmap->Height, pBitmap->Width ); nOffsety = (rcImage.bottom- rcImage.top - Dy)/2; nOffsetx = 0; } SetRect(Rect, 0, 0, Dx, Dy); OffsetRect(Rect, nOffsetx, nOffsety); } /* +--------------------------------------------------------------------------+ | Function :Child_OnLButtonDown | | Desc :starts the dragging of the splitter | | Return :void | | Notes : | +--------------------------------------------------------------------------+ */ static L_VOID Child_OnLButtonDown (HWND hWnd, L_BOOL bDoubleClick, L_INT x, L_INT y, L_UINT keyFlags) { RECT rcClient; POINT pt; pCHILDDATA pData; DWORD dwStyle; pData = LOCKCHILDDATA(hWnd); if(!GetCapture()&& pData->nRgnType != 0 && !IsIconic(hWnd)&& pData->LeadBitmap.Flags.Allocated) { if (pData->bLineHistogram) { SetCapture(hWnd); return; } GetClientRect(hWnd, &rcClient); IntersectRect(&rcClient, &rcClient, &pData->rcView); pt.x = x; pt.y = y; if(PtInRect(&rcClient, pt)) { MemorizeBitmap (hWnd); //...MEMDISK// /* If we click inside the existing region, allow its dragging */ /* x is in client coordinates and L_IsPtInBitmapRgn uses bitmap coordinates */ if(L_BitmapHasRgn(&pData->LeadBitmap)&& L_IsPtInBitmapRgn (&pData->LeadBitmap, YClientToBitmap(pData, x, y), XClientToBitmap(pData, x, y)) &&(pData->uCombineMode == L_RGN_SET)) { /* stop displaying the frame while dragging the region */ KillTimer(hWnd, 1); /* create the bitmaps needed to move the floater around If the floater was moved here, restore the background as well */ CreateRegionBitmaps(hWnd); pData->deltaX = pData->deltaY = 0; pData->xAnchor = x; pData->yAnchor = y; pData->bMovingFloater = TRUE; if (pData->nRgnType != 0) SetCursor(LoadCursor(NULL, IDC_SIZEALL)); SetCapture(hWnd); } else { BOOL bBitmapHasRgn = L_BitmapHasRgn(&pData->LeadBitmap)&& (pData->uCombineMode == L_RGN_SET); if(bBitmapHasRgn) FreeRegionBitmaps(pData); if(pData->nRgnType == 4) pptRegion = (LPPOINT)GlobalAllocPtr(GHND, (L_UINT32)sizeof(POINT)* MAXPOINTS); else pptRegion = (LPPOINT)GlobalAllocPtr(GHND, (L_UINT32)sizeof(POINT)* 2); if(pptRegion) { if(pData->uCombineMode == L_RGN_SET) { KillTimer(hWnd, 1); L_FreeBitmapRgn(&pData->LeadBitmap); } InvalidateRect(hWnd, NULL, FALSE); UpdateWindow(hWnd); nNextPt = 0; pptRegion[nNextPt].x = x; pptRegion[nNextPt].y = y; nNextPt++; SetCapture(hWnd); } InvalidateRect(hWnd, NULL, FALSE); } } } else if (pData->nRgnType == 0) { dwStyle = GetWindowLong(hWnd, GWL_STYLE); if (WS_VSCROLL & dwStyle)// if Vertical scroll { if (!(keyFlags & MK_SHIFT)) SetCursor(LoadCursor(hInst, MAKEINTRESOURCE(IDC_CURS11))); } else { if (WS_HSCROLL & dwStyle)// if Horizontal scroll { if (!(keyFlags & MK_SHIFT)) SetCursor(LoadCursor(hInst, MAKEINTRESOURCE(IDC_CURS11))); } else SetCursor(LoadCursor(NULL, IDC_ARROW)); } pData->bMoveView = TRUE; pData->ptMovePnt.x = x; pData->ptMovePnt.y = y; SetCapture(hWnd); } UNLOCKCHILDDATA(hWnd); return; } L_VOID SetStatusColorAndPixel(HWND hWnd) { pCHILDDATA pData = LOCKCHILDDATA (hWnd); POINT TmpPoint; L_INT nViewP; // L_INT nRet; GetCursorPos(&TmpPoint); ScreenToClient(hWnd, &TmpPoint); if (!((TmpPoint.x >= pData->LeadBitmap.Width) || (TmpPoint.y >= pData->LeadBitmap.Height))) { L_UCHAR nComp[8]; L_UCHAR nDst[8]; nViewP = pData->LeadBitmap.ViewPerspective; L_ChangeBitmapViewPerspective(&pData->LeadBitmap, &pData->LeadBitmap, sizeof(BITMAPHANDLE), TOP_LEFT); crColor = L_GetPixelColor(&pData->LeadBitmap, TmpPoint.y + pData->nVScrollPos, TmpPoint.x + pData->nHScrollPos); // for release version if(GetProcPixel(&pData->LeadBitmap) == 16) { L_INT nRed; if(pData->LeadBitmap.BitsPerPixel == 16) { nRed = (L_UCHAR)((crColor & 0x00FFFF) >> 8); } else { nRed = (L_UCHAR)(((crColor & 0x00FFF0) >> 4) >> 4); } crColor = ((L_UINT32)(((L_UCHAR)(nRed)|((L_UINT16)(nRed) << 8))|(((L_UINT32)(L_UCHAR)(nRed)) << 16))); } nComp[2] = (L_UCHAR) (crColor); nComp[1] = (L_UCHAR)((crColor) >> 8); nComp[0] = (L_UCHAR)((crColor) >> 16); switch(uColorSpace) { case 0: nDst[0] = nComp[2]; nDst[1] = nComp[1]; nDst[2] = nComp[0]; break; case 1: L_ConvertColorSpace(nComp, nDst, 1, CCS_RGB, CCS_HSV); break; case 2: L_ConvertColorSpace(nComp, nDst, 1, CCS_RGB, CCS_HLS); break; case 7: L_ConvertColorSpace(nComp, nDst, 1, CCS_RGB, CCS_CMY); break; case 5: L_ConvertColorSpace(nComp, nDst, 1, CCS_RGB, CCS_YUV); break; } nComp[0] = nDst[0]; nComp[1] = nDst[1]; nComp[2] = nDst[2]; //////////////////////////////////////////////////////////////////////////////////// /*nRet = L_GetPixelColorInCS(&pData->LeadBitmap, TmpPoint.y + pData->nVScrollPos, TmpPoint.x + pData->nHScrollPos, uColorSpace, nComp, &crColor);*/ L_ChangeBitmapViewPerspective(&pData->LeadBitmap, &pData->LeadBitmap, sizeof(BITMAPHANDLE), nViewP); if (IsDecimal) wsprintf(szColor, TEXT("%d, %d, %d"), nComp[0], nComp[1], nComp[2]); else wsprintf(szColor, TEXT("%X, %X, %X"), nComp[0], nComp[1], nComp[2]); wsprintf(szPos, TEXT("%d, %d"), TmpPoint.x + pData->nHScrollPos, TmpPoint.y + pData->nVScrollPos); SetDlgItemText(hStatusWnd, IDC_STATUS_COLOR, szColor); SetDlgItemText(hStatusWnd, IDC_STATUS_MOUSEPOS, szPos); } } /*--------------------------------------------------------------------------+ | Function :Child_OnMouseMove | Desc :continues dragging the splitter | Return :void | Notes : +--------------------------------------------------------------------------*/ static L_VOID Child_OnMouseMove (HWND hWnd, L_INT x, L_INT y, L_UINT keyFlags) { pCHILDDATA pData; POINT TmpPoint; RECT TmpRect; DWORD dwStyle; pData = LOCKCHILDDATA (hWnd); TmpPoint.x = x; TmpPoint.y = y; SetStatusColorAndPixel(hWnd); InvalidateRect(hStatusWnd, NULL, FALSE); if (L_BitmapHasRgn(&pData->LeadBitmap) && (pData->nRgnType != 0)) { if ((L_IsPtInBitmapRgn(&pData->LeadBitmap, TmpPoint.y + pData->nVScrollPos, TmpPoint.x + pData->nHScrollPos)|| pData->bMovingFloater)&& pData->nRgnType != 0) SetCursor(LoadCursor(NULL, IDC_SIZEALL)); else SetCursor(LoadCursor(NULL, IDC_ARROW)); } if (pData->nRgnType == 0) { dwStyle = GetWindowLong(hWnd, GWL_STYLE); if (WS_VSCROLL & dwStyle)// if Vertical scroll { if (!(keyFlags & MK_SHIFT)) SetCursor(LoadCursor(hInst, MAKEINTRESOURCE(IDC_CURS11))); } else { if (WS_HSCROLL & dwStyle)// if Horizontal scroll { if (!(keyFlags & MK_SHIFT)) SetCursor(LoadCursor(hInst, MAKEINTRESOURCE(IDC_CURS11))); } else SetCursor(LoadCursor(NULL, IDC_ARROW)); } } GetClientRect(hWnd, &TmpRect); IntersectRect(&TmpRect , &TmpRect, &pData->rcView); if(pData->bMoveView) { OffsetRect(&pData->rcView, -(pData->ptMovePnt.x - TmpPoint.x), -(pData->ptMovePnt.y - TmpPoint.y)); if(pData->rcView.left > 0) OffsetRect(&pData->rcView, -pData->rcView.left, 0); if(pData->rcView.right < TmpRect.right) OffsetRect(&pData->rcView, TmpRect.right - pData->rcView.right, 0); if(pData->rcView.top > 0) OffsetRect(&pData->rcView, 0, -pData->rcView.top); if(pData->rcView.bottom < TmpRect.bottom) OffsetRect(&pData->rcView, 0, TmpRect.bottom - pData->rcView.bottom); pData->nHScrollPos = min(pData->nHScrollMax, -(pData->rcView.left)); pData->nVScrollPos = min(pData->nVScrollMax, -(pData->rcView.top)); SetScrollPos(hWnd, SB_HORZ, pData->nHScrollPos, TRUE); SetScrollPos(hWnd, SB_VERT, pData->nVScrollPos, TRUE); pData->ptMovePnt = TmpPoint; InvalidateRect(hWnd, &pData->rcView, FALSE); return; } if( (GetCapture()== hWnd)) { if( pData->bMovingFloater ) { SetCursor(LoadCursor(NULL, IDC_SIZEALL)); MoveFloater(hWnd, pData, x, y); } else { switch(pData->nRgnType) { case 4: if(nNextPt < MAXPOINTS) { pptRegion[nNextPt].x = x; pptRegion[nNextPt].y = y; nNextPt++; } break; default: HiliteMark(hWnd, FALSE); pptRegion[1].x = x; pptRegion[1].y = y; nNextPt = 2; break; } HiliteMark(hWnd, TRUE); } } UNLOCKCHILDDATA(hWnd); } /*--------------------------------------------------------------------------+ | Function :Child_OnLButtonUp | Desc :ends the dragging of the splitter | Return :void | Notes : +--------------------------------------------------------------------------*/ static L_VOID Child_OnLButtonUp (HWND hWnd, L_INT x, L_INT y, L_UINT keyFlags) { pCHILDDATA pData; RGNXFORM XForm; L_INT nRet; RECT rcRect; HCURSOR hOldCursor; L_INT nOrigX, nOrigY, nOrigWidth, nOrigHeight; L_INT32 dwValue; pData = LOCKCHILDDATA(hWnd); pData->uThrPt.x = x + pData->nHScrollPos; pData->uThrPt.y = y + pData->nVScrollPos; if (pData->bLineHistogram) { ReleaseCapture(); return; } if (pData->bMoveView) { pData->bMoveView = FALSE; ReleaseCapture(); } if(GetCapture()== hWnd) { if( pData->bMovingFloater ) { L_UINT uArea; pData->bMovingFloater = FALSE; hOldCursor = SetCursor(LoadCursor(NULL, IDC_WAIT)); /* get the original rectangle in bitmap coordinates */ SetRect(&rcRect, pData->xMoveSrc, pData->yMoveSrc, pData->xMoveSrc + pData->nMoveWidth - 1, pData->yMoveSrc + pData->nMoveHeight - 1); /* change it to display coordinates */ L_RectFromBitmap(&pData->LeadBitmap, TOP_LEFT, &rcRect); /* calculate the position in the bitmap based on the original position and by the distance moved. This helps reduce the approximation errors */ /* Favor the left and up move. */ /* Consider a 7:1 zoomin factor. If you move to the right by 6 pixels on the screen, you don't move in the original bitmap. But if you move 1 pixel to the left, you move 1 pixel to the left in original bitmap */ dwValue = (L_INT32)pData->deltaX * BITMAPWIDTH(&pData->LeadBitmap); if( pData->deltaX < 0 ) /* favor the moving to the left */ dwValue -= RECTWIDTH(&pData->rcView)- 1; OffsetRect(&rcRect, (L_INT)(dwValue/RECTWIDTH(&pData->rcView)), 0); dwValue = (L_INT32)pData->deltaY * BITMAPHEIGHT(&pData->LeadBitmap); if( pData->deltaY < 0 ) /* favor the moving to the top */ dwValue -= RECTHEIGHT(&pData->rcView)- 1; OffsetRect(&rcRect, 0, (L_INT)(dwValue / RECTHEIGHT(&pData->rcView))); /* now rcRect contains the coordinates in TOP_LEFT ViewPerspective. Change them in bitmap's ViewPerspective */ L_RectToBitmap(&pData->LeadBitmap, TOP_LEFT, &rcRect); /* now I can update pData->xMoveSrc and pData->yMoveSrc */ nOrigX = pData->xMoveSrc = rcRect.left; /* save these coordinates for the combine later on */ nOrigY = pData->yMoveSrc = rcRect.top; /* SafeCopyBitmapRect might change them */ nOrigWidth = pData->nMoveWidth; nOrigHeight = pData->nMoveHeight; /* save the background */ SafeCopyBitmapRect( &pData->bmSave, &pData->LeadBitmap, &pData->xMoveSrc, &pData->yMoveSrc, &pData->nMoveWidth, &pData->nMoveHeight ); pData->xSaveSrc = pData->xMoveSrc; pData->ySaveSrc = pData->yMoveSrc; /* set up the transform structure. */ XForm.uViewPerspective = pData->LeadBitmap.ViewPerspective; XForm.nXScalarNum = XForm.nXScalarDen = XForm.nYScalarNum = XForm.nYScalarDen = 1; XForm.nXOffset = nOrigX; XForm.nYOffset = nOrigY; /* set the region in the original bitmap */ L_SetBitmapRgnHandle( &pData->LeadBitmap, &XForm, pData->hrgnRegion, L_RGN_SET ); SetRect(&rcRect, nOrigX, nOrigY, nOrigX + nOrigWidth, nOrigY + nOrigHeight); L_RectFromBitmap(&pData->LeadBitmap, TOP_LEFT, &rcRect); /* copy the floater bitmap to the new position */ L_CombineBitmap( &pData->LeadBitmap, rcRect.left, rcRect.top, RECTWIDTH(&rcRect), RECTHEIGHT(&rcRect), &pData->bmFloater, 0, 0, L_SRCCOPY ); /* and we can still move */ InvalidateRect (hWnd, NULL, FALSE); UpdateWindow (hWnd); SetTimer((hWnd), 1, 100, NULL); /* outline the region without waiting for the WM_TIMER uMessage */ OutlineBitmapRgn(hWnd, NULL); L_GetBitmapRgnArea(&pData->LeadBitmap, &uArea); if(!uArea) { KillTimer(hWnd, 1); FreeRegionBitmaps(pData); L_FreeBitmapRgn(&pData->LeadBitmap); } ReleaseCapture(); SetCursor(hOldCursor); MemorizeBitmap(hWnd); L_UndoList_AddBitmap (hWnd);//UNDOLIST// } else { hOldCursor = SetCursor(LoadCursor(NULL, IDC_WAIT)); HiliteMark(hWnd, FALSE); if(nNextPt > 1 || pData->nRgnType == 5) { XForm.uViewPerspective = TOP_LEFT; XForm.nXScalarNum = BITMAPWIDTH(&pData->LeadBitmap); XForm.nYScalarNum = BITMAPHEIGHT(&pData->LeadBitmap); XForm.nXScalarDen = RECTWIDTH(&pData->rcView); XForm.nYScalarDen = RECTHEIGHT(&pData->rcView); XForm.nXOffset = -pData->rcView.left; XForm.nYOffset = -pData->rcView.top; /*if ((abs(pptRegion[0].y - pptRegion[1].y)<= 2)&& (abs(pptRegion[0].x - pptRegion[1].x)<= 2)) return;*/ switch(pData->nRgnType) { case 1: SetRect(&rcRect, min(pptRegion[0].x, pptRegion[1].x), min(pptRegion[0].y, pptRegion[1].y), max(pptRegion[0].x, pptRegion[1].x), max(pptRegion[0].y, pptRegion[1].y)); nRet = L_SetBitmapRgnRect(&pData->LeadBitmap, &XForm, &rcRect, L_BitmapHasRgn(&(pData->LeadBitmap))|| pData->uCombineMode != L_RGN_OR ? pData->uCombineMode : L_RGN_SET); break; case 2: SetRect(&rcRect, min(pptRegion[0].x, pptRegion[1].x), min(pptRegion[0].y, pptRegion[1].y), max(pptRegion[0].x, pptRegion[1].x), max(pptRegion[0].y, pptRegion[1].y)); nRet = L_SetBitmapRgnRoundRect(&pData->LeadBitmap, &XForm, &rcRect, abs(pptRegion[0].x - pptRegion[1].x)/ 4, abs(pptRegion[0].y - pptRegion[1].y)/ 4, L_BitmapHasRgn(&(pData->LeadBitmap))|| pData->uCombineMode != L_RGN_OR ? pData->uCombineMode : L_RGN_SET); break; case 3: SetRect(&rcRect, min(pptRegion[0].x, pptRegion[1].x), min(pptRegion[0].y, pptRegion[1].y), max(pptRegion[0].x, pptRegion[1].x), max(pptRegion[0].y, pptRegion[1].y)); nRet = L_SetBitmapRgnEllipse(&pData->LeadBitmap, &XForm, &rcRect, L_BitmapHasRgn(&(pData->LeadBitmap))|| pData->uCombineMode != L_RGN_OR ? pData->uCombineMode : L_RGN_SET); break; case 4: nRet = L_SetBitmapRgnPolygon(&pData->LeadBitmap, &XForm, pptRegion, nNextPt, L_POLY_WINDING, L_BitmapHasRgn(&(pData->LeadBitmap))|| pData->uCombineMode != L_RGN_OR ? pData->uCombineMode : L_RGN_SET); break; case 5: nRet = L_SetBitmapRgnMagicWand(&pData->LeadBitmap, x + pData->nHScrollPos, y + pData->nVScrollPos, RGB(pData->uThreshold,pData->uThreshold,pData->uThreshold), RGB(pData->uThreshold,pData->uThreshold,pData->uThreshold), L_BitmapHasRgn(&(pData->LeadBitmap))|| pData->uCombineMode != L_RGN_OR ? pData->uCombineMode : L_RGN_SET); case 6: // nRet = L_SetBitmapRgnMagicWandExt(&pData->LeadBitmap, x + pData->nHScrollPos, y + pData->nVScrollPos, pData->crLowerTolerance, pData->crUpperTolerance, L_BitmapHasRgn(&(pData->LeadBitmap))|| pData->uCombineMode != L_RGN_OR ? pData->uCombineMode : L_RGN_SET); break; } if(nRet == SUCCESS) { L_GetBitmapRgnBounds(&pData->LeadBitmap, NULL, &rcRect); if (!rcRect.left && !rcRect.top && !rcRect.right && !rcRect.bottom) { L_FreeBitmapRgn(&pData->LeadBitmap); ReleaseCapture(); return; } if (pData->bmSave.Flags.Allocated) L_FreeBitmap(&pData->bmSave); L_CopyBitmapRect(&pData->bmSave, &pData->LeadBitmap, sizeof(BITMAPHANDLE), rcRect.left, rcRect.top, RECTWIDTH(&rcRect), RECTHEIGHT(&rcRect)); pData->xSaveSrc=rcRect.left; pData->ySaveSrc=rcRect.top; SetTimer((hWnd), 1, 100, NULL); } } InvalidateRect(hWnd, NULL, FALSE); OutlineBitmapRgn(hWnd, NULL); ReleaseCapture (); GlobalFreePtr(pptRegion); pptRegion = NULL; nNextPt = 0; MemorizeBitmap(hWnd); L_UndoList_AddBitmap (hWnd);//UNDOLIST// SetCursor(hOldCursor); } } UNLOCKCHILDDATA(hWnd); } /**************************************************************************************/ /**************************************************************************************/ static L_INT CancelRgn(HWND hWnd, L_BOOL bAddUndoBitmap) { pCHILDDATA pData; RGNXFORM XForm; RECT rcRegion; RECT rcRect; pData = LOCKCHILDDATA (hWnd); if (!pData) return FAILURE; /* get the region bounds */ XForm.uViewPerspective = pData->LeadBitmap.ViewPerspective; XForm.nXScalarNum = XForm.nXScalarDen = XForm.nYScalarNum = XForm.nYScalarDen = 1; XForm.nXOffset = 0; XForm.nYOffset = 0; L_GetBitmapRgnBounds(&pData->LeadBitmap, &XForm, &rcRegion ); pData->xMoveSrc = rcRegion.left; pData->yMoveSrc = rcRegion.top; pData->nMoveWidth = RECTWIDTH(&rcRegion); pData->nMoveHeight = RECTHEIGHT(&rcRegion); if(pData->bmSave.Flags.Allocated) { SetRect(&rcRect, pData->xMoveSrc, pData->yMoveSrc, pData->xMoveSrc + pData->nMoveWidth, pData->yMoveSrc + pData->nMoveHeight); L_RectFromBitmap(&pData->LeadBitmap, TOP_LEFT, &rcRect); L_CombineBitmap(&pData->LeadBitmap, rcRect.left, rcRect.top, RECTWIDTH(&rcRect), RECTHEIGHT(&rcRect), &pData->bmSave, 0, 0, L_SRCCOPY); } L_FreeBitmapRgn(&pData->LeadBitmap); KillTimer(hWnd, 1); if (bAddUndoBitmap) { MemorizeBitmap(hWnd); L_UndoList_AddBitmap (hWnd); //UNDOLIST// } InvalidateRect(hWnd, NULL, FALSE); return SUCCESS; } /*====(StatusCallBack)============================================== Description:Track The Processes witch come from LEADTOOLS API's Syntax : L_INT L_FAR StatusCallBack (L_INT nPercent, L_VOID L_FAR *pUserData) Parameters : nPercent How Much Done From The Process. Return Value: SUCCESS Or 0. ==========================================================================*/ L_INT L_FAR L_EXPORT StatusCallBack (L_INT nPercent, L_VOID L_FAR *pUserData) { MSG msg; HWND hWndParent; L_INT nRet = 0; if (StatusProc.bStillWork) { nRet = StatusBarProgressCallBack(nPercent, pUserData); } if(nRet == ERROR_USER_ABORT) return nRet; hWndParent = FORWARD_WM_MDIGETACTIVE(hWndClient, SendMessage); if(StatusProc.bProgress) { StatusProc.ProgressValue = nPercent; while (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE)) { if ( msg.message == WM_QUIT ) { PostQuitMessage ( 0 ); StatusProc.ProgressValue = 100; return ERROR_USER_ABORT; } else { TranslateMessage ( &msg ); DispatchMessage ( &msg ); } } if ( StatusProc.bKillProgress ) { StatusProc.bKillProgress = FALSE ; StatusProc.ProgressValue = 100 ; PostMessage ( StatusProc.DlgWnd , WM_USER_UPDATEVIEW, 0, 0 ); return ERROR_USER_ABORT ; } if (StatusProc.ProgressValue != 100) { Progress_SetPos(StatusProc.ProgWnd , StatusProc.ProgressValue); if(StatusProc.bOneTick) StatusProc.nStatusCnt = StatusProc.ProgressValue; else StatusProc.nStatusCnt = SendMessage(StatusProc.ProgWnd, PBM_GETPOS, 0, 0); if(StatusProc.bInvalidate) { InvalidateRect(hWndParent, NULL, FALSE); } } return (SUCCESS); } else { return SUCCESS ; } } L_VOID Dialog_Timer(L_INT nID) { RGNXFORM XForm; pCHILDDATA pData; HDC hDC; HWND hWndParent; hWndParent = FORWARD_WM_MDIGETACTIVE(hWndClient, SendMessage); pData = LOCKCHILDDATA (hWndParent); if (!pData) { return; } if ((L_INT)pData->uTimerID != nID) return; if(L_BitmapHasRgn(&pData->LeadBitmap)) { hDC = GetDC(hWndParent); if (!hDC) return; XForm.uViewPerspective = TOP_LEFT; XForm.nXScalarNum = 1; XForm.nXScalarDen = 1; XForm.nYScalarNum = 1; XForm.nYScalarDen = 1; XForm.nXOffset = -GetScrollPos(hWndParent, SB_HORZ); XForm.nYOffset = -GetScrollPos(hWndParent, SB_VERT); pData->uFrameType = (pData->uFrameType + 2) % 8; L_FrameBitmapRgn(hDC, &pData->LeadBitmap, &XForm, pData->uFrameType ); ReleaseDC(hWndParent, hDC); } UNLOCKCHILDDATA(hWndParent); } L_INT L_FAR L_EXPORT BrowseBitmapsCB(pBITMAPHANDLE pBitmap, L_TCHAR L_FAR *pszFile, pFILEINFO pInfo, L_INT nStatusCode, L_INT nPercent, L_VOID L_FAR *pUserData) { L_INT nRet; if ( nStatusCode == SUCCESS_RETRY) { LPDLGBITMAPLISTITEM pBitmapListItem ; pBitmapListItem = (LPDLGBITMAPLISTITEM)pUserData ; nBitmapsCount++ ; if ( nBitmapsCount >= IMAGES_COUNT ) { nBitmapsCount-- ; return ERROR_USER_ABORT; } nRet = L_LoadBitmapResize ( pszFile, pBitmapListItem[nBitmapsCount].pBitmap, sizeof(BITMAPHANDLE), 80, 80, 24, 0, ORDER_BGRORGRAY, 0, 0); pBitmapListItem[nBitmapsCount].pszFileName = _tcsdup( pszFile ); } return SUCCESS; } COLORREF ShowColorDialog(HWND hWnd, COLORREF crOldColor) { COLORDLGPARAMS DlgParams ; L_INT nRet; memset(&DlgParams, 0, sizeof(COLORDLGPARAMS)); SetCursor(LoadCursor(NULL, IDC_WAIT)); DlgParams.uStructSize = sizeof(COLORDLGPARAMS); DlgParams.crColor = crOldColor; DlgParams.uDlgFlags = 0x0001fffe; DlgParams.uColorSpace = DLG_COLOR_COLORSPACE_SHOW_RGB; nRet = L_DlgColor ( hWnd, &DlgParams ) ; return (nRet == SUCCESS_DLG_OK) ? DlgParams.crColor : crOldColor; } L_VOID ConvertFloatToString (L_INT flt, L_TCHAR szBuff[], L_INT nPrecise) { L_INT left, right; TCHAR lChar[10] = TEXT("\0"); TCHAR rChar[10] = TEXT("\0"); L_INT nPercentage; nPercentage = (L_INT)pow(10, nPrecise); left = flt / nPercentage; if (left) right = flt % (left * nPercentage); else right = flt; wsprintf(lChar, TEXT("%d"), left); if (right > 9) wsprintf(rChar, TEXT("%d"), right); else wsprintf(rChar, TEXT("0%d"), right); wsprintf(szBuff, TEXT("%s.%s"), lChar, rChar); } /*====(ProgressBarProc)==================================================== Description: Processes messages for the Progress Bar. Syntax : LRESULT CALLBACK L_EXPORT ProgressBarProc (HWND hWnd, L_UINT uMessage, WPARAM wParam, LPARAM lParam) Prototype : demo.h Parameters : hWnd Window handle. uMessage Windows uMessage to process. wParam Windows word parameter. lParam Windows long parameter. Return Value: 0 WM_PAINT uMessage processed. DefWindowProc A different uMessage processed. ==========================================================================*/ LRESULT CALLBACK L_EXPORT ProgressBarProc (HWND hWnd, L_UINT uMessage, WPARAM wParam, LPARAM lParam) { PAINTSTRUCT ps; L_TCHAR szPercent[5]; RECT rcClient; RECT rcClip; L_INT nLen; L_INT xCenter; HRGN hRgn; switch (uMessage) { case WM_PAINT: BeginPaint (hWnd, &ps); if (StatusProc.ProgressValue > 100) break; SaveDC(ps.hdc); GetClientRect (hWnd, &rcClient); nLen = wsprintf ((LPTSTR) szPercent, TEXT("%d%%"), StatusProc.ProgressValue); SetTextAlign(ps.hdc, TA_CENTER); SetTextColor(ps.hdc, RGB(255, 255, 255)); SetBkColor(ps.hdc, RGB(0, 0, 255)); hRgn = CreateRectRgnIndirect(&rcClient); SelectObject(ps.hdc, hRgn); SetRect(&rcClip, 0, 0, MulDiv(StatusProc.ProgressValue, RECTWIDTH(&rcClient), 100), RECTHEIGHT(&rcClient)); OffsetRect(&rcClip, rcClient.left, rcClient.top); xCenter = (rcClient.left + rcClient.right + 1) / 2; IntersectClipRect(ps.hdc, rcClip.left, rcClip.top, rcClip.right, rcClip.bottom); ExtTextOut(ps.hdc, xCenter, 0, ETO_OPAQUE, &rcClient, szPercent, nLen, NULL); SetTextColor(ps.hdc, RGB(0, 0, 255)); SetBkColor(ps.hdc, RGB(255, 255, 255)); SelectObject(ps.hdc, hRgn); ExcludeClipRect(ps.hdc, rcClip.left, rcClip.top, rcClip.right, rcClip.bottom); ExtTextOut(ps.hdc, xCenter, 0, ETO_OPAQUE, &rcClient, szPercent, nLen, NULL); DeleteObject(hRgn); RestoreDC(ps.hdc, -1); EndPaint (hWnd, &ps); return (0); } return (DefWindowProc (hWnd, uMessage, wParam, lParam)); } /*====(SetStatusBarProgress)=============================================== Description: Paints the Progress Bar. Syntax : L_VOID SetStatusBarProgress(L_INT nPercent) Prototype : demo.h Parameters : nPercent Percent of processing complete. Return Value: None. ==========================================================================*/ L_VOID SetStatusBarProgress(L_INT nPercent) { HWND hWnd; StatusProc.ProgressValue = nPercent; hWnd = GetDlgItem (hStatusWnd, IDC_STATUS_PROG); InvalidateRect (hWnd, NULL, FALSE); UpdateWindow (hWnd); return; } /*====(StatusBarProc)====================================================== Description: Processes messages for the Status Bar. Syntax : L_BOOL CALLBACK L_EXPORT StatusBarProc (HWND hDlg, L_UINT uMessage, WPARAM wParam, LPARAM lParam) Prototype : demo.h Parameters : hDlg Window handle. uMessage Windows uMessage to process. wParam Windows word parameter. lParam Windows long parameter. Return Value: TRUE WM_INITDIALOG or WM_PAINT uMessage processed. FALSE A different uMessage processed. ==========================================================================*/ L_BOOL CALLBACK L_EXPORT StatusBarProc (HWND hDlg, L_UINT uMessage, WPARAM wParam, LPARAM lParam) { static L_INT x = 0; RECT rcRect; POINT pt; HMENU hColorMenu; HBRUSH hBrush; HDC hDC, hDC1; PAINTSTRUCT ps; switch(uMessage) { case WM_INITDIALOG: hStatusWnd = hDlg; SetStatusBarText(NULL, NULL, szPos, szColor); return TRUE; case WM_PAINT: GetClientRect(GetDlgItem(hDlg, IDC_STATUS_INK), &rcRect); hDC = BeginPaint(hStatusWnd, &ps); hDC1 = GetDC(GetDlgItem(hDlg, IDC_STATUS_INK)); hBrush = CreateSolidBrush(crColor); FillRect(hDC1, &rcRect, hBrush); DeleteBrush(hBrush); ReleaseDC(GetDlgItem(hDlg, IDC_STATUS_INK), hDC1); EndPaint(hStatusWnd, &ps); return TRUE; case WM_COMMAND: SetFocus(GetDlgItem(hDlg, IDC_STATUS_INK)); GetCursorPos(&pt); hColorMenu = LoadMenu(hInst, MAKEINTRESOURCE(IDR_CSP)); CheckMenuItem(hColorMenu, IDM_COLORSPACEPOPUP_RGB + uColorSpace, MF_CHECKED); TrackPopupMenu(GetSubMenu(hColorMenu, 0), 0, pt.x, pt.y, 0, FORWARD_WM_MDIGETACTIVE(hWndClient, SendMessage), NULL); break; case WM_LBUTTONUP: GetClientRect(GetDlgItem(hStatusWnd, IDC_STATUS_COLOR), &rcRect); pt.x = LOWORD(lParam); pt.y = HIWORD(lParam); ClientToScreen(hStatusWnd, &pt); ScreenToClient(GetDlgItem(hStatusWnd, IDC_STATUS_COLOR), &pt); if (PtInRect(&rcRect, pt)) { hColorMenu = LoadMenu(hInst, MAKEINTRESOURCE(IDR_NUMORDER)); ClientToScreen(GetDlgItem(hStatusWnd, IDC_STATUS_COLOR), &pt); CheckMenuItem(hColorMenu, IDC_STATUS_HEX + IsDecimal, MF_CHECKED); TrackPopupMenu(GetSubMenu(hColorMenu, 0), 0, pt.x, pt.y, 0, FORWARD_WM_MDIGETACTIVE(hWndClient, SendMessage), NULL); } return TRUE; } return (FALSE); } /*====(SetStatusBarText)=================================================== Description: Sets text into various controls on the Status Bar of the Frame. Syntax : L_VOID SetStatusBarText(LPSTR pTitle, pBITMAPHANDLE pBitmap, L_INT nZoom) Prototype : demo.h Parameters : pTitle Text for the Title control. pBitmap Bitmap currently being processed. nZoom Zoom factor the image is displayed as. Return Value: None. ==========================================================================*/ L_VOID SetStatusBarText(LPTSTR pTitle, pBITMAPHANDLE pBitmap, LPTSTR szPos, LPTSTR szColor) { L_TCHAR szText[80]; L_TCHAR L_FAR* p; HDC hDC; RECT rcRect; L_TCHAR szColorSpace[8][6] = {TEXT("RGB"), TEXT("HSV"), TEXT("HLS"), TEXT("XYZ"), TEXT("YCrCb"), TEXT("YUV"), TEXT("LAB"), TEXT("CMY")}; if(pTitle) { wsprintf(szText, TEXT("%u X %u"), pBitmap->Width, pBitmap->Height); SetDlgItemText(hStatusWnd, IDC_STATUS_DIMENSION, szText); wsprintf(szText, TEXT("%u BPP"), pBitmap->BitsPerPixel); SetDlgItemText(hStatusWnd, IDC_STATUS_BITSPIXEL, szText); p = (pBitmap->Flags.Compressed ? TEXT("COMP"): pBitmap->Flags.SuperCompressed ? TEXT("SUP.CMP"): pBitmap->Flags.Tiled ? TEXT("TILED"): (pBitmap->Flags.DiskMemory ? TEXT("DISK"): TEXT("MEMORY"))); // bitmap size < 10MB ? if (pBitmap->Size < 100000) wsprintf(szText, TEXT("%lu bytes, %s"), pBitmap->Size, p); else { if(pBitmap->Size < 10000000) wsprintf(szText, TEXT("%lu KB, %s"), pBitmap->Size >> 10, p); else // > 100MB wsprintf(szText, TEXT("%lu MB, %s"), pBitmap->Size >> 20, p); } SetDlgItemText(hStatusWnd, IDC_STATUS_MEMORY, szText); wsprintf(szText, L_IsGrayScaleBitmap(pBitmap) ? TEXT("GrayScale Bitmap") : TEXT("Colored Bitmap")); SetDlgItemText(hStatusWnd, IDC_STATUS_REGIONBOUNDS, szText); SetDlgItemText(hStatusWnd, IDC_STATUS_SPC, szColorSpace[uColorSpace]); SetDlgItemText(hStatusWnd, IDC_STATUS_COLOR, szColor); SetDlgItemText(hStatusWnd, IDC_STATUS_MOUSEPOS, szPos); } else { SetDlgItemText(hStatusWnd, IDC_STATUS_DIMENSION, TEXT("")); SetDlgItemText(hStatusWnd, IDC_STATUS_BITSPIXEL, TEXT("")); SetDlgItemText(hStatusWnd, IDC_STATUS_MEMORY, TEXT("")); SetDlgItemText(hStatusWnd, IDC_STATUS_REGIONBOUNDS, TEXT("")); SetDlgItemText(hStatusWnd, IDC_STATUS_COLOR, TEXT("")); SetDlgItemText(hStatusWnd, IDC_STATUS_MOUSEPOS, TEXT("")); SetDlgItemText(hStatusWnd, IDC_STATUS_SPC, TEXT("")); GetClientRect(GetDlgItem(hStatusWnd, IDC_STATUS_INK), &rcRect); hDC = GetDC(GetDlgItem(hStatusWnd, IDC_STATUS_INK)); FillRect(hDC, &rcRect, (HBRUSH)COLOR_WINDOW); ReleaseDC(GetDlgItem(hStatusWnd, IDC_STATUS_INK), hDC); } return; } L_VOID Strip(LPTSTR StripName, LPTSTR pszTitle) { L_INT nEndPos = 0; L_INT nSlashPos; L_INT nCount; L_TCHAR cX = '\0'; memset(StripName, 0, (lstrlen(StripName)*sizeof(L_TCHAR))); while(pszTitle[nEndPos] != cX) { nEndPos++; } for(nSlashPos = nEndPos; nSlashPos >= 0; nSlashPos--) { if(pszTitle[nSlashPos ] == '\\') break; } for(nCount = 0, nSlashPos++; nSlashPos < nEndPos; nSlashPos++, nCount++) { if (pszTitle[nSlashPos] == '.') break; StripName[nCount] = pszTitle[nSlashPos]; } } /*====(StatusCallBack)====================================================== Description: Performs as a callback for the Progress Bar. Syntax : STATUSCALLBACK L_EXPORT StatusCallBack( L_INT nPercent ); Prototype : demo.h Parameters : nPercent Percent of operation complete. Return Value: SUCCESS The function was successful. ERROR_USER_ABORT User wants to cancel the operation. ==========================================================================*/ L_INT L_FAR L_EXPORT StatusBarProgressCallBack (L_INT nPercent, L_VOID L_FAR * pUserData) { MSG msg; while (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE)) { if ((msg.message == WM_CHAR) && (msg.wParam == 27)) { return ERROR_USER_ABORT; } else { TranslateMessage (&msg); if (msg.message == WM_PAINT) DispatchMessage (&msg); } } SetStatusBarProgress(nPercent); return (SUCCESS); } L_VOID TransToStatusBar(pBITMAPHANDLE pTempBitmap, pBITMAPHANDLE pLeadBitmap) { L_CopyBitmap(pTempBitmap, pLeadBitmap, sizeof(BITMAPHANDLE)); ShowWindow(GetDlgItem(hStatusWnd, IDC_STATUS_PROG), SW_SHOW); ShowWindow(GetDlgItem(hStatusWnd, IDC_STATUS_BITSPIXEL), SW_HIDE); ShowWindow(GetDlgItem(hStatusWnd, IDC_STATUS_INK), SW_HIDE); ShowWindow(GetDlgItem(hStatusWnd, IDC_STATUS_COLOR), SW_HIDE); ShowWindow(GetDlgItem(hStatusWnd, IDC_STATUS_DIMENSION), SW_HIDE); ShowWindow(GetDlgItem(hStatusWnd, IDC_STATUS_MEMORY), SW_HIDE); ShowWindow(GetDlgItem(hStatusWnd, IDC_STATUS_MOUSEPOS), SW_HIDE); ShowWindow(GetDlgItem(hStatusWnd, IDC_STATUS_REGIONBOUNDS), SW_HIDE); ShowWindow(GetDlgItem(hStatusWnd, IDC_STATUS_SPC), SW_HIDE); ShowWindow(GetDlgItem(hStatusWnd, IDC_STATUS_ESCAPE), SW_SHOW); ShowWindow(GetDlgItem(hStatusWnd, IDC_STATUS_PROG), SW_SHOW); nStatusPercent = 0; } L_VOID TransBack(pBITMAPHANDLE pTempBitmap, pBITMAPHANDLE pLeadBitmap, L_INT nRet) { if (nRet != SUCCESS) { L_FreeBitmap(pLeadBitmap); L_CopyBitmap(pLeadBitmap, pTempBitmap, sizeof(BITMAPHANDLE)); } L_FreeBitmap(pTempBitmap); ShowWindow(GetDlgItem(hStatusWnd, IDC_STATUS_BITSPIXEL), SW_SHOW); ShowWindow(GetDlgItem(hStatusWnd, IDC_STATUS_INK), SW_SHOW); ShowWindow(GetDlgItem(hStatusWnd, IDC_STATUS_COLOR), SW_SHOW); ShowWindow(GetDlgItem(hStatusWnd, IDC_STATUS_DIMENSION), SW_SHOW); ShowWindow(GetDlgItem(hStatusWnd, IDC_STATUS_MEMORY), SW_SHOW); ShowWindow(GetDlgItem(hStatusWnd, IDC_STATUS_MOUSEPOS), SW_SHOW); ShowWindow(GetDlgItem(hStatusWnd, IDC_STATUS_REGIONBOUNDS), SW_SHOW); ShowWindow(GetDlgItem(hStatusWnd, IDC_STATUS_SPC), SW_SHOW); ShowWindow(GetDlgItem(hStatusWnd, IDC_STATUS_ESCAPE), SW_HIDE); ShowWindow(GetDlgItem(hStatusWnd, IDC_STATUS_PROG), SW_HIDE); StatusProc.bProgress = FALSE; StatusProc.bKillProgress = TRUE; StatusProc.ProgressValue = 100; ShowWindow(GetDlgItem(hStatusWnd, IDC_STATUS_PROG), SW_HIDE); } L_BOOL Is16Bit(pBITMAPHANDLE pBitmap) { return ((pBitmap->BitsPerPixel == 64) || (pBitmap->BitsPerPixel == 48) || (pBitmap->BitsPerPixel == 12) || (pBitmap->BitsPerPixel == 16) && ISGRAY(pBitmap)); } L_VOID MoveDialogToMiddle(HWND hWnd) { RECT rcDlgPos; RECT rcDlgSize; POINT ptPoint; GetWindowRect(hWndClient, &rcDlgPos); GetWindowRect(hWnd, &rcDlgSize); ptPoint.x = (RECTWIDTH(&rcDlgPos) >> 1) - (RECTWIDTH(&rcDlgSize) >> 1); ptPoint.y = (RECTHEIGHT(&rcDlgPos) >> 1) - (RECTHEIGHT(&rcDlgSize) >> 1); ClientToScreen(hWndFrame, &ptPoint); MoveWindow(hWnd, ptPoint.x , ptPoint.y, RECTWIDTH(&rcDlgSize), RECTHEIGHT(&rcDlgSize), TRUE); } L_INT GetProcPixel(pBITMAPHANDLE pBitmap) { if(pBitmap->BitsPerPixel >= 48) return 48; if(pBitmap->BitsPerPixel <= 8 && L_IsGrayScaleBitmap(pBitmap)) return 8; if((pBitmap->BitsPerPixel == 16 || pBitmap->BitsPerPixel == 12) && (ISGRAY(pBitmap) & L_IsGrayScaleBitmap(pBitmap))) return 16; return 24; } L_BOOL CALLBACK SetFontEnumProce ( HWND hWnd, LPARAM lParam ) { SendMessage ( hWnd, WM_SETFONT, ( WPARAM ) lParam, ( LPARAM ) TRUE ) ; return TRUE ; } L_VOID SetControlFont ( HWND hWnd, HFONT hFont ) { if ( NULL != hFont ) { EnumChildWindows ( hWnd, SetFontEnumProce, ( LPARAM ) hFont ) ; } } L_VOID GenerateDefaultFont ( HFONT* phFont ) { HFONT hDefFont = NULL ; HDC hDC = NULL ; LOGFONT LogFont ; hDC = GetDC ( NULL ) ; LogFont.lfHeight = -MulDiv ( 8, GetDeviceCaps ( hDC, LOGPIXELSY ), 72 ) ; ReleaseDC ( NULL, hDC ) ; LogFont.lfWidth = 0 ; LogFont.lfEscapement = 0 ; LogFont.lfOrientation = 0 ; LogFont.lfWeight = FW_NORMAL ; LogFont.lfItalic = FALSE ; LogFont.lfUnderline = FALSE ; LogFont.lfStrikeOut = FALSE ; LogFont.lfCharSet = DEFAULT_CHARSET ; LogFont.lfOutPrecision = OUT_STROKE_PRECIS ; LogFont.lfClipPrecision = CLIP_STROKE_PRECIS ; LogFont.lfQuality = DRAFT_QUALITY ; LogFont.lfPitchAndFamily = DEFAULT_PITCH | FF_DONTCARE ; lstrcpy ( LogFont.lfFaceName, _T ( "Tahoma" ) ) ; *phFont = CreateFontIndirect ( &LogFont ) ; } L_VOID MakeRectangleWindow(HWND hWnd, L_INT nID) { RECT rcRect; POINT pt ; L_INT nSize = 0 ; ZeroMemory ( &rcRect, sizeof(rcRect)); GetWindowRect (GetDlgItem(hWnd, nID), &rcRect); pt.x = rcRect.left ; pt.y = rcRect.top ; nSize = min((rcRect.right - rcRect.left), (rcRect.bottom - rcRect.top)); ScreenToClient (hWnd, &pt); MoveWindow (GetDlgItem(hWnd, nID),pt.x, pt.y, nSize, nSize, TRUE); }