/*[]=====================================================================[]*/ /*[] LeadTools Run Time Library - Version 13 []*/ /*[] []*/ /*[] []*/ /*[] Copyright (c) 1991-2001 LEAD Technologies, Inc. []*/ /*[] All Rights Reserved. []*/ /*[]=====================================================================[]*/ #define STRICT #include #include #include #include #include #include #include #include #include #include #include #include "../../../include/l_bitmap.h" #include "../../../include/l_error.h" #include "../../../include/ltdlg.h" #include "demo.h" /* for cancel loading dialog*/ #define L_START_LOADING 0x01 #define L_CHECK_LOADING 0x02 #define L_END_LOADING 0x03 /* error code used to signal the the program is being closed */ #define ERROR_PROGRAMCLOSED 2 //FORPANWINDOW #ifdef WIN32 #define PANWINDOW_CLASS TEXT("L_PANWINDOW_32") #else #define PANWINDOW_CLASS TEXT("L_PANWINDOW_16") #endif /* External Functions */ extern L_INT ShowJPEGWebTunerDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPJPEGWEBTUNERDLGPARAMS pDlgParams ) ; extern L_INT ShowPNGWebTunerDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPPNGWEBTUNERDLGPARAMS pDlgParams ) ; extern L_INT ShowGIFWebTunerDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPGIFWEBTUNERDLGPARAMS pDlgParams ) ; extern L_INT ShowHTMLMapperDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPHTMLMAPPERDLGPARAMS pDlgParams ) ; extern L_INT ShowRotateDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPROTATEDLGPARAMS pDlgParams ) ; extern L_INT ShowShearDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPSHEARDLGPARAMS pDlgParams ) ; extern L_INT ShowAutoTrimDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPAUTOTRIMDLGPARAMS pDlgParams ) ; extern L_INT ShowAddBorderDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPADDBORDERDLGPARAMS pDlgParams, LPADDBORDERINFO pAddBorderInfo) ; extern L_INT ShowAddFrameDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPADDFRAMEDLGPARAMS pDlgParams, LPADDFRAMEINFO pAddFrameInfo) ; extern L_INT ShowSmoothDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPSMOOTHDLGPARAMS pDlgParams ) ; extern L_INT ShowLineRemoveDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPLINEREMOVEDLGPARAMS pDlgParams ) ; extern L_INT ShowBorderRemoveDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPBORDERREMOVEDLGPARAMS pDlgParams ) ; extern L_INT ShowDotRemoveDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPDOTREMOVEDLGPARAMS pDlgParams ) ; extern L_INT ShowInvertedTextDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPINVERTEDTEXTDLGPARAMS pDlgParams ) ; extern L_INT ShowHolePunchRemoveDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPHOLEPUNCHREMOVEDLGPARAMS pDlgParams ) ; extern L_INT ShowRemoveRedeyeDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPREMOVEREDEYEDLGPARAMS pDlgParams ) ; extern L_INT ShowCanvasResizeDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPCANVASRESIZEDLGPARAMS pDlgParams ) ; extern L_INT ShowResizeDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPRESIZEDLGPARAMS pDlgParams ) ; extern L_INT ShowHistogramDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPHISTOGRAMDLGPARAMS pDlgParams ) ; extern L_INT ShowMotionBlurDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPMOTIONBLURDLGPARAMS pDlgParams ) ; extern L_INT ShowRadialBlurDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPRADIALBLURDLGPARAMS pDlgParams ) ; extern L_INT ShowZoomBlurDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPZOOMBLURDLGPARAMS pDlgParams ) ; extern L_INT ShowGaussianBlurDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPGAUSSIANBLURDLGPARAMS pDlgParams ) ; extern L_INT ShowAntiAliasDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPANTIALIASDLGPARAMS pDlgParams ) ; extern L_INT ShowAverageDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPAVERAGEDLGPARAMS pDlgParams ) ; extern L_INT ShowMedianDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPMEDIANDLGPARAMS pDlgParams ) ; extern L_INT ShowAddNoiseDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPADDNOISEDLGPARAMS pDlgParams ) ; extern L_INT ShowMaxFilterDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPMAXFILTERDLGPARAMS pDlgParams ) ; extern L_INT ShowMinFilterDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPMINFILTERDLGPARAMS pDlgParams ) ; extern L_INT ShowUnsharpMaskDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPUNSHARPMASKDLGPARAMS pDlgParams ) ; extern L_INT ShowSharpenDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPSHARPENDLGPARAMS pDlgParams ) ; extern L_INT ShowMultiplyDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPMULTIPLYDLGPARAMS pDlgParams ) ; extern L_INT ShowFreeHandWaveDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPFREEHANDWAVEDLGPARAMS pDlgParams ) ; extern L_INT ShowWindDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPWINDDLGPARAMS pDlgParams ) ; extern L_INT ShowPolarDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPPOLARDLGPARAMS pDlgParams ) ; extern L_INT ShowZoomWaveDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPZOOMWAVEDLGPARAMS pDlgParams ) ; extern L_INT ShowRadialWaveDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPRADIALWAVEDLGPARAMS pDlgParams ) ; extern L_INT ShowSwirlDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPSWIRLDLGPARAMS pDlgParams ) ; extern L_INT ShowWaveDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPWAVEDLGPARAMS pDlgParams ) ; extern L_INT ShowWaveShearDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPWAVESHEARDLGPARAMS pDlgParams ) ; extern L_INT ShowEmbossDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPEMBOSSDLGPARAMS pDlgParams ) ; extern L_INT ShowPunchDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPPUNCHDLGPARAMS pDlgParams ) ; extern L_INT ShowRippleDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPRIPPLEDLGPARAMS pDlgParams ) ; extern L_INT ShowBendingDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPBENDINGDLGPARAMS pDlgParams ) ; extern L_INT ShowCylindricalDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPCYLINDRICALDLGPARAMS pDlgParams ) ; extern L_INT ShowSpherizeDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPSPHERIZEDLGPARAMS pDlgParams ) ; extern L_INT ShowImpressionistDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPIMPRESSIONISTDLGPARAMS pDlgParams ) ; extern L_INT ShowOilifyDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPOILIFYDLGPARAMS pDlgParams ) ; extern L_INT ShowUnderlayDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPUNDERLAYDLGPARAMS pDlgParams, pBITMAPHANDLE pUnderLayBitmap ) ; extern L_INT ShowPixelateDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPPIXELATEDLGPARAMS pDlgParams ) ; extern L_INT ShowMosaicDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPMOSAICDLGPARAMS pDlgParams ) ; extern L_INT ShowPicturizeDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPPICTURIZEDLGPARAMS pDlgParams ) ; extern L_INT ShowEdgeDetectorDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPEDGEDETECTORDLGPARAMS pDlgParams ) ; extern L_INT ShowErosionFilterDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPEROSIONFILTERDLGPARAMS pDlgParams ) ; extern L_INT ShowDilationFilterDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPDILATIONFILTERDLGPARAMS pDlgParams ) ; extern L_INT ShowContourFilterDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPCONTOURFILTERDLGPARAMS pDlgParams ) ; extern L_INT ShowGradientFilterDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPGRADIENTFILTERDLGPARAMS pDlgParams ) ; extern L_INT ShowLaplacianFilterDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPLAPLACIANFILTERDLGPARAMS pDlgParams ) ; extern L_INT ShowSobelFilterDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPSOBELFILTERDLGPARAMS pDlgParams ) ; extern L_INT ShowPrewittFilterDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPPREWITTFILTERDLGPARAMS pDlgParams ) ; extern L_INT ShowShiftDifferenceFilterDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPSHIFTDIFFERENCEFILTERDLGPARAMS pDlgParams ) ; extern L_INT ShowLineSegmentFilterDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPLINESEGMENTFILTERDLGPARAMS pDlgParams ) ; extern L_INT ShowIntensityDetectDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPINTENSITYDETECTDLGPARAMS pDlgParams ) ; extern L_INT ShowSolarizeDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPSOLARIZEDLGPARAMS pDlgParams ) ; extern L_INT ShowPosterizeDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPPOSTERIZEDLGPARAMS pDlgParams ) ; extern L_INT ShowBrightnessDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPBRIGHTNESSDLGPARAMS pDlgParams ) ; extern L_INT ShowContrastDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPCONTRASTDLGPARAMS pDlgParams ) ; extern L_INT ShowHueDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPHUEDLGPARAMS pDlgParams ) ; extern L_INT ShowSaturationDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPSATURATIONDLGPARAMS pDlgParams ) ; extern L_INT ShowGammaAdjustmentDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPGAMMAADJUSTMENTDLGPARAMS pDlgParams ) ; extern L_INT ShowBalanceColorsDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPBALANCECOLORSDLGPARAMS pDlgParams ) ; extern L_INT ShowHalftoneDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPHALFTONEDLGPARAMS pDlgParams, LPDLGBITMAPLIST pBitmapList ) ; extern L_INT ShowColorResDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPCOLORRESDLGPARAMS pDlgParams ) ; extern L_INT ShowGrayScaleDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPGRAYSCALEDLGPARAMS pDlgParams ) ; extern L_INT ShowColoredGrayDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPCOLOREDGRAYDLGPARAMS pDlgParams ) ; extern L_INT ShowRemapIntensityDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPREMAPINTENSITYDLGPARAMS pDlgParams ) ; extern L_INT ShowRemapHueDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPREMAPHUEDLGPARAMS pDlgParams ) ; extern L_INT ShowLocalHistoEqualizeDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPLOCALHISTOEQUALIZEDLGPARAMS pDlgParams ) ; extern L_INT ShowHistoContrastDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPHISTOCONTRASTDLGPARAMS pDlgParams ) ; extern L_INT ShowPrintPreviewDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPPRINTPREVIEWDLGPARAMS pDlgParams ) ; extern L_INT ShowWindowLevelDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPWINDOWLEVELDLGPARAMS pDlgParams ) ; /* the PanWindow Callback */ L_VOID L_FAR L_EXPORT PanWindowCallback( HWND hPanWindow, HWND hWndParent, L_UINT uMsg, LPRECT prcPan, L_VOID L_FAR* pUserData ); static SAVEDLGPARAMS FSParm; static L_BOOL bDragExist=FALSE; static L_INT nLastX=0; static L_BOOL bCancelLoad=FALSE; #ifdef WIN32 static L_INT nListBoxLastCx=0; #endif static L_VOID DisplayImageStatus (HWND hWnd); static VOID Child_OnPaint (HWND hWnd); static BOOL Child_OnCreate (HWND hWnd, CREATESTRUCT FAR * lpCreateStruct); static VOID Child_OnSize (HWND hWnd, UINT nState, int nCx, int nCy); static VOID Child_OnLButtonDown (HWND hWnd, BOOL fDoubleClick, L_INT x, L_INT y,UINT keyFlags); static VOID Child_OnLButtonUp (HWND hWnd, L_INT x, L_INT y, UINT keyFlags); static VOID Child_OnMouseMove (HWND hWnd, L_INT x, L_INT y, UINT keyFlags); static VOID Child_OnTimer(HWND hWnd, UINT id); static VOID Child_OnSetFocus(HWND hwnd, HWND hwndOldFocus); static VOID Child_OnKillFocus(HWND hwnd, HWND hwndNewFocus); static VOID Child_OnCommand (HWND hWnd, int id, HWND hwndCtl, UINT codeNotify); static VOID Child_OnMDIActivate (HWND hWnd, BOOL fActive, HWND hWndActivate,HWND hWndDeactivate); static VOID Child_OnPaletteChanged (HWND hWnd, HWND hWndPaletteChange); static BOOL Child_OnQueryNewPalette (HWND hWnd); static VOID Child_OnDestroy (HWND hWnd); static VOID Child_OnKey (HWND hWnd, UINT vk, BOOL fDown, int cRepeat, UINT flags); static VOID Child_OnUserMessage(HWND hWnd,UINT wParam,LPARAM lParam); static VOID Child_OnClose(HWND hWnd); #ifdef WIN32 static VOID Child_OnMeasureItem(HWND hwnd, MEASUREITEMSTRUCT *lpMeasureItem); static VOID Child_OnDrawItem(HWND hwnd, const DRAWITEMSTRUCT *lpDrawItem); static HBRUSH Child_OnCtlColorListBox(HWND hWnd,HDC hDC,HWND hListBoxWnd,COLORREF Color); #else static HBRUSH Child_OnCtlColorListBox(HWND hwnd, HDC hdc, HWND hwndChild, int type); static VOID Child_OnMeasureItem(HWND hwnd, MEASUREITEMSTRUCT FAR*lpMeasureItem); static VOID Child_OnDrawItem(HWND hwnd, const DRAWITEMSTRUCT FAR*lpDrawItem); #endif static VOID BmpWnd_OnKey (HWND hWnd, UINT vk, BOOL fDown, int cRepeat, UINT flags); static VOID BmpWnd_OnVScroll (HWND hWnd, HWND hWndCtl, UINT nCode, int npos); static VOID BmpWnd_OnHScroll (HWND hWnd, HWND hWndCtl, UINT nCode, int npos); static VOID BmpWnd_OnSize (HWND hWnd, UINT nState, int nCx, int nCy); static BOOL BmpWnd_OnEraseBkgnd (HWND hWnd, HDC hDC); static VOID BmpWnd_OnPaint (HWND hWnd); static VOID BmpWnd_OnLButtonDown (HWND hWnd, BOOL fDoubleClick, L_INT x, L_INT y,UINT keyFlags); static VOID BmpWnd_OnRButtonDown (HWND hWnd, BOOL fDoubleClick, L_INT x, L_INT y,UINT keyFlags); static VOID BmpWnd_OnLButtonUp (HWND hWnd, L_INT x, L_INT y, UINT keyFlags); static VOID BmpWnd_OnMouseMove (HWND hWnd, L_INT x, L_INT y, UINT keyFlags);static VOID BmpWnd_OnRButtonDown (HWND hWnd, BOOL fDoubleClick, L_INT x, L_INT y,UINT keyFlags); static BOOL BmpWnd_OnSetCursor(HWND hwnd, HWND hwndCursor, UINT codeHitTest, UINT msg); static L_VOID DemoEffects (HWND hWnd); static L_VOID DemoElements (HWND hWnd); static L_VOID PlayAnimation (HWND hWnd); static VOID Child_ProcessSize (HWND hWnd, UINT nState, L_INT nCx, L_INT nCy); static L_VOID MatchAspectRatio (LPRECT pRect, L_INT nWidth, L_INT nHeight); static L_INT InitBitmapProcess (HWND hWnd, pBITMAPHANDLE FAR * ppBitmap, L_BOOL fCopy); static L_INT TermBitmapProcess (HWND hWnd, L_INT nRet, L_BOOL fSize, L_BOOL fColor); static L_VOID EnableStatusDialog (HWND hWnd, L_BOOL fEnable); static L_VOID SetZoomFactor (HWND hWnd, L_INT nZoom); static L_VOID SaveBitmap(HWND hWnd); static L_VOID HiliteMark(HWND hWnd, L_BOOL fUpdate); static L_VOID OutlineBitmapRgn(HWND hWnd, HDC hdc); static VOID MoveFloater(HWND hWnd, LPCHILDDATA pData, int x, int y); static L_INT CreateRegionBitmaps(HWND hWnd); static VOID FreeRegionBitmaps (LPCHILDDATA pData); static L_INT ChangeRegion( HWND hWnd, L_INT id, LPCHILDDATA pData ); static int XClientToBitmap(LPCHILDDATA pData, int x, int y); static int YClientToBitmap(LPCHILDDATA pData, int x, int y); static HBITMAP ResizeToDDB( LPCHILDDATA pData, HDC hdc, pBITMAPHANDLE bmSrc, int nClientX, int nClientY, int nNewWidth, int nNewHeight, int nClientWidth, int nClientHeight ); static 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_BOOL CALLBACK L_EXPORT CancelLoadDlgProc (HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam); static L_INT CancelFileLoading(L_INT nStatus,L_INT nPageNo,L_INT nTotalPages); static VOID ResizeChildBitmapWindows(HWND hWnd); static VOID PrepareBitmapList(HBITMAPLIST hList,pBITMAPHANDLE pBitmap); static L_INT OpenBitmapFrame(pBITMAPHANDLE pBitmap, L_TCHAR * lpsTitle); static L_INT OpenBitmapFile(L_TCHAR* lpFileName,L_INT nBuffSize,pBITMAPHANDLE pBitmap,L_TCHAR* lpsTitle); static VOID CreateThumbnailsFromBList(HWND hChildWnd); static VOID AddThumbnail(HWND hListBox,pBITMAPHANDLE pBitmap,L_INT nPos); static VOID DeleteThumbnail(HWND hListBox,L_INT nPos); static VOID FillImageListBox(HWND hListBox, L_TCHAR* szFileName,L_BOOL bShowCancelDlg); static VOID LoadBitmapPage(HWND hChildWnd,L_INT nPageNo,L_BOOL bAskForSave); static VOID CenterRect(LPRECT pRect1,LPRECT pRect2,BOOL bCntrH,BOOL bCntrV); static VOID DrawListBoxButton(HDC hDC,BOOL bEdgeType,LPRECT pButtonRect); static VOID SetThumbnails(HWND hChildWnd,BOOL bAdd); static VOID SaveThumbnailData(HWND hChildWnd,L_INT nIndex); static VOID RestoreThumbnailData(HWND hChildWnd,L_INT nIndex); static VOID FixChildSize(HWND hChildWnd); L_INT GammaCorrect(pBITMAPHANDLE pBitmap, L_UINT uRed, L_UINT uGreen, L_UINT uBlue); //Forward declarations for dialog.c static HCURSOR hcurProcess; static L_BOOL fInScroll = FALSE; /* region marking variables */ static LPPOINT pptRegion; static L_INT nNextPt; #define ID_REGIONEVENT 1 /* region outline timer id */ #define REGIONEVENTDELAY 100 /* region outine animation delay */ #define MAXPOINTS 0x4000 /* maximum number of points allowed in freehand */ /* the combine flag that copies the source into the destination */ #define L_SRCCOPY (CB_DST_0 | CB_OP_OR) /* the directory where the images used for picturize are used */ static L_TCHAR szDirectory[_MAX_PATH]; enum { EFX_TEXT_TYPE, EFX_SHAPE_TYPE, EFX_GRADIENT_TYPE, EFX_TRANSITION_TYPE, EFX_EFFECT_TYPE, }; typedef struct _EFFECTDEF { short nIndex; L_TCHAR *szText; } EFFECTDEF; static EFFECTDEF TextDef[] = { { EFX_TEXT_NORMAL, TEXT("Normal") }, { EFX_TEXT_INSETLIGHT, TEXT("Inset light") }, { EFX_TEXT_INSETHEAVY, TEXT("Inset heavy") }, { EFX_TEXT_RAISEDLIGHT, TEXT("Raised light") }, { EFX_TEXT_RAISEDHEAVY, TEXT("Raised heavy") }, { EFX_TEXT_DROPSHADOW, TEXT("Drop shadow") }, { EFX_TEXT_BLOCKSHADOW, TEXT("Block shadow") }, { EFX_TEXT_OUTLINEBLOCK, TEXT("Outline block") }, { EFX_TEXT_INSETEXTRALIGHT, TEXT("Inset extra light") }, { EFX_TEXT_INSETEXTRAHEAVY, TEXT("Inset extra heavy") }, { EFX_TEXT_RAISEDEXTRALIGHT, TEXT("Raised extra light") }, { EFX_TEXT_RAISEDEXTRAHEAVY, TEXT("Raised extra heavy") }, }; static EFFECTDEF ShapeDef[] = { // Square { EFX_SHAPE_SQUARE, TEXT("Square") }, { EFX_SHAPE_SQUARE_ROUNDED, TEXT("Rounded square") }, // Rectangle { EFX_SHAPE_RECTANGLE, TEXT("Rectangle") }, { EFX_SHAPE_RECTANGLE_ROUNDED, TEXT("Rounded rectangle") }, // Parallelogram { EFX_SHAPE_PARALLELOGRAM_L, TEXT("Parallelogram left") }, { EFX_SHAPE_PARALLELOGRAM_R, TEXT("Parallelogram right") }, { EFX_SHAPE_PARALLELOGRAM_T, TEXT("Parallelogram top") }, { EFX_SHAPE_PARALLELOGRAM_B, TEXT("Parallelogram bottom") }, // Trapezoid { EFX_SHAPE_TRAPEZOID_L, TEXT("Trapezoid left") }, { EFX_SHAPE_TRAPEZOID_R, TEXT("Trapezoid right") }, { EFX_SHAPE_TRAPEZOID_T, TEXT("Trapezoid top") }, { EFX_SHAPE_TRAPEZOID_B, TEXT("Trapezoid bottom") }, // Triangle { EFX_SHAPE_TRIANGLE_EQUILATERAL_L, TEXT("Equilateral triangle left") }, { EFX_SHAPE_TRIANGLE_EQUILATERAL_R, TEXT("Equilateral triangle right") }, { EFX_SHAPE_TRIANGLE_EQUILATERAL_T, TEXT("Equilateral triangle top") }, { EFX_SHAPE_TRIANGLE_EQUILATERAL_B, TEXT("Equilateral triangle bottom") }, { EFX_SHAPE_TRIANGLE_ISOSCELES_L, TEXT("Isosceles triangle left") }, { EFX_SHAPE_TRIANGLE_ISOSCELES_R, TEXT("Isosceles triangle right") }, { EFX_SHAPE_TRIANGLE_ISOSCELES_T, TEXT("Isosceles triangle top") }, { EFX_SHAPE_TRIANGLE_ISOSCELES_B, TEXT("Isosceles triangle bottom") }, { EFX_SHAPE_TRIANGLE_RIGHT_LT, TEXT("Right triangle left-top") }, { EFX_SHAPE_TRIANGLE_RIGHT_LB, TEXT("Right triangle left-bottom") }, { EFX_SHAPE_TRIANGLE_RIGHT_RT, TEXT("Right triangle right-top") }, { EFX_SHAPE_TRIANGLE_RIGHT_RB, TEXT("Right triangle right-bottom") }, // Other polygons { EFX_SHAPE_OCTAGON, TEXT("Octagon") }, { EFX_SHAPE_DIAMOND, TEXT("Diamond") }, { EFX_SHAPE_PENTAGON, TEXT("Pentagon") }, { EFX_SHAPE_HEXAGON, TEXT("Hexagon") }, { EFX_SHAPE_LINE, TEXT("Line") }, { EFX_SHAPE_REGION, TEXT("Region") }, // Circle { EFX_SHAPE_CIRCLE, TEXT("Circle") }, { EFX_SHAPE_CIRCLE_90_LT, TEXT("Circle 90° left-top") }, { EFX_SHAPE_CIRCLE_90_LB, TEXT("Circle 90° left-bottom") }, { EFX_SHAPE_CIRCLE_90_RT, TEXT("Circle 90° right-top") }, { EFX_SHAPE_CIRCLE_90_RB, TEXT("Circle 90° right-bottom") }, { EFX_SHAPE_CIRCLE_180_L, TEXT("Circle 180° left") }, { EFX_SHAPE_CIRCLE_180_R, TEXT("Circle 180° right") }, { EFX_SHAPE_CIRCLE_180_T, TEXT("Circle 180° top") }, { EFX_SHAPE_CIRCLE_180_B, TEXT("Circle 180° bottom") }, { EFX_SHAPE_CIRCLE_270_LT, TEXT("Circle 270° left-top") }, { EFX_SHAPE_CIRCLE_270_LB, TEXT("Circle 270° left-bottom") }, { EFX_SHAPE_CIRCLE_270_RT, TEXT("Circle 270° right-top") }, { EFX_SHAPE_CIRCLE_270_RB, TEXT("Circle 270° right-bottom") }, // Ellipse { EFX_SHAPE_ELLIPSE, TEXT("Ellipse") }, { EFX_SHAPE_ELLIPSE_90_LT, TEXT("Ellipse 90° left-top") }, { EFX_SHAPE_ELLIPSE_90_LB, TEXT("Ellipse 90° left-bottom") }, { EFX_SHAPE_ELLIPSE_90_RT, TEXT("Ellipse 90° right-top") }, { EFX_SHAPE_ELLIPSE_90_RB, TEXT("Ellipse 90° right-bottom") }, { EFX_SHAPE_ELLIPSE_180_L, TEXT("Ellipse 180° left") }, { EFX_SHAPE_ELLIPSE_180_R, TEXT("Ellipse 180° right") }, { EFX_SHAPE_ELLIPSE_180_T, TEXT("Ellipse 180° top") }, { EFX_SHAPE_ELLIPSE_180_B, TEXT("Ellipse 180° bottom") }, { EFX_SHAPE_ELLIPSE_270_LT, TEXT("Ellipse 270° left-top") }, { EFX_SHAPE_ELLIPSE_270_LB, TEXT("Ellipse 270° left-bottom") }, { EFX_SHAPE_ELLIPSE_270_RT, TEXT("Ellipse 270° right-top") }, { EFX_SHAPE_ELLIPSE_270_RB, TEXT("Ellipse 270° right-bottom") }, // Star { EFX_SHAPE_STAR4, TEXT("Star 4 points") }, { EFX_SHAPE_STAR5, TEXT("Star 5 points") }, { EFX_SHAPE_STAR8, TEXT("Star 8 points") }, { EFX_SHAPE_STAR16, TEXT("Star 16 points") }, { EFX_SHAPE_STAR24, TEXT("Star 24 points") }, { EFX_SHAPE_STAR32, TEXT("Star 36 points") }, // Cross { EFX_SHAPE_CROSS_SMALL, TEXT("Cross small") }, { EFX_SHAPE_CROSS_MEDIUM, TEXT("Cross medium") }, { EFX_SHAPE_CROSS_LARGE, TEXT("Cross large") }, // Arrow { EFX_SHAPE_ARROW_L, TEXT("Arrow left") }, { EFX_SHAPE_ARROW_R, TEXT("Arrow right") }, { EFX_SHAPE_ARROW_T, TEXT("Arrow top") }, { EFX_SHAPE_ARROW_B, TEXT("Arrow bottom") }, { EFX_SHAPE_ARROW2_L_AND_R, TEXT("Arrow2 left and right") }, { EFX_SHAPE_ARROW2_T_AND_B, TEXT("Arrow2 top and bottom") }, { EFX_SHAPE_ARROW2_L_AND_T, TEXT("Arrow2 left and top") }, { EFX_SHAPE_ARROW2_L_AND_B, TEXT("Arrow2 left and bottom") }, { EFX_SHAPE_ARROW2_R_AND_T, TEXT("Arrow2 right and top") }, { EFX_SHAPE_ARROW2_R_AND_B, TEXT("Arrow2 right and bottom") }, { EFX_SHAPE_ARROW3_L_AND_T_AND_R, TEXT("Arrow3 left and top and right") }, { EFX_SHAPE_ARROW3_T_AND_R_AND_B, TEXT("Arrow3 top and right and bottom") }, { EFX_SHAPE_ARROW3_L_AND_B_AND_R, TEXT("Arrow3 left and bottom and right") }, { EFX_SHAPE_ARROW3_L_AND_T_AND_B, TEXT("Arrow3 left and top and bottom") }, { EFX_SHAPE_ARROW4_L_AND_T_AND_R_AND_B, TEXT("Arrow4 left and top and right and bottom") }, }; static EFFECTDEF GradientDef[] = { // Linear gradient { EFX_GRADIENT_LINE_L_TO_R, TEXT("Line left to right") }, { EFX_GRADIENT_LINE_R_TO_L, TEXT("Line right to left") }, { EFX_GRADIENT_LINE_T_TO_B, TEXT("Line top to bottom") }, { EFX_GRADIENT_LINE_B_TO_T, TEXT("Line bottom to top") }, { EFX_GRADIENT_LINE_LT_TO_RB, TEXT("Line left-top to right-bottom") }, { EFX_GRADIENT_LINE_LB_TO_RT, TEXT("Line left-bottom to right-top") }, { EFX_GRADIENT_LINE_RT_TO_LB, TEXT("Line right-top to left-bottom") }, { EFX_GRADIENT_LINE_RB_TO_LT, TEXT("Line right-bottom to left-top") }, { EFX_GRADIENT_LINE2_L_AND_R_TO_C, TEXT("Line2 left and right to center") }, { EFX_GRADIENT_LINE2_C_TO_L_AND_R, TEXT("Line2 center to left and right") }, { EFX_GRADIENT_LINE2_T_AND_B_TO_C, TEXT("Line2 top and bottom to center") }, { EFX_GRADIENT_LINE2_C_TO_T_AND_B, TEXT("Line2 center to top and bottom") }, { EFX_GRADIENT_LINE2_LT_AND_RB_TO_C, TEXT("Line2 left-top and right-bottom to center") }, { EFX_GRADIENT_LINE2_C_TO_LT_AND_RB, TEXT("Line2 center to left-top and right-bottom") }, { EFX_GRADIENT_LINE2_RT_AND_LB_TO_C, TEXT("Line2 right-top and left-bottom to center") }, { EFX_GRADIENT_LINE2_C_TO_RT_AND_LB, TEXT("Line2 center to right-top and left-bottom") }, // Angular gradient { EFX_GRADIENT_ANGLE_TO_LT, TEXT("Angle to left-top") }, { EFX_GRADIENT_ANGLE_TO_LB, TEXT("Angle to left-bottom") }, { EFX_GRADIENT_ANGLE_TO_RT, TEXT("Angle to right-top") }, { EFX_GRADIENT_ANGLE_TO_RB, TEXT("Angle to right-bottom") }, { EFX_GRADIENT_ANGLE_FROM_LT, TEXT("Angle from left-top") }, { EFX_GRADIENT_ANGLE_FROM_LB, TEXT("Angle from left-bottom") }, { EFX_GRADIENT_ANGLE_FROM_RT, TEXT("Angle from right-top") }, { EFX_GRADIENT_ANGLE_FROM_RB, TEXT("Angle from right-bottom") }, // Rectangular gradient { EFX_GRADIENT_RECTANGLE_TO_C, TEXT("Rectangle to center") }, { EFX_GRADIENT_RECTANGLE_FROM_C, TEXT("Rectangle from center") }, // Elliptical gradient { EFX_GRADIENT_ELLIPSE_TO_C, TEXT("Ellipse to center") }, { EFX_GRADIENT_ELLIPSE_FROM_C, TEXT("Ellipse from center") }, // Conical gradient { EFX_GRADIENT_CONE_FROM_L, TEXT("Cone from left") }, { EFX_GRADIENT_CONE_FROM_R, TEXT("Cone from right") }, { EFX_GRADIENT_CONE_FROM_T, TEXT("Cone from top") }, { EFX_GRADIENT_CONE_FROM_B, TEXT("Cone from bottom") }, { EFX_GRADIENT_CONE_FROM_LT, TEXT("Cone from left-top") }, { EFX_GRADIENT_CONE_FROM_LB, TEXT("Cone from left-bottom") }, { EFX_GRADIENT_CONE_FROM_RT, TEXT("Cone from right-top") }, { EFX_GRADIENT_CONE_FROM_RB, TEXT("Cone from right-bottom") }, }; static EFFECTDEF TransitionDef[] = { // Pattern { EFX_TRANS_SOLID, TEXT("Solid") }, { EFX_TRANS_HORZ_LINE, TEXT("Horizontal lines") }, { EFX_TRANS_VERT_LINE, TEXT("Vertical lines") }, { EFX_TRANS_DOWNWARD_DIAG, TEXT("Downward diagonal lines") }, { EFX_TRANS_UPWARD_DIAG, TEXT("Upward diagonal lines") }, { EFX_TRANS_CROSS, TEXT("Cross lines") }, { EFX_TRANS_DIAG_CROSS, TEXT("Diagonal cross lines") }, // Linear gradient { EFX_TRANS_GRADIENT_LINE_L_TO_R, TEXT("Line left to right") }, { EFX_TRANS_GRADIENT_LINE_R_TO_L, TEXT("Line right to left") }, { EFX_TRANS_GRADIENT_LINE_T_TO_B, TEXT("Line top to bottom") }, { EFX_TRANS_GRADIENT_LINE_B_TO_T, TEXT("Line bottom to top") }, { EFX_TRANS_GRADIENT_LINE_LT_TO_RB, TEXT("Line left-top to right-bottom") }, { EFX_TRANS_GRADIENT_LINE_LB_TO_RT, TEXT("Line left-bottom to right-top") }, { EFX_TRANS_GRADIENT_LINE_RT_TO_LB, TEXT("Line right-top to left-bottom") }, { EFX_TRANS_GRADIENT_LINE_RB_TO_LT, TEXT("Line right-bottom to left-top") }, { EFX_TRANS_GRADIENT_LINE2_L_AND_R_TO_C, TEXT("Line2 left and right to center") }, { EFX_TRANS_GRADIENT_LINE2_C_TO_L_AND_R, TEXT("Line2 center to left and right") }, { EFX_TRANS_GRADIENT_LINE2_T_AND_B_TO_C, TEXT("Line2 top and bottom to center") }, { EFX_TRANS_GRADIENT_LINE2_C_TO_T_AND_B, TEXT("Line2 center to top and bottom") }, { EFX_TRANS_GRADIENT_LINE2_LT_AND_RB_TO_C, TEXT("Line2 left-top and right-bottom to center") }, { EFX_TRANS_GRADIENT_LINE2_C_TO_LT_AND_RB, TEXT("Line2 center to left-top and right-bottom") }, { EFX_TRANS_GRADIENT_LINE2_RT_AND_LB_TO_C, TEXT("Line2 right-top and left-bottom to center") }, { EFX_TRANS_GRADIENT_LINE2_C_TO_RT_AND_LB, TEXT("Line2 center to right-top and left-bottom") }, // Angular gradient { EFX_TRANS_GRADIENT_ANGLE_TO_LT, TEXT("Angle to left-top") }, { EFX_TRANS_GRADIENT_ANGLE_TO_LB, TEXT("Angle to left-bottom") }, { EFX_TRANS_GRADIENT_ANGLE_TO_RT, TEXT("Angle to right-top") }, { EFX_TRANS_GRADIENT_ANGLE_TO_RB, TEXT("Angle to right-bottom") }, { EFX_TRANS_GRADIENT_ANGLE_FROM_LT, TEXT("Angle from left-top") }, { EFX_TRANS_GRADIENT_ANGLE_FROM_LB, TEXT("Angle from left-bottom") }, { EFX_TRANS_GRADIENT_ANGLE_FROM_RT, TEXT("Angle from right-top") }, { EFX_TRANS_GRADIENT_ANGLE_FROM_RB, TEXT("Angle from right-bottom") }, // Rectangular gradient { EFX_TRANS_GRADIENT_RECTANGLE_TO_C, TEXT("Rectangle to center") }, { EFX_TRANS_GRADIENT_RECTANGLE_FROM_C, TEXT("Rectangle from center") }, // Elliptical gradient { EFX_TRANS_GRADIENT_ELLIPSE_TO_C, TEXT("Ellipse to center") }, { EFX_TRANS_GRADIENT_ELLIPSE_FROM_C, TEXT("Ellipse from center") }, // Conical gradient { EFX_TRANS_GRADIENT_CONE_FROM_L, TEXT("Cone from left") }, { EFX_TRANS_GRADIENT_CONE_FROM_R, TEXT("Cone from right") }, { EFX_TRANS_GRADIENT_CONE_FROM_T, TEXT("Cone from top") }, { EFX_TRANS_GRADIENT_CONE_FROM_B, TEXT("Cone from bottom") }, { EFX_TRANS_GRADIENT_CONE_FROM_LT, TEXT("Cone from left-top") }, { EFX_TRANS_GRADIENT_CONE_FROM_LB, TEXT("Cone from left-bottom") }, { EFX_TRANS_GRADIENT_CONE_FROM_RT, TEXT("Cone from right-top") }, { EFX_TRANS_GRADIENT_CONE_FROM_RB, TEXT("Cone from right-bottom") }, }; static EFFECTDEF EffectDef[] = { // No effect { EFX_EFFECT_NONE, TEXT("No effect") }, { EFX_EFFECT_NO_PICTURE, TEXT("No picture (no background)") }, // Linear wipe { EFX_EFFECT_WIPE_L_TO_R, TEXT("Wipe left to right") }, { EFX_EFFECT_WIPE_R_TO_L, TEXT("Wipe right to left") }, { EFX_EFFECT_WIPE_T_TO_B, TEXT("Wipe top to bottom") }, { EFX_EFFECT_WIPE_B_TO_T, TEXT("Wipe bottom to top") }, { EFX_EFFECT_WIPE_LT_TO_RB, TEXT("Wipe left-top to right-bottom") }, { EFX_EFFECT_WIPE_LB_TO_RT, TEXT("Wipe left-bottom to right-top") }, { EFX_EFFECT_WIPE_RT_TO_LB, TEXT("Wipe right-top to left-bottom") }, { EFX_EFFECT_WIPE_RB_TO_LT, TEXT("Wipe right-bottom to left-top") }, { EFX_EFFECT_WIPE_INTERH_L_TO_R_THEN_L_TO_R, TEXT("Wipe horizontal interlace left to right twice") }, { EFX_EFFECT_WIPE_INTERV_T_TO_B_THEN_T_TO_B, TEXT("Wipe vertical interlace top to bottom twice") }, { EFX_EFFECT_WIPE_INTERH_L_TO_R_THEN_R_TO_L, TEXT("Wipe horizontal interlace left to right then back") }, { EFX_EFFECT_WIPE_INTERV_T_TO_B_THEN_B_TO_T, TEXT("Wipe vertical interlace top to bottom then back") }, { EFX_EFFECT_WIPE_INTERV_L_TO_R_THEN_L_TO_R, TEXT("Wipe vertical interlace left to right twice") }, { EFX_EFFECT_WIPE_INTERV_R_TO_L_THEN_R_TO_L, TEXT("Wipe vertical interlace right to left twice") }, { EFX_EFFECT_WIPE_INTERH_T_TO_B_THEN_T_TO_B, TEXT("Wipe horizontal interlace top to bottom twice") }, { EFX_EFFECT_WIPE_INTERH_B_TO_T_THEN_B_TO_T, TEXT("Wipe horizontal interlace bottom to top twice") }, { EFX_EFFECT_WIPE_INTERV_L_TO_R_THEN_R_TO_L, TEXT("Wipe vertical interlace left to right then back") }, { EFX_EFFECT_WIPE_INTERV_R_TO_L_THEN_L_TO_R, TEXT("Wipe vertical interlace right to left then back") }, { EFX_EFFECT_WIPE_INTERH_T_TO_B_THEN_B_TO_T, TEXT("Wipe horizontal interlace top to bottom then back") }, { EFX_EFFECT_WIPE_INTERH_B_TO_T_THEN_T_TO_B, TEXT("Wipe horizontal interlace bottom to top then back") }, { EFX_EFFECT_WIPE_INTERH_L_TO_R_AND_R_TO_L, TEXT("Wipe horizontal interlace left to right and right to left") }, { EFX_EFFECT_WIPE_INTERV_T_TO_B_AND_B_TO_T, TEXT("Wipe vertical interlace top to bottom and bottom to top") }, { EFX_EFFECT_WIPE_INTERV_L_AND_R_TO_C, TEXT("Wipe vertical interlace left and right to center") }, { EFX_EFFECT_WIPE_INTERV_C_TO_L_AND_R, TEXT("Wipe vertical interlace center to left and right") }, { EFX_EFFECT_WIPE_INTERH_T_AND_B_TO_C, TEXT("Wipe horizontal interlace top and bottom to center") }, { EFX_EFFECT_WIPE_INTERH_C_TO_T_AND_B, TEXT("Wipe horizontal interlace center to top and bottom") }, { EFX_EFFECT_WIPE_INTERV_L_AND_R_TO_C_THEN_C_TO_L_AND_R, TEXT("Wipe vertical interlace left and right to center then back") }, { EFX_EFFECT_WIPE_INTERV_C_TO_L_AND_R_THEN_L_AND_R_TO_C, TEXT("Wipe vertical interlace center to left and right then back") }, { EFX_EFFECT_WIPE_INTERH_T_AND_B_TO_C_THEN_C_TO_T_AND_B, TEXT("Wipe horizontal interlace top and bottom to center then back") }, { EFX_EFFECT_WIPE_INTERH_C_TO_T_AND_B_THEN_T_AND_B_TO_C, TEXT("Wipe horizontal interlace center to top and bottom then back") }, { EFX_EFFECT_WIPE2_LT_AND_RB_TO_C, TEXT("Wipe2 left-top and right-bottom to center") }, { EFX_EFFECT_WIPE2_LB_AND_RT_TO_C, TEXT("Wipe2 left-bottom and right-top to center") }, { EFX_EFFECT_WIPE2_C_TO_LT_AND_RB, TEXT("Wipe2 center to left-top and right-bottom") }, { EFX_EFFECT_WIPE2_C_TO_LB_AND_RT, TEXT("Wipe2 center to left-bottom and right-top") }, { EFX_EFFECT_WIPE2_LB_AND_RB_TO_T, TEXT("Wipe2 left-bottom and right-bottom to top") }, { EFX_EFFECT_WIPE2_LT_AND_RT_TO_B, TEXT("Wipe2 left-top and right-top to bottom") }, { EFX_EFFECT_WIPE2_RT_AND_RB_TO_L, TEXT("Wipe2 right-top and right-bottom to left") }, { EFX_EFFECT_WIPE2_LT_AND_LB_TO_R, TEXT("Wipe2 left-top and left-bottom to right") }, { EFX_EFFECT_WIPE2_L_T_TO_B_AND_R_B_TO_T, TEXT("Wipe2 left top to bottom and right bottom to top") }, { EFX_EFFECT_WIPE2_T_L_TO_R_AND_B_R_TO_L, TEXT("Wipe2 top left to right and bottom right to left") }, { EFX_EFFECT_WIPE4_CORNERS_OUT, TEXT("Wipe4 corners out") }, { EFX_EFFECT_WIPE4_C_TO_L_AND_R_THEN_T_AND_B, TEXT("Wipe4 center to left and right then top and bottom") }, { EFX_EFFECT_WIPE4_T_AND_B_THEN_L_AND_R_TO_C, TEXT("Wipe4 top and bottom then left and right to center") }, // Rectangular wipe { EFX_EFFECT_WIPE_RECTANGLE_IN, TEXT("Wipe rectangle in") }, { EFX_EFFECT_WIPE_RECTANGLE_OUT, TEXT("Wipe rectangle out") }, { EFX_EFFECT_WIPE_RECTANGLE_INTER_IN_THEN_IN, TEXT("Wipe rectangle interlace in then in") }, { EFX_EFFECT_WIPE_RECTANGLE_INTER_OUT_THEN_OUT, TEXT("Wipe rectangle interlace out then out") }, { EFX_EFFECT_WIPE_RECTANGLE_INTER_IN_THEN_OUT, TEXT("Wipe rectangle interlace in then out") }, { EFX_EFFECT_WIPE_RECTANGLE_INTER_OUT_THEN_IN, TEXT("Wipe rectangle interlace out then in") }, // Circular wipe { EFX_EFFECT_WIPE_CIRCLE_C_CW_FROM_L, TEXT("Wipe circle center CW from left") }, { EFX_EFFECT_WIPE_CIRCLE_C_CCW_FROM_L, TEXT("Wipe circle center CCW from left") }, { EFX_EFFECT_WIPE_CIRCLE_C_CW_FROM_R, TEXT("Wipe circle center CW from right") }, { EFX_EFFECT_WIPE_CIRCLE_C_CCW_FROM_R, TEXT("Wipe circle center CCW from right") }, { EFX_EFFECT_WIPE_CIRCLE_C_CW_FROM_T, TEXT("Wipe circle center CW from top") }, { EFX_EFFECT_WIPE_CIRCLE_C_CCW_FROM_T, TEXT("Wipe circle center CCW from top") }, { EFX_EFFECT_WIPE_CIRCLE_C_CW_FROM_B, TEXT("Wipe circle center CW from bottom") }, { EFX_EFFECT_WIPE_CIRCLE_C_CCW_FROM_B, TEXT("Wipe circle center CCW from bottom") }, { EFX_EFFECT_WIPE_CIRCLE_L_CCW_FROM_B, TEXT("Wipe circle left CCW from bottom") }, { EFX_EFFECT_WIPE_CIRCLE_L_CW_FROM_T, TEXT("Wipe circle left CW from top") }, { EFX_EFFECT_WIPE_CIRCLE_R_CW_FROM_B, TEXT("Wipe circle right CW from bottom") }, { EFX_EFFECT_WIPE_CIRCLE_R_CCW_FROM_T, TEXT("Wipe circle right CCW from top") }, { EFX_EFFECT_WIPE_CIRCLE_T_CCW_FROM_L, TEXT("Wipe circle top CCW from left") }, { EFX_EFFECT_WIPE_CIRCLE_T_CW_FROM_R, TEXT("Wipe circle top CW from right") }, { EFX_EFFECT_WIPE_CIRCLE_B_CW_FROM_L, TEXT("Wipe circle bottom CW from left") }, { EFX_EFFECT_WIPE_CIRCLE_B_CCW_FROM_R, TEXT("Wipe circle bottom CCW from right") }, { EFX_EFFECT_WIPE_CIRCLE2_C_CW_FROM_L_AND_FROM_R, TEXT("Wipe circle2 center CW from left and from right") }, { EFX_EFFECT_WIPE_CIRCLE2_C_CCW_FROM_L_AND_FROM_R, TEXT("Wipe circle2 center CCW from left and from right") }, { EFX_EFFECT_WIPE_CIRCLE2_C_CW_FROM_T_AND_FROM_B, TEXT("Wipe circle2 center CW from top and from bottom") }, { EFX_EFFECT_WIPE_CIRCLE2_C_CCW_FROM_T_AND_FROM_B, TEXT("Wipe circle2 center CCW from top and from bottom") }, { EFX_EFFECT_WIPE_CIRCLE2_L_CW_FROM_T_AND_CCW_FROM_B, TEXT("Wipe circle2 left CW from top and CCW from bottom") }, { EFX_EFFECT_WIPE_CIRCLE2_L_CCW_TO_T_AND_CW_TO_B, TEXT("Wipe circle2 left CCW to top and CW to bottom") }, { EFX_EFFECT_WIPE_CIRCLE2_R_CCW_FROM_T_AND_CW_FROM_B, TEXT("Wipe circle2 right CCW from top and CW from bottom") }, { EFX_EFFECT_WIPE_CIRCLE2_R_CW_TO_T_AND_CCW_TO_B, TEXT("Wipe circle2 right CW to top and CCW to bottom") }, { EFX_EFFECT_WIPE_CIRCLE2_T_CCW_FROM_L_AND_CW_FROM_R, TEXT("Wipe circle2 top CCW from left and CW from right") }, { EFX_EFFECT_WIPE_CIRCLE2_T_CW_TO_L_AND_CCW_TO_R, TEXT("Wipe circle2 top CW to left and CCW to right") }, { EFX_EFFECT_WIPE_CIRCLE2_B_CW_FROM_L_AND_CCW_FROM_R, TEXT("Wipe circle2 bottom CW from left and CCW from right") }, { EFX_EFFECT_WIPE_CIRCLE2_B_CCW_TO_L_AND_CW_TO_R, TEXT("Wipe circle2 bottom CCW to left and CW to right") }, { EFX_EFFECT_WIPE_CIRCLE4_C_CW_CCW_CCW_CW, TEXT("Wipe circle4 center CW CCW CCW CW") }, { EFX_EFFECT_WIPE_CIRCLE4_C_CCW_CW_CW_CCW, TEXT("Wipe circle4 center CCW CW CW CCW") }, // Push { EFX_EFFECT_PUSH_R_TO_L, TEXT("Push right to left") }, { EFX_EFFECT_PUSH_L_TO_R, TEXT("Push left to right") }, { EFX_EFFECT_PUSH_B_TO_T, TEXT("Push bottom to top") }, { EFX_EFFECT_PUSH_T_TO_B, TEXT("Push top to bottom") }, { EFX_EFFECT_PUSH2_T_R_TO_L_AND_B_L_TO_R, TEXT("Push2 top right to left and bottom left to right") }, { EFX_EFFECT_PUSH2_T_L_TO_R_AND_B_R_TO_L, TEXT("Push2 top left to right and bottom right to left") }, { EFX_EFFECT_PUSH2_L_B_TO_T_AND_R_T_TO_B, TEXT("Push2 left bottom to top and right top to bottom") }, { EFX_EFFECT_PUSH2_L_T_TO_B_AND_R_B_TO_T, TEXT("Push2 left top to bottom and right bottom to top") }, // Slide { EFX_EFFECT_SLIDE_R_TO_L, TEXT("Slide right to left") }, { EFX_EFFECT_SLIDE_L_TO_R, TEXT("Slide left to right") }, { EFX_EFFECT_SLIDE_B_TO_T, TEXT("Slide bottom to top") }, { EFX_EFFECT_SLIDE_T_TO_B, TEXT("Slide top to bottom") }, { EFX_EFFECT_SLIDE_LT_TO_RB, TEXT("Slide left-top to right-bottom") }, { EFX_EFFECT_SLIDE_RT_TO_LB, TEXT("Slide right-top to left-bottom") }, { EFX_EFFECT_SLIDE_LB_TO_RT, TEXT("Slide left-bottom to right-top") }, { EFX_EFFECT_SLIDE_RB_TO_LT, TEXT("Slide right-bottom to left-top") }, { EFX_EFFECT_SLIDE_INTERH_L_TO_R_AND_R_TO_L, TEXT("Slide horizontal interlace left to right and right to left") }, { EFX_EFFECT_SLIDE_INTERV_T_TO_B_AND_B_TO_T, TEXT("Slide vertical interlace top to bottom and bottom to top") }, { EFX_EFFECT_SLIDE2_T_R_TO_L_AND_B_L_TO_R, TEXT("Slide2 top right to left and bottom left to right") }, { EFX_EFFECT_SLIDE2_T_L_TO_R_AND_B_R_TO_L, TEXT("Slide2 top left to right and bottom right to left") }, { EFX_EFFECT_SLIDE2_L_B_TO_T_AND_R_T_TO_B, TEXT("Slide2 left bottom to top and right top to bottom") }, { EFX_EFFECT_SLIDE2_L_T_TO_B_AND_R_B_TO_T, TEXT("Slide2 left top to bottom and right bottom to top") }, // Roll { EFX_EFFECT_ROLL_L_TO_R, TEXT("Roll left to right") }, { EFX_EFFECT_ROLL_R_TO_L, TEXT("Roll right to left") }, { EFX_EFFECT_ROLL_T_TO_B, TEXT("Roll top to bottom") }, { EFX_EFFECT_ROLL_B_TO_T, TEXT("Roll bottom to top") }, { EFX_EFFECT_ROLL2_T_R_TO_L_AND_B_L_TO_R, TEXT("Roll2 top right to left and bottom left to right") }, { EFX_EFFECT_ROLL2_T_L_TO_R_AND_B_R_TO_L, TEXT("Roll2 top left to right and bottom right to left") }, { EFX_EFFECT_ROLL2_L_B_TO_T_AND_R_T_TO_B, TEXT("Roll2 left bottom to top and right top to bottom") }, { EFX_EFFECT_ROLL2_L_T_TO_B_AND_R_B_TO_T, TEXT("Roll2 left top to bottom and right bottom to top") }, // Rotate { EFX_EFFECT_ROTATE_L_TO_R, TEXT("Rotate left to right") }, { EFX_EFFECT_ROTATE_R_TO_L, TEXT("Rotate right to left") }, { EFX_EFFECT_ROTATE_T_TO_B, TEXT("Rotate top to bottom") }, { EFX_EFFECT_ROTATE_B_TO_T, TEXT("Rotate bottom to top") }, // Zoom { EFX_EFFECT_ZOOM_TO_C, TEXT("Zoom to center") }, { EFX_EFFECT_ZOOM_FROM_C, TEXT("Zoom from center") }, // Drip { EFX_EFFECT_DRIP_T_TO_B, TEXT("Drip top to bottom") }, { EFX_EFFECT_DRIP_B_TO_T, TEXT("Drip bottom to top") }, { EFX_EFFECT_DRIP_L_TO_R, TEXT("Drip left to right") }, { EFX_EFFECT_DRIP_R_TO_L, TEXT("Drip right to left") }, // Blind { EFX_EFFECT_BLIND_T_TO_B, TEXT("Blind top to bottom") }, { EFX_EFFECT_BLIND_L_TO_R, TEXT("Blind left to right") }, { EFX_EFFECT_BLIND_GROWING_L_TO_R, TEXT("Blind growing left to right") }, { EFX_EFFECT_BLIND_GROWING_R_TO_L, TEXT("Blind growing right to left") }, { EFX_EFFECT_BLIND_GROWING_T_TO_B, TEXT("Blind growing top to bottom") }, { EFX_EFFECT_BLIND_GROWING_B_TO_T, TEXT("Blind growing bottom to top") }, { EFX_EFFECT_BLIND2_T_TO_B_AND_L_TO_R, TEXT("Blind2 top to bottom and left to right") }, // Random { EFX_EFFECT_RANDOM_BARS_R_TO_L, TEXT("Random bars right to left") }, { EFX_EFFECT_RANDOM_BARS_L_TO_R, TEXT("Random bars left to right") }, { EFX_EFFECT_RANDOM_BARS_B_TO_T, TEXT("Random bars bottom to top") }, { EFX_EFFECT_RANDOM_BARS_T_TO_B, TEXT("Random bars top to bottom") }, { EFX_EFFECT_RANDOM_LINES, TEXT("Random lines") }, { EFX_EFFECT_RANDOM_BLOCKS, TEXT("Random blocks") }, { EFX_EFFECT_RANDOM_BLOCKS_R_TO_L, TEXT("Random blocks right to left") }, { EFX_EFFECT_RANDOM_BLOCKS_L_TO_R, TEXT("Random blocks left to right") }, { EFX_EFFECT_RANDOM_BLOCKS_B_TO_T, TEXT("Random blocks bottom to top") }, { EFX_EFFECT_RANDOM_BLOCKS_T_TO_B, TEXT("Random blocks top to bottom") }, // Checkerboard { EFX_EFFECT_CHECKERBOARD_T_TO_B_THEN_T_TO_B, TEXT("Checkerboard top to bottom then top to bottom") }, { EFX_EFFECT_CHECKERBOARD_B_TO_T_THEN_B_TO_T, TEXT("Checkerboard bottom to top then bottom to top") }, { EFX_EFFECT_CHECKERBOARD_L_TO_R_THEN_L_TO_R, TEXT("Checkerboard left to right then left to right") }, { EFX_EFFECT_CHECKERBOARD_R_TO_L_THEN_R_TO_L, TEXT("Checkerboard right to left then right to left") }, { EFX_EFFECT_CHECKERBOARD_T_TO_B_THEN_B_TO_T, TEXT("Checkerboard top to bottom then bottom to top") }, { EFX_EFFECT_CHECKERBOARD_B_TO_T_THEN_T_TO_B, TEXT("Checkerboard bottom to top then top to bottom") }, { EFX_EFFECT_CHECKERBOARD_L_TO_R_THEN_R_TO_L, TEXT("Checkerboard left to right then right to left") }, { EFX_EFFECT_CHECKERBOARD_R_TO_L_THEN_L_TO_R, TEXT("Checkerboard right to left then left to right") }, // Blocks { EFX_EFFECT_BLOCKS_T_TO_B, TEXT("Blocks top to bottom") }, { EFX_EFFECT_BLOCKS_B_TO_T, TEXT("Blocks bottom to top") }, { EFX_EFFECT_BLOCKS_L_TO_R, TEXT("Blocks left to right") }, { EFX_EFFECT_BLOCKS_R_TO_L, TEXT("Blocks right to left") }, { EFX_EFFECT_BLOCKS_SWIRL_CW_TO_C, TEXT("Blocks swirl CW to center") }, { EFX_EFFECT_BLOCKS_SWIRL_CW_FROM_C, TEXT("Blocks swirl CW from center") }, { EFX_EFFECT_BLOCKS_SWIRL_CCW_TO_C, TEXT("Blocks swirl CCW to center") }, { EFX_EFFECT_BLOCKS_SWIRL_CCW_FROM_C, TEXT("Blocks swirl CCW from center") }, // Circle { EFX_EFFECT_CIRCLE_C_IN, TEXT("Circle center in") }, { EFX_EFFECT_CIRCLE_C_OUT, TEXT("Circle center out") }, { EFX_EFFECT_CIRCLE_L_IN, TEXT("Circle left in") }, { EFX_EFFECT_CIRCLE_L_OUT, TEXT("Circle left out") }, { EFX_EFFECT_CIRCLE_R_IN, TEXT("Circle right in") }, { EFX_EFFECT_CIRCLE_R_OUT, TEXT("Circle right out") }, { EFX_EFFECT_CIRCLE_T_IN, TEXT("Circle top in") }, { EFX_EFFECT_CIRCLE_T_OUT, TEXT("Circle top out") }, { EFX_EFFECT_CIRCLE_B_IN, TEXT("Circle bottom in") }, { EFX_EFFECT_CIRCLE_B_OUT, TEXT("Circle bottom out") }, { EFX_EFFECT_CIRCLE_C_INTER_IN_THEN_IN, TEXT("Circle center interlace in then in") }, { EFX_EFFECT_CIRCLE_C_INTER_OUT_THEN_OUT, TEXT("Circle center interlace out then out") }, { EFX_EFFECT_CIRCLE_C_INTER_IN_THEN_OUT, TEXT("Circle center interlace in then out") }, { EFX_EFFECT_CIRCLE_C_INTER_OUT_THEN_IN, TEXT("Circle center interlace out then in") }, { EFX_EFFECT_CIRCLE_L_INTER_IN_THEN_IN, TEXT("Circle left interlace in then in") }, { EFX_EFFECT_CIRCLE_L_INTER_OUT_THEN_OUT, TEXT("Circle left interlace out then out") }, { EFX_EFFECT_CIRCLE_L_INTER_IN_THEN_OUT, TEXT("Circle left interlace in then out") }, { EFX_EFFECT_CIRCLE_L_INTER_OUT_THEN_IN, TEXT("Circle left interlace out then in") }, { EFX_EFFECT_CIRCLE_R_INTER_IN_THEN_IN, TEXT("Circle right interlace in then in") }, { EFX_EFFECT_CIRCLE_R_INTER_OUT_THEN_OUT, TEXT("Circle right interlace out then out") }, { EFX_EFFECT_CIRCLE_R_INTER_IN_THEN_OUT, TEXT("Circle right interlace in then out") }, { EFX_EFFECT_CIRCLE_R_INTER_OUT_THEN_IN, TEXT("Circle right interlace out then in") }, { EFX_EFFECT_CIRCLE_T_INTER_IN_THEN_IN, TEXT("Circle top interlace in then in") }, { EFX_EFFECT_CIRCLE_T_INTER_OUT_THEN_OUT, TEXT("Circle top interlace out then out") }, { EFX_EFFECT_CIRCLE_T_INTER_IN_THEN_OUT, TEXT("Circle top interlace in then out") }, { EFX_EFFECT_CIRCLE_T_INTER_OUT_THEN_IN, TEXT("Circle top interlace out then in") }, { EFX_EFFECT_CIRCLE_B_INTER_IN_THEN_IN, TEXT("Circle bottom interlace in then in") }, { EFX_EFFECT_CIRCLE_B_INTER_OUT_THEN_OUT, TEXT("Circle bottom interlace out then out") }, { EFX_EFFECT_CIRCLE_B_INTER_IN_THEN_OUT, TEXT("Circle bottom interlace in then out") }, { EFX_EFFECT_CIRCLE_B_INTER_OUT_THEN_IN, TEXT("Circle bottom interlace out then in") }, { EFX_EFFECT_CIRCLE_L_R_INTER, TEXT("Circle left right interlace") }, { EFX_EFFECT_CIRCLE_T_B_INTER, TEXT("Circle top bottom interlace") }, { EFX_EFFECT_CIRCLE2_L_R_OUT, TEXT("Circle2 left right out") }, { EFX_EFFECT_CIRCLE2_L_R_IN, TEXT("Circle2 left right in") }, { EFX_EFFECT_CIRCLE2_T_B_OUT, TEXT("Circle2 top bottom out") }, { EFX_EFFECT_CIRCLE2_T_B_IN, TEXT("Circle2 top bottom in") }, // Ellipse { EFX_EFFECT_ELLIPSE_C_IN, TEXT("Ellipse center in") }, { EFX_EFFECT_ELLIPSE_C_OUT, TEXT("Ellipse center out") }, { EFX_EFFECT_ELLIPSE_L_IN, TEXT("Ellipse left in") }, { EFX_EFFECT_ELLIPSE_L_OUT, TEXT("Ellipse left out") }, { EFX_EFFECT_ELLIPSE_R_IN, TEXT("Ellipse right in") }, { EFX_EFFECT_ELLIPSE_R_OUT, TEXT("Ellipse right out") }, { EFX_EFFECT_ELLIPSE_T_IN, TEXT("Ellipse top in") }, { EFX_EFFECT_ELLIPSE_T_OUT, TEXT("Ellipse top out") }, { EFX_EFFECT_ELLIPSE_B_IN, TEXT("Ellipse bottom in") }, { EFX_EFFECT_ELLIPSE_B_OUT, TEXT("Ellipse bottom out") }, { EFX_EFFECT_ELLIPSE_C_INTER_IN_THEN_IN, TEXT("Ellipse center interlace in then in") }, { EFX_EFFECT_ELLIPSE_C_INTER_OUT_THEN_OUT, TEXT("Ellipse center interlace out then out") }, { EFX_EFFECT_ELLIPSE_C_INTER_IN_THEN_OUT, TEXT("Ellipse center interlace in then out") }, { EFX_EFFECT_ELLIPSE_C_INTER_OUT_THEN_IN, TEXT("Ellipse center interlace out then in") }, { EFX_EFFECT_ELLIPSE_L_INTER_IN_THEN_IN, TEXT("Ellipse left interlace in then in") }, { EFX_EFFECT_ELLIPSE_L_INTER_OUT_THEN_OUT, TEXT("Ellipse left interlace out then out") }, { EFX_EFFECT_ELLIPSE_L_INTER_IN_THEN_OUT, TEXT("Ellipse left interlace in then out") }, { EFX_EFFECT_ELLIPSE_L_INTER_OUT_THEN_IN, TEXT("Ellipse left interlace out then in") }, { EFX_EFFECT_ELLIPSE_R_INTER_IN_THEN_IN, TEXT("Ellipse right interlace in then in") }, { EFX_EFFECT_ELLIPSE_R_INTER_OUT_THEN_OUT, TEXT("Ellipse right interlace out then out") }, { EFX_EFFECT_ELLIPSE_R_INTER_IN_THEN_OUT, TEXT("Ellipse right interlace in then out") }, { EFX_EFFECT_ELLIPSE_R_INTER_OUT_THEN_IN, TEXT("Ellipse right interlace out then in") }, { EFX_EFFECT_ELLIPSE_T_INTER_IN_THEN_IN, TEXT("Ellipse top interlace in then in") }, { EFX_EFFECT_ELLIPSE_T_INTER_OUT_THEN_OUT, TEXT("Ellipse top interlace out then out") }, { EFX_EFFECT_ELLIPSE_T_INTER_IN_THEN_OUT, TEXT("Ellipse top interlace in then out") }, { EFX_EFFECT_ELLIPSE_T_INTER_OUT_THEN_IN, TEXT("Ellipse top interlace out then in") }, { EFX_EFFECT_ELLIPSE_B_INTER_IN_THEN_IN, TEXT("Ellipse bottom interlace in then in") }, { EFX_EFFECT_ELLIPSE_B_INTER_OUT_THEN_OUT, TEXT("Ellipse bottom interlace out then out") }, { EFX_EFFECT_ELLIPSE_B_INTER_IN_THEN_OUT, TEXT("Ellipse bottom interlace in then out") }, { EFX_EFFECT_ELLIPSE_B_INTER_OUT_THEN_IN, TEXT("Ellipse bottom interlace out then in") }, { EFX_EFFECT_ELLIPSE_L_R_INTER, TEXT("Ellipse left right interlace") }, { EFX_EFFECT_ELLIPSE_T_B_INTER, TEXT("Ellipse top bottom interlace") }, { EFX_EFFECT_ELLIPSE2_L_R_OUT, TEXT("Ellipse2 left right out") }, { EFX_EFFECT_ELLIPSE2_L_R_IN, TEXT("Ellipse2 left right in") }, { EFX_EFFECT_ELLIPSE2_T_B_OUT, TEXT("Ellipse2 top bottom out") }, { EFX_EFFECT_ELLIPSE2_T_B_IN, TEXT("Ellipse2 top bottom in") }, }; static L_TCHAR *szEffect4Class[] = { TEXT("left"), TEXT("right"), TEXT("top"), TEXT("bottom"), TEXT("left-top"), TEXT("left-bottom"), TEXT("right-top"), TEXT("right-bottom"), }; static int nTextIndex[] = { EFX_TEXT_NORMAL, EFX_TEXT_RAISEDEXTRAHEAVY }; static int nShapeIndex[] = { EFX_SHAPE_SQUARE_CLASS, EFX_SHAPE_SQUARE_MAX, EFX_SHAPE_RECTANGLE_CLASS, EFX_SHAPE_RECTANGLE_MAX, EFX_SHAPE_PARALLELOGRAM_CLASS, EFX_SHAPE_PARALLELOGRAM_MAX, EFX_SHAPE_TRAPEZOID_CLASS, EFX_SHAPE_TRAPEZOID_MAX, EFX_SHAPE_TRIANGLE_CLASS, EFX_SHAPE_TRIANGLE_MAX, EFX_SHAPE_OTHER_CLASS, EFX_SHAPE_OTHER_MAX, EFX_SHAPE_CIRCLE_CLASS, EFX_SHAPE_CIRCLE_MAX, EFX_SHAPE_ELLIPSE_CLASS, EFX_SHAPE_ELLIPSE_MAX, EFX_SHAPE_STAR_CLASS, EFX_SHAPE_STAR_MAX, EFX_SHAPE_CROSS_CLASS, EFX_SHAPE_CROSS_MAX, EFX_SHAPE_ARROW_CLASS, EFX_SHAPE_ARROW_MAX, }; static int nGradientIndex[] = { EFX_GRADIENT_LINE_CLASS, EFX_GRADIENT_LINE_MAX, EFX_GRADIENT_ANGLE_CLASS, EFX_GRADIENT_ANGLE_MAX, EFX_GRADIENT_RECTANGLE_CLASS, EFX_GRADIENT_RECTANGLE_MAX, EFX_GRADIENT_ELLIPSE_CLASS, EFX_GRADIENT_ELLIPSE_MAX, EFX_GRADIENT_CONE_CLASS, EFX_GRADIENT_CONE_MAX, }; static int nTransitionIndex[] = { EFX_TRANS_PATTERN_CLASS, EFX_TRANS_PATTERN_MAX, EFX_TRANS_GRADIENT_LINE_CLASS, EFX_TRANS_GRADIENT_LINE_MAX, EFX_TRANS_GRADIENT_ANGLE_CLASS, EFX_TRANS_GRADIENT_ANGLE_MAX, EFX_TRANS_GRADIENT_RECTANGLE_CLASS, EFX_TRANS_GRADIENT_RECTANGLE_MAX, EFX_TRANS_GRADIENT_ELLIPSE_CLASS, EFX_TRANS_GRADIENT_ELLIPSE_MAX, EFX_TRANS_GRADIENT_CONE_CLASS, EFX_TRANS_GRADIENT_CONE_MAX, }; static int nEffectIndex[] = { EFX_EFFECT_NONE_CLASS, EFX_EFFECT_NONE_MAX, EFX_EFFECT_WIPE_CLASS, EFX_EFFECT_WIPE_MAX, EFX_EFFECT_WIPE_RECTANGLE_CLASS, EFX_EFFECT_WIPE_RECTANGLE_MAX, EFX_EFFECT_WIPE_CIRCLE_CLASS, EFX_EFFECT_WIPE_CIRCLE_MAX, EFX_EFFECT_PUSH_CLASS, EFX_EFFECT_PUSH_MAX, EFX_EFFECT_SLIDE_CLASS, EFX_EFFECT_SLIDE_MAX, EFX_EFFECT_ROLL_CLASS, EFX_EFFECT_ROLL_MAX, EFX_EFFECT_ROTATE_CLASS, EFX_EFFECT_ROTATE_MAX, EFX_EFFECT_ZOOM_CLASS, EFX_EFFECT_ZOOM_MAX, EFX_EFFECT_DRIP_CLASS, EFX_EFFECT_DRIP_MAX, EFX_EFFECT_BLIND_CLASS, EFX_EFFECT_BLIND_MAX, EFX_EFFECT_RANDOM_CLASS, EFX_EFFECT_RANDOM_MAX, EFX_EFFECT_CHECKERBOARD_CLASS, EFX_EFFECT_CHECKERBOARD_MAX, EFX_EFFECT_BLOCKS_CLASS, EFX_EFFECT_BLOCKS_MAX, EFX_EFFECT_CIRCLE_CLASS, EFX_EFFECT_CIRCLE_MAX, EFX_EFFECT_ELLIPSE_CLASS, EFX_EFFECT_ELLIPSE_MAX, }; int GETCOUNT(HWND hListBox) { int nResult; if (hListBox == NULL) { return 1; } nResult = ListBox_GetCount(hListBox); if ((nResult == LB_ERR) || (nResult == 0)) { nResult = 1; } return nResult; } int GETCURSEL(HWND hListBox) { int nResult; if (hListBox == NULL) { return 1; } nResult = ListBox_GetCurSel(hListBox); if (nResult == LB_ERR) { nResult = 1; } return nResult; } int SETCURSEL(HWND hListBox, int nSelect) { if (hListBox == NULL) { return 1; } nSelect = min(nSelect, GETCOUNT(hListBox)); return ListBox_SetCurSel(hListBox, nSelect); } DWORD GETITEMDATA(HWND hListBox, int nIndex) { DWORD nResult; if (hListBox == NULL) { return 0; } nIndex = min(nIndex, GETCOUNT(hListBox)); nResult = ListBox_GetItemData(hListBox, nIndex); if (nResult == LB_ERR) { nResult = 0; } return nResult; } int SETITEMDATA(HWND hListBox, int nIndex, DWORD dwItemData) { if (hListBox == NULL) { return LB_ERR; } nIndex = min(nIndex, GETCOUNT(hListBox)); return ListBox_SetItemData(hListBox, nIndex, dwItemData); } int ADDSTRING(HWND hListBox, L_TCHAR * lpszItem) { if (hListBox == NULL) { return LB_ERR; } return ListBox_AddString(hListBox, lpszItem); } int INSERTSTRING(HWND hListBox, int nIndex, L_TCHAR *lpszItem) { if (hListBox == NULL) { return LB_ERR; } nIndex = min(nIndex, GETCOUNT(hListBox)); return ListBox_InsertString(hListBox, nIndex, lpszItem); } int DELETESTRING(HWND hListBox, int nIndex) { if (hListBox == NULL) { return LB_ERR; } nIndex = min(nIndex, GETCOUNT(hListBox)); return ListBox_DeleteString(hListBox, nIndex); } int SETTOPINDEX(HWND hListBox, int nIndex) { if (hListBox == NULL) { return LB_ERR; } nIndex = min(nIndex, GETCOUNT(hListBox)); return ListBox_SetTopIndex(hListBox, nIndex); } void SETHORIZONTALEXTENT(HWND hListBox, int cxExtent) { if (hListBox == NULL) { return; } ListBox_SetHorizontalExtent(hListBox, cxExtent); } int GetMaxEffect(int nType) { int i, n, t, far *p; switch (nType) { case EFX_TEXT_TYPE: p = nTextIndex; n = sizeof(nTextIndex) / sizeof(nTextIndex[0]); break; case EFX_SHAPE_TYPE: p = nShapeIndex; n = sizeof(nShapeIndex) / sizeof(nShapeIndex[0]); break; case EFX_GRADIENT_TYPE: p = nGradientIndex; n = sizeof(nGradientIndex) / sizeof(nGradientIndex[0]); break; case EFX_TRANSITION_TYPE: p = nTransitionIndex; n = sizeof(nTransitionIndex) / sizeof(nTransitionIndex[0]); break; case EFX_EFFECT_TYPE: p = nEffectIndex; n = sizeof(nEffectIndex) / sizeof(nEffectIndex[0]); break; default: return -1; } for (i = 0, t = 0; i < n; i += 2) { t += p[i+1] - p[i] + 1; } return t; } int GetConstEffect(int nType, int nIndex) { int i, n, far *p; switch (nType) { case EFX_TEXT_TYPE: p = nTextIndex; n = sizeof(nTextIndex) / sizeof(nTextIndex[0]); break; case EFX_SHAPE_TYPE: p = nShapeIndex; n = sizeof(nShapeIndex) / sizeof(nShapeIndex[0]); break; case EFX_GRADIENT_TYPE: p = nGradientIndex; n = sizeof(nGradientIndex) / sizeof(nGradientIndex[0]); break; case EFX_TRANSITION_TYPE: p = nTransitionIndex; n = sizeof(nTransitionIndex) / sizeof(nTransitionIndex[0]); break; case EFX_EFFECT_TYPE: p = nEffectIndex; n = sizeof(nEffectIndex) / sizeof(nEffectIndex[0]); break; default: return -1; } for (i = 0; i < n; i += 2) { if (nIndex < p[i+1] - p[i] + 1) { return p[i] + nIndex; } nIndex -= p[i+1] - p[i] + 1; } return -1; } int GetTextEffect(int nType, int nEffect, L_TCHAR *szText) { L_TCHAR s[10]; int i, n, k; EFFECTDEF far *p; switch (nType) { case EFX_TEXT_TYPE: p = TextDef; n = sizeof(TextDef) / sizeof(TextDef[0]); break; case EFX_SHAPE_TYPE: p = ShapeDef; n = sizeof(ShapeDef) / sizeof(ShapeDef[0]); break; case EFX_GRADIENT_TYPE: p = GradientDef; n = sizeof(GradientDef) / sizeof(GradientDef[0]); break; case EFX_TRANSITION_TYPE: p = TransitionDef; n = sizeof(TransitionDef) / sizeof(TransitionDef[0]); break; case EFX_EFFECT_TYPE: p = EffectDef; n = sizeof(EffectDef) / sizeof(EffectDef[0]); break; default: return -1; } for (i = 0; i < n; i++) { if (nEffect == p[i].nIndex) { lstrcpy(szText, p[i].szText); return TRUE; } } if (nType == EFX_EFFECT_TYPE) { k = -1; switch ((nEffect / 1000) * 1000) { case EFX_EFFECT_WIPE_CLASS: if ((nEffect >= EFX_EFFECT_WIPE4_L_L_L_L) && (nEffect <= EFX_EFFECT_WIPE4_B_B_B_B)) { nEffect -= EFX_EFFECT_WIPE4_L_L_L_L; k = 0; lstrcpy(s, TEXT("Wipe")); } else if ((nEffect >= EFX_EFFECT_WIPE4_LT_LT_LT_LT) && (nEffect < EFX_EFFECT_WIPE4_RB_RB_RB_RB)) { nEffect -= EFX_EFFECT_WIPE4_LT_LT_LT_LT; k = 4; lstrcpy(s, TEXT("Wipe")); } break; case EFX_EFFECT_PUSH_CLASS: if ((nEffect >= EFX_EFFECT_PUSH4_L_L_L_L) && (nEffect <= EFX_EFFECT_PUSH4_B_B_B_B)) { nEffect -= EFX_EFFECT_PUSH4_L_L_L_L; k = 0; lstrcpy(s, TEXT("Push")); } break; case EFX_EFFECT_SLIDE_CLASS: if ((nEffect >= EFX_EFFECT_SLIDE4_L_L_L_L) && (nEffect <= EFX_EFFECT_SLIDE4_B_B_B_B)) { nEffect -= EFX_EFFECT_SLIDE4_L_L_L_L; k = 0; lstrcpy(s, TEXT("Slide")); } else if ((nEffect >= EFX_EFFECT_SLIDE4_LT_LT_LT_LT) && (nEffect < EFX_EFFECT_SLIDE4_RB_RB_RB_RB)) { nEffect -= EFX_EFFECT_SLIDE4_LT_LT_LT_LT; k = 4; lstrcpy(s, TEXT("Slide")); } break; case EFX_EFFECT_ROLL_CLASS: if ((nEffect >= EFX_EFFECT_ROLL4_L_L_L_L) && (nEffect <= EFX_EFFECT_ROLL4_B_B_B_B)) { nEffect -= EFX_EFFECT_ROLL4_L_L_L_L; k = 0; lstrcpy(s, TEXT("Roll")); } break; case EFX_EFFECT_ROTATE_CLASS: if ((nEffect >= EFX_EFFECT_ROTATE4_L_L_L_L) && (nEffect <= EFX_EFFECT_ROTATE4_B_B_B_B)) { nEffect -= EFX_EFFECT_ROTATE4_L_L_L_L; k = 0; lstrcpy(s, TEXT("Rotate")); } break; } if (k >= 0) { strprintf(szText, TEXT("%s4 %s %s %s %s"), s, szEffect4Class[((nEffect/64)%4)+k], szEffect4Class[((nEffect/16)%4)+k], szEffect4Class[((nEffect/4)%4)+k], szEffect4Class[(nEffect%4)+k]); return TRUE; } } return FALSE; } /*--------------------------------------------------------------------------+ | Function :CenterRect | Desc :centers the given rectangle horizontally and vertically | Return : void | Notes : +--------------------------------------------------------------------------*/ static VOID CenterRect(LPRECT pRect1,LPRECT pRect2,BOOL bCntrH,BOOL bCntrV) { L_INT nWidth1=pRect1->right-pRect1->left; L_INT nHeight1=pRect1->bottom-pRect1->top; L_INT nWidth2=((pRect2->right-pRect2->left)-nWidth1)>>1; L_INT nHeight2=((pRect2->bottom-pRect2->top)-nHeight1)>>1; if(bCntrH) { pRect1->left=pRect2->left+nWidth2; pRect1->right=pRect1->left+nWidth1; } if(bCntrV) { pRect1->top=pRect2->top+nHeight2; pRect1->bottom=pRect1->top+nHeight1; } } /*--------------------------------------------------------------------------+ | Function :DrawListBoxButton | Desc :draws the button of a thumbnail | Return :void | Notes :if the thumbnail is selected the button is drawn pressed +--------------------------------------------------------------------------*/ static VOID DrawListBoxButton(HDC hDC,BOOL bEdgeType,LPRECT pButtonRect) { #ifdef WIN32 //first set the colors that will be used in drawing //the thumbnail button COLORREF color1=GetSysColor(COLOR_BTNHILIGHT); #else COLORREF color1=GetSysColor(COLOR_BTNHIGHLIGHT); #endif COLORREF color2=GetSysColor(COLOR_BTNSHADOW); COLORREF color3; //calculate the inner rectangle (button face) L_INT nInleft=pButtonRect->left+THUMBNAILEDGEWIDTH; L_INT nIntop=pButtonRect->top+THUMBNAILEDGEWIDTH; L_INT nInright=pButtonRect->right-THUMBNAILEDGEWIDTH; L_INT nInbottom=pButtonRect->bottom-THUMBNAILEDGEWIDTH; POINT Point[6];//for shadow/hilight areas polygon HPEN hOldPen; HBRUSH hOldBrush; if(bEdgeType) //if the button is pressed then exchange the colors { color3=color2; color2=color1; color1=color3; } SetPolyFillMode(hDC,WINDING); /////////////////////////////////////////drawing on area hOldPen=SelectObject(hDC,CreatePen(PS_SOLID,1,color1)); hOldBrush=SelectObject(hDC,CreateSolidBrush(color1)); Point[0].x=pButtonRect->left; Point[0].y=pButtonRect->top; Point[1].x=pButtonRect->right; Point[1].y=pButtonRect->top; Point[2].x=nInright; Point[2].y=nIntop; Point[3].x=nInleft; Point[3].y=nIntop; Point[4].x=nInleft; Point[4].y=nInbottom; Point[5].x=pButtonRect->left; Point[5].y=pButtonRect->bottom; Polygon(hDC,Point,6); /////////////////////////////////////////drawing off area DeleteObject(SelectObject(hDC,CreatePen(PS_SOLID,1,color2))); DeleteObject(SelectObject(hDC,CreateSolidBrush(color2))); Point[0].x=pButtonRect->right; Point[0].y=pButtonRect->bottom; Point[1].x=pButtonRect->left; Point[1].y=pButtonRect->bottom; Point[2].x=nInleft; Point[2].y=nInbottom; Point[3].x=nInright; Point[3].y=nInbottom; Point[4].x=nInright; Point[4].y=nIntop; Point[5].x=pButtonRect->right; Point[5].y=pButtonRect->top; Polygon(hDC,Point,6); DeleteObject(SelectObject(hDC,CreatePen(PS_SOLID,1,GetSysColor(COLOR_BTNFACE)))); DeleteObject(SelectObject(hDC,CreateSolidBrush(GetSysColor(COLOR_BTNFACE)))); //draw a black frame arround the rectangle FrameRect(hDC,pButtonRect,GetStockObject(BLACK_BRUSH)); DeleteObject(SelectObject(hDC,hOldPen)); DeleteObject(SelectObject(hDC,hOldBrush)); } /*--------------------------------------------------------------------------+ | Function :IsPaletteBW(HWND hWnd) | Desc :Tests for a 1-bit black and white palette | Return :TRUE if 1-bit b/w, FALSE otherwise | Notes : +--------------------------------------------------------------------------*/ L_BOOL IsPaletteBW(HWND hWnd) { RGBQUAD pal[256]; L_BOOL bRet; L_UINT uColors; LPCHILDDATA pData; pData = LOCKCHILDDATA (hWnd); uColors = pData->ActiveBitmap.nColors; uColors = L_GetBitmapColors (&pData->ActiveBitmap, 0, 256, pal); if (uColors != 2) bRet = FALSE; else if ( (pal[0].rgbRed == 0) && (pal[0].rgbGreen == 0) && (pal[0].rgbBlue == 0) && (pal[1].rgbRed == 255) && (pal[1].rgbGreen == 255) && (pal[1].rgbBlue == 255) ) bRet = TRUE; else if ( (pal[0].rgbRed == 255) && (pal[0].rgbGreen == 255) && (pal[0].rgbBlue == 255) && (pal[1].rgbRed == 0) && (pal[1].rgbGreen == 0) && (pal[1].rgbBlue == 0) ) bRet = TRUE; else { bRet = FALSE; } UNLOCKCHILDDATA (hWnd); return bRet; } /*====(ChildWindowProc)==================================================== Description: Processes child window messages. Syntax : LRESULT CALLBACK L_EXPORT ChildWindowProc(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam) Prototype : demo.h Parameters : hWnd Handle of a window. Msg Message to be processed. wParam First message parameter. lParam Second message parameter. Return Value: Depends on the message. ==========================================================================*/ LRESULT CALLBACK L_EXPORT ChildWindowProc (HWND hWnd, UINT Msg, WPARAM wParam,LPARAM lParam) { switch (Msg) { HANDLE_MSG (hWnd, WM_KEYDOWN, Child_OnKey); HANDLE_MSG (hWnd, WM_SIZE, Child_OnSize); HANDLE_MSG (hWnd, WM_CREATE, Child_OnCreate); HANDLE_MSG (hWnd, WM_COMMAND, Child_OnCommand); HANDLE_MSG (hWnd, WM_PAINT, Child_OnPaint); HANDLE_MSG (hWnd, WM_DESTROY, Child_OnDestroy); HANDLE_MSG (hWnd, WM_PALETTECHANGED, Child_OnPaletteChanged); HANDLE_MSG (hWnd, WM_QUERYNEWPALETTE, Child_OnQueryNewPalette); HANDLE_MSG (hWnd, WM_MDIACTIVATE, Child_OnMDIActivate); HANDLE_MSG (hWnd, WM_LBUTTONDOWN, Child_OnLButtonDown); HANDLE_MSG (hWnd, WM_LBUTTONUP, Child_OnLButtonUp); HANDLE_MSG (hWnd, WM_MOUSEMOVE, Child_OnMouseMove); HANDLE_MSG (hWnd, WM_TIMER, Child_OnTimer); HANDLE_MSG (hWnd, WM_SETFOCUS, Child_OnSetFocus); HANDLE_MSG (hWnd, WM_KILLFOCUS, Child_OnKillFocus); HANDLE_MSG (hWnd, WM_MEASUREITEM, Child_OnMeasureItem); HANDLE_MSG (hWnd, WM_DRAWITEM, Child_OnDrawItem); HANDLE_MSG (hWnd,WM_CLOSE,Child_OnClose); HANDLE_MSG (hWnd,WM_USER,Child_OnUserMessage); #ifdef WIN32 HANDLE_MSG (hWnd, WM_CTLCOLORLISTBOX, Child_OnCtlColorListBox); #else HANDLE_MSG (hWnd, WM_CTLCOLOR, Child_OnCtlColorListBox); #endif } return(DefMDIChildProc (hWnd, Msg, wParam, lParam)); } /*--------------------------------------------------------------------------+ | Function :BitmapWindowProc | Desc :the window procedure for the displayed bitmap window | Return :long result depends on the passed message | Notes : +--------------------------------------------------------------------------*/ LRESULT CALLBACK L_EXPORT BitmapWindowProc (HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam) { switch (Msg) { HANDLE_MSG (hWnd, WM_KEYDOWN, BmpWnd_OnKey); HANDLE_MSG (hWnd, WM_VSCROLL, BmpWnd_OnVScroll); HANDLE_MSG (hWnd, WM_HSCROLL, BmpWnd_OnHScroll); HANDLE_MSG (hWnd, WM_SIZE, BmpWnd_OnSize); HANDLE_MSG (hWnd, WM_ERASEBKGND, BmpWnd_OnEraseBkgnd); HANDLE_MSG (hWnd, WM_PAINT, BmpWnd_OnPaint); HANDLE_MSG (hWnd, WM_LBUTTONDOWN, BmpWnd_OnLButtonDown); HANDLE_MSG (hWnd, WM_RBUTTONDOWN, BmpWnd_OnRButtonDown); HANDLE_MSG (hWnd, WM_LBUTTONUP, BmpWnd_OnLButtonUp); HANDLE_MSG (hWnd, WM_MOUSEMOVE, BmpWnd_OnMouseMove); HANDLE_MSG (hWnd, WM_SETCURSOR, BmpWnd_OnSetCursor); } return(DefWindowProc(hWnd,Msg,wParam,lParam)); } /*====(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) { LPCHILDDATA pData; pData = LOCKCHILDDATA(hWnd); if(L_BitmapHasRgn(&pData->ActiveBitmap)) SetTimer(hWnd, ID_REGIONEVENT, REGIONEVENTDELAY, NULL); if(pData->hListBox) RedrawWindow(pData->hListBox,0,0,RDW_INVALIDATE|RDW_UPDATENOW|RDW_ERASE); UNLOCKCHILDDATA(hWnd); } /*====(Child_OnKillFocus)====================================================== Description: Indicates when the window is losing the input focus Syntax : VOID Child_OnKillFocus(HWND hWnd) Parameters : hWnd Handle of the child window. hWndNewFocus New window to get focus Return Value: None. ==========================================================================*/ static VOID Child_OnKillFocus(HWND hWnd, HWND hWndNewFocus) { LPCHILDDATA pData; pData = LOCKCHILDDATA(hWnd); if(L_BitmapHasRgn(&pData->ActiveBitmap)) KillTimer(hWnd, ID_REGIONEVENT); UNLOCKCHILDDATA(hWnd); } /*--------------------------------------------------------------------------+ | Function :BmpWnd_OnSetCursor | Desc :sets the cursor for the bitmap window | Return :true if the cursor has been set | Notes : +--------------------------------------------------------------------------*/ static BOOL BmpWnd_OnSetCursor(HWND hWnd, HWND hWndCursor, UINT codeHitTest, UINT msg) { LPCHILDDATA pData; RECT rcClient; POINT pt; pData = LOCKCHILDDATA(GetParent(hWnd)); if(nRegionTool != IDM_TOOLNONE && !IsIconic(GetParent(hWnd)) && pData->ActiveBitmap.Flags.Allocated && !fInLoadFile && !fInProcess) { GetCursorPos(&pt); ScreenToClient(hWnd, &pt); GetClientRect(hWnd, &rcClient); IntersectRect(&rcClient, &rcClient, &pData->rcView); if(PtInRect(&rcClient, pt)) { SetCursor(LoadCursor (NULL, IDC_CROSS)); UNLOCKCHILDDATA(GetParent(hWnd)); return(TRUE); } } UNLOCKCHILDDATA(GetParent(hWnd)); return(FORWARD_WM_SETCURSOR(hWnd, hWndCursor, codeHitTest, msg, DefWindowProc)); } /*====(Child_OnTimer)====================================================== Description: Called when the timer value expires Syntax : L_VOID Child_OnTimer(HWND hWnd, UINT id) Parameters : hWnd Handle of the child window. id Timer id supplied in SetTimr Return Value: None. ==========================================================================*/ static L_VOID Child_OnTimer(HWND hWnd, UINT id) { LPCHILDDATA pData; pData = LOCKCHILDDATA(hWnd); switch(id) { case ID_REGIONEVENT: pData->uFrameType = (pData->uFrameType + 2) % 8; OutlineBitmapRgn(hWnd, NULL); break; } UNLOCKCHILDDATA(hWnd); } /*--------------------------------------------------------------------------+ | Function :Child_OnLButtonDown | Desc :starts the dragging of the splitter | Return :void | Notes : +--------------------------------------------------------------------------*/ static VOID Child_OnLButtonDown (HWND hWnd, BOOL fDoubleClick, L_INT x, L_INT y,UINT keyFlags) { LPCHILDDATA pData=LOCKCHILDDATA(hWnd); RECT rcListBox; if(pData&&IsWindow(pData->hListBox)&&(bDragExist==FALSE)&&(fDoubleClick==FALSE)) { //set the capture to this window and start the dragging process SetCapture(hWnd); SetFocus(hWnd); bDragExist=TRUE; GetWindowRect(pData->hListBox,&rcListBox); MapWindowPoints(0,hWnd,(LPPOINT)&rcListBox,2); #ifdef WIN32 //optimize the dragging operation by disabling the //updating of the list box if the splitter is far a way //from the thumbnails listbox SetWindowRedraw(pData->hListBox,FALSE); nListBoxLastCx=rcListBox.right-GetSystemMetrics(SM_CXVSCROLL); #endif nLastX=x; } UNLOCKCHILDDATA(hWnd); } /*--------------------------------------------------------------------------+ | Function :Child_OnMouseMove | Desc :continues dragging the splitter | Return :void | Notes : +--------------------------------------------------------------------------*/ static VOID Child_OnMouseMove (HWND hWnd, int x, int y, UINT keyFlags) { LPCHILDDATA pData=LOCKCHILDDATA(hWnd); RECT rcListBox,rcClient; #ifdef WIN32 L_BOOL bRedrawListBox; #endif if(pData&&IsWindow(pData->hListBox)) if(bDragExist) //if there is a dragging process { GetClientRect(hWnd,&rcClient); GetWindowRect(pData->hListBox,&rcListBox); MapWindowPoints(0,hWnd,(LPPOINT)&rcListBox,2); x=(x>(rcClient.right-SPLITWIDTH))? (rcClient.right-SPLITWIDTH):((x<0)? 0: x); rcListBox.right+=(x-nLastX); #ifdef WIN32 //for dragging optimization bRedrawListBox=( (nListBoxLastCx<(rcListBox.right-GetSystemMetrics(SM_CXVSCROLL)))&& (nListBoxLastCx<=LISTBOXWIDTH) ); SetWindowRedraw(pData->hListBox,bRedrawListBox); nListBoxLastCx=rcListBox.right-GetSystemMetrics(SM_CXVSCROLL); #endif nLastX=x; //resize the thumbnails listbox & the bitmap window to the new size MoveWindow(pData->hListBox,0,0,rcListBox.right,rcClient.bottom,TRUE); MoveWindow(pData->hBitmapWnd,rcListBox.right+SPLITWIDTH+1,0,rcClient.right-(rcListBox.right+SPLITWIDTH+1),rcClient.bottom,TRUE); InvalidateRect(hWnd,0,TRUE); UpdateWindow(hWnd); } UNLOCKCHILDDATA (hWnd); } /*--------------------------------------------------------------------------+ | Function :Child_OnLButtonUp | Desc :ends the dragging of the splitter | Return :void | Notes : +--------------------------------------------------------------------------*/ static VOID Child_OnLButtonUp (HWND hWnd, int x, int y, UINT keyFlags) { LPCHILDDATA pData=LOCKCHILDDATA(hWnd); if(pData&&IsWindow(pData->hListBox)&&bDragExist) { //end the dragging session ReleaseCapture(); bDragExist=FALSE; nLastX=0; SetFocus(hWnd); #ifdef WIN32 SetWindowRedraw(pData->hListBox,TRUE); #endif InvalidateRect(hWnd,0,TRUE); UpdateWindow(hWnd); } UNLOCKCHILDDATA(hWnd); } static VOID DrawPoint(LPCHILDDATA pData, L_INT x, L_INT y) { HDC hDC; int nPrevROP2; hDC = GetDC(pData->hBitmapWnd); if (hDC) { nPrevROP2 = SetROP2(hDC, R2_XORPEN); Ellipse(hDC, x-4, y-4, x+4, y+4); SetROP2(hDC, nPrevROP2); ReleaseDC(pData->hBitmapWnd, hDC); } } #define DRAW_BEZIER_SEGMENT(i0, i1, i2, i3)\ {\ InPoints[0] = pptRegion[i0];\ InPoints[1] = pptRegion[i1];\ InPoints[2] = pptRegion[i2];\ InPoints[3] = pptRegion[i3];\ Curve.pPoints = InPoints;\ L_CurveToBezier(&Curve, &nOutCount, OutPoints);\ PolyBezier(hDC, OutPoints, 4);\ } static VOID DrawBezierSegment(LPCHILDDATA pData, POINT *pptRegion, L_INT32 nNextPt) { HPEN hPen, hPrevPen; HDC hDC; int nPrevROP2; int iPointIndex; if (nNextPt < 4) return; iPointIndex = ((int)((nNextPt - 1) / 3)) * 3 + 1; if (iPointIndex != nNextPt) return; hDC = GetDC(pData->hBitmapWnd); if (hDC) { hPen = CreatePen(PS_SOLID, 1,RGB(255,255,255)); hPrevPen = SelectObject(hDC, hPen); nPrevROP2 = SetROP2(hDC, R2_XORPEN); PolyBezier(hDC, pptRegion + iPointIndex - 4, 4); //Restore the hDC SetROP2(hDC, nPrevROP2); SelectObject(hDC, hPrevPen); ReleaseDC(pData->hBitmapWnd, hDC); DeleteObject(hPen); } } static VOID DrawCurveSegment(LPCHILDDATA pData, POINT *pptRegion, L_INT32 nNextPt, L_BOOL bErase) { CURVE Curve; POINT OutPoints[4], InPoints[4]; HPEN hPen, hPrevPen; HDC hDC; int nPrevROP2; L_INT nOutCount; if (nNextPt < 2) return; hDC = GetDC(pData->hBitmapWnd); if (hDC) { hPen = CreatePen(PS_SOLID, 1,RGB(255,255,255)); hPrevPen = SelectObject(hDC, hPen); nPrevROP2 = SetROP2(hDC, R2_XORPEN); Curve.uStructSize = sizeof(CURVE); //Curve.pOutPoints = OutPoints; //Curve.nOutCount = 4; Curve.nPointCount = 4; Curve.dTension = dCurveTension; Curve.nClose = CURVE_NO_CLOSE; Curve.nType = CURVE_STANDARD; //do the drawing if (nNextPt == 2) { MoveToEx(hDC, pptRegion[0].x, pptRegion[0].y, NULL); LineTo(hDC, pptRegion[1].x, pptRegion[1].y); } else if (nNextPt == 3) { DRAW_BEZIER_SEGMENT(2,0,1,2); //1st segment DRAW_BEZIER_SEGMENT(0,1,2,0); //2nd segment } else if (nNextPt == 4) { // DRAW_BEZIER_SEGMENT(3,0,1,2); //1st segment DRAW_BEZIER_SEGMENT(0,1,2,3); //2nd segment DRAW_BEZIER_SEGMENT(1,2,3,0); //3rd segment } else { int n = nNextPt - 5; //Draw new segments if (bErase) { DRAW_BEZIER_SEGMENT(nNextPt-1, 0, 1, 2); // 0th segment DRAW_BEZIER_SEGMENT(n+2,n+3,n+4, 0); //3rd segment } else { if (nNextPt == 5) DRAW_BEZIER_SEGMENT(n+0,n+1,n+2,n+3); //1st segment DRAW_BEZIER_SEGMENT(n+1,n+2,n+3,n+4); //2nd segment DRAW_BEZIER_SEGMENT(n+2,n+3,n+4, 0); //3rd segment DRAW_BEZIER_SEGMENT(nNextPt-1, 0, 1, 2); //new 0th segment } } //Restore the hDC SetROP2(hDC, nPrevROP2); SelectObject(hDC, hPrevPen); ReleaseDC(pData->hBitmapWnd, hDC); DeleteObject(hPen); } } /*--------------------------------------------------------------------------+ | Function :BmpWnd_OnLButtonDown | Desc :starts the drawing of the bitmap region | Return :void | Notes : +--------------------------------------------------------------------------*/ static VOID BmpWnd_OnLButtonDown (HWND hWnd, BOOL fDoubleClick, L_INT x, L_INT y,UINT keyFlags) { RECT rcClient; POINT pt; LPCHILDDATA pData; pData = LOCKCHILDDATA(GetParent(hWnd)); if(!GetCapture() && nRegionTool != IDM_TOOLNONE && !IsIconic(GetParent(hWnd)) && pData->ActiveBitmap.Flags.Allocated && !fInLoadFile && !fInProcess) { if (bEraseCurvePoints) { InvalidateRect(hWnd, NULL, FALSE); bEraseCurvePoints = FALSE; } GetClientRect(hWnd, &rcClient); IntersectRect(&rcClient, &rcClient, &pData->rcView); pt.x = x; pt.y = y; if(PtInRect(&rcClient, pt)) { /* 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->ActiveBitmap) && L_IsPtInBitmapRgn (&pData->ActiveBitmap, YClientToBitmap(pData,x,y), XClientToBitmap(pData,x,y))) { /* stop displaying the frame while dragging the region */ KillTimer(GetParent(hWnd), ID_REGIONEVENT); /* create the bitmaps needed to move the floater around If the floater was moved here, restore the background as well */ CreateRegionBitmaps(GetParent(hWnd)); pData->deltaX = pData->deltaY = 0; pData->xAnchor = x; pData->yAnchor = y; pData->bMovingFloater = TRUE; SetCapture(hWnd); } else { BOOL bBitmapHasRgn = L_BitmapHasRgn(&pData->ActiveBitmap); FreeRegionBitmaps(pData); if((nRegionTool == IDM_TOOLFREEHAND) || (nRegionTool == IDM_TOOLCURVE) || (nRegionTool == IDM_TOOLBEZIER) ) pptRegion = (LPPOINT) GlobalAllocPtr(GHND, (L_UINT32) sizeof(POINT) * MAXPOINTS); else pptRegion = (LPPOINT) GlobalAllocPtr(GHND, (L_UINT32) sizeof(POINT) * 2); if(pptRegion) { KillTimer(GetParent(hWnd), ID_REGIONEVENT); L_FreeBitmapRgn(&pData->ActiveBitmap); InvalidateRect(hWnd, NULL, FALSE); UpdateWindow(hWnd); if (((nRegionTool == IDM_TOOLBEZIER) || (nRegionTool == IDM_TOOLCURVE) ) && (!bBitmapHasRgn)) { bDrawingCurve = TRUE; DrawPoint(pData, x,y); } nNextPt = 0; pptRegion[nNextPt].x = x; pptRegion[nNextPt].y = y; nNextPt++; SetCapture(hWnd); SetStatusBarRegion(&pData->ActiveBitmap, pptRegion[0].x, pptRegion[0].y, x, y, &pData->rcView); } } } } else if(((nRegionTool == IDM_TOOLBEZIER) || (nRegionTool == IDM_TOOLCURVE)) && (bDrawingCurve)) { pptRegion[nNextPt].x = x; pptRegion[nNextPt].y = y; nNextPt++; DrawPoint(pData, x, y); if (nRegionTool == IDM_TOOLCURVE) { DrawCurveSegment(pData, pptRegion, nNextPt-1, TRUE); DrawCurveSegment(pData, pptRegion, nNextPt, FALSE); } else { DrawBezierSegment(pData, pptRegion, nNextPt); } } UNLOCKCHILDDATA(GetParent(hWnd)); } static VOID BmpWnd_OnRButtonDown(HWND hWnd, BOOL fDoubleClick, L_INT x, L_INT y,UINT keyFlags) { LPCHILDDATA pData; pData = LOCKCHILDDATA(GetParent(hWnd)); // if magnifying glass is running, exit if((GetCapture() == hWnd) && (!pData->bMagGlass)) { if (bEraseCurvePoints) { InvalidateRect(hWnd, NULL, FALSE); } if ((nNextPt < 4) && (nRegionTool == IDM_TOOLBEZIER)) { MessageBox(hWnd, TEXT("There must be at least 4 points to draw a bezier"), TEXT(""), MB_OK); InvalidateRect(hWnd, NULL, FALSE); } else if ((nNextPt < 3) && (nRegionTool == IDM_TOOLCURVE)) { MessageBox(hWnd, TEXT("There must be at least 3 points to draw a curve"), TEXT(""), MB_OK); InvalidateRect(hWnd, NULL, FALSE); } bDrawingCurve = FALSE; bEraseCurvePoints = TRUE; if ((nRegionTool == IDM_TOOLBEZIER) || (nRegionTool == IDM_TOOLCURVE)) { InvalidateRect(hWnd, NULL, FALSE); UpdateWindow(hWnd); } BmpWnd_OnLButtonUp(hWnd, x,y , keyFlags); } UNLOCKCHILDDATA(GetParent(hWnd)); } /*--------------------------------------------------------------------------+ | Function :BmpWnd_OnLButtonUp | Desc :end the drawing of the bitmap region | Return :void | Notes : +--------------------------------------------------------------------------*/ static VOID BmpWnd_OnLButtonUp (HWND hWnd, int x, int y, UINT keyFlags) { LPCHILDDATA pData; RGNXFORM XForm; L_INT nRet; RECT rc; HCURSOR hOldCursor; L_INT nOrigX, nOrigY, nOrigWidth, nOrigHeight; L_INT32 dwValue; if (((nRegionTool == IDM_TOOLBEZIER) || (nRegionTool == IDM_TOOLCURVE) ) && (bDrawingCurve)) return; pData = LOCKCHILDDATA(GetParent(hWnd)); 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(&rc, pData->xMoveSrc, pData->yMoveSrc, pData->xMoveSrc + pData->nMoveWidth - 1, pData->yMoveSrc + pData->nMoveHeight - 1); /* change it to display coordinates */ L_RectFromBitmap(&pData->ActiveBitmap, TOP_LEFT, &rc); /* 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->ActiveBitmap); if( pData->deltaX < 0 ) /* favor the moving to the left */ dwValue -= RECTWIDTH(&pData->rcView) - 1; OffsetRect(&rc, (L_INT)(dwValue/RECTWIDTH(&pData->rcView)), 0); dwValue = (L_INT32)pData->deltaY * BITMAPHEIGHT(&pData->ActiveBitmap); if( pData->deltaY < 0 ) /* favor the moving to the top */ dwValue -= RECTHEIGHT(&pData->rcView) - 1; OffsetRect(&rc, 0, (L_INT)(dwValue / RECTHEIGHT(&pData->rcView))); /* now rc contains the coordinates in TOP_LEFT ViewPerspective. Change them in bitmap's ViewPerspective */ L_RectToBitmap(&pData->ActiveBitmap, TOP_LEFT, &rc); /* now I can update pData->xMoveSrc and pData->yMoveSrc */ nOrigX = pData->xMoveSrc = rc.left; /* save these coordinates for the combine later on */ nOrigY = pData->yMoveSrc = rc.top; /* SafeCopyBitmapRect might change them */ nOrigWidth = pData->nMoveWidth; nOrigHeight = pData->nMoveHeight; /* save the background */ SafeCopyBitmapRect( &pData->bmSave, &pData->ActiveBitmap, &pData->xMoveSrc, &pData->yMoveSrc, &pData->nMoveWidth, &pData->nMoveHeight ); pData->xSaveSrc=pData->xMoveSrc; pData->ySaveSrc=pData->yMoveSrc; /* set up the transform structure. */ XForm.uViewPerspective = pData->ActiveBitmap.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->ActiveBitmap, &XForm, pData->hrgnRegion, L_RGN_SET ); SetRect(&rc, nOrigX, nOrigY, nOrigX + nOrigWidth, nOrigY + nOrigHeight); L_RectFromBitmap(&pData->ActiveBitmap, TOP_LEFT, &rc); /* copy the floater bitmap to the new position */ L_CombineBitmap( &pData->ActiveBitmap, rc.left, rc.top, RECTWIDTH(&rc), RECTHEIGHT(&rc), &pData->bmFloater, 0, 0, L_SRCCOPY ); /* and we can still move */ InvalidateRect (hWnd, NULL, FALSE); UpdateWindow (hWnd); SetTimer(GetParent(hWnd), ID_REGIONEVENT, REGIONEVENTDELAY, NULL); /* outline the region without waiting for the WM_TIMER message */ OutlineBitmapRgn(GetParent(hWnd), NULL); DisplayImageStatus (GetParent(hWnd)); L_GetBitmapRgnArea(&pData->ActiveBitmap,&uArea); if(!uArea) { KillTimer(hWnd, ID_REGIONEVENT); FreeRegionBitmaps(pData); L_FreeBitmapRgn(&pData->ActiveBitmap); } ReleaseCapture(); SetCursor(hOldCursor); } else { hOldCursor = SetCursor(LoadCursor(NULL,IDC_WAIT)); HiliteMark(GetParent(hWnd), FALSE); if(nNextPt > 1) { XForm.uViewPerspective = TOP_LEFT; XForm.nXScalarNum = BITMAPWIDTH(&pData->ActiveBitmap); XForm.nYScalarNum = BITMAPHEIGHT(&pData->ActiveBitmap); XForm.nXScalarDen = RECTWIDTH(&pData->rcView); XForm.nYScalarDen = RECTHEIGHT(&pData->rcView); XForm.nXOffset = -pData->rcView.left; XForm.nYOffset = -pData->rcView.top; switch(nRegionTool) { case IDM_TOOLRECT: SetRect(&rc, 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->ActiveBitmap, &XForm, &rc, L_RGN_SET); break; case IDM_TOOLRNDRECT: SetRect(&rc, 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->ActiveBitmap, &XForm, &rc, abs(pptRegion[0].x - pptRegion[1].x) / 4, abs(pptRegion[0].y - pptRegion[1].y) / 4, L_RGN_SET); break; case IDM_TOOLELLIPSE: SetRect(&rc, 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->ActiveBitmap, &XForm, &rc, L_RGN_SET); break; case IDM_TOOLFREEHAND: nRet = L_SetBitmapRgnPolygon(&pData->ActiveBitmap, &XForm, pptRegion, nNextPt, L_POLY_WINDING, L_RGN_SET); break; case IDM_TOOLCURVE: { CURVE Curve; Curve.uStructSize = sizeof(CURVE); Curve.nType = CURVE_STANDARD; Curve.nPointCount = nNextPt; Curve.pPoints = pptRegion; Curve.uFillMode = L_POLY_WINDING; Curve.dTension = dCurveTension; Curve.nClose = nCurveClose; //rgnCurve.nClose = CURVE_NO_CLOSE; //HOPKINS remove and use line above nRet = L_SetBitmapRgnCurve( &pData->ActiveBitmap, &XForm, &Curve, L_RGN_SET); } break; case IDM_TOOLBEZIER: { CURVE Curve; Curve.uStructSize = sizeof(CURVE); //Point count must be f(x) = 3x + 1 where x = 1,2,3,... Curve.nType = CURVE_BEZIER; Curve.nPointCount = nNextPt - (nNextPt - 1)%3; //if (rgnCurve.nPointCount < 4) //{ // MessageBox(hWnd, TEXT("There must be at least 4 points to draw a bezier"), TEXT(""), MB_OK); // InvalidateRect(hWnd, NULL, FALSE); //} Curve.pPoints = pptRegion; Curve.uFillMode = L_POLY_WINDING; nRet = L_SetBitmapRgnCurve( &pData->ActiveBitmap, &XForm, &Curve, L_RGN_SET); } break; } if(nRet == SUCCESS) { L_GetBitmapRgnBounds(&pData->ActiveBitmap, NULL, &rc); L_CopyBitmapRect(&pData->bmSave, &pData->ActiveBitmap, sizeof(BITMAPHANDLE), rc.left, rc.top, RECTWIDTH(&rc), RECTHEIGHT(&rc)); pData->xSaveSrc=rc.left; pData->ySaveSrc=rc.top; SetTimer(GetParent(hWnd), ID_REGIONEVENT, REGIONEVENTDELAY, NULL); } } OutlineBitmapRgn(GetParent(hWnd), NULL); ReleaseCapture (); GlobalFreePtr(pptRegion); pptRegion = NULL; DisplayImageStatus (GetParent(hWnd)); SetCursor(hOldCursor); } } UNLOCKCHILDDATA(GetParent(hWnd)); } /*--------------------------------------------------------------------------+ | Function :BmpWnd_OnMouseMove | Desc :moves the drawn region or contiues drawing the region | Return :void | Notes : +--------------------------------------------------------------------------*/ static VOID BmpWnd_OnMouseMove (HWND hWnd, int x, int y, UINT keyFlags) { LPCHILDDATA pData; pData = LOCKCHILDDATA (GetParent(hWnd)); if( (GetCapture() == hWnd) && (!pData->bMagGlass)) { if( pData->bMovingFloater ) MoveFloater(GetParent(hWnd), pData, x, y); else { switch(nRegionTool) { case IDM_TOOLBEZIER: case IDM_TOOLCURVE: //Do nothing break; case IDM_TOOLFREEHAND: if(nNextPt < MAXPOINTS) { pptRegion[nNextPt].x = x; pptRegion[nNextPt].y = y; nNextPt++; } break; default: HiliteMark(GetParent(hWnd), FALSE); pptRegion[1].x = x; pptRegion[1].y = y; nNextPt = 2; break; } HiliteMark(GetParent(hWnd), TRUE); SetStatusBarRegion(&pData->ActiveBitmap, pptRegion[0].x, pptRegion[0].y, x, y, &pData->rcView); } } UNLOCKCHILDDATA(GetParent(hWnd)); } /*====(Child_OnPaint)====================================================== Description: Paints the child window. Syntax : VOID Child_OnPaint(HWND hWnd) Parameters : hWnd Handle of the child window. Return Value: None. ==========================================================================*/ static VOID Child_OnPaint (HWND hWnd) { LPCHILDDATA pData=LOCKCHILDDATA(hWnd); PAINTSTRUCT ps; RECT rcListBox,Rect; HPEN hOldPen; GetClientRect(hWnd,&Rect); InvalidateRect(hWnd,0,TRUE); BeginPaint(hWnd,&ps); if(pData) if(IsWindow(pData->hListBox)) { GetWindowRect(pData->hListBox,&rcListBox); MapWindowPoints(0,hWnd,(LPPOINT)&rcListBox,2); rcListBox.right-=rcListBox.left; rcListBox.bottom-=rcListBox.top; hOldPen=SelectObject(ps.hdc,GetStockObject(WHITE_PEN)); MoveToEx(ps.hdc,rcListBox.right+SPLITWIDTH-1,0,0); LineTo(ps.hdc,rcListBox.right,0); LineTo(ps.hdc,rcListBox.right,Rect.bottom); SelectObject(ps.hdc,GetStockObject(BLACK_PEN)); MoveToEx(ps.hdc,rcListBox.right+SPLITWIDTH-1,0,0); LineTo(ps.hdc,rcListBox.right+SPLITWIDTH-1,Rect.bottom-1); LineTo(ps.hdc,rcListBox.right,Rect.bottom-1); SelectObject(ps.hdc,hOldPen); } UNLOCKCHILDDATA(hWnd); ValidateRect(hWnd,0); EndPaint(hWnd,&ps); } /*--------------------------------------------------------------------------+ | Function :BmpWnd_OnPaint | Desc :displays the bitmap | Return :void | Notes : +--------------------------------------------------------------------------*/ static VOID BmpWnd_OnPaint (HWND hWnd) { PAINTSTRUCT ps; HPALETTE hPalette = NULL; LPCHILDDATA pData; L_UINT32 ulFlags; BeginPaint (hWnd, &ps); pData = LOCKCHILDDATA (GetParent(hWnd)); if (pData->ActiveBitmap.Flags.Allocated && !fInLoadFile) { if (pData->hPalette) { hPalette = SelectPalette (ps.hdc, pData->hPalette,TRUE); RealizePalette(ps.hdc); } ulFlags = L_GetDisplayMode (); switch (nDitherMode) { case IDM_ORDEREDDITHERING: L_SetDisplayMode (DISPLAYMODE_ORDEREDDITHER, DISPLAYMODE_ORDEREDDITHER); break; case IDM_ERRORDIFFUSION: L_SetDisplayMode (DISPLAYMODE_ORDEREDDITHER, 0); break; } L_SetDisplayMode (DISPLAYMODE_FAVORBLACK|DISPLAYMODE_SCALETOGRAY, nBitonalFlags); // set the linear interpolation or bicubic resample during paint L_SetDisplayMode(DISPLAYMODE_RESAMPLE|DISPLAYMODE_BICUBIC, nPaintResizeFlags); if(nPaletteMode == IDM_PALETTEFIXED) L_SetDisplayMode (DISPLAYMODE_FIXEDPALETTE, DISPLAYMODE_FIXEDPALETTE); if(fNetscapePalette) L_SetDisplayMode (DISPLAYMODE_NETSCAPEPALETTE, DISPLAYMODE_NETSCAPEPALETTE); pData->ulPanDisFlags = L_GetDisplayMode(); L_PaintDC (ps.hdc, &pData->ActiveBitmap, NULL, NULL, &pData->rcView, &ps.rcPaint, SRCCOPY ); L_SetDisplayMode (DISPLAYMODE_RESETPOSITIONS, ulFlags); if (pData->hPalette) SelectPalette (ps.hdc, hPalette, TRUE); OutlineBitmapRgn(GetParent(hWnd), ps.hdc); #ifdef USE_LEADTOOLS_FRAME { RECT rc, rc2; HFONT hFont; HDC hdcMem; HBITMAP hbmMem; rc = pData->rcView; hFont = CreateFont (-MulDiv(32, GetDeviceCaps(ps.hdc, LOGPIXELSY), 72), 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH, "Arial"); L_EfxDrawFrame(ps.hdc, &rc, EFX_FRAME_ADJUST_RECT | EFX_FRAME_OUTER_RAISED, 5, RGB(192, 192, 192), 5, RGB(128, 128, 128), RGB(255, 255, 255), 5, RGB(128, 128, 128), RGB(255, 255, 255)); rc2 = rc; OffsetRect(&rc2, -rc2.left, -rc2.top); hdcMem = CreateCompatibleDC(ps.hdc); hbmMem = CreateCompatibleBitmap(ps.hdc, rc2.right, rc2.bottom); hbmMem = SelectObject(hdcMem, hbmMem); L_EfxGradientFillRect(hdcMem, &rc2, EFX_GRADIENT_LINE_L_TO_R, RGB(255, 0, 0), RGB(0, 0, 255), 16); BitBlt(hdcMem, 0, 0, rc2.right, rc2.bottom, ps.hdc, rc.left, rc.top, SRCCOPY); L_EfxDrawRotated3dText(ps.hdc, "LEADTOOLS", &rc, 300, EFX_TEXT_OUTLINEBLOCK | EFX_TEXT_HCENTER, 5, 5, RGB(255, 0, 0), RGB(0, 0, 0), RGB(255, 255, 255), hFont, hdcMem); DeleteObject(hFont); DeleteObject(SelectObject(hdcMem, hbmMem)); DeleteDC(hdcMem); } #endif //FORPANWINDOW //UPDATE THE PAN WINDOW if(pData->bUpdatePan && pData->bPanWindow) L_UpdatePanWindow(pData->hPanWindow, &pData->ActiveBitmap, pData->ulPanDisFlags, RGB(255,0,0), TEXT("Pan Window"), &pData->rcView ); else pData->bUpdatePan = TRUE; //END } UNLOCKCHILDDATA (GetParent(hWnd)); EndPaint (hWnd, &ps); return; } typedef struct _SETDUPTITLECOUNTSTRUCT { L_BOOL fRemove; HWND hWnd; L_UINT uCountLast; HWND hWndLast; } SETDUPTITLECOUNTSTRUCT, L_FAR *LPSETDUPTITLECOUNTSTRUCT; /*--------------------------------------------------------------------------+ | Function :SetDupTitleCountCB | Desc :tests for duplicate titles | Return :TRUE : success | Notes : +--------------------------------------------------------------------------*/ L_BOOL CALLBACK L_EXPORT SetDupTitleCountCB (HWND hWnd, LPARAM lParam) { LPCHILDDATA pData1; LPCHILDDATA pData2; LPSETDUPTITLECOUNTSTRUCT pdts = (LPSETDUPTITLECOUNTSTRUCT) lParam; if(GetParent(hWnd)!=hWndClient) return(TRUE); if (GetWindow (hWnd, GW_OWNER)) return(TRUE); if(hWnd == pdts->hWnd) return(TRUE); pData1 = LOCKCHILDDATA(pdts->hWnd); pData2 = LOCKCHILDDATA(hWnd); if((pData1==0)||(pData2==0)) return(TRUE); if(!sicmp(pData1->szTitle, pData2->szTitle)) { if(pdts->fRemove) { if(pData2->uTitleCount > pData1->uTitleCount) { pData2->uTitleCount--; DisplayImageTitle (hWnd); } if(pData2->uTitleCount > pdts->uCountLast) { pdts->uCountLast = pData2->uTitleCount; pdts->hWndLast = hWnd; } } else { pdts->uCountLast++; pdts->hWndLast = hWnd; } } UNLOCKCHILDDATA(hWnd); UNLOCKCHILDDATA(pdts->hWnd); return(TRUE); } /*--------------------------------------------------------------------------+ | Function :SetDupTitleCountCB | Desc :tests for duplicate titles | Return : | Notes : +--------------------------------------------------------------------------*/ static L_VOID SetDupTitleCount(HWND hWnd, L_BOOL fRemove) { LPCHILDDATA pData; SETDUPTITLECOUNTSTRUCT dts; dts.hWnd = hWnd; dts.fRemove = fRemove; dts.uCountLast = 0; dts.hWndLast = NULL; EnumChildWindows(hWndClient, (WNDENUMPROC) SetDupTitleCountCB, (LPARAM) (LPSETDUPTITLECOUNTSTRUCT) &dts); if(fRemove) { if(dts.uCountLast == 1) { pData = LOCKCHILDDATA(dts.hWndLast); pData->uTitleCount = 0; DisplayImageTitle (dts.hWndLast); UNLOCKCHILDDATA(dts.hWndLast); } } else { if(dts.uCountLast) { if(dts.uCountLast == 1) { pData = LOCKCHILDDATA(dts.hWndLast); pData->uTitleCount = dts.uCountLast; DisplayImageTitle (dts.hWndLast); UNLOCKCHILDDATA(dts.hWndLast); } pData = LOCKCHILDDATA(hWnd); pData->uTitleCount = dts.uCountLast + 1; DisplayImageTitle (hWnd); UNLOCKCHILDDATA(hWnd); } else { pData = LOCKCHILDDATA(hWnd); pData->uTitleCount = 0; DisplayImageTitle (hWnd); UNLOCKCHILDDATA(hWnd); } } } L_INT L_EXPORT EXT_CALLBACK SliceDemoCB ( pBITMAPHANDLE pBitmap, LPRECT lpSliceRect, L_INT nAngle, L_VOID L_FAR * pUserData ) { pBITMAPHANDLE pSliceBitmap; pSliceBitmap = (pBITMAPHANDLE)pUserData; if(!L_BitmapHasRgn(pSliceBitmap)) L_SetBitmapRgnRect(pSliceBitmap, NULL, lpSliceRect, L_RGN_SET); else L_SetBitmapRgnRect(pSliceBitmap, NULL, lpSliceRect, L_RGN_XOR); L_FreeBitmap(pBitmap); GlobalFree(pBitmap); return SUCCESS; } L_INT SliceBitmapDemo(HWND hWnd, pBITMAPHANDLE pBitmap) { SLICEBITMAPOPTIONS Options; L_INT nRet; Options.uStructSize = sizeof(SLICEBITMAPOPTIONS); // Deskew the sliced image, the deskew angle is located between -5 and 5 degrees Options.uFlags = SLC_DESKEW|SLC_DSKW_LINEAR; Options.uMaxDeskewAngle = 500; Options.crFill = RGB(0,0,0); L_FreeBitmapRgn(pBitmap); nRet = L_SliceBitmap(pBitmap, &Options, NULL, SliceDemoCB, (L_VOID L_FAR *)(pBitmap)); if(nRet != SUCCESS) MessageBox (hWnd, TEXT("Error occurred while trying to slice bitmap"), TEXT("ERROR"), MB_OK); return nRet; } L_BOOL CALLBACK SliceDlgProc(HWND hWnd,UINT message, WPARAM wParam, LPARAM lParam) { switch(message) { case WM_CLOSE: EndDialog (hWnd, 0); return TRUE; case WM_COMMAND: switch(LOWORD (wParam)) { case IDCANCEL: case IDOK: EndDialog(hWnd , IDCANCEL - LOWORD (wParam)); return TRUE; } break; } return FALSE ; } /*====(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. ==========================================================================*/ static BOOL Child_OnCreate (HWND hWnd, CREATESTRUCT FAR * lpCreateStruct) { HANDLE hMem; LPCREATEDATA pCreateData; LPCHILDDATA pData; FILEINFO fi; L_BOOL bShowThumbnails=(GetMenuState(GetMenu(hWndFrame),IDM_THUMBNAILS,MF_BYCOMMAND)&MF_CHECKED)>0; pCreateData = (LPCREATEDATA) CHILDCREATELPARAM (lpCreateStruct); hMem = GlobalAlloc (GHND, sizeof (CHILDDATA)); SETCHILDDATA (hWnd, hMem); if(!hMem) return(FALSE); pData = LOCKCHILDDATA (hWnd); pData->nCurrentPage=nCurrentPage; lstrcpy (pData->szTitle, pCreateData->pszTitle); SetDupTitleCount(hWnd, FALSE); L_CopyBitmapHandle ( &pData->Bitmap, pCreateData->pBitmap, sizeof ( BITMAPHANDLE ) ) ; pData->ActiveBitmap = pData->Bitmap; _fmemset(pCreateData->pBitmap, 0, sizeof(BITMAPHANDLE)); pData->hList = pCreateData->hList; pData->fLoop = pCreateData->fLoop; L_GetBitmapListCount(pData->hList, &pData->uLastFrame); pData->uLastFrame--; pData->uFrame = 0; PostFrameChange(hWnd); pData->bGifAnimationFile=(pCreateData->bGifAnimationFile); pData->hbmSave = (HBITMAP)NULL; pData->hbmFloater = (HBITMAP)NULL; pData->bMovingFloater = FALSE; pData->hrgnRegion = pData->hrgnFloater = NULL; pData->nZoom=100; //if a new file is opened and we haven't already loaded all the pages if(pCreateData->bIsFile && !pData->hList) { if( fTotalPages ) { LoadFileOption.PageNumber = 32000; //get number of pages in the file L_FileInfo(pData->szTitle,&fi,sizeof(FILEINFO),FILEINFO_TOTALPAGES,&LoadFileOption); //if multi page file then we can display thumbnails } else fi.PageNumber = 1; bShowThumbnails&=(fi.PageNumber>1); //create the bitmap window that will contain the viewed image pData->hBitmapWnd=CreateWindow(szBitmapWndClass,0, WS_VISIBLE|WS_CHILD|WS_HSCROLL|WS_VSCROLL, (bShowThumbnails)? LISTBOXWIDTH+GetSystemMetrics(SM_CXVSCROLL)+1:0,0, 100,100, hWnd,(HMENU)1000,hInst,0); if(pData->hBitmapWnd) { if(fi.PageNumber>1) //if multipage file { //then create the thumbnail window pData->hListBox=CreateWindow(TEXT("LISTBOX"),0, LBS_NOTIFY|WS_VSCROLL|WS_CHILD|LBS_NOINTEGRALHEIGHT|LBS_OWNERDRAWFIXED/*|LBS_DISABLENOSCROLL|LBS_MULTICOLUMN*/, 0,0, LISTBOXWIDTH+GetSystemMetrics(SM_CXVSCROLL),100, hWnd,(HMENU)IDC_LISTBOX,hInst,0); if(pData->hListBox) { //fill the listbox with thumbnail images FillImageListBox(pData->hListBox,pData->szTitle,TRUE); SetThumbnails(hWnd,bShowThumbnails); if(GETCOUNT(pData->hListBox)==0) { UNLOCKCHILDDATA(hWnd); return(FALSE); } } } } else { UNLOCKCHILDDATA(hWnd); return(FALSE); } } else //if not a file then create the bitmap window only if((pData->hBitmapWnd=CreateWindow(szBitmapWndClass,0, WS_VISIBLE|WS_CHILD|WS_HSCROLL|WS_VSCROLL, 0,0,100,100,hWnd,(HMENU)1000,hInst,0))!=0) { if(pData->hList) { pData->hListBox=CreateWindow(TEXT("LISTBOX"),0, LBS_NOTIFY|WS_VSCROLL|WS_CHILD|LBS_NOINTEGRALHEIGHT|LBS_OWNERDRAWFIXED/*|LBS_DISABLENOSCROLL|LBS_MULTICOLUMN*/, 0,0, LISTBOXWIDTH+GetSystemMetrics(SM_CXVSCROLL),100, hWnd,(HMENU)IDC_LISTBOX,hInst,0); if(pData->hListBox) { //fill the listbox with thumbnail images CreateThumbnailsFromBList(hWnd); SetThumbnails(hWnd,bShowThumbnails); } } } else { UNLOCKCHILDDATA(hWnd); return(FALSE); } UNLOCKCHILDDATA(hWnd); FORWARD_WM_CREATE(hWnd, lpCreateStruct, DefMDIChildProc); return(TRUE); } #define DO_SNAP 0x1 #define DO_SIZE 0x2 #define DO_FIT 0x4 /*--------------------------------------------------------------------------+ | Function :FixChildSize | Desc :fixes the size of the child window to include as much of the image as posible | Return : | Notes : +--------------------------------------------------------------------------*/ static VOID FixChildSize(HWND hChildWnd) { LPCHILDDATA pData; RECT rcChild,rcTemp; L_UINT nToDo=0; L_INT nBmpWndH; L_INT nListBoxW=0,nChildClientX=0; L_INT nClientW,nClientH; pData=LOCKCHILDDATA(hChildWnd); if(pData) if(pData->bSizeFixed==FALSE) { pData->bSizeFixed=TRUE; //get MDI client window width & height GetClientRect(hWndClient,&rcTemp); nClientW=rcTemp.right; nClientH=rcTemp.bottom; //get child window rectangle GetWindowRect(hChildWnd,&rcChild); MapWindowPoints(0,hWndClient,(LPPOINT)&rcChild,2); rcChild.right-=rcChild.left; rcChild.bottom-=rcChild.top; GetClientRect(hChildWnd,&rcTemp); MapWindowPoints(hChildWnd,hWndClient,(LPPOINT)&rcTemp,1); nChildClientX=rcTemp.left; //get bitmap window height GetWindowRect(pData->hBitmapWnd,&rcTemp); MapWindowPoints(0,hWndClient,(LPPOINT)&rcTemp,2); nBmpWndH=rcTemp.bottom-rcTemp.top; //get thumbnails listbox width & x position if(IsWindow(pData->hListBox)&&pData->bListBoxVisible) { GetWindowRect(pData->hListBox,&rcTemp); MapWindowPoints(0,hWndClient,(LPPOINT)&rcTemp,2); nListBoxW=rcTemp.right-rcTemp.left+SPLITWIDTH; } //calculate the needed size of the chile window in order //to display the loaded image in full size view rcChild.right=BITMAPWIDTH(&pData->ActiveBitmap)+ ((nChildClientX-rcChild.left)<<1)+nListBoxW; rcChild.bottom=BITMAPHEIGHT(&pData->ActiveBitmap)+ (rcChild.bottom-nBmpWndH); //if the height of the child window is greater than client height //then restrict it to MDI client window height if(rcChild.bottom>nClientH) { rcChild.top=0; rcChild.bottom=nClientH; nToDo=DO_FIT|DO_SIZE; } else nToDo|=DO_SNAP; //if the width of the child window is greater than client width //then restrict it to MDI client window width if(rcChild.right>nClientW) { rcChild.left=0; rcChild.right=nClientW; nToDo=DO_FIT|DO_SIZE; } else nToDo|=DO_SNAP; //if the child window is not totaly visible then recalculate //a new x,y position for it if((rcChild.top+rcChild.bottom)>nClientH) { rcChild.top-=((rcChild.top+rcChild.bottom)-nClientH); nToDo|=DO_SIZE; } if((rcChild.left+rcChild.right)>nClientW) { rcChild.left-=((rcChild.left+rcChild.right)-nClientW); nToDo|=DO_SIZE; } if(nToDo&DO_SIZE) //if to resize the child window MoveWindow(hChildWnd,rcChild.left,rcChild.top,rcChild.right,rcChild.bottom,FALSE); if(nToDo&DO_FIT) //if to fit the image in the child window Child_OnCommand(hChildWnd,IDM_FITIMAGE,0,0); else if(nToDo&DO_SNAP) //if to snap the child window to image { if(pData->ActiveBitmap.Flags.Allocated) SizeClientRect(hChildWnd,BITMAPWIDTH(&pData->ActiveBitmap),BITMAPHEIGHT(&pData->ActiveBitmap)); } } UNLOCKCHILDDATA(hChildWnd); } /*====(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 BOOL BmpWnd_OnEraseBkgnd (HWND hWnd, HDC hDC) { HGDIOBJ hBrush; HRGN hClientRgn, hFillRgn; RECT rcView, rcClient; LPCHILDDATA pData; pData = LOCKCHILDDATA (GetParent(hWnd)); if (IsIconic(GetParent(hWnd))) hBrush = GetStockObject (BLACK_BRUSH); else hBrush = GETHBRBACKGROUND (hWnd); GetClientRect (hWnd, &rcClient); GetUpdateRect(hWnd, &rcView,0); if (fInScroll || pData->ActiveBitmap.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 (GetParent(hWnd)); return(TRUE); } /*====(Child_OnSize)======================================================= Description: Responds to WM_SIZE message and sets the internal data accordingly. Also forwards the message to DefMDIChildProc. Syntax : VOID Child_OnSize(HWND hWnd, UINT nState, int nCx, 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. ==========================================================================*/ static VOID Child_OnSize (HWND hWnd, UINT nState, int nCx, int nCy) { LPCHILDDATA pData=LOCKCHILDDATA(hWnd); ResizeChildBitmapWindows(hWnd); FixChildSize(hWnd); //FORPANWINDOW if(pData->hPanWindow) if(nState == SIZE_MINIMIZED) ShowWindow(pData->hPanWindow, SW_HIDE); pData = LOCKCHILDDATA (hWnd); if( pData->bMagGlass ) { StopMagGlass( pData ); StartMagGlass( pData ); } UNLOCKCHILDDATA(hWnd); FORWARD_WM_SIZE(hWnd,nState,nCx,nCy,DefMDIChildProc); } /*--------------------------------------------------------------------------+ | Function :BmpWnd_OnSize | Desc :handles the changes in size in the bitmap window | Return : | Notes : +--------------------------------------------------------------------------*/ static VOID BmpWnd_OnSize (HWND hWnd, UINT nState, int nCx, int nCy) { LPCHILDDATA pData=LOCKCHILDDATA(GetParent(hWnd)); Child_ProcessSize (GetParent(hWnd),nState,nCx,nCy); if((pData->fFitImage==TRUE)&&(pData->nZoom==100)) InvalidateRect(hWnd,0,TRUE); if( pData->bMagGlass ) L_UpdateMagGlassRect(pData->hBitmapWnd, &pData->rcView); UNLOCKCHILDDATA(GetParent(hWnd)); } /*====(BmpWnd_OnHScroll)==================================================== Description: Scrolls the child window horizontally. Syntax : VOID BmpWnd_OnHScroll(HWND hWnd, HWND hWndCtl, UINT nCode, 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 VOID BmpWnd_OnHScroll (HWND hWnd, HWND hWndCtl, UINT nCode, int nPos) { LPCHILDDATA pData; L_INT nScrollInc; UNREFERENCED_PARAMETER(hWndCtl); pData = LOCKCHILDDATA(GetParent(hWnd)); fInScroll = TRUE; switch (nCode) { case SB_LEFT: nScrollInc = -pData->nHScrollPos; break; case SB_RIGHT: nScrollInc = pData->nHScrollMax - pData->nHScrollPos; break; case SB_LINELEFT: nScrollInc = -pData->nHScrollStep; break; case SB_LINERIGHT: nScrollInc = pData->nHScrollStep; break; case SB_PAGELEFT: nScrollInc = -max (pData->nHScrollStep, (pData->cxClient - pData->nHScrollStep)); break; case SB_PAGERIGHT: nScrollInc = max (pData->nHScrollStep, (pData->cxClient - pData->nHScrollStep)); break; case SB_THUMBTRACK: case SB_THUMBPOSITION: nScrollInc = (nPos << pData->nHScrollFactor) - pData->nHScrollPos; break; default: nScrollInc = 0; break; } nScrollInc = max (-pData->nHScrollPos, min (nScrollInc, (pData->nHScrollMax - pData->nHScrollPos))); if(nScrollInc) { pData->nHScrollPos += nScrollInc; OffsetRect (&pData->rcView, -nScrollInc, 0); ScrollWindow (hWnd, -nScrollInc, 0, NULL, NULL); SetScrollPos (hWnd, SB_HORZ, pData->nHScrollPos >> pData->nHScrollFactor, TRUE); UpdateWindow (hWnd); } if( pData->bMagGlass ) L_UpdateMagGlassRect(pData->hBitmapWnd, &pData->rcView); UNLOCKCHILDDATA (GetParent(hWnd)); fInScroll = FALSE; } /*====(BmpWnd_OnVScroll)==================================================== Description: Scrolls the child window vertically. Syntax : VOID BmpWnd_OnVScroll(HWND hWnd, HWND hWndCtl, UINT nCode, 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 VOID BmpWnd_OnVScroll (HWND hWnd, HWND hWndCtl, UINT nCode, int nPos) { L_INT nScrollInc; LPCHILDDATA pData; UNREFERENCED_PARAMETER(hWndCtl); fInScroll = TRUE; pData = LOCKCHILDDATA (GetParent(hWnd)); 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->nVScrollFactor) - 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 >> pData->nVScrollFactor, TRUE); UpdateWindow (hWnd); } if( pData->bMagGlass ) L_UpdateMagGlassRect(pData->hBitmapWnd, &pData->rcView); UNLOCKCHILDDATA (GetParent(hWnd)); fInScroll = FALSE; } /*====(BmpWnd_OnKey)======================================================== Description: Responds to the virtual keys. Syntax : VOID BmpWnd_OnKey(HWND hWnd, UINT vk, BOOL fDown, int cRepeat, UINT flags) Parameters : hWnd Handle to the child window. vk Virtual key code. fDown Is the key down or up. cRepeat Not used. flags Not used. Return Value: None. ==========================================================================*/ static VOID BmpWnd_OnKey (HWND hWnd, UINT vk, BOOL fDown, int cRepeat, UINT flags) { UNREFERENCED_PARAMETER(cRepeat); UNREFERENCED_PARAMETER(flags); if (fDown) { switch (vk) { case VK_ESCAPE: fKillProgress = TRUE; break; case VK_HOME: FORWARD_WM_VSCROLL (hWnd, 0, SB_TOP, 0, SendMessage); break; case VK_END: FORWARD_WM_VSCROLL (hWnd, 0, SB_BOTTOM, 0, SendMessage); break; case VK_PRIOR: FORWARD_WM_VSCROLL (hWnd, 0, SB_PAGEUP, 0, SendMessage); break; case VK_NEXT: FORWARD_WM_VSCROLL (hWnd, 0, SB_PAGEDOWN, 0, SendMessage); break; case VK_UP: FORWARD_WM_VSCROLL (hWnd, 0, SB_LINEUP, 0, SendMessage); break; case VK_DOWN: FORWARD_WM_VSCROLL (hWnd, 0, SB_LINEDOWN, 0, SendMessage); break; case VK_LEFT: FORWARD_WM_HSCROLL (hWnd, 0, SB_LINELEFT, 0, SendMessage); break; case VK_RIGHT: FORWARD_WM_HSCROLL (hWnd, 0, SB_LINERIGHT, 0, SendMessage); break; } } } /*====(Child_OnKey)======================================================== Description: Responds to the virtual keys. Syntax : VOID Child_OnKey(HWND hWnd, UINT vk, BOOL fDown, int cRepeat, UINT flags) Parameters : hWnd Handle to the child window. vk Virtual key code. fDown Is the key down or up. cRepeat Not used. flags Not used. Return Value: None. ==========================================================================*/ static VOID Child_OnKey (HWND hWnd, UINT vk, BOOL fDown, int cRepeat, UINT flags) { UNREFERENCED_PARAMETER(cRepeat); UNREFERENCED_PARAMETER(flags); if((fDown)&&(vk==VK_ESCAPE)) fKillProgress=TRUE; return; } typedef struct tagREMAPHUEDATA { pBITMAPHANDLE pBitmap; COLORREF crStartColor; COLORREF crReplaceColor; COLORREF crMouseMoveColor; L_UCHAR uHStart; L_UCHAR uSStart; L_UCHAR uVStart; L_UCHAR uAngleRange; L_UCHAR uHEnd; L_UCHAR uSEnd; L_UCHAR uVEnd; } REMAPHUEDATA, L_FAR *LPREMAPHUEDATA; void ResetRemapHueData(LPREMAPHUEDATA pData) { pData->crStartColor =255; pData->crReplaceColor =255; pData->crMouseMoveColor =0; pData->uHStart =0; pData->uSStart =255; pData->uVStart =255; pData->uAngleRange =0; pData->uHEnd =0; pData->uSEnd =255; pData->uVEnd =255; } L_VOID PaintButton(HWND hwnd,COLORREF ColorRef ) { HBRUSH hNewBrush,hOldBrush; HDC hdc; RECT rect; hdc=GetDC (hwnd); GetClientRect(hwnd, &rect); hNewBrush = CreateSolidBrush (ColorRef); hOldBrush = (HBRUSH) SelectObject (hdc, hNewBrush); Rectangle (hdc, rect.left, rect.top, rect.right, rect.bottom); SelectObject(hdc, hOldBrush); DeleteObject (hNewBrush); ReleaseDC (hwnd, hdc); } L_INT ChooseAColor(HWND hwnd, LPCOLORREF pColor) { CHOOSECOLOR Choose; static COLORREF crCustColors[16] ; BOOL bRet; //crCustColors[0]=RGB(255,0,0); Choose.lStructSize = sizeof (CHOOSECOLOR) ; Choose.hwndOwner = hwnd ; Choose.hInstance = NULL ; Choose.rgbResult = *pColor; Choose.lpCustColors = crCustColors ; Choose.Flags = CC_RGBINIT | CC_FULLOPEN ; Choose.lCustData = 0L ; Choose.lpfnHook = NULL ; Choose.lpTemplateName = NULL ; bRet= ChooseColor (&Choose) ; if (bRet != 0) { *pColor = Choose.rgbResult; } return bRet; } typedef struct tagBUTTONIMAGEDATA { long OldWindowProc; pBITMAPHANDLE pBitmap; HCURSOR hCursorColorPick; } BUTTONIMAGEDATA, L_FAR *LPBUTTONIMAGEDATA; void GetMaxRect(pBITMAPHANDLE pBitmap, int nButtonX, int nButtonY, LPRECT prcDst) { int nBitmapX; int nBitmapY; nBitmapX = BITMAPWIDTH(pBitmap); nBitmapY = BITMAPHEIGHT(pBitmap); prcDst->left = prcDst->top = 0; if (nBitmapY * nButtonX > nBitmapX * nButtonY) //maximize height { prcDst->bottom = nButtonY; prcDst->right = nButtonY * nBitmapX / nBitmapY; } else //maximize width { prcDst->right = nButtonX; prcDst->bottom = nButtonX * nBitmapY / nBitmapX; } } #define INCREMENT(x) ((x+1)%256) #define DECREMENT(x) ((x+255)%256) #define ADD(x,y) ((x+y)%256) void BuildMaskTable(L_UINT *uMaskTable, L_UINT uHStart, L_UINT uAngleCount) { L_INT i; L_UCHAR iCount; for (i=0; i<256; i++) uMaskTable[i] = 0; uMaskTable[uHStart] = 1; iCount = uAngleCount; for (i=INCREMENT(uHStart); iCount > 0; i = INCREMENT(i), iCount--) uMaskTable[i] = 1; iCount = uAngleCount; for (i=DECREMENT(uHStart); iCount > 0; i =DECREMENT(i), iCount--) uMaskTable[i] = 1; } void BuildHueTable(L_UINT *uHTable, L_UINT uHStart, L_UINT uHEnd, L_UINT uAngleCount) { L_INT i; L_UCHAR iCount; L_INT iDiff = (int)uHEnd - (int)uHStart; L_UCHAR uHChange = (uHEnd >= uHStart) ? (L_UCHAR)iDiff : (L_UCHAR)(iDiff + 256); for (i=0; i<256; i++) uHTable[i] = (i) % 256; uHTable[uHStart] = (uHTable[uHStart] + uHChange) % 256; iCount = uAngleCount; for (i=INCREMENT(uHStart); iCount > 0; i = INCREMENT(i), iCount--) uHTable[i] = ADD(uHTable[i], uHChange); iCount = uAngleCount; for (i=DECREMENT(uHStart); iCount > 0; i =DECREMENT(i), iCount--) uHTable[i] = ADD(uHTable[i],uHChange); } /* void BuildSTable2(L_UCHAR *uSTable, L_UCHAR uS, L_UCHAR uTableS) { L_INT i; double dS, dTableS; double a,b, den; //Fit a quadratic to three points //(0,0), (255,255), (s,table(s) // //Table(s) = a*s*s + b*s //a = (s - table(s)) / (255*s - s*s) //b = (255 * table(s) - s*s)/(255*s - s*s) dS = (double)uS; dTableS = (double)uTableS; den = (255 * dS - dS * dS); //if den == 0 then we only have two points (not three) //build standard table (straight line) if (den == 0) { for (i=0; i<256; i++) uSTable[i] = i; return; } a = (dS - dTableS) / den; b = (255 * dTableS - dS * dS) / den; for (i=0; i<256; i++) { double dTemp; dTemp = a*i*i + b*i; if (dTemp < 0) dTemp = 0; if (dTemp >255) dTemp = 255; uSTable[i] = (L_UCHAR)(dTemp); } } */ void BuildSTable(L_UINT *uSTable, L_UINT uS, L_UINT uTableS) { L_INT i; double dS, dTableS; //Fit a line to two points //(0,0), (s,table(s) // //Table(s) = m * s //m = uTableX / uS dS = (double)uS; dTableS = (double)uTableS; for (i=0; i<256; i++) { double dTemp; dTemp = dTableS * (double)i / dS; if (dTemp < 0) dTemp = 0; if (dTemp >255) dTemp = 255; uSTable[i] = (L_UCHAR)(dTemp); } } LRESULT CALLBACK ButtonImageProc(HWND hWnd, UINT iMsg, WPARAM wParam, LPARAM lParam) { HPALETTE hOurPalette, hSavedPalette; LPBUTTONIMAGEDATA pButtonData; static int nButtonX, nButtonY, nBitmapX, nBitmapY; static RECT rcDst; COLORREF crMouseColor; //int i = GetWindowLong(hWnd, GWL_ID); pButtonData = (LPBUTTONIMAGEDATA)GetWindowLong(hWnd,GWL_USERDATA); switch(iMsg) { case WM_PAINT: { RECT rcClient; HDC hDC; PAINTSTRUCT ps; //hDC = GetDC(hWnd); hDC = BeginPaint(hWnd, &ps); GetClientRect(hWnd, &rcClient); nButtonX = rcClient.right; nButtonY = rcClient.bottom; GetMaxRect(pButtonData->pBitmap, nButtonX, nButtonY, &rcDst); // Create the palette that we will use to paint hOurPalette = L_CreatePaintPalette (hDC, pButtonData->pBitmap); // Select our palette and save the old one hSavedPalette = SelectPalette (hDC, hOurPalette, TRUE); // Realize our palette RealizePalette (hDC); L_PaintDC ( hDC, //HDC hDC, pButtonData->pBitmap, //pBITMAPHANDLE pBitmap, NULL, //LPRECT pSrc, NULL, //LPRECT pClipSrc, &rcDst, //LPRECT pDst, &rcDst, //LPRECT pClipDst, SRCCOPY //L_UINT32 uROP3 ); // Restore the old palette SelectPalette (hDC, hSavedPalette, TRUE); // Delete the newly created palette DeleteObject (hOurPalette); //ReleaseDC(hWnd, hDC); EndPaint(hWnd, &ps); return 0; //I've handled this messgae } break; case WM_SETCURSOR: SetCursor(pButtonData->hCursorColorPick); return TRUE; break; case WM_MOUSEMOVE: case WM_LBUTTONDOWN: case WM_RBUTTONDOWN: { int xPos, yPos; //IDC_BUTTON_COLOR_MOUSEMOVE xPos = GET_X_LPARAM(lParam); yPos = GET_Y_LPARAM(lParam); //Convert to bitmap coordinates L_PointFromBitmap(pButtonData->pBitmap, TOP_LEFT, &xPos, &yPos); if ((xPos < BITMAPWIDTH(pButtonData->pBitmap)) && (yPos < BITMAPHEIGHT(pButtonData->pBitmap))) { //SetCursor(pButtonData->hCursorColorPick); crMouseColor = L_GetPixelColor(pButtonData->pBitmap, yPos, xPos); //lParam identifies this as W_MOUSEMOVE or WM_LBUTTONDOWN SendMessage(GetParent(hWnd), WM_UPDATECOLOR, crMouseColor, iMsg); } } break; } return CallWindowProc( (WNDPROC)pButtonData->OldWindowProc, //WNDPROC lpPrevWndFunc, // pointer to previous procedure hWnd, // handle to window iMsg, // message wParam, // first message parameter lParam // second message parameter ); } void UpdateThumb(HWND hDlg, L_UINT *uMaskTable, L_UINT *uHTable, L_UINT *uSTable, L_UINT *uVTable, pBITMAPHANDLE pThumbHue, pBITMAPHANDLE pThumbMaster, LPREMAPHUEDATA lpData) { BuildMaskTable(uMaskTable, lpData->uHStart, lpData->uAngleRange); BuildHueTable(uHTable, lpData->uHStart, lpData->uHEnd, lpData->uAngleRange); BuildSTable(uSTable, lpData->uSStart, lpData->uSEnd); BuildSTable(uVTable, lpData->uVStart, lpData->uVEnd); L_FreeBitmap(pThumbHue); L_CopyBitmap(pThumbHue, pThumbMaster,sizeof(BITMAPHANDLE)); L_RemapBitmapHue (pThumbHue, uMaskTable, uHTable, uSTable, uVTable,256); InvalidateRect(GetDlgItem(hDlg, IDC_BUTTON_THUMB), NULL, FALSE); } void UpdateStartColor(HWND hDlg, LPREMAPHUEDATA lpData, COLORREF crStartColor) { HSVREF hsvRef; L_TCHAR szMsg[200]; //If this is a gray value it has no color--this cannot be the start color if ((GetRValue(crStartColor) == GetGValue(crStartColor)) && (GetGValue(crStartColor) == GetBValue(crStartColor))) { MessageBox(hDlg, TEXT("Start Color cannot have same value for R, G, B"), TEXT(""), MB_OK); return; } lpData->crStartColor = lpData->crReplaceColor = crStartColor; hsvRef = L_RGBtoHSV(lpData->crStartColor); lpData->uHStart = lpData->uHEnd = hsvRef.uH; lpData->uSStart = lpData->uSEnd = hsvRef.uS; lpData->uVStart = lpData->uVEnd = hsvRef.uV; InvalidateRect(GetDlgItem(hDlg, IDC_BUTTON_START_COLOR), NULL, FALSE); InvalidateRect(GetDlgItem(hDlg, IDC_BUTTON_REPLACE_COLOR), NULL, FALSE); SendDlgItemMessage(hDlg,IDC_SLIDER_H, TBM_SETPOS, TRUE, lpData->uHStart); SendDlgItemMessage(hDlg,IDC_SLIDER_S, TBM_SETPOS, TRUE, lpData->uSStart); SendDlgItemMessage(hDlg,IDC_SLIDER_V, TBM_SETPOS, TRUE, lpData->uVStart); //SetDlgItemInt(hDlg, IDC_EDIT_DELTA, lpData->uVStart, FALSE); SetDlgItemInt(hDlg, IDC_EDIT_H, lpData->uHStart, FALSE); SetDlgItemInt(hDlg, IDC_EDIT_S, lpData->uSStart, FALSE); SetDlgItemInt(hDlg, IDC_EDIT_V, lpData->uVStart, FALSE); strprintf(szMsg, TEXT("RGB(%d,%d,%d)"), GetRValue(lpData->crStartColor), GetGValue(lpData->crStartColor), GetBValue(lpData->crStartColor)); SetDlgItemText(hDlg,IDC_STATIC_RGB_START,szMsg); strprintf(szMsg, TEXT("HSV(%d,%d,%d)"), lpData->uHStart, lpData->uSStart, lpData->uVStart); SetDlgItemText(hDlg,IDC_STATIC_HSV_START,szMsg); } void UpdateReplaceColor(HWND hDlg, LPREMAPHUEDATA lpData) { HSVREF hsvChange; hsvChange.uH = lpData->uHEnd; hsvChange.uS = lpData->uSEnd; hsvChange.uV = lpData->uVEnd; lpData->crReplaceColor = L_HSVtoRGB(hsvChange); InvalidateRect(GetDlgItem(hDlg, IDC_BUTTON_REPLACE_COLOR), NULL, FALSE); } void EditBoxValidate(HWND hDlg, L_UCHAR uMax, long lEditBox, long lSlider, L_UCHAR *puEnd) { L_INT nVal; BOOL bTranslated; nVal = GetDlgItemInt(hDlg, lEditBox, &bTranslated, FALSE); if ((nVal > uMax) || (bTranslated == FALSE)) { MessageBeep(MB_OK); SetFocus(GetDlgItem(hDlg, lEditBox)); SendDlgItemMessage(hDlg, lEditBox, EM_SETSEL, 0, -1); } else { SendDlgItemMessage(hDlg,lSlider,TBM_SETPOS, TRUE, nVal); *puEnd = nVal; } } void UpdateReplaceColorSettings(HWND hDlg, LPREMAPHUEDATA lpData) { SetDlgItemInt(hDlg, IDC_EDIT_DELTA, lpData->uAngleRange, FALSE); SendDlgItemMessage(hDlg,IDC_SLIDER_DELTA,TBM_SETRANGE,TRUE,MAKELONG(0,127)); SendDlgItemMessage(hDlg,IDC_SLIDER_DELTA,TBM_SETPOS ,TRUE, lpData->uAngleRange); SendDlgItemMessage(hDlg,IDC_SLIDER_H, TBM_SETRANGE,TRUE,MAKELONG(0,255)); SendDlgItemMessage(hDlg,IDC_SLIDER_H, TBM_SETPOS ,TRUE, lpData->uHEnd); SetDlgItemInt(hDlg, IDC_EDIT_H, lpData->uHStart, FALSE); SendDlgItemMessage(hDlg,IDC_SLIDER_S, TBM_SETRANGE,TRUE,MAKELONG(0,255)); SendDlgItemMessage(hDlg,IDC_SLIDER_S, TBM_SETPOS ,TRUE, lpData->uSEnd); SetDlgItemInt(hDlg, IDC_EDIT_S, lpData->uSStart, FALSE); SendDlgItemMessage(hDlg,IDC_SLIDER_V, TBM_SETRANGE,TRUE,MAKELONG(0,255)); SendDlgItemMessage(hDlg,IDC_SLIDER_V, TBM_SETPOS ,TRUE, lpData->uVEnd); SetDlgItemInt(hDlg, IDC_EDIT_V, lpData->uVStart, FALSE); InvalidateRect(GetDlgItem(hDlg, IDC_BUTTON_START_COLOR), NULL, FALSE); InvalidateRect(GetDlgItem(hDlg, IDC_BUTTON_COLOR_MOUSEMOVE), NULL, FALSE); } LRESULT CALLBACK DlgRemapHue(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam) { L_INT nRet; LPREMAPHUEDATA lpData; static BUTTONIMAGEDATA ButtonImageData; static HWND hWndImage; static BITMAPHANDLE ThumbMaster, ThumbHue; static L_UINT uMaskTable[256]; static L_UINT uHTable[256]; static L_UINT uSTable[256]; static L_UINT uVTable[256]; static HCURSOR hCursorColorPick; lpData = (LPREMAPHUEDATA)GetWindowLong(hDlg, GWL_USERDATA); switch (message) { case WM_INITDIALOG: { HWND hWndImage; SetWindowLong(hDlg, GWL_USERDATA, lParam); lpData = (LPREMAPHUEDATA)lParam; ResetRemapHueData(lpData); UpdateReplaceColorSettings(hDlg, lpData); L_CopyBitmap(&ThumbMaster, lpData->pBitmap, sizeof(BITMAPHANDLE)); { HWND hWndThumb; RECT rcClient, rcDst; hWndThumb = GetDlgItem(hDlg, IDC_BUTTON_THUMB); GetClientRect(hWndThumb, &rcClient); GetMaxRect(lpData->pBitmap, rcClient.right, rcClient.bottom, &rcDst); L_SizeBitmap(&ThumbMaster, rcDst.right, rcDst.bottom, SIZE_RESAMPLE); } L_CopyBitmap(&ThumbHue, &ThumbMaster, sizeof(BITMAPHANDLE)); hWndImage = GetDlgItem(hDlg, IDC_BUTTON_THUMB); ButtonImageData.OldWindowProc = GetWindowLong(hWndImage, GWL_WNDPROC); ButtonImageData.pBitmap = &ThumbHue; SetWindowLong(hWndImage, GWL_WNDPROC, (long)ButtonImageProc); SetWindowLong(hWndImage, GWL_USERDATA, (long)&ButtonImageData); ButtonImageData.hCursorColorPick = LoadCursor(hInst, MAKEINTRESOURCE(IDC_COLORPICK)); //IDC_SIZEALL } return TRUE; case WM_CLOSE: SetWindowLong(hWndImage, GWL_WNDPROC, ButtonImageData.OldWindowProc); L_FreeBitmap(&ThumbMaster); L_FreeBitmap(&ThumbHue); DeleteObject(ButtonImageData.hCursorColorPick); break; case WM_UPDATECOLOR: { PaintButton(GetDlgItem(hDlg, IDC_BUTTON_COLOR_MOUSEMOVE), (COLORREF)wParam); switch (lParam) { case WM_LBUTTONDOWN: case WM_RBUTTONDOWN: { UpdateStartColor(hDlg, lpData, (COLORREF)wParam); UpdateThumb(hDlg, uMaskTable, uHTable, uSTable, uVTable, &ThumbHue, &ThumbMaster, lpData); } break; case WM_MOUSEMOVE: { L_TCHAR szMsg[100]; HSVREF hsvRef; lpData->crMouseMoveColor = (COLORREF)wParam; strprintf(szMsg, TEXT("RGB(%d,%d,%d)"), GetRValue(wParam), GetGValue(wParam), GetBValue(wParam)); SetDlgItemText(hDlg,IDC_STATIC_RGB,szMsg); hsvRef = L_RGBtoHSV(wParam); strprintf(szMsg, TEXT("HSV(%d,%d,%d)"), hsvRef.uH, hsvRef.uS, hsvRef.uV); SetDlgItemText(hDlg,IDC_STATIC_HSV,szMsg); } break; } } break; case WM_DRAWITEM: //owner drawn buttons { HPALETTE hOurPalette = NULL; HPALETTE hSavedPalette = NULL; LPDRAWITEMSTRUCT pDraw = (LPDRAWITEMSTRUCT)lParam; HWND hWndItem = pDraw->hwndItem; if (wParam == IDC_BUTTON_START_COLOR) { PaintButton(hWndItem, lpData->crStartColor); } else if (wParam == IDC_BUTTON_REPLACE_COLOR) { PaintButton(hWndItem, lpData->crReplaceColor); } else if (wParam == IDC_BUTTON_COLOR_MOUSEMOVE) { PaintButton(hWndItem, lpData->crMouseMoveColor); } else if (wParam == IDC_BUTTON_THUMB) { //nothing--this window proc is subclassed to do its own painting } } break; case WM_HSCROLL: { int nScrollCode; HWND hwndScrollBar; HWND hwndSliderDelta; nScrollCode = (int) LOWORD(wParam); // scroll bar value hwndSliderDelta = GetDlgItem(hDlg, IDC_SLIDER_DELTA); hwndScrollBar = (HWND) lParam; // handle of scroll bar if (hwndScrollBar == hwndSliderDelta) { switch (nScrollCode) { case TB_THUMBPOSITION: case TB_THUMBTRACK: case TB_BOTTOM: case TB_TOP: case TB_LINEDOWN: case TB_LINEUP: case TB_PAGEDOWN: case TB_PAGEUP: lpData->uAngleRange = (L_UCHAR)SendDlgItemMessage(hDlg,IDC_SLIDER_DELTA,TBM_GETPOS,0,0L); break; default: return FALSE; } SetDlgItemInt( hDlg, // handle to dialog box IDC_EDIT_DELTA, // control identifier lpData->uAngleRange, // value to set FALSE // signed or unsigned indicator ); } else { HSVREF hsvChange; switch (nScrollCode) { case TB_THUMBPOSITION: case TB_THUMBTRACK: case TB_BOTTOM: case TB_TOP: case TB_LINEDOWN: case TB_LINEUP: case TB_PAGEDOWN: case TB_PAGEUP: lpData->uHEnd = (L_UCHAR)SendDlgItemMessage(hDlg,IDC_SLIDER_H,TBM_GETPOS,0,0L); lpData->uSEnd = (L_UCHAR)SendDlgItemMessage(hDlg,IDC_SLIDER_S,TBM_GETPOS,0,0L); lpData->uVEnd = (L_UCHAR)SendDlgItemMessage(hDlg,IDC_SLIDER_V,TBM_GETPOS,0,0L); break; default: return FALSE; } hsvChange.uH = lpData->uHEnd; hsvChange.uS = lpData->uSEnd; hsvChange.uV = lpData->uVEnd; SetDlgItemInt(hDlg, IDC_EDIT_H, lpData->uHEnd, FALSE); SetDlgItemInt(hDlg, IDC_EDIT_S, lpData->uSEnd, FALSE); SetDlgItemInt(hDlg, IDC_EDIT_V, lpData->uVEnd, FALSE); lpData->crReplaceColor = L_HSVtoRGB(hsvChange); InvalidateRect(GetDlgItem(hDlg, IDC_BUTTON_REPLACE_COLOR), NULL, FALSE); } UpdateThumb(hDlg, uMaskTable, uHTable, uSTable, uVTable, &ThumbHue, &ThumbMaster, lpData); } break; case WM_COMMAND: switch (LOWORD(wParam)) { case IDC_BUTTON_RESET: ResetRemapHueData(lpData); UpdateReplaceColorSettings(hDlg, lpData); UpdateThumb(hDlg, uMaskTable, uHTable, uSTable, uVTable, &ThumbHue, &ThumbMaster, lpData); break; case IDC_EDIT_DELTA: EditBoxValidate(hDlg, 127, IDC_EDIT_DELTA, IDC_SLIDER_DELTA, &lpData->uAngleRange); UpdateReplaceColor(hDlg, lpData); UpdateThumb(hDlg, uMaskTable, uHTable, uSTable, uVTable, &ThumbHue, &ThumbMaster, lpData); break; case IDC_EDIT_H: EditBoxValidate(hDlg, 255, IDC_EDIT_H, IDC_SLIDER_H, &lpData->uHEnd); UpdateReplaceColor(hDlg, lpData); UpdateThumb(hDlg, uMaskTable, uHTable, uSTable, uVTable, &ThumbHue, &ThumbMaster, lpData); break; case IDC_EDIT_S: EditBoxValidate(hDlg, 255, IDC_EDIT_S, IDC_SLIDER_S, &lpData->uSEnd); UpdateReplaceColor(hDlg, lpData); UpdateThumb(hDlg, uMaskTable, uHTable, uSTable, uVTable, &ThumbHue, &ThumbMaster, lpData); break; case IDC_EDIT_V: EditBoxValidate(hDlg, 255, IDC_EDIT_V, IDC_SLIDER_V, &lpData->uVEnd); UpdateReplaceColor(hDlg, lpData); UpdateThumb(hDlg, uMaskTable, uHTable, uSTable, uVTable, &ThumbHue, &ThumbMaster, lpData); break; case IDC_BUTTON_START_COLOR: case IDC_BUTTON_COLOR_PICKER: { COLORREF crStartColor = RGB( 0x00, 0x00, 0x00 ); nRet = ChooseAColor(hDlg, &crStartColor); if (nRet != 0) { UpdateStartColor(hDlg, lpData, crStartColor); UpdateThumb(hDlg, uMaskTable, uHTable, uSTable, uVTable, &ThumbHue, &ThumbMaster, lpData); } } break; case IDCANCEL: EndDialog(hDlg, IDCANCEL); return TRUE; break; case IDOK: { EndDialog(hDlg, IDOK); return TRUE; } break; } } return FALSE; } /*====(Child_OnCommand)==================================================== Description: Processes the WM_COMMAND for a child window. Syntax : VOID Child_OnCommand(HWND hWnd, int id, HWND hWndCtl, UINT codeNotify) Parameters : hWnd Handle to the child window. id Value of the command to be processed. hWndCtl Not used. codeNotify Not used. Return Value: None. ==========================================================================*/ static VOID Child_OnCommand (HWND hWnd, int id, HWND hWndCtl, UINT codeNotify) { L_TCHAR szText[_MAX_PATH]; HCURSOR hCursor; LPCHILDDATA pData; pBITMAPHANDLE pBitmap =NULL; DWORD dwColor; L_BOOL bResize; L_INT nBits = 0; L_UINT32 uColorResFlags =0; L_UINT uGamma; L_UINT uDirection; FRAMESETTINGSPARM FrameSettingsParm; static BITMAPHANDLE Bitmap; BITMAPHANDLE NewBitmap; L_INT nValue=0; L_INT nRet; L_UINT u; RGBQUAD aPalette[256]; L_UINT32 ulColors; static COLORREF crBack = RGB(255,255,255); L_UINT32 nSize = 0; L_UINT32 ulFlags; FILEINFO FileInfoSrc,FileInfoDst; HWND hTmpWnd=0; L_INT nLastIndex; L_BOOL bColorsChanged; L_INT nBitsPerPixel = -1; L_INT nViewPerspective = TOP_LEFT; switch (id) { case IDM_COLORRES: pData = LOCKCHILDDATA(hWnd); if(!pData->hList) { L_TCHAR szTitle [_MAX_PATH]; ZeroMemory(&ColorParam,sizeof(COLORRESDLGPARAMS)); nRet = ShowColorResDialog ( hWnd, &pData->ActiveBitmap, &ColorParam); if(nRet == SUCCESS_DLG_OK) { COLORRESCALLBACK crcb; L_INT nEntries = 0 ; GetObject(ColorParam.hpalCustom, sizeof(WORD), &nEntries); pData->bImageChanged=TRUE; nRet = InitBitmapProcess (hWnd, &pBitmap, TRUE); if (nRet == SUCCESS) { nValue = 0; if(fUseProgress) crcb = ColorResCallback; else crcb = NULL; if(ColorParam.uColorResFlags&CRF_OPTIMIZEDPALETTE) ColorParam.uColorResFlags|=CRF_SLOWMATCH; nRet = L_ColorResBitmap ( pBitmap, pBitmap, sizeof(BITMAPHANDLE),ColorParam.nBitsPerPixel, ColorParam.uColorResFlags, NULL, ColorParam.hpalCustom, nEntries, crcb, (L_VOID L_FAR *) &nValue); /* if we have a floater, we have to change the bits per pixel of the background as well */ if(nRet == SUCCESS && pData->bmSave.Flags.Allocated) L_ColorResBitmap ( &pData->bmSave, &pData->bmSave, sizeof(BITMAPHANDLE),ColorParam.nBitsPerPixel, ColorParam.uColorResFlags, NULL, ColorParam.hpalCustom, nEntries, crcb, (L_VOID L_FAR *) &nValue); } TermBitmapProcess (hWnd, nRet, FALSE, TRUE); } else { GetChildTitle(hWnd, szTitle); L_FileError (hWndFrame, nRet, TEXT("Color Resolution"), szTitle); } UNLOCKCHILDDATA(hWnd); break; } else // Unlock pData and fall through UNLOCKCHILDDATA(hWnd); case IDM_ANICOLORRES: pData = LOCKCHILDDATA(hWnd); ZeroMemory(&ColorParam,sizeof(COLORRESDLGPARAMS)); ColorParam.uStructSize = sizeof ( COLORRESDLGPARAMS ) ; ColorParam.pBitmap = &pData->ActiveBitmap ; ColorParam.nBitsPerPixel = pData->ActiveBitmap.BitsPerPixel; ColorParam.uColorResFlags = CRF_SLOWMATCH; ColorParam.uDlgFlags = DLG_COLORRES_SHOW_ORDER | DLG_COLORRES_SHOW_TOOL_ZOOMLEVEL; ColorParam.uDlgFlagsEx = DLG_COLORRES_SHOW_BITALL | DLG_COLORRES_SHOW_DITHER_ALL | DLG_COLORRES_SHOW_PAL_ALL; if(L_DlgColorRes( hWnd,&ColorParam) == SUCCESS_DLG_OK) { pData->bImageChanged=TRUE; PreFrameChange(hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { nValue = 0; if(uColorResFlags&CRF_OPTIMIZEDPALETTE) uColorResFlags|=CRF_SLOWMATCH; nRet = L_ColorResBitmapList ( pData->hList, ColorParam.nBitsPerPixel, ColorParam.uColorResFlags, NULL, ColorParam.hpalCustom, 0); if(nRet == SUCCESS) { L_GetBitmapListItem(pData->hList, 0, &Bitmap,sizeof(BITMAPHANDLE)); L_GetBitmapColors(&Bitmap, 0, Bitmap.nColors, aPalette); nRet = L_CreateBitmap (&NewBitmap, sizeof(BITMAPHANDLE), TYPE_CONV, pData->Bitmap.Width, pData->Bitmap.Height, Bitmap.BitsPerPixel, Bitmap.Order, aPalette, Bitmap.ViewPerspective, NULL, 0); if(nRet == SUCCESS) { NewBitmap.Background = L_TranslateBitmapColor(&NewBitmap, &pData->Bitmap, pData->Bitmap.Background); L_FreeBitmap(&pData->Bitmap); pData->Bitmap = NewBitmap; } } if(!pData->fComposite) { L_GetBitmapListItem(pData->hList, pData->uFrame, &pData->ActiveBitmap,sizeof(BITMAPHANDLE)); } else { pData->ActiveBitmap = pData->Bitmap; PostFrameChange(hWnd); } } TermBitmapProcess (hWnd, nRet, FALSE, TRUE); } UNLOCKCHILDDATA(hWnd); break; case IDM_ANILOOP: pData = LOCKCHILDDATA(hWnd); pData->fLoop = !pData->fLoop; UNLOCKCHILDDATA(hWnd); break; case IDM_ANIFRAMESETTINGS: pData = LOCKCHILDDATA(hWnd); PreFrameChange(hWnd); L_GetBitmapListItem(pData->hList, pData->uFrame, &Bitmap,sizeof(BITMAPHANDLE)); FrameSettingsParm.fTransparency = Bitmap.Flags.Transparency; FrameSettingsParm.fWaitUserInput = Bitmap.Flags.WaitUserInput; FrameSettingsParm.crTransparency = Bitmap.Transparency; FrameSettingsParm.uDelay = Bitmap.Delay; FrameSettingsParm.uDisposalMethod = Bitmap.DisposalMethod; FrameSettingsParm.nLeft = Bitmap.Left; FrameSettingsParm.nTop = Bitmap.Top; FrameSettingsParm.fApplytoall = FALSE; FrameSettingsParm.pBitmap = &Bitmap; if(GetFrameSettingsParm(hWnd, &FrameSettingsParm)) { for(u = (FrameSettingsParm.fApplytoall ? 0 : pData->uFrame); u <= (FrameSettingsParm.fApplytoall ? pData->uLastFrame : pData->uFrame); u++) { L_GetBitmapListItem(pData->hList, u, &Bitmap,sizeof(BITMAPHANDLE)); Bitmap.Flags.Transparency = FrameSettingsParm.fTransparency; Bitmap.Flags.WaitUserInput = FrameSettingsParm.fWaitUserInput; Bitmap.Transparency = FrameSettingsParm.crTransparency; Bitmap.Delay = FrameSettingsParm.uDelay; Bitmap.DisposalMethod = FrameSettingsParm.uDisposalMethod; Bitmap.Left = FrameSettingsParm.nLeft; Bitmap.Top = FrameSettingsParm.nTop; L_SetBitmapListItem(pData->hList, u, &Bitmap); } PostFrameChange(hWnd); } UNLOCKCHILDDATA(hWnd); break; case IDM_ANIBACKCOLOR: pData = LOCKCHILDDATA(hWnd); PreFrameChange(hWnd); if(GetColor(hWnd, &pData->Bitmap, &pData->Bitmap.Background, &bColorsChanged)) PostFrameChange(hWnd); UNLOCKCHILDDATA(hWnd); break; case IDM_ANICOMPOSITE: pData = LOCKCHILDDATA(hWnd); PreFrameChange(hWnd); pData->fComposite = !pData->fComposite; PostFrameChange(hWnd); UNLOCKCHILDDATA(hWnd); break; case IDM_ANIFIRSTFRAME: pData = LOCKCHILDDATA(hWnd); PreFrameChange(hWnd); pData->uFrame = 0; if(IsWindow(pData->hListBox)) { pData->nCurrentPage=pData->uFrame+1; SETCURSEL(pData->hListBox,pData->uFrame); } PostFrameChange(hWnd); UNLOCKCHILDDATA(hWnd); break; case IDM_ANIPREVFRAME: pData = LOCKCHILDDATA(hWnd); PreFrameChange(hWnd); if(pData->uFrame) { pData->uFrame--; if(IsWindow(pData->hListBox)) { pData->nCurrentPage=pData->uFrame+1; SETCURSEL(pData->hListBox,pData->uFrame); } PostFrameChange(hWnd); } UNLOCKCHILDDATA(hWnd); break; case IDM_ANINEXTFRAME: pData = LOCKCHILDDATA(hWnd); PreFrameChange(hWnd); if(pData->uFrame < pData->uLastFrame) { pData->uFrame++; if(IsWindow(pData->hListBox)) { pData->nCurrentPage=pData->uFrame+1; SETCURSEL(pData->hListBox,pData->uFrame); } PostFrameChange(hWnd); } UNLOCKCHILDDATA(hWnd); break; case IDM_ANILASTFRAME: pData = LOCKCHILDDATA(hWnd); PreFrameChange(hWnd); pData->uFrame = pData->uLastFrame; if(IsWindow(pData->hListBox)) { pData->nCurrentPage=pData->uFrame+1; SETCURSEL(pData->hListBox,pData->uFrame); } PostFrameChange(hWnd); UNLOCKCHILDDATA(hWnd); break; case IDM_ADD_PAGE: pData = LOCKCHILDDATA(hWnd); _fmemset(pData->szFileName,0,sizeof(pData->szFileName)); if(OpenBitmapFile(pData->szFileName,sizeof(pData->szFileName)-1,&Bitmap,TEXT("Open Bitmap: Add Page(s)"))==SUCCESS) { memset (&FileInfoSrc, 0, sizeof ( FileInfoSrc ) ) ; memset (&FileInfoDst, 0, sizeof ( FileInfoDst ) ) ; memset (&SaveFileOption, 0, sizeof ( SaveFileOption ) ) ; FileInfoSrc.uStructSize = sizeof ( FileInfoSrc ) ; FileInfoDst.uStructSize = sizeof ( FileInfoDst ) ; SaveFileOption.uStructSize = sizeof ( SaveFileOption ) ; LoadFileOption.PageNumber = 32000; //get number of pages in the file L_FileInfo(pData->szFileName,&FileInfoSrc,sizeof(FILEINFO),FILEINFO_TOTALPAGES,&LoadFileOption); LoadFileOption.PageNumber = 32000; //get number of pages in the file L_FileInfo(pData->szTitle, &FileInfoDst, sizeof(FILEINFO),FILEINFO_TOTALPAGES,&LoadFileOption); if(FileInfoSrc.TotalPages>1) nRet=MessageBox(hWnd,TEXT("This file contains more than one page\nDo you want to add all of them?"),TEXT("ADD IMAGE PAGE"),MB_YESNO|MB_APPLMODAL|MB_ICONQUESTION); else nRet = IDNO; if(FileInfoDst.TotalPages==1) { pData->hListBox=CreateWindow(TEXT("LISTBOX"),0, LBS_NOTIFY|WS_VSCROLL|WS_CHILD|LBS_NOINTEGRALHEIGHT|LBS_OWNERDRAWFIXED, 0,0, LISTBOXWIDTH+GetSystemMetrics(SM_CXVSCROLL),100, hWnd,(HMENU)IDC_LISTBOX,hInst,0); if(pData->hListBox==0) { //fill the listbox with thumbnail images MessageBox(hWnd,TEXT("Not enough memory"),TEXT("Error"),MB_APPLMODAL|MB_ICONSTOP); L_FreeBitmap(&Bitmap); UNLOCKCHILDDATA(hWnd); break; } SetThumbnails(hWnd,(GetMenuState(GetMenu(hWndFrame),IDM_THUMBNAILS,MF_BYCOMMAND)&MF_CHECKED)>0); } if( nRet == IDNO ) FileInfoSrc.TotalPages = 1; nRet=GETCOUNT(pData->hListBox); L_FreeBitmap(&Bitmap); uDirection=CancelFileLoading(L_START_LOADING,0,0); EnableFrameMenu (FALSE,TRUE); for(nValue=0;nValueszFileName,&Bitmap, sizeof(BITMAPHANDLE), 0, fIsBGRDevice ? ORDER_BGRORGRAY : ORDER_RGBORGRAY, &LoadFileOption, NULL); SaveFileOption.PageNumber = 2; if( L_SaveFile(pData->szTitle,&Bitmap,FileInfoDst.Format,0, GetProperQualityFactor(FileInfoDst.Format),SAVEFILE_MULTIPAGE|SAVEFILE_OPTIMIZEDPALETTE,0,0,&SaveFileOption) == SUCCESS) { if(FileInfoDst.TotalPages>1) { L_FreeBitmap(&Bitmap); LoadFileOption.PageNumber = FileInfoDst.TotalPages+nValue + 1; L_LoadBitmap( pData->szTitle, &Bitmap, sizeof(BITMAPHANDLE),0, fIsBGRDevice ? ORDER_BGRORGRAY : ORDER_RGBORGRAY, &LoadFileOption,NULL); AddThumbnail(pData->hListBox,&Bitmap,LoadFileOption.PageNumber - 1); } L_FreeBitmap(&Bitmap); uDirection=CancelFileLoading(L_CHECK_LOADING,nValue,FileInfoSrc.TotalPages); if(uDirection==FAILURE) { CancelFileLoading(L_END_LOADING,0,0); if(FileInfoDst.TotalPages>1) { for(u=0;u<(L_UINT)(nValue+1);u++) { SaveFileOption.PageNumber = nRet+u+1; L_DeletePage(pData->szTitle,nRet+u+1,0,&SaveFileOption); DeleteThumbnail(pData->hListBox,nRet+nValue); } for(u=0;u<(L_UINT)(nValue+1);u++) DELETESTRING(pData->hListBox,nRet); } EnableFrameMenu(TRUE,TRUE); UNLOCKCHILDDATA(hWnd); return; } } EnableFrameMenu(TRUE,TRUE); CancelFileLoading(L_END_LOADING,0,0); } if(FileInfoDst.TotalPages==1) FillImageListBox(pData->hListBox,pData->szTitle,FALSE); SETCURSEL(pData->hListBox,GETCOUNT(pData->hListBox)-1); LoadBitmapPage(hWnd,GETCOUNT(pData->hListBox),FALSE); } if(pData->hListBox) SetFocus(pData->hListBox); UNLOCKCHILDDATA(hWnd); break; case IDM_REPLACE_PAGE: pData = LOCKCHILDDATA(hWnd); if(OpenBitmapFrame(&Bitmap,TEXT("Open Bitmap: Replace Page"))==SUCCESS) if(Bitmap.Flags.Allocated) { memset (&FileInfoDst, 0, sizeof ( FileInfoDst ) ) ; memset (&SaveFileOption, 0, sizeof ( SaveFileOption ) ) ; FileInfoDst.uStructSize = sizeof ( FileInfoDst ) ; SaveFileOption.uStructSize = sizeof ( SaveFileOption ) ; LoadFileOption.PageNumber = 32000; //get number of pages in the file L_FileInfo(pData->szTitle,&FileInfoDst,sizeof(FILEINFO),0,&LoadFileOption); SaveFileOption.PageNumber = GETCURSEL(pData->hListBox)+1; SaveFileOption.Flags&=~ESO_INSERTPAGE; SaveFileOption.Flags|=ESO_REPLACEPAGE; if(L_SaveFile(pData->szTitle,&Bitmap,FileInfoDst.Format, 0, GetProperQualityFactor(FileInfoDst.Format),SAVEFILE_OPTIMIZEDPALETTE,0,0,&SaveFileOption)==SUCCESS) { L_FreeBitmap(&Bitmap); LoadFileOption.PageNumber = SaveFileOption.PageNumber; L_LoadBitmap( pData->szTitle, &Bitmap, sizeof(BITMAPHANDLE),0, fIsBGRDevice ? ORDER_BGRORGRAY : ORDER_RGBORGRAY, &LoadFileOption, NULL); nRet=GETCURSEL(pData->hListBox); DeleteThumbnail(pData->hListBox,nRet); DELETESTRING(pData->hListBox,nRet); AddThumbnail(pData->hListBox,&Bitmap,nRet); SETCURSEL(pData->hListBox,nRet); L_FreeBitmap(&Bitmap); LoadBitmapPage(hWnd,nRet+1,FALSE); } L_GetDefaultSaveFileOption(&SaveFileOption, sizeof(SAVEFILEOPTION)); } if(pData->hListBox) SetFocus(pData->hListBox); UNLOCKCHILDDATA(hWnd); break; case IDM_INSERT_PAGE: pData = LOCKCHILDDATA(hWnd); _fmemset(pData->szFileName,0,sizeof(pData->szFileName)); if(OpenBitmapFile(pData->szFileName,sizeof(pData->szFileName)-1,&Bitmap,TEXT("Open Bitmap: Insert Page(s)"))==SUCCESS) { pBITMAPHANDLE pTmpBitmapArr= NULL; LoadFileOption.PageNumber = 32000; //get number of pages in the file L_FileInfo(pData->szFileName,&FileInfoSrc,sizeof(FILEINFO),FILEINFO_TOTALPAGES,&LoadFileOption); LoadFileOption.PageNumber = 32000; //get number of pages in the file L_FileInfo(pData->szTitle, &FileInfoDst, sizeof(FILEINFO),FILEINFO_TOTALPAGES,&LoadFileOption); if(FileInfoSrc.TotalPages>1) nRet=MessageBox(hWnd,TEXT("This file contains more than one page\nDo you want to insert all of them?"),TEXT("ADD IMAGE PAGE"),MB_YESNO|MB_APPLMODAL|MB_ICONQUESTION); else nRet = IDNO; if(FileInfoDst.TotalPages==1) { pData->hListBox=CreateWindow(TEXT("LISTBOX"),0, LBS_NOTIFY|WS_VSCROLL|WS_CHILD|LBS_NOINTEGRALHEIGHT|LBS_OWNERDRAWFIXED, 0,0, LISTBOXWIDTH+GetSystemMetrics(SM_CXVSCROLL),100, hWnd,(HMENU)IDC_LISTBOX,hInst,0); if(pData->hListBox==0) { //fill the listbox with thumbnail images MessageBox(hWnd,TEXT("Not enough memory"),TEXT("Error"),MB_APPLMODAL|MB_ICONSTOP); L_FreeBitmap(&Bitmap); UNLOCKCHILDDATA(hWnd); break; } SetThumbnails(hWnd,(GetMenuState(GetMenu(hWndFrame),IDM_THUMBNAILS,MF_BYCOMMAND)&MF_CHECKED)>0); } nSize=GETCURSEL(pData->hListBox); SaveFileOption.Flags&=~ESO_REPLACEPAGE; SaveFileOption.Flags|=ESO_INSERTPAGE; if( nRet == IDNO ) FileInfoSrc.TotalPages = 1; L_FreeBitmap(&Bitmap); uDirection=CancelFileLoading(L_START_LOADING,0,0); EnableFrameMenu(FALSE,TRUE); pTmpBitmapArr = GlobalAllocPtr(GHND,sizeof(BITMAPHANDLE)*FileInfoSrc.TotalPages); for(nValue=0;nValueszFileName,&pTmpBitmapArr[nValue], sizeof(BITMAPHANDLE), 0, fIsBGRDevice ? ORDER_BGRORGRAY : ORDER_RGBORGRAY, &LoadFileOption, NULL); } for(nValue=0;nValueszTitle,&pTmpBitmapArr[nValue], FileInfoDst.Format, 0, GetProperQualityFactor(FileInfoDst.Format),SAVEFILE_OPTIMIZEDPALETTE,0,0,&SaveFileOption)==SUCCESS) { if(FileInfoDst.TotalPages>1) { L_FreeBitmap( &Bitmap ); LoadFileOption.PageNumber = nSize+nValue+1; //nRet = L_LoadBitmap( pData->szTitle, &Bitmap, sizeof(BITMAPHANDLE), 0, fIsBGRDevice ? ORDER_BGRORGRAY : ORDER_RGBORGRAY, &LoadFileOption, NULL); AddThumbnail(pData->hListBox,&pTmpBitmapArr[nValue],(L_INT)nSize+nValue); } } L_FreeBitmap(&pTmpBitmapArr[nValue]); LoadBitmapPage(hWnd,nSize+1,FALSE); SETCURSEL(pData->hListBox,nSize); nLastIndex = nSize; uDirection=CancelFileLoading(L_CHECK_LOADING,nValue,FileInfoSrc.TotalPages); if(uDirection==FAILURE) { CancelFileLoading(L_END_LOADING,0,0); if(FileInfoDst.TotalPages>1) { for(u=0;u<(L_UINT)(nValue+1);u++) { SaveFileOption.PageNumber = ((L_INT)nSize+(L_INT)u+1); L_DeletePage(pData->szTitle,(L_INT)nSize+(L_INT)u+1,0,&SaveFileOption); DeleteThumbnail(pData->hListBox,(L_INT)nSize+(L_INT)u); } for(u=0;u<(L_UINT)(nValue+1);u++) DELETESTRING(pData->hListBox,(int)nSize); } EnableFrameMenu(TRUE,TRUE); UNLOCKCHILDDATA(hWnd); for(u=(L_UINT)(nValue+1);u<(L_UINT)FileInfoSrc.TotalPages;u++) L_FreeBitmap(&pTmpBitmapArr[u]); GlobalFreePtr(pTmpBitmapArr); pTmpBitmapArr = NULL; return; } } if(pTmpBitmapArr != NULL) { GlobalFreePtr(pTmpBitmapArr); pTmpBitmapArr = NULL; } EnableFrameMenu(TRUE,TRUE); CancelFileLoading(L_END_LOADING,0,0); if(FileInfoDst.TotalPages==1) FillImageListBox(pData->hListBox,pData->szTitle,FALSE); SETCURSEL(pData->hListBox,nSize); } if(pData->hListBox) SetFocus(pData->hListBox); UNLOCKCHILDDATA(hWnd); break; case IDM_DELETE_PAGE: pData = LOCKCHILDDATA(hWnd); if(MessageBox(hWnd,TEXT("Delete selected page?"),TEXT("Delete Page"),MB_YESNO|MB_APPLMODAL|MB_ICONSTOP)==IDYES) { nRet=(GETCURSEL(pData->hListBox)==(GETCOUNT(pData->hListBox)-1))? (GETCOUNT(pData->hListBox)-2): GETCURSEL(pData->hListBox); SaveFileOption.uStructSize = sizeof ( SAVEFILEOPTION ) ; L_GetDefaultSaveFileOption(&SaveFileOption, sizeof(SAVEFILEOPTION)); SaveFileOption.PageNumber = GETCURSEL(pData->hListBox)+1; SaveFileOption.Flags&=~ESO_REPLACEPAGE; SaveFileOption.Flags&=~ESO_INSERTPAGE; if((nValue=L_DeletePage(pData->szTitle,GETCURSEL(pData->hListBox)+1, 0, &SaveFileOption))==SUCCESS) { DeleteThumbnail(pData->hListBox,GETCURSEL(pData->hListBox)); DELETESTRING(pData->hListBox,GETCURSEL(pData->hListBox)); SETCURSEL(pData->hListBox,nRet); LoadBitmapPage(hWnd,nRet+1,FALSE); if(GETCOUNT(pData->hListBox)==1) { hTmpWnd=pData->hListBox; pData->hListBox=0; ShowWindow(hTmpWnd,SW_HIDE); ResizeChildBitmapWindows(hWnd); DeleteThumbnail(hTmpWnd,0); DELETESTRING(hTmpWnd,0); DestroyWindow(hTmpWnd); pData->nLastCy=0; } } L_GetDefaultSaveFileOption(&SaveFileOption, sizeof(SAVEFILEOPTION)); } if(pData->hListBox) SetFocus(pData->hListBox); UNLOCKCHILDDATA(hWnd); break; case IDM_SAVEAS: SaveBitmap(hWnd); break; case IDM_JPEGWEBTUNER: { L_TCHAR szTitle [_MAX_PATH]; pData = LOCKCHILDDATA(hWnd); ZeroMemory(&JPEGWebTunerParams,sizeof(JPEGWEBTUNERDLGPARAMS)); nRet = ShowJPEGWebTunerDialog ( hWnd, &pData->ActiveBitmap, &JPEGWebTunerParams ) ; if (nRet < 0 ) { GetChildTitle(hWnd, szTitle); L_FileError (hWndFrame, nRet, TEXT("Web Tuner"), szTitle); } UNLOCKCHILDDATA(hWnd); break; } case IDM_PNGWEBTUNER: { L_TCHAR szTitle [_MAX_PATH]; pData = LOCKCHILDDATA(hWnd); ZeroMemory(&PNGWebTunerParams,sizeof(PNGWEBTUNERDLGPARAMS)); nRet = ShowPNGWebTunerDialog ( hWnd, &pData->ActiveBitmap, &PNGWebTunerParams ) ; if (nRet < 0 ) { GetChildTitle(hWnd, szTitle); L_FileError (hWndFrame, nRet, TEXT("Web Tuner"), szTitle); } UNLOCKCHILDDATA(hWnd); break; } case IDM_GIFWEBTUNER: { L_TCHAR szTitle [_MAX_PATH]; pData = LOCKCHILDDATA(hWnd); ZeroMemory(&GIFWebTunerParams,sizeof(GIFWEBTUNERDLGPARAMS)); nRet = ShowGIFWebTunerDialog ( hWnd, &pData->ActiveBitmap, &GIFWebTunerParams ) ; if (nRet < 0 ) { GetChildTitle(hWnd, szTitle); L_FileError (hWndFrame, nRet, TEXT("Web Tuner"), szTitle); } UNLOCKCHILDDATA(hWnd); break; } case IDM_IMAGEMAPPER: { L_TCHAR szTitle [_MAX_PATH]; pData = LOCKCHILDDATA(hWnd); ZeroMemory(&HTMLMapperParams,sizeof(HTMLMAPPERDLGPARAMS)); nRet = ShowHTMLMapperDialog ( hWnd, &pData->ActiveBitmap, &HTMLMapperParams ) ; if (nRet < 0 ) { GetChildTitle(hWnd, szTitle); L_FileError (hWndFrame, nRet, TEXT("Web Tuner"), szTitle); } UNLOCKCHILDDATA(hWnd); break; } case IDM_PREVIEW: { L_TCHAR szTitle [_MAX_PATH]; HICON hIcon ; pData = LOCKCHILDDATA(hWnd); ZeroMemory(&PrintPreviewParams,sizeof(PRINTPREVIEWDLGPARAMS)); hIcon = (HICON) LoadImage( (HINSTANCE)GetWindowLong(hWnd,GWL_HINSTANCE), MAKEINTRESOURCE(IDI_MAIN), IMAGE_ICON, GetSystemMetrics( SM_CXSMICON ), GetSystemMetrics( SM_CYSMICON ), 0 ); PrintPreviewParams.hWindowIcon = hIcon ; nRet = ShowPrintPreviewDialog ( hWnd, &pData->ActiveBitmap, &PrintPreviewParams ) ; if ( NULL != PrintPreviewParams.hDevMode ) { GlobalFree ( PrintPreviewParams.hDevMode ) ; } if ( NULL != PrintPreviewParams.hDevNames ) { GlobalFree ( PrintPreviewParams.hDevNames ) ; } if ( NULL != hIcon ) { DeleteObject ( hIcon ) ; } if (nRet < 0 ) { GetChildTitle(hWnd, szTitle); L_FileError (hWndFrame, nRet, TEXT("Web Tuner"), szTitle); } UNLOCKCHILDDATA(hWnd); break; } case IDM_COLORSEP_ALPHA: nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { pData = LOCKCHILDDATA(hWnd); pData->bImageChanged=TRUE; UNLOCKCHILDDATA(hWnd); nRet = L_GetBitmapAlpha (pBitmap, &Bitmap,sizeof(BITMAPHANDLE)); if(nRet == SUCCESS) CreateChildWindow (TEXT("Alpha Plane"), &Bitmap, NULL, 1,0,0); } TermBitmapProcess (hWnd, nRet, FALSE, FALSE); break; case IDM_COLORSEP_RGB: case IDM_COLORSEP_CMYK: case IDM_COLORSEP_HSV: case IDM_COLORSEP_HLS: case IDM_COLORSEP_CMY: nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); switch(id) { case IDM_COLORSEP_RGB: nValue = COLORSEP_RGB; break; case IDM_COLORSEP_CMYK: nValue = COLORSEP_CMYK; break; case IDM_COLORSEP_HSV: nValue = COLORSEP_HSV; break; case IDM_COLORSEP_HLS: nValue = COLORSEP_HLS; break; case IDM_COLORSEP_CMY: nValue = COLORSEP_CMY; break; } if (nRet == SUCCESS) nRet = L_ColorSeparateBitmap (pBitmap, pColorPlanes, sizeof(BITMAPHANDLE), nValue); TermBitmapProcess (hWnd, nRet, FALSE, FALSE); if(nRet == SUCCESS) { pData = LOCKCHILDDATA(hWnd); pData->bImageChanged=TRUE; UNLOCKCHILDDATA(hWnd); switch(id) { case IDM_COLORSEP_RGB: CreateChildWindow (TEXT("Blue Plane"), pColorPlanes[0], NULL, 1,0,FALSE); CreateChildWindow (TEXT("Green Plane"), pColorPlanes[1], NULL, 1,0,FALSE); CreateChildWindow (TEXT("Red Plane"), pColorPlanes[2], NULL, 1,0,FALSE); break; case IDM_COLORSEP_CMYK: CreateChildWindow (TEXT("Cyan Plane"), pColorPlanes[0], NULL, 1,0,FALSE); CreateChildWindow (TEXT("Magenta Plane"), pColorPlanes[1], NULL, 1,0,FALSE); CreateChildWindow (TEXT("Yellow Plane"), pColorPlanes[2], NULL, 1,0,FALSE); CreateChildWindow (TEXT("Black Plane"), pColorPlanes[3], NULL, 1,0,FALSE); break; case IDM_COLORSEP_HSV: CreateChildWindow (TEXT("Hue Plane"), pColorPlanes[0], NULL, 1,0,FALSE); CreateChildWindow (TEXT("Saturation Plane"), pColorPlanes[1], NULL, 1,0,FALSE); CreateChildWindow (TEXT("Value Plane"), pColorPlanes[2], NULL, 1,0,FALSE); break; case IDM_COLORSEP_HLS: CreateChildWindow (TEXT("Hue Plane"), pColorPlanes[0], NULL, 1,0,FALSE); CreateChildWindow (TEXT("Lightness Plane"), pColorPlanes[1], NULL, 1,0,FALSE); CreateChildWindow (TEXT("Saturation Plane"), pColorPlanes[2], NULL, 1,0,FALSE); break; case IDM_COLORSEP_CMY: CreateChildWindow (TEXT("Cyan Plane"), pColorPlanes[0], NULL, 1,0,FALSE); CreateChildWindow (TEXT("Magenta Plane"), pColorPlanes[1], NULL, 1,0,FALSE); CreateChildWindow (TEXT("Yellow Plane"), pColorPlanes[2], NULL, 1,0,FALSE); break; } } break; case IDM_CANCELREGION: pData = LOCKCHILDDATA(hWnd); ChangeRegion(hWnd, id, pData ); UNLOCKCHILDDATA(hWnd); break; case IDM_WINDOWLEVEL: { pData = LOCKCHILDDATA(hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, TRUE); ZeroMemory ( &WindowLevelParams, sizeof(WINDOWLEVELDLGPARAMS)); if ( SUCCESS == nRet ) { nRet = ShowWindowLevelDialog ( hWnd, pBitmap, &WindowLevelParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet = L_WindowLevel ( pBitmap, WindowLevelParams.uLowBit, WindowLevelParams.uHighBit, (RGBQUAD L_HUGE*) WindowLevelParams.pLUT, WindowLevelParams.uLUTLength, WINDOWLEVEL_PAINT | WINDOWLEVEL_PAINT_AND_PROCESSING ); if ( nRet == SUCCESS ) { pData->bImageChanged=TRUE; } } } TermBitmapProcess (hWnd, nRet, FALSE, TRUE); free ( WindowLevelParams.pLUT ) ; UNLOCKCHILDDATA(hWnd); } break; case IDM_HISTOEQUALIZE: nRet = InitBitmapProcess (hWnd, &pBitmap, TRUE); if (nRet == SUCCESS) nRet = L_HistoEqualizeBitmap (pBitmap, GRAY_SPACE); if (nRet == SUCCESS) { pData = LOCKCHILDDATA(hWnd); pData->bImageChanged=TRUE; UNLOCKCHILDDATA(hWnd); } TermBitmapProcess (hWnd, nRet, FALSE, TRUE); break; case IDM_COUNTCOLORS: nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) nRet = L_GetBitmapColorCount (pBitmap, &ulColors); TermBitmapProcess (hWnd, nRet, FALSE, FALSE); if(nRet == SUCCESS) { strprintf(szText, TEXT("Bitmap contains %lu unique colors"), ulColors); MessageBox(hWnd, szText, TEXT(""), MB_OK); } break; case IDM_STRETCHINTENSITY: nRet = InitBitmapProcess (hWnd, &pBitmap, TRUE); if (nRet == SUCCESS) nRet = L_StretchBitmapIntensity (pBitmap); if(nRet == SUCCESS) { pData = LOCKCHILDDATA(hWnd); pData->bImageChanged=TRUE; } TermBitmapProcess (hWnd, nRet, FALSE, TRUE); UNLOCKCHILDDATA(hWnd); break; case IDM_BRIGHTNESS: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, TRUE); if (nRet == SUCCESS) { ZeroMemory(&BrightnessParams,sizeof (BRIGHTNESSDLGPARAMS)); nRet = ShowBrightnessDialog ( hWnd, pBitmap, &BrightnessParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_ChangeBitmapIntensity(pBitmap, BrightnessParams.nChange); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_CONTRAST: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&ContrastParams,sizeof(CONTRASTDLGPARAMS)); nRet = ShowContrastDialog ( hWnd, pBitmap, &ContrastParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_ChangeBitmapContrast(pBitmap, ContrastParams.nChange); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_HISTOCONTRAST: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&HistoContrastParams,sizeof(HISTOCONTRASTDLGPARAMS)); nRet = ShowHistoContrastDialog ( hWnd, pBitmap, &HistoContrastParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_HistoContrastBitmap(pBitmap,HistoContrastParams.nChange); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_SATURATION: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&SaturationParams,sizeof(SATURATIONDLGPARAMS)); nRet = ShowSaturationDialog ( hWnd, pBitmap, &SaturationParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_ChangeBitmapSaturation(pBitmap, SaturationParams.nChange); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_SHARPEN: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&SharpenParams,sizeof(SHARPENDLGPARAMS)); nRet = ShowSharpenDialog ( hWnd, pBitmap, &SharpenParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_SharpenBitmap(pBitmap,SharpenParams.nSharpness); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_HUE: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&HueParams,sizeof(HUEDLGPARAMS)); nRet = ShowHueDialog ( hWnd, pBitmap, &HueParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_ChangeBitmapHue(pBitmap, HueParams.nAngle); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_FILLBLACK: case IDM_FILLWHITE: case IDM_FILLRED: case IDM_FILLGREEN: case IDM_FILLBLUE: case IDM_FILLCYAN: case IDM_FILLMAGENTA: case IDM_FILLYELLOW: switch (id) { case IDM_FILLBLACK: dwColor = RGB (0, 0, 0); break; case IDM_FILLWHITE: dwColor = RGB (255, 255, 255); break; case IDM_FILLRED: dwColor = RGB (255, 0, 0); break; case IDM_FILLGREEN: dwColor = RGB (0, 255, 0); break; case IDM_FILLBLUE: dwColor = RGB (0, 0, 255); break; case IDM_FILLCYAN: dwColor = RGB (0, 255, 255); break; case IDM_FILLMAGENTA: dwColor = RGB (255, 0, 255); break; case IDM_FILLYELLOW: default: dwColor = RGB (255, 255, 0); break; } nRet = InitBitmapProcess (hWnd, &pBitmap, TRUE); if (nRet == SUCCESS) nRet = L_FillBitmap (pBitmap, dwColor); if(nRet == SUCCESS) { pData = LOCKCHILDDATA(hWnd); pData->bImageChanged=TRUE; UNLOCKCHILDDATA(hWnd); } TermBitmapProcess (hWnd, nRet, FALSE, FALSE); break; case IDM_AVERAGE: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&AverageParams,sizeof(AVERAGEDLGPARAMS)); nRet = ShowAverageDialog ( hWnd, pBitmap, &AverageParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_AverageFilterBitmap(pBitmap,AverageParams.uDim); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_MEDIAN: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&MedianParams,sizeof(MEDIANDLGPARAMS)); nRet = ShowMedianDialog ( hWnd, pBitmap, &MedianParams ) ; if ( nRet == SUCCESS_DLG_OK ) { L_MedianFilterBitmap(pBitmap,MedianParams.uDim); pData->bImageChanged=TRUE; nRet = SUCCESS; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_OILIFY: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&OilifyParams,sizeof(OILIFYDLGPARAMS)); nRet = ShowOilifyDialog ( hWnd, pBitmap, &OilifyParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_OilifyBitmap(pBitmap,OilifyParams.uDim); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_MINFILTER: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&MinFilterParams,sizeof(MINFILTERDLGPARAMS)); nRet = ShowMinFilterDialog ( hWnd, pBitmap, &MinFilterParams ) ; if ( nRet == SUCCESS_DLG_OK ) { L_MinFilterBitmap(pBitmap,MinFilterParams.uDim); pData->bImageChanged=TRUE; nRet = SUCCESS; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_MAXFILTER: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&MaxFilterParams,sizeof(MAXFILTERDLGPARAMS)); nRet = ShowMaxFilterDialog ( hWnd, pBitmap, &MaxFilterParams ) ; if ( nRet == SUCCESS_DLG_OK ) { pData->bImageChanged=TRUE; L_MaxFilterBitmap(pBitmap,MaxFilterParams.uDim); nRet = SUCCESS; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_ADDNOISE: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&AddNoiseParams,sizeof(ADDNOISEDLGPARAMS)); nRet = ShowAddNoiseDialog ( hWnd, pBitmap, &AddNoiseParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_AddBitmapNoise(pBitmap,AddNoiseParams.uRange,AddNoiseParams.uChannel); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_POSTERIZE: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&PosterizeParams,sizeof(POSTERIZEDLGPARAMS)); nRet = ShowPosterizeDialog ( hWnd, pBitmap, &PosterizeParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_PosterizeBitmap(pBitmap, PosterizeParams.nLevels); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_MOSAIC: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&MosaicParams,sizeof(MOSAICDLGPARAMS)); nRet = ShowMosaicDialog ( hWnd, pBitmap, &MosaicParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_MosaicBitmap(pBitmap,MosaicParams.uDim); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_UNDERLAY: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { BITMAPHANDLE UnderLayBitmap; ZeroMemory(&UnderLayBitmap,sizeof(BITMAPHANDLE)); ZeroMemory(&UnderlayParams,sizeof(UNDERLAYDLGPARAMS)); nRet = ShowUnderlayDialog ( hWnd, pBitmap, &UnderlayParams, &UnderLayBitmap) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_UnderlayBitmap(pBitmap,&UnderLayBitmap,UnderlayParams.uUnderlayFlags); if(SUCCESS==nRet) pData->bImageChanged=TRUE; if(UnderLayBitmap.Flags.Allocated) L_FreeBitmap(&UnderLayBitmap); } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_CONTOURFILTER: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&ContourFilterParams,sizeof(CONTOURFILTERDLGPARAMS)); nRet = ShowContourFilterDialog ( hWnd, pBitmap, &ContourFilterParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_ContourFilterBitmap(pBitmap, ContourFilterParams.nThreshold, ContourFilterParams.nDeltaDirection, ContourFilterParams.nMaxError, ContourFilterParams.nOption); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_EMBOSS: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&EmbossParams,sizeof(EMBOSSDLGPARAMS)); nRet = ShowEmbossDialog ( hWnd, pBitmap, &EmbossParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_EmbossBitmap(pBitmap,EmbossParams.uDirection,EmbossParams.uDepth); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_GRADIENT: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&GradientFilterParams,sizeof(GRADIENTFILTERDLGPARAMS)); nRet = ShowGradientFilterDialog ( hWnd, pBitmap, &GradientFilterParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_SpatialFilterBitmap(pBitmap, GradientFilterParams.pFilter); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_LAPLACE: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&LaplacianFilterParams,sizeof(LAPLACIANFILTERDLGPARAMS)); nRet = ShowLaplacianFilterDialog ( hWnd, pBitmap, &LaplacianFilterParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_SpatialFilterBitmap(pBitmap, LaplacianFilterParams.pFilter); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_SOBEL: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&SobelFilterParams,sizeof(SOBELFILTERDLGPARAMS)); nRet = ShowSobelFilterDialog ( hWnd, pBitmap, &SobelFilterParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_SpatialFilterBitmap(pBitmap, SobelFilterParams.pFilter); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_PREWITT: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&PrewittFilterParams,sizeof(PREWITTFILTERDLGPARAMS)); nRet = ShowPrewittFilterDialog ( hWnd, pBitmap, &PrewittFilterParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_SpatialFilterBitmap(pBitmap, PrewittFilterParams.pFilter); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_SHIFTDIFF: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&ShiftDifferenceFilterParams,sizeof(SHIFTDIFFERENCEFILTERDLGPARAMS)); nRet = ShowShiftDifferenceFilterDialog ( hWnd, pBitmap, &ShiftDifferenceFilterParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_SpatialFilterBitmap(pBitmap, ShiftDifferenceFilterParams.pFilter); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_LINESEG: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&LineSegmentFilterParams,sizeof(LINESEGMENTFILTERDLGPARAMS)); nRet = ShowLineSegmentFilterDialog ( hWnd, pBitmap, &LineSegmentFilterParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_SpatialFilterBitmap(pBitmap, LineSegmentFilterParams.pFilter); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_EDGEENHANCE: { BITMAPHANDLE WrkBitmap; nRet = InitBitmapProcess (hWnd, &pBitmap, TRUE); if (nRet == SUCCESS) { nRet = L_CopyBitmap(&WrkBitmap, pBitmap, sizeof(BITMAPHANDLE)); if(nRet == SUCCESS) { nRet = L_SpatialFilterBitmap (&WrkBitmap, FLT_LAPLACE_1); if(nRet == SUCCESS) { nRet = L_CombineBitmap(pBitmap, 0, 0, BITMAPWIDTH(pBitmap), BITMAPHEIGHT(pBitmap), &WrkBitmap, 0, 0, CB_OP_ADD); if(nRet == SUCCESS) { pData = LOCKCHILDDATA(hWnd); pData->bImageChanged=TRUE; UNLOCKCHILDDATA(hWnd); } } L_FreeBitmap(&WrkBitmap); } } TermBitmapProcess (hWnd, nRet, FALSE, FALSE); } break; case IDM_EROSION: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&ErosionFilterParams,sizeof(EROSIONFILTERDLGPARAMS)); nRet = ShowErosionFilterDialog ( hWnd, pBitmap, &ErosionFilterParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_BinaryFilterBitmap(pBitmap,ErosionFilterParams.pFilter); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_DILATION: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&DilationFilterParams,sizeof(DILATIONFILTERDLGPARAMS)); nRet = ShowDilationFilterDialog ( hWnd, pBitmap, &DilationFilterParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_BinaryFilterBitmap(pBitmap,DilationFilterParams.pFilter); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_SOLARIZE: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&SolarizeParams,sizeof(SOLARIZEDLGPARAMS)); nRet = ShowSolarizeDialog ( hWnd, pBitmap, &SolarizeParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_SolarizeBitmap(pBitmap, SolarizeParams.nThreshold); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_INVERT: nRet = InitBitmapProcess (hWnd, &pBitmap, TRUE); if (nRet == SUCCESS) nRet = L_InvertBitmap (pBitmap); if(nRet == SUCCESS) { pData = LOCKCHILDDATA(hWnd); pData->bImageChanged=TRUE; UNLOCKCHILDDATA(hWnd); } TermBitmapProcess (hWnd, nRet, FALSE, TRUE); break; case IDM_GAMMA: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&GammaAdjustmentParams,sizeof(GAMMAADJUSTMENTDLGPARAMS)); L_FreeBitmapRgn(&pData->ActiveBitmap); nRet = ShowGammaAdjustmentDialog ( hWnd, pBitmap, &GammaAdjustmentParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=GammaCorrect(pBitmap, GammaAdjustmentParams.nRedValue, GammaAdjustmentParams.nGreenValue, GammaAdjustmentParams.nBlueValue); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_EDGEDETECT: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&EdgeDetectorParams,sizeof(EDGEDETECTORDLGPARAMS)); nRet = ShowEdgeDetectorDialog ( hWnd, pBitmap, &EdgeDetectorParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_EdgeDetectorBitmap(pBitmap, EdgeDetectorParams.uThreshold, EdgeDetectorParams.uFilter); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_PICTURIZE: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&PicturizeParams,sizeof(PICTURIZEDLGPARAMS)); PicturizeParams.pszPath = malloc((sizeof(L_TCHAR)*L_MAXPATH)); ZeroMemory(PicturizeParams.pszPath,(sizeof(L_TCHAR)*L_MAXPATH)); nRet = ShowPicturizeDialog ( hWnd, pBitmap, &PicturizeParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_PicturizeBitmap(pBitmap, PicturizeParams.pszPath, PicturizeParams.uResize | PICTURIZE_LOADALL, PicturizeParams.nCellWidth, PicturizeParams.nCellHeight, NULL, NULL); if(SUCCESS==nRet) pData->bImageChanged=TRUE; if(NULL!=PicturizeParams.pszPath) free(PicturizeParams.pszPath); } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_GRAYSCALE8: nRet = InitBitmapProcess (hWnd, &pBitmap, TRUE); if (nRet == SUCCESS) nRet = L_GrayScaleBitmap (pBitmap, 8); if(nRet == SUCCESS) { pData = LOCKCHILDDATA(hWnd); /* if we have a floater, we have to change the bits per pixel of the background as well */ if(pData->bmSave.Flags.Allocated) L_GrayScaleBitmap (&pData->bmSave, 8); pData->bImageChanged=TRUE; UNLOCKCHILDDATA(hWnd); } TermBitmapProcess (hWnd, nRet, FALSE, TRUE); break; case IDM_GRAYSCALE12: nRet = InitBitmapProcess (hWnd, &pBitmap, TRUE); if (nRet == SUCCESS) nRet = L_GrayScaleBitmap (pBitmap, 12); if(nRet == SUCCESS) { pData = LOCKCHILDDATA(hWnd); /* if we have a floater, we have to change the bits per pixel of the background as well */ if(pData->bmSave.Flags.Allocated) L_GrayScaleBitmap (&pData->bmSave, 12); pData->bImageChanged=TRUE; UNLOCKCHILDDATA(hWnd); } TermBitmapProcess (hWnd, nRet, FALSE, TRUE); break; case IDM_GRAYSCALE16: nRet = InitBitmapProcess (hWnd, &pBitmap, TRUE); if (nRet == SUCCESS) nRet = L_GrayScaleBitmap (pBitmap, 16); if(nRet == SUCCESS) { pData = LOCKCHILDDATA(hWnd); /* if we have a floater, we have to change the bits per pixel of the background as well */ if(pData->bmSave.Flags.Allocated) L_GrayScaleBitmap (&pData->bmSave, 16); pData->bImageChanged=TRUE; UNLOCKCHILDDATA(hWnd); } TermBitmapProcess (hWnd, nRet, FALSE, TRUE); break; case IDM_HALFTONE: { DLGBITMAPLIST BitmapList ; L_INT i = 0 ; L_TCHAR szTitle [_MAX_PATH]; pData = LOCKCHILDDATA(hWnd); ZeroMemory(&HalfToneParams,sizeof(HALFTONEDLGPARAMS)); ZeroMemory(&BitmapList,sizeof(DLGBITMAPLIST)); nRet = ShowHalftoneDialog ( hWnd, &pData->ActiveBitmap, &HalfToneParams, &BitmapList ) ; if ( SUCCESS_DLG_OK == nRet ) { nRet = InitBitmapProcess (hWnd, &pBitmap, TRUE); if (nRet == SUCCESS) { nRet = L_HalfToneBitmap (pBitmap, HalfToneParams.uType, HalfToneParams.nAngle, HalfToneParams.uDim,HalfToneParams.hList); /* if we have a floater, we have to change the bits per pixel of the background as well */ if(nRet == SUCCESS && pData->bmSave.Flags.Allocated) L_HalfToneBitmap (&pData->bmSave, HalfToneParams.uType, HalfToneParams.nAngle, HalfToneParams.uDim,HalfToneParams.hList); } if(nRet == SUCCESS) pData->bImageChanged=TRUE; TermBitmapProcess (hWnd, nRet, FALSE, TRUE); if ( NULL != HalfToneParams.hList ) { L_UINT uCount ; L_GetBitmapListCount ( HalfToneParams.hList, &uCount ) ; for ( i = uCount-1 ; i >= 0 ; i-- ) { L_RemoveBitmapListItem ( HalfToneParams.hList, i, NULL ) ; } L_DestroyBitmapList ( HalfToneParams.hList ) ; } } else { GetChildTitle(hWnd, szTitle); L_FileError (hWndFrame, nRet, TEXT("HalfTone"), szTitle); } if ( NULL != BitmapList.pBitmapList ) { // clean up for ( i = 0 ; i < DLG_IMAGE_LIST_COUNT ; i++ ) { if ( NULL != BitmapList.pBitmapList [ i ].pBitmap ) { if ( BitmapList.pBitmapList [ i ].pBitmap->Flags.Allocated ) { L_FreeBitmap ( BitmapList.pBitmapList [ i ].pBitmap ) ; } free ( BitmapList.pBitmapList [ i ].pBitmap ) ; } if ( NULL != BitmapList.pBitmapList [ i ].pszDescription ) { free ( BitmapList.pBitmapList [ i ].pszDescription ) ; } } free ( BitmapList.pBitmapList ) ; } UNLOCKCHILDDATA(hWnd); break; } case IDM_FLIP: pData = LOCKCHILDDATA(hWnd); if(L_BitmapHasRgn(&pData->ActiveBitmap)) { ChangeRegion( hWnd, id, pData ); } else { nRet = InitBitmapProcess (hWnd, &pBitmap, TRUE); if (nRet == SUCCESS) nRet = L_FlipBitmap (pBitmap); if(nRet == SUCCESS) pData->bImageChanged=TRUE; TermBitmapProcess (hWnd, nRet, FALSE, FALSE); } UNLOCKCHILDDATA(hWnd); break; case IDM_FASTFLIP: pData = LOCKCHILDDATA(hWnd); if(L_BitmapHasRgn(&pData->ActiveBitmap)) { ChangeRegion( hWnd, IDM_FLIP, pData ); } else { nRet = InitBitmapProcess (hWnd, &pBitmap, TRUE); if (nRet == SUCCESS) nRet = L_FlipBitmapViewPerspective (pBitmap); TermBitmapProcess (hWnd, nRet, FALSE, FALSE); } UNLOCKCHILDDATA(hWnd); break; case IDM_DESPECKLE: nRet = InitBitmapProcess (hWnd, &pBitmap, TRUE); if (nRet == SUCCESS) nRet = L_DespeckleBitmap(pBitmap); if(nRet == SUCCESS) { pData = LOCKCHILDDATA(hWnd); pData->bImageChanged=TRUE; UNLOCKCHILDDATA(hWnd); } TermBitmapProcess (hWnd, nRet, FALSE, FALSE); break; case IDM_DESKEW: nRet = InitBitmapProcess (hWnd, &pBitmap, TRUE); if (nRet == SUCCESS) nRet = L_DeskewBitmap(pBitmap, NULL,0,0); if(nRet == SUCCESS) { pData = LOCKCHILDDATA(hWnd); pData->bImageChanged=TRUE; UNLOCKCHILDDATA(hWnd); } TermBitmapProcess (hWnd, nRet, FALSE, FALSE); break; /* Document imaging */ case IDM_SMOOTH: { pData = LOCKCHILDDATA(hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, TRUE); ZeroMemory(&SmoothParams,sizeof(SMOOTHDLGPARAMS)); nRet= ShowSmoothDialog ( hWnd, pBitmap, &SmoothParams ) ; if( nRet == SUCCESS_DLG_OK) { SmoothParams.Smooth.uFlags &= ~SMOOTH_LEAD_REGION; SmoothParams.Smooth.uFlags &= ~SMOOTH_SINGLE_REGION; nRet=L_SmoothBitmap (pBitmap, &SmoothParams.Smooth, NULL, NULL); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } TermBitmapProcess (hWnd, nRet, TRUE, FALSE); UNLOCKCHILDDATA(hWnd); break; } case IDM_LINE: { pData = LOCKCHILDDATA(hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, TRUE); ZeroMemory(&LineRemoveParams,sizeof(LINEREMOVEDLGPARAMS)); if(ShowLineRemoveDialog ( hWnd, pBitmap, &LineRemoveParams ) == SUCCESS_DLG_OK) { LineRemoveParams.LineRemove.uFlags &= ~LINE_LEAD_REGION; LineRemoveParams.LineRemove.uFlags &= ~LINE_SINGLE_REGION; nRet=L_LineRemoveBitmap(pBitmap, &LineRemoveParams.LineRemove, NULL, NULL); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } TermBitmapProcess (hWnd, nRet, TRUE, FALSE); UNLOCKCHILDDATA(hWnd); break; } case IDM_BORDER: { pData = LOCKCHILDDATA(hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, TRUE); ZeroMemory(&BorderRemoveParams,sizeof(BORDERREMOVEDLGPARAMS)); if(ShowBorderRemoveDialog ( hWnd, pBitmap, &BorderRemoveParams ) == SUCCESS_DLG_OK) { BorderRemoveParams.BorderRemove.uFlags &= ~BORDER_LEAD_REGION; BorderRemoveParams.BorderRemove.uFlags &= ~BORDER_SINGLE_REGION; nRet=L_BorderRemoveBitmap(pBitmap, &BorderRemoveParams.BorderRemove, NULL, NULL); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } TermBitmapProcess (hWnd, nRet, TRUE, FALSE); UNLOCKCHILDDATA(hWnd); break; } case IDM_INVERTEDTEXT: { pData = LOCKCHILDDATA(hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, TRUE); ZeroMemory(&InvertedTextParams,sizeof(INVERTEDTEXTDLGPARAMS)); if(ShowInvertedTextDialog ( hWnd, pBitmap, &InvertedTextParams ) == SUCCESS_DLG_OK) { InvertedTextParams.InvertedText.uFlags &= ~INVERTEDTEXT_LEAD_REGION; InvertedTextParams.InvertedText.uFlags &= ~INVERTEDTEXT_SINGLE_REGION; nRet=L_InvertedTextBitmap(pBitmap, &InvertedTextParams.InvertedText, NULL, NULL); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } TermBitmapProcess (hWnd, nRet, TRUE, FALSE); UNLOCKCHILDDATA(hWnd); break; } case IDM_DOT: { pData = LOCKCHILDDATA(hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, TRUE); ZeroMemory(&DotRemoveParams,sizeof(DOTREMOVEDLGPARAMS)); if(ShowDotRemoveDialog ( hWnd, pBitmap, &DotRemoveParams ) == SUCCESS_DLG_OK) { DotRemoveParams.DotRemove.uFlags &= ~DOT_LEAD_REGION; DotRemoveParams.DotRemove.uFlags &= ~DOT_SINGLE_REGION; nRet=L_DotRemoveBitmap(pBitmap, &DotRemoveParams.DotRemove, NULL, NULL); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } TermBitmapProcess (hWnd, nRet, TRUE, FALSE); UNLOCKCHILDDATA(hWnd); break; } case IDM_HOLEPUNCH: { pData = LOCKCHILDDATA(hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, TRUE); ZeroMemory(&HolePunchRemoveParams,sizeof(HOLEPUNCHREMOVEDLGPARAMS)); if(ShowHolePunchRemoveDialog ( hWnd, pBitmap, &HolePunchRemoveParams ) == SUCCESS_DLG_OK) { HolePunchRemoveParams.HolePunchRemove.uFlags &= ~HOLEPUNCH_LEAD_REGION; HolePunchRemoveParams.HolePunchRemove.uFlags &= ~HOLEPUNCH_SINGLE_REGION; nRet=L_HolePunchRemoveBitmap(pBitmap, &HolePunchRemoveParams.HolePunchRemove, NULL, NULL); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } TermBitmapProcess (hWnd, nRet, TRUE, FALSE); UNLOCKCHILDDATA(hWnd); break; } case IDM_REMOVEREDEYE: { pData = LOCKCHILDDATA(hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, TRUE); ZeroMemory(&RemoveRedeyeParams,sizeof(REMOVEREDEYEDLGPARAMS)); nRet = ShowRemoveRedeyeDialog ( hWnd, pBitmap, &RemoveRedeyeParams ); if(nRet == SUCCESS_DLG_OK) { nRet=L_RemoveRedeyeBitmap(pBitmap, RemoveRedeyeParams.crNewColor, RemoveRedeyeParams.uThreshold, RemoveRedeyeParams.nLightness); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } else { L_TCHAR szTitle [_MAX_PATH]; GetChildTitle(hWnd, szTitle); L_FileError (hWndFrame, nRet, TEXT("Shear"), szTitle); } TermBitmapProcess (hWnd, nRet, TRUE, FALSE); UNLOCKCHILDDATA(hWnd); break; } case IDM_AUTOTRIM: pData = LOCKCHILDDATA(hWnd); if(L_BitmapHasRgn(&pData->ActiveBitmap)) { ChangeRegion( hWnd, id, pData ); } else { nRet = InitBitmapProcess (hWnd, &pBitmap, TRUE); ZeroMemory(&AutoTrimParams,sizeof(AUTOTRIMDLGPARAMS)); nRet = ShowAutoTrimDialog ( hWnd, pBitmap, &AutoTrimParams ); if(nRet == SUCCESS_DLG_OK) { nRet = L_AutoTrimBitmap ( pBitmap, AutoTrimParams.nThreshold ) ; if(SUCCESS == nRet) pData->bImageChanged=TRUE; } else { L_TCHAR szTitle [_MAX_PATH]; GetChildTitle(hWnd, szTitle); L_FileError (hWndFrame, nRet, TEXT("AutoTrim"), szTitle); } TermBitmapProcess (hWnd, nRet, TRUE, FALSE); } UNLOCKCHILDDATA(hWnd); break; case IDM_REVERSE: pData = LOCKCHILDDATA(hWnd); if(L_BitmapHasRgn(&pData->ActiveBitmap)) { ChangeRegion( hWnd, id, pData ); } else { nRet = InitBitmapProcess (hWnd, &pBitmap, TRUE); if (nRet == SUCCESS) nRet = L_ReverseBitmap (pBitmap); if(nRet == SUCCESS) pData->bImageChanged=TRUE; TermBitmapProcess (hWnd, nRet, FALSE, FALSE); } UNLOCKCHILDDATA(hWnd); break; case IDM_FASTREVERSE: pData = LOCKCHILDDATA(hWnd); if(L_BitmapHasRgn(&pData->ActiveBitmap)) { ChangeRegion( hWnd, IDM_REVERSE, pData ); } else { nRet = InitBitmapProcess (hWnd, &pBitmap, TRUE); if (nRet == SUCCESS) nRet = L_ReverseBitmapViewPerspective (pBitmap); if(nRet == SUCCESS) pData->bImageChanged=TRUE; TermBitmapProcess (hWnd, nRet, FALSE, FALSE); } UNLOCKCHILDDATA(hWnd); break; case IDM_CANVASSIZE: pData = LOCKCHILDDATA(hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, TRUE); if (nRet == SUCCESS) { ZeroMemory(&CanvasResizeParams,sizeof(CANVASRESIZEDLGPARAMS)); if(ShowCanvasResizeDialog ( hWnd, pBitmap, &CanvasResizeParams ) == SUCCESS_DLG_OK) { pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, FALSE); UNLOCKCHILDDATA(hWnd); break; case IDM_RESIZE: pData = LOCKCHILDDATA(hWnd); if(L_BitmapHasRgn(&pData->ActiveBitmap)) { ChangeRegion( hWnd, id, pData ); } else { ZeroMemory(&ReizeParams,sizeof(RESIZEDLGPARAMS)); if(ShowResizeDialog ( hWnd, &pData->ActiveBitmap, &ReizeParams ) == SUCCESS_DLG_OK) { nRet = InitBitmapProcess (hWnd, &pBitmap, TRUE); if (nRet == SUCCESS) nRet = L_SizeBitmap (pBitmap, ReizeParams.uNewWidth, ReizeParams.uNewHeight, ReizeParams.uResize); if(nRet == SUCCESS) pData->bImageChanged=TRUE; TermBitmapProcess (hWnd, nRet, TRUE, FALSE); } } UNLOCKCHILDDATA(hWnd); break; case IDM_HISTOGRAM: { L_TCHAR szTitle [_MAX_PATH]; pData = LOCKCHILDDATA(hWnd); ZeroMemory(&HistogramParams,sizeof(HISTOGRAMDLGPARAMS)); nRet = ShowHistogramDialog ( hWnd, &pData->ActiveBitmap, &HistogramParams ) ; if (nRet < 0 ) { GetChildTitle(hWnd, szTitle); L_FileError (hWndFrame, nRet, TEXT("Histogram"), szTitle); } UNLOCKCHILDDATA(hWnd); break; } case IDM_FASTROTATE90: pData = LOCKCHILDDATA(hWnd); if(L_BitmapHasRgn(&pData->ActiveBitmap)) { ChangeRegion( hWnd, IDM_ROTATE90, pData ); } else { nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if(nRet = SUCCESS) nRet = L_RotateBitmapViewPerspective(pBitmap, 90); TermBitmapProcess (hWnd, nRet, TRUE, FALSE); } UNLOCKCHILDDATA(hWnd); break; case IDM_FASTROTATE180: pData = LOCKCHILDDATA(hWnd); if(L_BitmapHasRgn(&pData->ActiveBitmap)) { ChangeRegion( hWnd, IDM_ROTATE180, pData ); } else { nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if(nRet = SUCCESS) nRet = L_RotateBitmapViewPerspective(pBitmap, 180); TermBitmapProcess (hWnd, nRet, TRUE, FALSE); } UNLOCKCHILDDATA(hWnd); break; case IDM_FASTROTATE270: pData = LOCKCHILDDATA(hWnd); if(L_BitmapHasRgn(&pData->ActiveBitmap)) { ChangeRegion( hWnd, IDM_ROTATE270, pData ); } else { nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if(nRet = SUCCESS) nRet = L_RotateBitmapViewPerspective(pBitmap, 270); TermBitmapProcess (hWnd, nRet, TRUE, FALSE); } UNLOCKCHILDDATA(hWnd); break; case IDM_ROTATE90: pData = LOCKCHILDDATA(hWnd); if(L_BitmapHasRgn(&pData->ActiveBitmap)) { ChangeRegion( hWnd, id, pData ); } else { nRet = InitBitmapProcess (hWnd, &pBitmap, TRUE); if (nRet == SUCCESS) nRet = L_RotateBitmap (pBitmap, 9000, ROTATE_RESIZE, RGB(255, 255, 255)); if(nRet == SUCCESS) pData->bImageChanged=TRUE; TermBitmapProcess (hWnd, nRet, TRUE, FALSE); } UNLOCKCHILDDATA(hWnd); break; case IDM_ROTATE180: pData = LOCKCHILDDATA(hWnd); if(L_BitmapHasRgn(&pData->ActiveBitmap)) { ChangeRegion( hWnd, id, pData ); } else { nRet = InitBitmapProcess (hWnd, &pBitmap, TRUE); if (nRet == SUCCESS) nRet = L_RotateBitmap (pBitmap, 18000, ROTATE_RESIZE, RGB(255, 255, 255)); if(nRet == SUCCESS) pData->bImageChanged=TRUE; TermBitmapProcess (hWnd, nRet, TRUE, FALSE); } UNLOCKCHILDDATA(hWnd); break; case IDM_ROTATE270: pData = LOCKCHILDDATA(hWnd); if(L_BitmapHasRgn(&pData->ActiveBitmap)) { ChangeRegion( hWnd, id, pData ); } else { nRet = InitBitmapProcess (hWnd, &pBitmap, TRUE); if (nRet == SUCCESS) nRet = L_RotateBitmap (pBitmap, 27000, ROTATE_RESIZE, RGB(255, 255, 255)); if(nRet == SUCCESS) pData->bImageChanged=TRUE; TermBitmapProcess (hWnd, nRet, TRUE, FALSE); } UNLOCKCHILDDATA(hWnd); break; case IDM_ROTATE: pData = LOCKCHILDDATA(hWnd); if(L_BitmapHasRgn(&pData->ActiveBitmap)) { ChangeRegion( hWnd, id, pData ); } else { ZeroMemory(&RotateParams,sizeof(ROTATEDLGPARAMS)) ; if(ShowRotateDialog ( hWnd, &pData->ActiveBitmap, &RotateParams ) == SUCCESS_DLG_OK) { nRet = InitBitmapProcess (hWnd, &pBitmap, TRUE); if (nRet == SUCCESS) nRet = L_RotateBitmap (pBitmap, RotateParams.nAngle, RotateParams.uRotateFlags|(RotateParams.bResize?ROTATE_RESIZE:0), RotateParams.crBack); if(nRet == SUCCESS) pData->bImageChanged=TRUE; TermBitmapProcess (hWnd, nRet, TRUE, FALSE); } } UNLOCKCHILDDATA(hWnd); break; case IDM_SHEAR: pData = LOCKCHILDDATA(hWnd); if(L_BitmapHasRgn(&pData->ActiveBitmap)) { ChangeRegion( hWnd, id, pData ); } else { ZeroMemory(&ShearParams,sizeof(SHEARDLGPARAMS)) ; nRet = ShowShearDialog ( hWnd, &pData->ActiveBitmap, &ShearParams ); if(nRet == SUCCESS_DLG_OK) { nRet = InitBitmapProcess (hWnd, &pBitmap, TRUE); if (nRet == SUCCESS) nRet = L_ShearBitmap (pBitmap, (L_INT) ShearParams.nAngle, ShearParams.bHorizontal, ShearParams.crBack); if(nRet == SUCCESS) pData->bImageChanged=TRUE; TermBitmapProcess (hWnd, nRet, TRUE, FALSE); } else { L_TCHAR szTitle [_MAX_PATH]; GetChildTitle(hWnd, szTitle); L_FileError (hWndFrame, nRet, TEXT("Shear"), szTitle); } } UNLOCKCHILDDATA(hWnd); break; case IDM_NORMAL: pData = LOCKCHILDDATA (hWnd); pData->fFitImage = FALSE; SetZoomFactor (hWnd, 100); DisplayImageStatus (hWnd); BitmapSizeChange (hWnd, TRUE); UNLOCKCHILDDATA (hWnd); break; case IDM_SNAPWINDOW: pData = LOCKCHILDDATA (hWnd); SizeClientRect (hWnd, MulDiv(BITMAPWIDTH(&pData->ActiveBitmap), pData->nZoom, 100), MulDiv(BITMAPHEIGHT(&pData->ActiveBitmap), pData->nZoom, 100)); UNLOCKCHILDDATA (hWnd); break; case IDM_FITIMAGE: pData = LOCKCHILDDATA (hWnd); pData->fFitImage = TRUE; pData->nZoom = 100; DisplayImageStatus (hWnd); BitmapSizeChange (hWnd, TRUE); UNLOCKCHILDDATA (hWnd); break; //FORPANWINDOW case IDM_PANWINDOW: ulFlags = 0; pData = LOCKCHILDDATA (hWnd); if(!pData->bPanWindow) { pData->bUpdatePan = TRUE; switch(nDitherMode) { case IDM_ORDEREDDITHERING: ulFlags |= DISPLAYMODE_ORDEREDDITHER; break; case IDM_ERRORDIFFUSION: ulFlags |= DISPLAYMODE_ORDEREDDITHER; break; } ulFlags |= nBitonalFlags | nPaintResizeFlags; if(nPaletteMode == IDM_PALETTEFIXED) ulFlags |= DISPLAYMODE_FIXEDPALETTE; if(fNetscapePalette) ulFlags |= DISPLAYMODE_NETSCAPEPALETTE; /* Pan Window is created invisible */ /* Create Pan Window */ if(L_CreatePanWindow( pData->hBitmapWnd, &pData->ActiveBitmap, ulFlags, 0, 0, 150, 150, PANWINDOW_CLASS, LoadIcon(hInst, MAKEINTRESOURCE(IDI_MAIN)), LoadCursor(hInst, MAKEINTRESOURCE(IDC_HANDMOVE)), TRUE, PanWindowCallback, NULL ) == SUCCESS) /* first update will show Pan Window */ { L_UpdatePanWindow( pData->hPanWindow, &pData->ActiveBitmap, ulFlags, RGB(255,0,0), TEXT("Pan Window"), &pData->rcView ); pData->bPanWindow = TRUE; } } else { pData->bPanWindow = FALSE; if(pData->hPanWindow) L_DestroyPanWindow(pData->hPanWindow); } UNLOCKCHILDDATA (hWnd); break; case IDM_MAGGLASS: pData = LOCKCHILDDATA (hWnd); if (L_BitmapHasRgn(&pData->ActiveBitmap)) ChangeRegion(hWnd, IDM_CANCELREGION, pData ); if(!pData->bMagGlass) StartMagGlass(pData); else StopMagGlass(pData); UNLOCKCHILDDATA (hWnd); break; case IDM_ZOOM: pData = LOCKCHILDDATA (hWnd); bResize=FALSE; if(codeNotify) { bResize=TRUE; nValue=codeNotify; } else if ((nValue = GetZoomFactor (hWnd, pData->nZoom)) > 0) bResize=TRUE; if(bResize) { pData->fFitImage = FALSE; SetZoomFactor (hWnd, nValue); DisplayImageStatus (hWnd); BitmapSizeChange (hWnd, TRUE); } UNLOCKCHILDDATA (hWnd); break; case IDM_COPY: hCursor = SetCursor (LoadCursor (NULL, IDC_WAIT)); pData = LOCKCHILDDATA (hWnd); /* if the bitmap is too big, we might get an error copying the DDB file. Try to copy to the clipboard only the DIB */ if(!L_CopyToClipboard (hWnd, &pData->ActiveBitmap, COPY2CB_EMPTY|COPY2CB_DIB|COPY2CB_PALETTE|COPY2CB_RGN)) { GetChildTitle(hWnd, szText); L_FileError(hWndFrame, ERROR_NO_MEMORY,TEXT("Copy"), szText); } SetCursor (hCursor); UNLOCKCHILDDATA (hWnd); break; case IDM_COPYRGN: { RECT rcRgn; BITMAPHANDLE bmpRgn; HRGN hRgn=NULL; hCursor = SetCursor (LoadCursor (NULL, IDC_WAIT)); pData = LOCKCHILDDATA (hWnd); L_GetBitmapRgnBounds(&pData->ActiveBitmap, NULL, &rcRgn); L_InitBitmap(&bmpRgn, sizeof(BITMAPHANDLE), 0, 0, 0); L_CopyBitmapRect(&bmpRgn, &pData->ActiveBitmap, 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); /* if the bitmap is too big, we might get an error copying the DDB file. Try to copy to the clipboard only the DIB */ if(!L_CopyToClipboard (hWnd, &bmpRgn, COPY2CB_EMPTY|COPY2CB_DIB|COPY2CB_PALETTE|COPY2CB_RGN)) { GetChildTitle(hWnd, szText); L_FileError (hWndFrame, ERROR_NO_MEMORY, TEXT("Copy"), szText); } L_FreeBitmap(&bmpRgn); SetCursor (hCursor); UNLOCKCHILDDATA (hWnd); } break; case IDM_PRINT: hCursor = SetCursor (LoadCursor (NULL, IDC_WAIT)); pData = LOCKCHILDDATA (hWnd); { HDC hdcPrinter = L_PrintBitmap(NULL,NULL,0,0,0,0,FALSE); L_INT nWidth = MulDiv(BITMAPWIDTH(&pData->ActiveBitmap),GetDeviceCaps(hdcPrinter,LOGPIXELSX),pData->ActiveBitmap.XResolution); L_INT nHeight = MulDiv(BITMAPHEIGHT(&pData->ActiveBitmap),GetDeviceCaps(hdcPrinter,LOGPIXELSX),pData->ActiveBitmap.YResolution); // fit to page if the bitmap is too large if(nWidth >= GetDeviceCaps(hdcPrinter, HORZRES) || nHeight >= GetDeviceCaps(hdcPrinter, VERTRES)) nWidth = nHeight = 0; if(fUseFastPrint) L_PrintBitmapFast(hdcPrinter, &pData->ActiveBitmap, 1, 1, nWidth, nHeight, TRUE); else L_PrintBitmap (hdcPrinter,&pData->ActiveBitmap, 1, 1, nWidth, nHeight, TRUE); } UNLOCKCHILDDATA (hWnd); SetCursor (hCursor); break; case IDM_EFFECTS: if (GetEffectsDelay (hWnd, &uEffectDelay)) DemoEffects (hWnd); break; case IDM_ELEMENTS: DemoElements (hWnd); break; case IDM_PLAYANIMATION: PlayAnimation (hWnd); break; case IDC_LISTBOX: if(codeNotify==LBN_SELCHANGE) { pData = LOCKCHILDDATA(hWnd); if(pData->nCurrentPage!=(GETCURSEL(hWndCtl)+1)) LoadBitmapPage(hWnd,GETCURSEL(hWndCtl)+1,!pData->bGifAnimationFile); if(pData->hListBox) RedrawWindow(pData->hListBox,0,0,RDW_INVALIDATE|RDW_UPDATENOW|RDW_ERASE); UNLOCKCHILDDATA (hWnd); } break; case IDM_VIEWPALETTE: pData = LOCKCHILDDATA (hWnd); GetColor(hWnd, &pData->ActiveBitmap, NULL, &bColorsChanged); if(bColorsChanged) { pData->bImageChanged=TRUE; FORWARD_WM_QUERYNEWPALETTE (hWnd, SendMessage); InvalidateRect(pData->hBitmapWnd, NULL, TRUE); } UNLOCKCHILDDATA (hWnd); break; case IDM_VIEWINTENSITY: pData = LOCKCHILDDATA (hWnd); ZeroMemory(&BrightnessParams,sizeof (BRIGHTNESSDLGPARAMS)); BrightnessParams.uStructSize = sizeof(BRIGHTNESSDLGPARAMS); BrightnessParams.pBitmap = &pData->ActiveBitmap; BrightnessParams.nChange = L_GetPaintIntensity(&pData->ActiveBitmap) ; BrightnessParams.uDlgFlags = 0; L_DlgSetString (DLG_BRIGHTNESS_IDSTR_CAPTION, TEXT("Paint Intensity")); if(L_DlgBrightness( hWnd,&BrightnessParams ) == SUCCESS_DLG_OK) { if(BrightnessParams.nChange >= -1000 && BrightnessParams.nChange <= 1000) { L_SetPaintIntensity(&pData->ActiveBitmap, BrightnessParams.nChange); FORWARD_WM_QUERYNEWPALETTE (hWnd, SendMessage); InvalidateRect(pData->hBitmapWnd, NULL, TRUE); if(pData->hPanWindow) { RedrawWindow(pData->hPanWindow,NULL,NULL,RDW_INVALIDATE); } if( pData->bMagGlass ) { StopMagGlass( pData ); StartMagGlass( pData ); } } } break; case IDM_VIEWCONTRAST: pData = LOCKCHILDDATA (hWnd); ZeroMemory(&ContrastParams,sizeof(CONTRASTDLGPARAMS)); ContrastParams.uStructSize = sizeof(CONTRASTDLGPARAMS); ContrastParams.pBitmap = &pData->ActiveBitmap; ContrastParams.nChange = L_GetPaintContrast(&pData->ActiveBitmap); ContrastParams.uDlgFlags = 0; if(L_DlgContrast( hWnd,&ContrastParams ) == SUCCESS_DLG_OK) { if(ContrastParams.nChange >= -1000 && ContrastParams.nChange <= 1000) { L_SetPaintContrast(&pData->ActiveBitmap, ContrastParams.nChange); FORWARD_WM_QUERYNEWPALETTE (hWnd, SendMessage); InvalidateRect(pData->hBitmapWnd, NULL, TRUE); if(pData->hPanWindow) { RedrawWindow(pData->hPanWindow,NULL,NULL,RDW_INVALIDATE); } if( pData->bMagGlass ) { StopMagGlass( pData ); StartMagGlass( pData ); } } } break; case IDM_VIEWGAMMA: pData = LOCKCHILDDATA (hWnd); ZeroMemory(&GammaAdjustmentParams,sizeof(GAMMAADJUSTMENTDLGPARAMS)); uGamma = (L_INT)L_GetPaintGamma(&pData->ActiveBitmap); GammaAdjustmentParams.uStructSize = sizeof(GAMMAADJUSTMENTDLGPARAMS); GammaAdjustmentParams.pBitmap = &pData->ActiveBitmap; GammaAdjustmentParams.nBlueValue = uGamma ; GammaAdjustmentParams.nGreenValue = uGamma ; GammaAdjustmentParams.nRedValue = uGamma ; GammaAdjustmentParams.bAllChannels = TRUE ; GammaAdjustmentParams.uDlgFlags = DLG_GAMMAADJUSTMENT_FORCELINKCHANNELS; if(L_DlgGammaAdjustment( hWnd,&GammaAdjustmentParams ) == SUCCESS_DLG_OK) { nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { L_SetPaintGamma(&pData->ActiveBitmap, GammaAdjustmentParams.nRedValue); FORWARD_WM_QUERYNEWPALETTE (hWnd, SendMessage); InvalidateRect(pData->hBitmapWnd, NULL, TRUE); if(pData->hPanWindow) { RedrawWindow(pData->hPanWindow,NULL,NULL,RDW_INVALIDATE); } if( pData->bMagGlass ) { StopMagGlass( pData ); StartMagGlass( pData ); } } TermBitmapProcess (hWnd, nRet, TRUE, FALSE); } break; case IDM_ADDBORDER: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ADDBORDERINFO AddBorderInfo; BITMAPHANDLE TileBitmap ; memset(&AddBorderParams,0,sizeof(ADDBORDERDLGPARAMS)); memset(&AddBorderInfo,0,sizeof(ADDBORDERINFO)); memset(&TileBitmap,0,sizeof(BITMAPHANDLE)); AddBorderInfo.pTileBitmap = &TileBitmap ; nRet = ShowAddBorderDialog ( hWnd, pBitmap, &AddBorderParams, &AddBorderInfo) ; if ( nRet == SUCCESS_DLG_OK ) { nRet = L_AddBorder ( pBitmap, &AddBorderInfo ) ; if(TileBitmap.Flags.Allocated) L_FreeBitmap (&TileBitmap); if(SUCCESS == nRet) { L_FreeBitmapRgn(&pData->ActiveBitmap); pData->bImageChanged=TRUE; } } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_ADDFRAME: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ADDFRAMEINFO AddFrameInfo; BITMAPHANDLE FrameBitmap; memset(&AddFrameParams,0,sizeof(ADDFRAMEDLGPARAMS)); memset(&AddFrameInfo,0,sizeof(ADDFRAMEINFO)); memset(&FrameBitmap,0,sizeof(BITMAPHANDLE)); AddFrameInfo.pBitmapFrame=&FrameBitmap; nRet = ShowAddFrameDialog ( hWnd, pBitmap, &AddFrameParams, &AddFrameInfo ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet = L_AddFrame ( pBitmap, &AddFrameInfo ) ; if(FrameBitmap.Flags.Allocated) L_FreeBitmap (&FrameBitmap); if(SUCCESS == nRet) { L_FreeBitmapRgn(&pData->ActiveBitmap); pData->bImageChanged=TRUE; } } } TermBitmapProcess (hWnd, nRet, TRUE, FALSE); break; } case IDM_MOTIONBLUR: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&MotionBlurParams,sizeof(MOTIONBLURDLGPARAMS)); nRet = ShowMotionBlurDialog ( hWnd, pBitmap, &MotionBlurParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_MotionBlurBitmap(pBitmap, MotionBlurParams.uDim, MotionBlurParams.nAngle, MotionBlurParams.bUnidirectional); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_RADIALBLUR: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&RadialBlurParams,sizeof(RADIALBLURDLGPARAMS)); nRet = ShowRadialBlurDialog ( hWnd, pBitmap, &RadialBlurParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_RadialBlurBitmap(pBitmap, RadialBlurParams.uDim, RadialBlurParams.uStress, RadialBlurParams.ptCenter); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_ZOOMBLUR: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&ZoomBlurParams,sizeof(ZOOMBLURDLGPARAMS)); nRet = ShowZoomBlurDialog ( hWnd, pBitmap, &ZoomBlurParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_ZoomBlurBitmap(pBitmap, ZoomBlurParams.uDim, ZoomBlurParams.uStress, ZoomBlurParams.ptCenter); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_GAUSSIANBLUR: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&GaussianBlurParams,sizeof(GAUSSIANBLURDLGPARAMS)); nRet = ShowGaussianBlurDialog ( hWnd, pBitmap, &GaussianBlurParams ) ; if ( nRet == SUCCESS_DLG_OK ) { L_GaussianFilterBitmap(pBitmap, GaussianBlurParams.nRadius); pData->bImageChanged=TRUE; nRet = SUCCESS; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_ANTIALIAS: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&AntiAliasParams,sizeof(ANTIALIASDLGPARAMS)); nRet = ShowAntiAliasDialog ( hWnd, pBitmap, &AntiAliasParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_AntiAliasBitmap(pBitmap, AntiAliasParams.uThreshold, AntiAliasParams.uDim, AntiAliasParams.uFilter); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_UNSHARPMASK: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&UnsharpMaskParams,sizeof(UNSHARPMASKDLGPARAMS)); nRet = ShowUnsharpMaskDialog ( hWnd, pBitmap, &UnsharpMaskParams ) ; if ( nRet == SUCCESS_DLG_OK ) { L_UnsharpMaskBitmap(pBitmap,UnsharpMaskParams.nAmount, UnsharpMaskParams.nRadius, UnsharpMaskParams.nThreshold, UnsharpMaskParams.uUnshrpMaskFlags); pData->bImageChanged=TRUE; nRet = SUCCESS; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_MULTIPLY: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&MultiplyParams,sizeof(MULTIPLYDLGPARAMS)); nRet = ShowMultiplyDialog ( hWnd, pBitmap, &MultiplyParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_MultiplyBitmap(pBitmap,MultiplyParams.uFactor); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_FREEHANDWAVE: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&FreeHandWaveParams,sizeof(FREEHANDWAVEDLGPARAMS)); nRet = ShowFreeHandWaveDialog ( hWnd, pBitmap, &FreeHandWaveParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_FreeHandWaveBitmap(pBitmap, FreeHandWaveParams.pAmplitudes, FreeHandWaveParams.uAmplitudesCount, FreeHandWaveParams.uScale, FreeHandWaveParams.uWaveLen, FreeHandWaveParams.nAngle, FreeHandWaveParams.crFill, FreeHandWaveParams.uFreeHandWaveFlags); if(SUCCESS==nRet) pData->bImageChanged=TRUE; if(NULL!=FreeHandWaveParams.pAmplitudes) GlobalFree(FreeHandWaveParams.pAmplitudes); } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_WIND: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&WindParams,sizeof(WINDDLGPARAMS)); nRet = ShowWindDialog ( hWnd, pBitmap, &WindParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_WindBitmap(pBitmap, WindParams.uDim, WindParams.nAngle, WindParams.uOpacity); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_POLAR: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&PolarParams,sizeof(POLARDLGPARAMS)); nRet = ShowPolarDialog ( hWnd, pBitmap, &PolarParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_PolarBitmap(pBitmap,PolarParams.crFill,PolarParams.uPolarFlags); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_ZOOMWAVE: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&ZoomWaveParams,sizeof(ZOOMWAVEDLGPARAMS)); nRet = ShowZoomWaveDialog ( hWnd, pBitmap, &ZoomWaveParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_ZoomWaveBitmap(pBitmap, ZoomWaveParams.uAmplitude, ZoomWaveParams.uFrequency, ZoomWaveParams.nPhase, ZoomWaveParams.uZoomFactor, ZoomWaveParams.ptCenter, ZoomWaveParams.crFill, ZoomWaveParams.uZoomWaveFlags); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_RADIALWAVE: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&RadialWaveParams,sizeof(RADIALWAVEDLGPARAMS)); nRet = ShowRadialWaveDialog ( hWnd, pBitmap, &RadialWaveParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_RadWaveBitmap(pBitmap, RadialWaveParams.uAmplitude, RadialWaveParams.uWaveLen, RadialWaveParams.nPhase, RadialWaveParams.ptCenter, RadialWaveParams.crFill, RadialWaveParams.uRadialWaveFlags); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_SWIRL: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&SwirlParams,sizeof(SWIRLDLGPARAMS)); nRet = ShowSwirlDialog ( hWnd, pBitmap, &SwirlParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_SwirlBitmap(pBitmap,SwirlParams.nAngle,SwirlParams.ptCenter); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_WAVESHEAR: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&WaveShearParams,sizeof(WAVESHEARDLGPARAMS)); nRet = ShowWaveShearDialog ( hWnd, pBitmap, &WaveShearParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_FreeHandShearBitmap(pBitmap, WaveShearParams.pAmplitudes, WaveShearParams.uAmplitudesCount, WaveShearParams.uScale, WaveShearParams.crFill, WaveShearParams.uWaveShearFlags); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_WAVE: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&WaveParams,sizeof(WAVEDLGPARAMS)); nRet = ShowWaveDialog ( hWnd, pBitmap, &WaveParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_WaveBitmap(pBitmap, WaveParams.uAmplitude, WaveParams.uWaveLen, WaveParams.nAngle, WaveParams.uHorzScale, WaveParams.uVertScale, WaveParams.crFill, WaveParams.uWaveFlags); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_PUNCH: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&PunchParams,sizeof(PUNCHDLGPARAMS)); nRet = ShowPunchDialog ( hWnd, pBitmap, &PunchParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_PunchBitmap(pBitmap, PunchParams.nValue, PunchParams.uStress, PunchParams.ptCenter, PunchParams.crFill, PunchParams.uPunchFlags); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_RIPPLE: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&RippleParams,sizeof(RIPPLEDLGPARAMS)); nRet = ShowRippleDialog ( hWnd, pBitmap, &RippleParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_RippleBitmap(pBitmap, RippleParams.uAmplitude, RippleParams.uFrequency, RippleParams.nPhase, RippleParams.uAttenuation, RippleParams.ptCenter, RippleParams.crFill, RippleParams.uRippleFlag); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_BENDING: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&BendingParams,sizeof(BENDINGDLGPARAMS)); nRet = ShowBendingDialog ( hWnd, pBitmap, &BendingParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_BendingBitmap(pBitmap, BendingParams.nValue, BendingParams.ptCenter, BendingParams.crFill, BendingParams.uBendingFlags); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_CYLINDRICAL: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&CylindricalParams,sizeof(CYLINDRICALDLGPARAMS)); nRet = ShowCylindricalDialog ( hWnd, pBitmap, &CylindricalParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_CylindricalBitmap(pBitmap, CylindricalParams.nValue, CylindricalParams.uType); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_SPHERIZE: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&SpherizeParams,sizeof(SPHERIZEDLGPARAMS)); nRet = ShowSpherizeDialog ( hWnd, pBitmap, &SpherizeParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_SpherizeBitmap(pBitmap, SpherizeParams.nValue, SpherizeParams.ptCenter, SpherizeParams.crFill, SpherizeParams.uSpherizeFlags); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_IMPRESSION: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&ImpressionistParams,sizeof(IMPRESSIONISTDLGPARAMS)); nRet = ShowImpressionistDialog ( hWnd, pBitmap, &ImpressionistParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_ImpressionistBitmap(pBitmap,ImpressionistParams.uHorzDim,ImpressionistParams.uVertDim); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_PIXELATE: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&PixelateParams,sizeof(PIXELATEDLGPARAMS)); nRet = ShowPixelateDialog ( hWnd, pBitmap, &PixelateParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_PixelateBitmap(pBitmap, PixelateParams.uCellWidth, PixelateParams.uCellHeight, PixelateParams.uOpacity, PixelateParams.ptCenter, PixelateParams.uPixelateFlags); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_DETECT: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&IntensityDetectParams,sizeof(INTENSITYDETECTDLGPARAMS)); nRet = ShowIntensityDetectDialog ( hWnd, pBitmap, &IntensityDetectParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_IntensityDetectBitmap(pBitmap, IntensityDetectParams.uLow, IntensityDetectParams.uHigh, IntensityDetectParams.crInColor, IntensityDetectParams.crOutColor, IntensityDetectParams.uChannel); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_BALANCECOLORS: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&BalanceColorsParams,sizeof(BALANCECOLORSDLGPARAMS)); nRet = ShowBalanceColorsDialog ( hWnd, pBitmap, &BalanceColorsParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_BalanceColors(pBitmap, &BalanceColorsParams.RedFactor, &BalanceColorsParams.GreenFactor, &BalanceColorsParams.BlueFactor); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_GRAYSCALE: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&GrayScaleParams,sizeof(GRAYSCALEDLGPARAMS)); nRet = ShowGrayScaleDialog ( hWnd, pBitmap, &GrayScaleParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_GrayScaleBitmapExt(pBitmap, GrayScaleParams.nRedFactor, GrayScaleParams.nGreenFactor, GrayScaleParams.nBlueFactor); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_COLOREDGRAY: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&ColoredGrayParams,sizeof(COLOREDGRAYDLGPARAMS)); nRet = ShowColoredGrayDialog ( hWnd, pBitmap, &ColoredGrayParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_ConvertToColoredGray(pBitmap, ColoredGrayParams.nRedFactor, ColoredGrayParams.nGreenFactor, ColoredGrayParams.nBlueFactor, ColoredGrayParams.nRedGrayFactor, ColoredGrayParams.nGreenGrayFactor, ColoredGrayParams.nBlueGrayFactor); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_REMAPINTENSITY: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&RemapIntensityParams,sizeof(REMAPINTENSITYDLGPARAMS)); nRet = ShowRemapIntensityDialog ( hWnd, pBitmap, &RemapIntensityParams ) ; if ( nRet == SUCCESS_DLG_OK ) { switch(RemapIntensityParams.uChannel) { case CHANNEL_MASTER: { nRet = L_RemapBitmapIntensity ( pBitmap, RemapIntensityParams.puRGBLookup, RemapIntensityParams.uLookupLen, CHANNEL_MASTER ) ; break ; } case CHANNEL_RED: { nRet = L_RemapBitmapIntensity ( pBitmap, RemapIntensityParams.puRedLookup, RemapIntensityParams.uLookupLen, CHANNEL_RED ) ; break ; } case CHANNEL_GREEN: { nRet = L_RemapBitmapIntensity ( pBitmap, RemapIntensityParams.puGreenLookup, RemapIntensityParams.uLookupLen, CHANNEL_GREEN ) ; break ; } case CHANNEL_BLUE: { nRet = L_RemapBitmapIntensity ( pBitmap, RemapIntensityParams.puBlueLookup, RemapIntensityParams.uLookupLen, CHANNEL_BLUE ) ; break ; } } if(SUCCESS==nRet) pData->bImageChanged=TRUE; if(NULL!=RemapIntensityParams.puRGBLookup) GlobalFree(RemapIntensityParams.puRGBLookup); if(NULL!=RemapIntensityParams.puRedLookup) GlobalFree(RemapIntensityParams.puRedLookup); if(NULL!=RemapIntensityParams.puGreenLookup) GlobalFree(RemapIntensityParams.puGreenLookup); if(NULL!=RemapIntensityParams.puBlueLookup) GlobalFree(RemapIntensityParams.puBlueLookup); } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_REMAPHUE: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&RemapHueParams,sizeof(REMAPHUEDLGPARAMS)); nRet = ShowRemapHueDialog ( hWnd, pBitmap, &RemapHueParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_RemapBitmapHue(pBitmap, RemapHueParams.puMaskLookup, RemapHueParams.puHueLookup, RemapHueParams.puSaturationLookup, RemapHueParams.puValueLookup, RemapHueParams.uLookupLen); if(SUCCESS==nRet) pData->bImageChanged=TRUE; if(NULL!=RemapHueParams.puMaskLookup) GlobalFree(RemapHueParams.puMaskLookup); if(NULL!=RemapHueParams.puHueLookup) GlobalFree(RemapHueParams.puHueLookup); if(NULL!=RemapHueParams.puSaturationLookup) GlobalFree(RemapHueParams.puSaturationLookup); if(NULL!=RemapHueParams.puValueLookup) GlobalFree(RemapHueParams.puValueLookup); } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_LOCALEQUALIZE: { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, FALSE); if (nRet == SUCCESS) { ZeroMemory(&LocalHistoEqualizeParams,sizeof(LOCALHISTOEQUALIZEDLGPARAMS)); nRet = ShowLocalHistoEqualizeDialog ( hWnd, pBitmap, &LocalHistoEqualizeParams ) ; if ( nRet == SUCCESS_DLG_OK ) { nRet=L_LocalHistoEqualizeBitmap(pBitmap, LocalHistoEqualizeParams.nWidth, LocalHistoEqualizeParams.nHeight, LocalHistoEqualizeParams.nXExtention, LocalHistoEqualizeParams.nYExtention, LocalHistoEqualizeParams.uType, LocalHistoEqualizeParams.uSmooth); if(SUCCESS==nRet) pData->bImageChanged=TRUE; } } TermBitmapProcess (hWnd, nRet, TRUE, TRUE); break; } case IDM_SLICE: nRet = 0; nRet = DoDialogBoxParam(IDD_SLC_DLG, hWnd, (DLGPROC) SliceDlgProc, 0); if(nRet) { pData = LOCKCHILDDATA (hWnd); nRet = InitBitmapProcess (hWnd, &pBitmap, TRUE); if (nRet == SUCCESS) nRet = SliceBitmapDemo(hWnd, pBitmap); if(nRet == SUCCESS) { pData = LOCKCHILDDATA(hWnd); pData->bImageChanged=TRUE; UNLOCKCHILDDATA(hWnd); } TermBitmapProcess (hWnd, nRet, FALSE, FALSE); } break; } return; } /*====(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 VOID Child_OnMDIActivate (HWND hWnd, BOOL fActive, HWND hWndActivate, HWND hWndDeactivate) { LPCHILDDATA pData; UNREFERENCED_PARAMETER(hWndDeactivate); pData = LOCKCHILDDATA(hWnd); if(fActive) { Child_OnQueryNewPalette(hWnd); if(pData->hListBox) RedrawWindow(pData->hListBox,0,0,RDW_INVALIDATE|RDW_UPDATENOW|RDW_ERASE); SetFocus(hWnd); DisplayImageStatus(hWnd); } else if(!hWndActivate) { SetStatusBarText(NULL, NULL, 0, FALSE); } UNLOCKCHILDDATA(hWnd); return; } /*====(Child_OnPaletteChanged)============================================== Description: Processes WM_PALETTECHANGED message 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 VOID Child_OnPaletteChanged (HWND hWnd, HWND hWndPaletteChange) { HDC hDC; HPALETTE hOldPalette; LPCHILDDATA pData; pData = LOCKCHILDDATA (hWnd); if ((hWnd == hWndPaletteChange)||(pData->hBitmapWnd==hWndPaletteChange)) return; if (pData->hPalette) { DeleteObject (pData->hPalette); pData->hPalette = NULL; } hDC = GetDC (pData->hBitmapWnd); pData->hPalette = L_CreatePaintPalette (hDC, &pData->ActiveBitmap); hOldPalette = SelectPalette (hDC, pData->hPalette, TRUE); RealizePalette (hDC); InvalidateRect (pData->hBitmapWnd, 0, FALSE); if(pData->hListBox) RedrawWindow(pData->hListBox,0,0,RDW_INVALIDATE|RDW_UPDATENOW|RDW_ERASE); SelectPalette (hDC, hOldPalette, TRUE); ReleaseDC (pData->hBitmapWnd, hDC); //FORPANWINDOW if(pData->hPanWindow) FORWARD_WM_PALETTECHANGED (pData->hPanWindow, (HWND) (UINT) (hWndPaletteChange), SendMessage); UNLOCKCHILDDATA (hWnd); return; } /*====(Child_OnQueryNewPalette)============================================ Description: Processes WM_QUERYNEWPALETTE message 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 BOOL Child_OnQueryNewPalette (HWND hWnd) { HDC hDC; HPALETTE hOldPalette; L_INT nNoColors = 0; LPCHILDDATA pData; L_UINT32 ulFlags; pData = LOCKCHILDDATA (hWnd); if (pData->hPalette) { DeleteObject (pData->hPalette); pData->hPalette = NULL; } if (pData->ActiveBitmap.Flags.Allocated) { hDC = GetDC (pData->hBitmapWnd); ulFlags = L_GetDisplayMode (); if ((nBitonalFlags & DISPLAYMODE_SCALETOGRAY) && !fInLoadFile) L_SetDisplayMode (DISPLAYMODE_SCALETOGRAY, DISPLAYMODE_SCALETOGRAY); if(nPaletteMode == IDM_PALETTEFIXED) L_SetDisplayMode (DISPLAYMODE_FIXEDPALETTE, DISPLAYMODE_FIXEDPALETTE); if(fNetscapePalette) L_SetDisplayMode (DISPLAYMODE_NETSCAPEPALETTE, DISPLAYMODE_NETSCAPEPALETTE); pData->hPalette = L_CreatePaintPalette (hDC, &pData->ActiveBitmap); if(pData->hPalette) { hOldPalette = SelectPalette (hDC, pData->hPalette,FALSE); nNoColors = RealizePalette (hDC); if (nNoColors) InvalidateRect (pData->hBitmapWnd, NULL, FALSE); if(pData->hListBox) RedrawWindow(pData->hListBox,0,0,RDW_INVALIDATE|RDW_UPDATENOW|RDW_ERASE); SelectPalette (hDC, hOldPalette, TRUE); } L_SetDisplayMode (DISPLAYMODE_RESETPOSITIONS, ulFlags); ReleaseDC (pData->hBitmapWnd, hDC); } UNLOCKCHILDDATA (hWnd); return(nNoColors); } /*====(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 VOID Child_OnClose(HWND hWnd) { LPCHILDDATA pData = LOCKCHILDDATA (hWnd); L_INT nItemsNo,i; if (!fInProcess) { if(pData) { StopMagGlass(pData); if(IsWindow(pData->hListBox)) { nItemsNo=GETCOUNT(pData->hListBox); for(i=0;ihListBox,i); for(i=0;ihListBox,0); } UNLOCKCHILDDATA (hWnd); } FORWARD_WM_CLOSE(hWnd,DefMDIChildProc); } } /*====(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 VOID Child_OnDestroy (HWND hWnd) { LPCHILDDATA pData = LOCKCHILDDATA (hWnd); if(pData) { SetDupTitleCount(hWnd, TRUE); if(L_BitmapHasRgn(&pData->ActiveBitmap)) KillTimer(hWnd, ID_REGIONEVENT); if (pData->hPalette) DeleteObject (pData->hPalette); PreFrameChange(hWnd); if (pData->Bitmap.Flags.Allocated) L_FreeBitmap (&pData->Bitmap); if (pData->hList) L_DestroyBitmapList (pData->hList); FreeRegionBitmaps (pData); //FORPANWINDOW //destroy Pan Window if(pData->hPanWindow) L_DestroyPanWindow(pData->hPanWindow); GlobalFreePtr(pData); } } /*--------------------------------------------------------------------------+ | Function :Child_OnCtlColorListBox | Desc :sets the background color for the thumbnail listbox | Return : | Notes : +--------------------------------------------------------------------------*/ #ifdef WIN32 static HBRUSH Child_OnCtlColorListBox(HWND hWnd,HDC hDC,HWND hListBoxWnd,COLORREF Color) #else static HBRUSH Child_OnCtlColorListBox(HWND hwnd, HDC hdc, HWND hwndChild, int type) #endif { return(hListBkGndBrush); } /*--------------------------------------------------------------------------+ | Function :Child_OnMeasureItem | Desc :sent by the list box to determine the items (thumbnail) size | Return : | Notes : +--------------------------------------------------------------------------*/ #ifdef WIN32 static VOID Child_OnMeasureItem(HWND hwnd, MEASUREITEMSTRUCT *lpMeasureItem) #else static VOID Child_OnMeasureItem(HWND hwnd, MEASUREITEMSTRUCT FAR*lpMeasureItem) #endif { if(lpMeasureItem->CtlID==IDC_LISTBOX) { lpMeasureItem->itemWidth=LISTBOXWIDTH; lpMeasureItem->itemHeight=LISTBOXWIDTH; } else DefMDIChildProc(hwnd,WM_MEASUREITEM,(WPARAM)lpMeasureItem->CtlID,(LPARAM)lpMeasureItem); } /*--------------------------------------------------------------------------+ | Function :Child_OnDrawItem | Desc :draws the thumbnails for multipage file | Return : | Notes : +--------------------------------------------------------------------------*/ #ifdef WIN32 static VOID Child_OnDrawItem(HWND hwnd, const DRAWITEMSTRUCT* lpDrawItem) #else static VOID Child_OnDrawItem(HWND hwnd, const DRAWITEMSTRUCT FAR* lpDrawItem) #endif { LPTHUMBNAILDATA pThumbnailData; pBITMAPHANDLE pBitmap; L_UINT32 uDisplayMode; RECT Rect,TmpRect; L_TCHAR str[15]; HPALETTE hPaintPalette,hOldPalette; if((lpDrawItem->CtlID==IDC_LISTBOX)) { RedrawWindow(lpDrawItem->hwndItem,0,0,RDW_ERASE); if((pThumbnailData=(LPTHUMBNAILDATA)GlobalLock((HGLOBAL)lpDrawItem->itemData))!=0) { pBitmap=&pThumbnailData->ThumbnailBitmap; Rect.left=lpDrawItem->rcItem.left; Rect.top=lpDrawItem->rcItem.top; Rect.right=Rect.left+LISTBOXWIDTH; Rect.bottom=Rect.top+LISTBOXWIDTH; TmpRect=Rect; InflateRect(&Rect,-THUMBNAILEDGEWIDTH,-THUMBNAILEDGEWIDTH); DrawListBoxButton(lpDrawItem->hDC,(BOOL)((lpDrawItem->itemState&ODS_SELECTED)>0),&Rect); Rect.left=Rect.top=0; Rect.right=LISTBOXWIDTH-(THUMBNAILEDGEWIDTH<<2)-2; Rect.bottom=LISTBOXWIDTH-(THUMBNAILEDGEWIDTH<<2)-22; MatchAspectRatio(&Rect,pBitmap->Width,pBitmap->Height); CenterRect(&Rect,&TmpRect,TRUE,TRUE); OffsetRect(&Rect,0,-10); uDisplayMode=L_GetDisplayMode(); L_SetDisplayMode(DISPLAYMODE_FIXEDPALETTE|DISPLAYMODE_FAVORBLACK|DISPLAYMODE_SCALETOGRAY,DISPLAYMODE_FIXEDPALETTE|DISPLAYMODE_FAVORBLACK|DISPLAYMODE_SCALETOGRAY); if(fNetscapePalette) uDisplayMode=L_SetDisplayMode (DISPLAYMODE_NETSCAPEPALETTE, DISPLAYMODE_NETSCAPEPALETTE); if((hPaintPalette=L_CreatePaintPalette(lpDrawItem->hDC,pBitmap))!=0) { hOldPalette=SelectPalette(lpDrawItem->hDC,hPaintPalette,TRUE); RealizePalette(lpDrawItem->hDC); L_PaintDC(lpDrawItem->hDC,pBitmap,0,0,&Rect,0,SRCCOPY); DeleteObject(SelectPalette(lpDrawItem->hDC,hOldPalette,TRUE)); } else L_PaintDC(lpDrawItem->hDC,pBitmap,0,0,&Rect,0,SRCCOPY); L_SetDisplayMode(DISPLAYMODE_RESETPOSITIONS,uDisplayMode); Rect.bottom=lpDrawItem->rcItem.bottom-(THUMBNAILEDGEWIDTH<<1); Rect.top=Rect.bottom-20; strprintf(str,TEXT("%03d"),lpDrawItem->itemID+1); SetBkMode(lpDrawItem->hDC,TRANSPARENT); DrawText(lpDrawItem->hDC,str,lstrlen(str),&Rect,DT_VCENTER|DT_CENTER); GlobalUnlock((HGLOBAL)lpDrawItem->itemData); } } } /*--------------------------------------------------------------------------+ | Function :ResizeChildBitmapWindows | Desc :prepares the bitmap list with a suitable bitmap holder | Return : | Notes : +--------------------------------------------------------------------------*/ static VOID ResizeChildBitmapWindows(HWND hWnd) { LPCHILDDATA pData=LOCKCHILDDATA(hWnd); RECT rcListBox,Rect; GetClientRect(hWnd,&Rect); if(pData) if(IsWindow(pData->hListBox)&&pData->bListBoxVisible) { //resize the thumbnails listbox and the bitmap window GetWindowRect(pData->hListBox,&rcListBox); MapWindowPoints(0,hWnd,(LPPOINT)&rcListBox,2); rcListBox.right-=rcListBox.left; if(pData->nLastCy!=Rect.bottom) { MoveWindow(pData->hListBox,0,0,rcListBox.right,Rect.bottom,TRUE); pData->nLastCy=Rect.bottom; } MoveWindow(pData->hBitmapWnd,rcListBox.right+SPLITWIDTH+1,0,Rect.right-(rcListBox.right+SPLITWIDTH+1),Rect.bottom,TRUE); } else MoveWindow(pData->hBitmapWnd,0,0,Rect.right,Rect.bottom,TRUE); UNLOCKCHILDDATA(hWnd); } /*--------------------------------------------------------------------------+ | Function :PrepareBitmapList | Desc :prepares the bitmap list with a suitable bitmap holder | Return : | Notes : +--------------------------------------------------------------------------*/ static VOID PrepareBitmapList(HBITMAPLIST hList,pBITMAPHANDLE pBitmap) { L_INT i,nItemsNo,nWidth =0, nHeight = 0; HDC hDC; L_GetBitmapListCount(hList, (L_UINT L_FAR *) &nItemsNo); for(i = 0; i < nItemsNo; i++) { L_GetBitmapListItem(hList, i, pBitmap, sizeof(BITMAPHANDLE)); nWidth = max(pBitmap->Left + pBitmap->Width, nWidth); nHeight = max(pBitmap->Top + pBitmap->Height, nHeight); } hDC = GetDC(0); L_CreateBitmap (pBitmap, sizeof(BITMAPHANDLE), TYPE_CONV, nWidth, nHeight, (L_INT) (GetDeviceCaps(hDC, BITSPIXEL) * GetDeviceCaps(hDC, PLANES)), fIsBGRDevice ? ORDER_BGR : ORDER_RGB, NULL, BOTTOM_LEFT, NULL, 0); ReleaseDC(0, hDC); } /*--------------------------------------------------------------------------+ | Function :CancelLoadDlgProc | Desc :cancel image loading dialog proc | Return :void | Notes : +--------------------------------------------------------------------------*/ L_BOOL CALLBACK L_EXPORT CancelLoadDlgProc (HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam) { static L_BOOL* lpbCancelLoading=0; switch(message) { case WM_INITDIALOG: if(lParam) lpbCancelLoading=(L_BOOL*)lParam; else DestroyWindow(hDlg); return(TRUE); case WM_COMMAND: if(GET_WM_COMMAND_ID(wParam,lParam)==IDCANCEL) if(lpbCancelLoading) *lpbCancelLoading=TRUE; else DestroyWindow(hDlg); return(TRUE); } return(FALSE); } /*--------------------------------------------------------------------------+ | Function :CancelFileLoading | Desc :for cancelling the loading of image files | Return : | Notes : +--------------------------------------------------------------------------*/ static L_INT CancelFileLoading(L_INT nStatus,L_INT nPageNo,L_INT nTotalPages) { static HWND hCancelDlg=0; static L_BOOL bCancelLoading; static FARPROC lpDlgProc=(FARPROC)CancelLoadDlgProc; L_INT nRet=SUCCESS; MSG Msg; L_TCHAR sBuff[10]; switch(nStatus) { case L_START_LOADING: if(IsWindow(hCancelDlg)) DestroyWindow(hCancelDlg); bCancelLoading=FALSE; #ifndef _WIN32 lpDlgProc=(FARPROC)MakeProcInstance((FARPROC)CancelLoadDlgProc,(HINSTANCE)hInst); #endif hCancelDlg=CreateDialogParam(hInst,MAKEINTRESOURCE(IDD_LOAD_FILE), hWndFrame,(DLGPROC)lpDlgProc,(LPARAM)(L_BOOL L_FAR*)&bCancelLoading); nRet=(hCancelDlg)? SUCCESS:FAILURE; break; case L_CHECK_LOADING: if(IsWindow(hCancelDlg)) { //strprintf(sBuff,TEXT("%04d/%04d"),nPageNo,nTotalPages); wsprintf(sBuff,TEXT("%d"),nPageNo); SetDlgItemText(hCancelDlg,IDC_STATIC_PAGENO,sBuff); } while(IsWindow(hCancelDlg)&&PeekMessage(&Msg,0,0,0,PM_REMOVE)) { if(!IsDialogMessage(hCancelDlg,&Msg)) { TranslateMessage(&Msg); DispatchMessage(&Msg); } if(bCancelLoading) return(FAILURE); } nRet=(bCancelLoading)? FAILURE:SUCCESS; break; case L_END_LOADING: if(IsWindow(hCancelDlg)) { DestroyWindow(hCancelDlg); #ifndef _WIN32 FreeProcInstance(lpDlgProc); #endif bCancelLoading=FALSE; hCancelDlg=0; nRet=SUCCESS; } } return(nRet); } /*--------------------------------------------------------------------------+ | Function :CleanOpenDlgParam | Desc :Clean File open Param structuer | Return : | Notes : +--------------------------------------------------------------------------*/ L_VOID CleanOpenDlgParam(LPOPENDLGPARAMS pFOParam) { int i=0; if(pFOParam!=NULL && pFOParam->pFileData!= NULL ) { for(i=0; i < pFOParam->nNumOfFiles; ++i ) { if(pFOParam->pFileData[i].pBitmap != NULL) { L_FreeBitmap(pFOParam->pFileData[i].pBitmap); GlobalFreePtr(pFOParam->pFileData[i].pBitmap); } if(pFOParam->pFileData[i].pThumbnail != NULL) { L_FreeBitmap(pFOParam->pFileData[i].pThumbnail); GlobalFreePtr(pFOParam->pFileData[i].pThumbnail); } if(pFOParam->pFileData[i].pFileInfo != NULL) { GlobalFreePtr(pFOParam->pFileData[i].pFileInfo); } } GlobalFreePtr(pFOParam->pFileData); pFOParam->pFileData =NULL; pFOParam->nNumOfFiles = 0; } } /*--------------------------------------------------------------------------+ | Function :OpenBitmapFile | Desc :opens a bitmap using the common dialog of lead | Return : | Notes : +--------------------------------------------------------------------------*/ static L_INT OpenBitmapFile(L_TCHAR* lpFileName,L_INT nBuffSize,pBITMAPHANDLE pBitmap,L_TCHAR * lpsTitle) { static OPENDLGPARAMS FOParm; static OPENFILENAME OpenFileName; static L_BOOL bEnablePreview=TRUE; static L_TCHAR szFileName[_MAX_PATH]=TEXT(""); static FILEINFO foFileInfo; L_INT nRet; if(lpFileName&&(nBuffSize>=15)) { _fmemset(&FOParm, 0, sizeof(OPENDLGPARAMS)); _fmemset(&OpenFileName, 0, sizeof(OpenFileName)); FOParm.uStructSize = sizeof(OPENDLGPARAMS); FOParm.bShowLoadOptions = FALSE ; FOParm.bPreviewEnabled = bEnablePreview; FOParm.uDlgFlags = (fShowResize?DLG_OPEN_ENABLESIZING:0) | DLG_OPEN_LOADBITMAP | DLG_OPEN_SHOW_PREVIEW | DLG_OPEN_SHOW_FILEINFO; OpenFileName.lStructSize = sizeof(OPENFILENAME); OpenFileName.hwndOwner = hWndFrame; OpenFileName.lpstrFilter = NULL; OpenFileName.lpstrCustomFilter = NULL; OpenFileName.nMaxCustFilter = 0; OpenFileName.nFilterIndex = nOpenIndex; OpenFileName.lpstrTitle = lpsTitle; OpenFileName.lpstrDefExt = NULL; OpenFileName.Flags = 0; nRet = L_DlgOpen( hWndFrame, &OpenFileName, &FOParm); if(nRet == SUCCESS_DLG_OK) { nRet=FAILURE; nOpenIndex = OpenFileName.nFilterIndex; bEnablePreview = FOParm.bPreviewEnabled; if ( ( FOParm.pFileData != NULL ) && ( FOParm.nNumOfFiles > 0 ) ) { if ( FOParm.pFileData[ 0 ].pBitmap != NULL ) { if ( FOParm.pFileData[ 0 ].pBitmap->Flags.Allocated ) { *pBitmap = *FOParm.pFileData[ 0 ].pBitmap; memset(FOParm.pFileData[ 0 ].pBitmap,0,sizeof(BITMAPHANDLE)); nRet = SUCCESS ; lstrcpy(lpFileName,FOParm.pFileData[ 0 ].szFileName); } } } CleanOpenDlgParam(&FOParm); } } return nRet; } /*--------------------------------------------------------------------------+ | Function :OpenBitmapFrame | Desc :opens a bitmap using the common dialog of lead | Return : | Notes : +--------------------------------------------------------------------------*/ static L_INT OpenBitmapFrame(pBITMAPHANDLE pBitmap,L_TCHAR * lpsTitle) { L_INT nRet; static OPENDLGPARAMS FOParm; static OPENFILENAME OpenFileName; static L_BOOL bEnablePreview=TRUE; static FILEINFO foFileInfo; _fmemset(&FOParm, 0, sizeof(OPENDLGPARAMS)); _fmemset(&OpenFileName, 0, sizeof(OpenFileName)); FOParm.uStructSize = sizeof(OPENDLGPARAMS); FOParm.bShowLoadOptions = TRUE ; FOParm.bPreviewEnabled = bEnablePreview; FOParm.uDlgFlags = (fShowResize?DLG_OPEN_ENABLESIZING:0) | (fShowPreview? DLG_OPEN_SHOW_PREVIEW:0) | DLG_OPEN_LOADBITMAP | DLG_OPEN_SHOW_PROGRESSIVE | DLG_OPEN_SHOW_MULTIPAGE | DLG_OPEN_SHOW_LOADROTATED | DLG_OPEN_SHOW_LOADCOMPRESSED | DLG_OPEN_SHOW_FILEINFO | DLG_OPEN_SHOW_LOADOPTIONS | DLG_OPEN_SHOW_RASTEROPTIONS | DLG_OPEN_SHOW_PDFOPTIONS | DLG_OPEN_SHOW_VECTOROPTIONS ; OpenFileName.lStructSize = sizeof(OPENFILENAME); OpenFileName.hwndOwner = hWndFrame; OpenFileName.nFilterIndex = nOpenIndex; OpenFileName.lpstrTitle = lpsTitle; nRet = L_DlgOpen( hWndFrame, &OpenFileName, &FOParm ); if (nRet == SUCCESS_DLG_OK) { nRet = FAILURE; nOpenIndex = OpenFileName.nFilterIndex; bEnablePreview = FOParm.bPreviewEnabled; if ( ( FOParm.pFileData != NULL ) && ( FOParm.nNumOfFiles > 0 ) ) { if ( FOParm.pFileData[ 0 ].pBitmap != NULL ) { if ( FOParm.pFileData[ 0 ].pBitmap->Flags.Allocated ) { * pBitmap = *FOParm.pFileData[ 0 ].pBitmap; memset(FOParm.pFileData[ 0 ].pBitmap,0,sizeof(BITMAPHANDLE)); nRet = SUCCESS ; } } } CleanOpenDlgParam(&FOParm); } return nRet; } /*--------------------------------------------------------------------------+ | Function :DeleteThumbnail | Desc :deletes the thumbnail at nposs from the thumnails listbox | Return : | Notes : +--------------------------------------------------------------------------*/ static VOID DeleteThumbnail(HWND hListBox,L_INT nPos) { HGLOBAL hBitmapBuff; LPTHUMBNAILDATA pThumbnailData; hBitmapBuff=(HGLOBAL)GETITEMDATA(hListBox,nPos); if(hBitmapBuff) { if((pThumbnailData=(LPTHUMBNAILDATA)GlobalLock(hBitmapBuff))!=0) { if(pThumbnailData->ThumbnailBitmap.Flags.Allocated) L_FreeBitmap(&pThumbnailData->ThumbnailBitmap); GlobalUnlock(hBitmapBuff); } GlobalFree(hBitmapBuff); } } /*--------------------------------------------------------------------------+ | Function :AddThumbnail | Desc : generates a thumbnail (pThumbnailBitmap) from the input bitmap (pBitmap) | Return : | Notes : +--------------------------------------------------------------------------*/ L_INT GenerateThumbnailBitmap(pBITMAPHANDLE pThumbnailBitmap, pBITMAPHANDLE pBitmap) { L_INT nRet; RECT Rect; nRet = L_CopyBitmap(pThumbnailBitmap, pBitmap, sizeof(BITMAPHANDLE)); if(nRet != SUCCESS) return nRet; //set the size of the thumbnail SetRect(&Rect,0,0,LISTBOXWIDTH-(THUMBNAILEDGEWIDTH<<2),LISTBOXWIDTH-(THUMBNAILEDGEWIDTH<<2)-20); MatchAspectRatio(&Rect,pThumbnailBitmap->Width,pThumbnailBitmap->Height); //now resize the image to thumbnail size if((pThumbnailBitmap->BitsPerPixel>1)||(L_IsGrayScaleBitmap(pThumbnailBitmap)==GRAY_NO)) L_SizeBitmap(pThumbnailBitmap,Rect.right,Rect.bottom,SIZE_RESAMPLE); else L_SizeBitmap( pThumbnailBitmap,Rect.right,Rect.bottom, (L_IsSupportLocked(L_SUPPORT_DOCUMENT))? SIZE_NORMAL:(SIZE_FAVORBLACK|SIZE_NORMAL) ); return SUCCESS; } /*--------------------------------------------------------------------------+ | Function :AddThumbnail | Desc :adds a thumbnails to the created animation list to the child window | Return : | Notes : +--------------------------------------------------------------------------*/ static VOID AddThumbnail(HWND hListBox,pBITMAPHANDLE pBitmap,L_INT nPos) { HGLOBAL hBitmapBuff; LPTHUMBNAILDATA pThumbnailData; if((hBitmapBuff=GlobalAlloc(GHND,sizeof(THUMBNAILDATA)))!=0) { pThumbnailData=(LPTHUMBNAILDATA)GlobalLock(hBitmapBuff); // generate the thumbnail bitmap into pThumbnailData->ThumbnailBitmap if(GenerateThumbnailBitmap(&pThumbnailData->ThumbnailBitmap, pBitmap) == SUCCESS) { pThumbnailData->nZoom=100; GlobalUnlock(hBitmapBuff); // add it to the thumbnails listbox INSERTSTRING(hListBox,nPos,(L_TCHAR*)hBitmapBuff); } else { // free the allocated memory GlobalUnlock(hBitmapBuff); GlobalFree(hBitmapBuff); } } } /*--------------------------------------------------------------------------+ | Function :CreateThumbnailsFromBList | Desc :adds a thumbnails to the created animation list to the child window | Return : | Notes : +--------------------------------------------------------------------------*/ static VOID CreateThumbnailsFromBList(HWND hChildWnd) { LPCHILDDATA pData; BITMAPHANDLE TBitmap; L_UINT nPage; HCURSOR hOldCursor = SetCursor(LoadCursor(NULL, IDC_WAIT)); if((pData=LOCKCHILDDATA(hChildWnd))!=0) { if(pData->bAnimationExist) { UNLOCKCHILDDATA(hChildWnd); return; } if(pData->hList) { //loop through the pages for(nPage=0;nPage<=pData->uLastFrame;nPage++) if(L_GetBitmapListItem(pData->hList,nPage,&TBitmap,sizeof(BITMAPHANDLE))==SUCCESS) AddThumbnail(pData->hListBox,&TBitmap,nPage); //press the thumbnail of the displayed page nCurrentPage=0; SETHORIZONTALEXTENT(pData->hListBox,LISTBOXWIDTH); SETCURSEL(pData->hListBox,0); SETTOPINDEX(pData->hListBox,0); //reset the extended file options SetCursor(hOldCursor); } UNLOCKCHILDDATA (hChildWnd); } } /*--------------------------------------------------------------------------+ | Function :FillImageListBox | Desc :fills the listbox by the thumbnails of the pages contained in the multipage file | Return : | Notes : +--------------------------------------------------------------------------*/ static VOID FillImageListBox(HWND hListBox,L_TCHAR* szFileName,L_BOOL bShowCancelDlg) { LPTHUMBNAILDATA pThumbnailData; BITMAPHANDLE TmpBitmap; FILEINFO FileInfo; HGLOBAL hBitmapBuff; L_INT nPage,nRet; RECT Rect; HCURSOR hOldCursor = SetCursor(LoadCursor(NULL, IDC_WAIT)); L_INT nTotalPages; L_GetDefaultLoadFileOption(&LoadFileOption, sizeof(LOADFILEOPTION)); //retrieve the number of pages in the multipage file LoadFileOption.PageNumber = 32000; if(fLoadRotated) LoadFileOption.Flags |= ELO_ROTATED; else LoadFileOption.Flags &= ~ELO_ROTATED; L_FileInfo(szFileName,&FileInfo, sizeof(FILEINFO), fTotalPages? FILEINFO_TOTALPAGES : 0, &LoadFileOption); if(!fTotalPages) FileInfo.TotalPages = 1; if ( ( FileInfo.Format == FILE_ABC ) || ( FileInfo.Format == FILE_TIF_ABC ) ) { LoadFileOption.Flags |= ELO_FAST; } //loop through the pages if(bShowCancelDlg) { CancelFileLoading(L_START_LOADING,0,0); EnableFrameMenu(FALSE,TRUE); } nTotalPages = FileInfo.TotalPages; for(nPage=1;nPage<=nTotalPages;nPage++) { if(bShowCancelDlg) nRet=CancelFileLoading(L_CHECK_LOADING,nPage,FileInfo.TotalPages); LoadFileOption.PageNumber = nPage; // only the format is valid since different pages might have different width, height, etc FileInfo.Flags = FILEINFO_FORMATVALID; //load page[nPage] from the file if(L_LoadBitmap(szFileName,&TmpBitmap, sizeof(BITMAPHANDLE),0,fIsBGRDevice ? ORDER_BGRORGRAY : ORDER_RGBORGRAY, &LoadFileOption, &FileInfo)==SUCCESS) if((hBitmapBuff=GlobalAlloc(GHND,sizeof(THUMBNAILDATA)))!=0) { pThumbnailData=(LPTHUMBNAILDATA)GlobalLock(hBitmapBuff); //set the size of the thumbnail SetRect(&Rect,0,0,LISTBOXWIDTH-(THUMBNAILEDGEWIDTH<<2),LISTBOXWIDTH-(THUMBNAILEDGEWIDTH<<2)-20); MatchAspectRatio(&Rect,BITMAPWIDTH(&TmpBitmap),BITMAPHEIGHT(&TmpBitmap)); //now resize the image to thumbnail size if((TmpBitmap.BitsPerPixel>1)||(L_IsGrayScaleBitmap(&TmpBitmap)==GRAY_NO)) L_SizeBitmap(&TmpBitmap,Rect.right,Rect.bottom,SIZE_RESAMPLE); else L_SizeBitmap( &TmpBitmap,Rect.right,Rect.bottom, (L_IsSupportLocked(L_SUPPORT_DOCUMENT))? SIZE_NORMAL:(SIZE_FAVORBLACK|SIZE_NORMAL) ); //and reset the thumbnail data for that thumbnail pThumbnailData->ThumbnailBitmap=TmpBitmap; pThumbnailData->nZoom=100; GlobalUnlock(hBitmapBuff); //and add it to the thamnails listbox ADDSTRING(hListBox,(L_TCHAR* )hBitmapBuff); } if(bShowCancelDlg) { nRet=CancelFileLoading(L_CHECK_LOADING,nPage,FileInfo.TotalPages); if(nRet==FAILURE) { CancelFileLoading(L_END_LOADING,0,0); for(nRet=0;nRet<(nPage+1);nRet++) DeleteThumbnail(hListBox,nRet); for(nRet=0;nRet<(nPage+1);nRet++) DELETESTRING(hListBox,0); DestroyWindow(hListBox); break; } } } if ( ( FileInfo.Format == FILE_ABC ) || ( FileInfo.Format == FILE_TIF_ABC ) ) { LoadFileOption.Flags &= ~ELO_FAST; } if(bShowCancelDlg) { EnableFrameMenu(TRUE,TRUE); CancelFileLoading(L_END_LOADING,0,0); } //press the thumbnail of the displayed page nCurrentPage=(nCurrentPage<=FileInfo.PageNumber)? nCurrentPage:1; SETHORIZONTALEXTENT(hListBox,LISTBOXWIDTH); SETCURSEL(hListBox,nCurrentPage-1); SETTOPINDEX(hListBox,nCurrentPage-1); SetCursor(hOldCursor); } /*--------------------------------------------------------------------------+ | Function :LoadBitmapPage | Desc :Update the thumbnail from the current image. This function | should be called when an image belonging to a multipage file | or an animation is changed. | Return : | Notes : +--------------------------------------------------------------------------*/ static L_VOID UpdateThumbnailData(LPCHILDDATA pData) { LPTHUMBNAILDATA pThumbnailData; HGLOBAL hThumbnailData; hThumbnailData=(HGLOBAL)GETITEMDATA(pData->hListBox,pData->nCurrentPage-1); if(hThumbnailData) { pThumbnailData=(LPTHUMBNAILDATA)GlobalLock(hThumbnailData); // Regenerate the thumbnail bitmap L_FreeBitmap(&pThumbnailData->ThumbnailBitmap); GenerateThumbnailBitmap(&pThumbnailData->ThumbnailBitmap, &pData->ActiveBitmap); GlobalUnlock(hThumbnailData); SETITEMDATA(pData->hListBox, pData->nCurrentPage-1, (DWORD) hThumbnailData); } } /*--------------------------------------------------------------------------+ | Function :LoadBitmapPage | Desc :loads the selected thumbnail page from the multipage file | Return : | Notes : +--------------------------------------------------------------------------*/ static VOID LoadBitmapPage(HWND hChildWnd,L_INT nPageNo,L_BOOL bAskForSave) { LPCHILDDATA pData; LOADFILEOPTION LoadFileOption; BITMAPHANDLE TmpBitmap; LPTHUMBNAILDATA pThumbnailData; HGLOBAL hThumbnailData; THUMBNAILDATA ThumbnailData; FILEINFO FileInfo; L_BOOL bMagGlassWasOn; if((pData=LOCKCHILDDATA(hChildWnd))!=0) { if(pData->bAnimationExist) { UNLOCKCHILDDATA(hChildWnd); return; } if( pData->bMagGlass ) { bMagGlassWasOn = TRUE; StopMagGlass( pData ); } else bMagGlassWasOn = FALSE; //if the image is changed then notify the user if(((pData->bImageChanged)||(L_BitmapHasRgn(&pData->ActiveBitmap)==SUCCESS) )&&bAskForSave) switch(MessageBox(hChildWnd,TEXT("This page has been modified, Save changes?"),TEXT("LEAD API Main Demo"),MB_ICONSTOP|MB_YESNOCANCEL)) { case IDYES: L_FileInfo(pData->szTitle,&FileInfo,sizeof(FILEINFO),0,NULL); L_GetDefaultSaveFileOption(&SaveFileOption, sizeof(SAVEFILEOPTION)); SaveFileOption.PageNumber = pData->nCurrentPage; SaveFileOption.Flags&=~ESO_INSERTPAGE; SaveFileOption.Flags|=ESO_REPLACEPAGE; L_SaveFile(pData->szTitle,&pData->ActiveBitmap,FileInfo.Format,pData->ActiveBitmap.BitsPerPixel, GetProperQualityFactor(FileInfo.Format),SAVEFILE_OPTIMIZEDPALETTE,0,0,&SaveFileOption); break; case IDCANCEL: SETCURSEL(pData->hListBox,pData->nCurrentPage-1); UNLOCKCHILDDATA(hChildWnd); return; case IDNO: break; } //save the scrollbars positions for this thumbnail if(bAskForSave) { SaveThumbnailData(hChildWnd,pData->nCurrentPage); UpdateThumbnailData(pData); } //free any allocated regions or bitmaps if(L_BitmapHasRgn(&pData->ActiveBitmap)) { KillTimer(hChildWnd, ID_REGIONEVENT); L_FreeBitmapRgn(&pData->ActiveBitmap); } FreeRegionBitmaps(pData); if(pData->bGifAnimationFile) { if(pData->bImageChanged) pData->bImageChanged=FALSE; PreFrameChange(hChildWnd); pData->nCurrentPage=nPageNo; pData->uFrame=nPageNo-1; PostFrameChange(hChildWnd); UNLOCKCHILDDATA(hChildWnd); return; } if(pData->ActiveBitmap.Flags.Allocated) L_FreeBitmap (&pData->ActiveBitmap); L_GetDefaultLoadFileOption(&LoadFileOption, sizeof(LOADFILEOPTION)); //now load the selected thumbnail page from the file LoadFileOption.PageNumber = nPageNo; if(fLoadRotated) LoadFileOption.Flags |= ELO_ROTATED; else LoadFileOption.Flags &= ~ELO_ROTATED; if(L_LoadBitmap(pData->szTitle,&TmpBitmap, sizeof(BITMAPHANDLE),0,fIsBGRDevice ? ORDER_BGRORGRAY : ORDER_RGBORGRAY, &LoadFileOption, NULL)==SUCCESS) { pData->ActiveBitmap=TmpBitmap; if(pData->hListBox) { //and retrieve the thumbnail data of the selected thumbnail hThumbnailData=(HGLOBAL)GETITEMDATA(pData->hListBox,GETCURSEL(pData->hListBox)); if(hThumbnailData) { pThumbnailData=(LPTHUMBNAILDATA)GlobalLock(hThumbnailData); ThumbnailData=*pThumbnailData; GlobalUnlock(hThumbnailData); } } //restore the thumbnail zoom/fit/scrollbars values RestoreThumbnailData(hChildWnd,nPageNo); //and save the new values for the thumbnail data SaveThumbnailData(hChildWnd,nPageNo); pData->nCurrentPage=nPageNo; pData->bImageChanged=FALSE; Child_OnQueryNewPalette(hChildWnd); InvalidateRect(pData->hBitmapWnd,0,TRUE); RedrawWindow(pData->hListBox,0,0,RDW_INVALIDATE|RDW_UPDATENOW|RDW_ERASE); if( bMagGlassWasOn ) StartMagGlass( pData ); } } UNLOCKCHILDDATA(hChildWnd); } /*--------------------------------------------------------------------------+ | Function :SetThumbnails | Desc :hides or displayes the thumbnail listbox | Return : | Notes : +--------------------------------------------------------------------------*/ static VOID SetThumbnails(HWND hChildWnd,BOOL bAdd) { LPCHILDDATA pData=LOCKCHILDDATA(hChildWnd); if(pData&&IsWindow(hChildWnd)&&IsWindow(pData->hListBox)) { //show/hide the thumbnails listbox pData->bListBoxVisible=bAdd; pData->bSizeFixed=FALSE; ShowWindow(pData->hListBox,(bAdd)? SW_SHOWNA:SW_HIDE); ResizeChildBitmapWindows(hChildWnd); } if(!IsWindow(pData->hListBox)) pData->hListBox = NULL; UNLOCKCHILDDATA(hChildWnd); } /*--------------------------------------------------------------------------+ | Function :SaveThumbnailData | Desc :saves the data of the bitmap window scrollbars to the current thumbnail | Return : | Notes : +--------------------------------------------------------------------------*/ static VOID SaveThumbnailData(HWND hChildWnd,L_INT nIndex) { LPCHILDDATA pData=LOCKCHILDDATA(hChildWnd); LPTHUMBNAILDATA pThumbnailData; HGLOBAL hThumbnailData; L_INT nMin=0,nMax=0; if(pData&&IsWindow(pData->hListBox)) { hThumbnailData=(HGLOBAL)GETITEMDATA(pData->hListBox,nIndex-1); if(hThumbnailData) { pThumbnailData=(LPTHUMBNAILDATA)GlobalLock(hThumbnailData); if(pThumbnailData) { pThumbnailData->nHScrollPos = pData->nHScrollPos; pThumbnailData->nHScrollMax = pData->nHScrollMax; pThumbnailData->nVScrollPos = pData->nVScrollPos; pThumbnailData->nVScrollMax = pData->nVScrollMax; pThumbnailData->nFitType=pData->fFitImage; pThumbnailData->nZoom=pData->nZoom; // save the PaintIntensity, PaintContrast and PaintGamma settings pThumbnailData->nPaintContrast = L_GetPaintContrast(&pData->ActiveBitmap); pThumbnailData->nPaintIntensity = L_GetPaintIntensity(&pData->ActiveBitmap); pThumbnailData->uPaintGamma = L_GetPaintGamma(&pData->ActiveBitmap); } GlobalUnlock(hThumbnailData); } } UNLOCKCHILDDATA(hChildWnd); } /*--------------------------------------------------------------------------+ | Function :RestoreThumbnailData | Desc :restores the data of the wanted thumbnail to the bitmap window scrollbars | Return : | Notes : +--------------------------------------------------------------------------*/ static VOID RestoreThumbnailData(HWND hChildWnd,L_INT nIndex) { LPCHILDDATA pData=LOCKCHILDDATA(hChildWnd); LPTHUMBNAILDATA pThumbnailData; HGLOBAL hThumbnailData; RECT Rect; if(pData&&IsWindow(pData->hListBox)) { hThumbnailData=(HGLOBAL)GETITEMDATA(pData->hListBox,nIndex-1); if(hThumbnailData) { pThumbnailData=(LPTHUMBNAILDATA)GlobalLock(hThumbnailData); if(pThumbnailData->nFitType) Child_OnCommand(hChildWnd,IDM_FITIMAGE,0,0); else { pData->nHScrollPos=0; pData->nVScrollPos=0; pData->nHScrollMax=0; pData->nVScrollMax=0; pData->nZoom=100; pData->fFitImage=FALSE; GetClientRect(pData->hBitmapWnd,&Rect); Child_ProcessSize(hChildWnd,SIZE_RESTORED,Rect.right+1,Rect.bottom+1); SetScrollPos(pData->hBitmapWnd,SB_HORZ,pData->nHScrollPos=0,FALSE); SetScrollPos(pData->hBitmapWnd,SB_VERT,pData->nVScrollPos=0,FALSE); Child_OnCommand(hChildWnd,IDM_ZOOM,0,pThumbnailData->nZoom); OffsetRect(&pData->rcView,-pThumbnailData->nHScrollPos-pData->rcView.left,-pThumbnailData->nVScrollPos-pData->rcView.top); SetScrollPos(pData->hBitmapWnd,SB_HORZ,(pData->nHScrollPos=pThumbnailData->nHScrollPos) >> pData->nHScrollFactor,TRUE); SetScrollPos(pData->hBitmapWnd,SB_VERT,(pData->nVScrollPos=pThumbnailData->nVScrollPos) >> pData->nVScrollFactor,TRUE); } // restore the PaintIntensity, PaintContrast and PaintGamma settings L_SetPaintContrast(&pData->ActiveBitmap, pThumbnailData->nPaintContrast); L_SetPaintIntensity(&pData->ActiveBitmap, pThumbnailData->nPaintIntensity); L_SetPaintGamma(&pData->ActiveBitmap, pThumbnailData->uPaintGamma); GlobalUnlock(hThumbnailData); } } UNLOCKCHILDDATA(hChildWnd); } /*--------------------------------------------------------------------------+ | Function :Child_OnUserMessage | Desc :sent to hide or show the thumbnails listbox | Return : | Notes : +--------------------------------------------------------------------------*/ static VOID Child_OnUserMessage(HWND hWnd,UINT wParam,LPARAM lParam) { SetThumbnails(hWnd,(BOOL)wParam); lParam=lParam; } 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_ProcessSize)=================================================== Description: Responds to WM_SIZE message and sets the internal data accordingly. Syntax : VOID Child_ProcessSize(HWND hWnd, 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. ==========================================================================*/ static VOID Child_ProcessSize (HWND hWnd, UINT nState, L_INT nCx, L_INT nCy) { static L_BOOL fSizeInUse = FALSE; L_INT nWidth, nHeight, nVScroll, nHScroll; DWORD dwStyle; LPCHILDDATA pData; if (!fSizeInUse) { fSizeInUse = TRUE; pData = LOCKCHILDDATA (hWnd); if (nState != SIZEICONIC) { if (pData->fFitImage) { nWidth = 0; nHeight = 0; } else { nWidth = MulDiv (BITMAPWIDTH(&pData->ActiveBitmap), pData->nZoom, 100); nHeight = MulDiv (BITMAPHEIGHT(&pData->ActiveBitmap), pData->nZoom, 100); } pData->cxClient = nCx; pData->cyClient = nCy; dwStyle = GetWindowLong (pData->hBitmapWnd, GWL_STYLE); nVScroll = GetSystemMetrics (SM_CXVSCROLL) - GetSystemMetrics(SM_CXBORDER); nHScroll = GetSystemMetrics (SM_CYHSCROLL) - GetSystemMetrics(SM_CYBORDER); if (WS_VSCROLL & dwStyle) pData->cxClient += nVScroll; if (WS_HSCROLL & dwStyle) pData->cyClient += nHScroll; if (pData->cxClient < nWidth) { pData->cyClient -= nHScroll; if (pData->cyClient < nHeight) pData->cxClient -= nVScroll; } else if (pData->cyClient < nHeight) { pData->cxClient -= nVScroll; if (pData->cxClient < nWidth) pData->cyClient -= nHScroll; } pData->nHScrollStep = max (1, pData->cxClient / SCROLL_RATIO); pData->nVScrollStep = max (1, pData->cyClient / SCROLL_RATIO); pData->nVScrollMax = max (0, (nHeight - pData->cyClient /*- 1*/)); pData->nVScrollPos = max (0, min (pData->nVScrollPos, pData->nVScrollMax)); pData->nHScrollMax = max (0, (nWidth - pData->cxClient /*- 1*/)); pData->nHScrollPos = max (0, min (pData->nHScrollPos, pData->nHScrollMax)); if (pData->fFitImage) { SetRect (&pData->rcView, 0, 0, pData->cxClient, pData->cyClient); MatchAspectRatio (&pData->rcView, BITMAPWIDTH(&pData->ActiveBitmap), BITMAPHEIGHT(&pData->ActiveBitmap)); } else { SetRect (&pData->rcView, 0, 0, nWidth, nHeight); OffsetRect (&pData->rcView, -pData->nHScrollPos, -pData->nVScrollPos); } pData->nHScrollFactor = 0; while((pData->nHScrollMax >> pData->nHScrollFactor) > 0x7FFF) pData->nHScrollFactor++; MySetScrollRange (pData->hBitmapWnd, SB_HORZ, 0, pData->nHScrollMax >> pData->nHScrollFactor, max (pData->nHScrollStep, (pData->cxClient - pData->nHScrollStep)), FALSE); SetScrollPos (pData->hBitmapWnd, SB_HORZ, pData->nHScrollPos >> pData->nHScrollFactor, TRUE); pData->nVScrollFactor = 0; while((pData->nVScrollMax >> pData->nVScrollFactor) > 0x7FFF) pData->nVScrollFactor++; MySetScrollRange (pData->hBitmapWnd, SB_VERT, 0, pData->nVScrollMax >> pData->nVScrollFactor, max (pData->nVScrollStep, (pData->cyClient - pData->nVScrollStep)), FALSE); SetScrollPos (pData->hBitmapWnd, SB_VERT, pData->nVScrollPos >> pData->nVScrollFactor, TRUE); } else { pData->cxClient = nCx; pData->cyClient = nCy; SetRect (&pData->rcView, 0, 0, pData->cxClient, pData->cyClient); MatchAspectRatio (&pData->rcView, BITMAPWIDTH(&pData->ActiveBitmap), BITMAPHEIGHT(&pData->ActiveBitmap)); } UNLOCKCHILDDATA (hWnd); fSizeInUse = FALSE; } return; } /*====(DemoEffects)======================================================== Description: Demonstrates the various painting effects available in the toolkit. Syntax : static L_VOID DemoEffects (HWND hWnd) Parameters : hWnd Handle of a window. Return Value: None. ==========================================================================*/ static L_VOID DemoEffects (HWND hWnd) { HCURSOR hCursor; LPCHILDDATA pData; L_INT u, i; L_TCHAR szText[256]; HDC hDC; RECT rcPaint; HPALETTE hPalette = NULL; DWORD dw; L_UINT32 ulFlags; L_BOOL bMagGlassWasOn; hCursor = SetCursor (LoadCursor (NULL, IDC_WAIT)); fUseProgress = TRUE; pData = LOCKCHILDDATA (hWnd); if( pData->bMagGlass ) { bMagGlassWasOn = TRUE; StopMagGlass( pData ); } else bMagGlassWasOn = FALSE; hDC = GetDC (pData->hBitmapWnd); if (pData->hPalette) hPalette = SelectPalette (hDC, pData->hPalette, TRUE); if(L_BitmapHasRgn(&pData->ActiveBitmap)) KillTimer(hWnd, ID_REGIONEVENT); if (fUseProgress) EnableStatusDialog (hWnd, TRUE); UpdateWindow(pData->hBitmapWnd); for (i = 0; ; i++) { if( i >= GetMaxEffect(EFX_EFFECT_TYPE) ) i = 0; u = GetConstEffect(EFX_EFFECT_TYPE, i); GetTextEffect(EFX_EFFECT_TYPE, u, szText); SetWindowText (hWnd, szText); ulFlags = L_GetDisplayMode (); switch (nDitherMode) { case IDM_ORDEREDDITHERING: L_SetDisplayMode (DISPLAYMODE_ORDEREDDITHER, DISPLAYMODE_ORDEREDDITHER); break; case IDM_ERRORDIFFUSION: L_SetDisplayMode (DISPLAYMODE_ORDEREDDITHER, 0); break; } L_SetDisplayMode (DISPLAYMODE_FAVORBLACK|DISPLAYMODE_SCALETOGRAY, nBitonalFlags); // set the linear interpolation or bicubic resample during paint L_SetDisplayMode(DISPLAYMODE_RESAMPLE|DISPLAYMODE_BICUBIC, nPaintResizeFlags); if(nPaletteMode == IDM_PALETTEFIXED) L_SetDisplayMode (DISPLAYMODE_FIXEDPALETTE, DISPLAYMODE_FIXEDPALETTE); if(fNetscapePalette) L_SetDisplayMode (DISPLAYMODE_NETSCAPEPALETTE, DISPLAYMODE_NETSCAPEPALETTE); GetClientRect (pData->hBitmapWnd, &rcPaint); L_EfxPaintTransition (hDC, EFX_TRANS_GRADIENT_ELLIPSE_FROM_C, RGB(0, 0, 0), RGB(0, 0, 255), 64, &pData->rcView, EFX_EFFECT_NONE, 10, 0, 0,0,1, 1, FALSE, 0, 0, 0, SRCCOPY); L_EfxPaintBitmap (hDC, &pData->ActiveBitmap, NULL, NULL, &pData->rcView, &rcPaint, u, 11, uEffectDelay, 0,0,1, 1, FALSE, RGB(0, 0, 0), 3, RGB(255, 0, 0), SRCCOPY); L_SetDisplayMode (DISPLAYMODE_RESETPOSITIONS, ulFlags); if (fUseProgress && fKillProgress) goto abort; dw = GetTickCount (); while ((GetTickCount () - dw) < 1000); } abort: if (fUseProgress) EnableStatusDialog (hWnd, FALSE); if (pData->hPalette) SelectPalette (hDC, hPalette, TRUE); ReleaseDC (pData->hBitmapWnd, hDC); if(L_BitmapHasRgn(&pData->ActiveBitmap) && GetFocus() == hWnd) SetTimer(hWnd, ID_REGIONEVENT, REGIONEVENTDELAY, NULL); DisplayImageTitle (hWnd); InvalidateRect (pData->hBitmapWnd, NULL, TRUE); UpdateWindow (pData->hBitmapWnd); if( bMagGlassWasOn ) StartMagGlass( pData ); UNLOCKCHILDDATA (hWnd); SetCursor (hCursor); fUseProgress=0; return; } /*====(DemoElements)======================================================= Description: Demonstrates the various painting elements available in the toolkit. Syntax : static L_VOID DemoElements (HWND hWnd) Parameters : hWnd Handle of a window. Return Value: None. ==========================================================================*/ static L_VOID DemoElements (HWND hWnd) { HCURSOR hCursor; LPCHILDDATA pData; L_INT u, i, j; L_TCHAR szText[256]; HDC hDC; RECT rcPaint; HPALETTE hPalette = NULL; DWORD dw; L_UINT32 ulFlags; RECT rc, rc2; HFONT hFont; HDC hdcMem; HBITMAP hbmMem; L_BOOL bMagGlassWasOn=FALSE; fUseProgress = TRUE; #if 0 u = GetFilterOption (hWnd, "Effect", szEfxEffect); if(u == -1) return; #endif hCursor = SetCursor (LoadCursor (NULL, IDC_WAIT)); pData = LOCKCHILDDATA (hWnd); if( pData->bMagGlass ) { bMagGlassWasOn = TRUE; StopMagGlass( pData ); } GetClientRect (pData->hBitmapWnd, &rcPaint); hDC = GetDC (pData->hBitmapWnd); if (pData->hPalette) hPalette = SelectPalette (hDC, pData->hPalette, TRUE); if(L_BitmapHasRgn(&pData->ActiveBitmap)) KillTimer(hWnd, ID_REGIONEVENT); if (fUseProgress) EnableStatusDialog (hWnd, TRUE); rc = pData->rcView; hFont = CreateFont (-MulDiv(32, GetDeviceCaps(hDC, LOGPIXELSY), 72), 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH, TEXT("Arial")); rc2 = rc; OffsetRect(&rc2, -rc2.left, -rc2.top); hdcMem = CreateCompatibleDC(hDC); hbmMem = CreateCompatibleBitmap(hDC, rc2.right, rc2.bottom); hbmMem = SelectObject(hdcMem, hbmMem); UpdateWindow(hWnd); for(j = 0; ; j++) { if (j > 2) { j = 0; } for (i = 0; i < GetMaxEffect(j); i++) { ulFlags = L_GetDisplayMode (); switch (nDitherMode) { case IDM_ORDEREDDITHERING: L_SetDisplayMode (DISPLAYMODE_ORDEREDDITHER, DISPLAYMODE_ORDEREDDITHER); break; case IDM_ERRORDIFFUSION: L_SetDisplayMode (DISPLAYMODE_ORDEREDDITHER, 0); break; } L_SetDisplayMode (DISPLAYMODE_FAVORBLACK|DISPLAYMODE_SCALETOGRAY, nBitonalFlags); // set the linear interpolation or bicubic resample during paint L_SetDisplayMode(DISPLAYMODE_RESAMPLE|DISPLAYMODE_BICUBIC, nPaintResizeFlags); if(nPaletteMode == IDM_PALETTEFIXED) L_SetDisplayMode (DISPLAYMODE_FIXEDPALETTE, DISPLAYMODE_FIXEDPALETTE); if(fNetscapePalette) L_SetDisplayMode (DISPLAYMODE_NETSCAPEPALETTE, DISPLAYMODE_NETSCAPEPALETTE); if (j < 2) { L_EfxPaintBitmap (hDC, &pData->ActiveBitmap, NULL, NULL, &pData->rcView, &rcPaint, EFX_EFFECT_NONE, 11, 0,0,0, 1, 1, FALSE, RGB(0, 0, 0), 3, RGB(255, 0, 0), SRCCOPY); } switch (j) { case EFX_SHAPE_TYPE: u = GetConstEffect(EFX_SHAPE_TYPE, i); GetTextEffect(EFX_SHAPE_TYPE, u, szText); SetWindowText (hWnd, szText); L_EfxDraw3dShape(hDC, u, &rc, RGB(0, 0, 255), hdcMem, &rc2, EFX_BACKSTYLE_TRANSLUCENT, RGB(255, 0, 0), EFX_FILLSTYLE_VERTICAL, RGB(192, 192, 192), EFX_BORDERSTYLE_SOLID, 5, RGB(255, 255, 255), RGB(128, 128, 128), EFX_INNERSTYLE_NONE, 0, RGB(255, 255, 255), RGB(128, 128, 128), EFX_OUTERSTYLE_RAISED, 3, 0, 0, RGB(0, 0, 0), NULL); break; case EFX_TEXT_TYPE: u = GetConstEffect(EFX_TEXT_TYPE, i); GetTextEffect(EFX_TEXT_TYPE, u, szText); SetWindowText (hWnd, szText); L_EfxDrawRotated3dText(hDC, TEXT("LEADTOOLS"), &rc, 0, u | EFX_TEXT_HCENTER, 5, 5, RGB(255, 0, 0), RGB(0, 0, 0), RGB(255, 255, 255), hFont, NULL); break; case EFX_GRADIENT_TYPE: u = GetConstEffect(EFX_GRADIENT_TYPE, i); GetTextEffect(EFX_GRADIENT_TYPE, u, szText); SetWindowText (hWnd, szText); L_EfxGradientFillRect(hDC, &rc2, u, RGB(255, 0, 0), RGB(0, 0, 255), 64); break; } L_SetDisplayMode (DISPLAYMODE_RESETPOSITIONS, ulFlags); if (fUseProgress && fKillProgress) goto abort; dw = GetTickCount (); while ((GetTickCount () - dw) < 1000) ; } } abort: DeleteObject(hFont); DeleteObject(SelectObject(hdcMem, hbmMem)); DeleteDC(hdcMem); if (fUseProgress) EnableStatusDialog (hWnd, FALSE); if (pData->hPalette) SelectPalette (hDC, hPalette, TRUE); ReleaseDC (pData->hBitmapWnd, hDC); if(L_BitmapHasRgn(&pData->ActiveBitmap) && GetFocus() == hWnd) SetTimer(hWnd, ID_REGIONEVENT, REGIONEVENTDELAY, NULL); DisplayImageTitle (hWnd); InvalidateRect (pData->hBitmapWnd, NULL, TRUE); UpdateWindow (pData->hBitmapWnd); if( bMagGlassWasOn ) StartMagGlass( pData ); UNLOCKCHILDDATA (hWnd); SetCursor (hCursor); fUseProgress=0; return; } /*====(MatchAspectRatio)===================================================== Description: Reduces a given rectangle to match a given aspect ratio. Syntax : L_VOID MatchAspectRatio(LPRECT pRect, L_INT nWidth, L_INT nHeight) Parameters : pRect Pointer to rectangle to scale. nWidth Aspect width. nHeight Aspect height. Return Value: None. ==========================================================================*/ static L_VOID MatchAspectRatio(LPRECT pRect, L_INT nWidth, L_INT nHeight) { L_INT cxRect, cyRect; cyRect = RECTHEIGHT(pRect); cxRect = MulDiv(cyRect,nWidth,nHeight); if(cxRect>RECTWIDTH(pRect)) { cxRect=RECTWIDTH(pRect); cyRect=MulDiv(cxRect,nHeight,nWidth); } pRect->bottom = pRect->top + cyRect; pRect->right = pRect->left + cxRect; } /*====(SetZoomFactor)===================================================== Description: Sets the scale of the image. Syntax : L_VOID SetZoomFactor (HWND hWnd, L_INT nZoom) Parameters : hWnd Handle of a window. nZoom Scalar to use for resizing. Return Value: None. ==========================================================================*/ static L_VOID SetZoomFactor (HWND hWnd, L_INT nZoom) { DWORD dwStyle; L_INT nHScroll, nVScroll; L_INT nHeight, nWidth; RECT rcClient; L_INT cxClient, cyClient; LPCHILDDATA pData; L_INT x, y; pData = LOCKCHILDDATA (hWnd); GetClientRect (pData->hBitmapWnd, &rcClient); cxClient = RECTWIDTH (&rcClient); cyClient = RECTHEIGHT (&rcClient); x = cxClient / 2; y = cyClient / 2; nWidth = MulDiv (BITMAPWIDTH(&pData->ActiveBitmap), nZoom, 100); nHeight = MulDiv (BITMAPHEIGHT(&pData->ActiveBitmap), nZoom, 100); dwStyle = GetWindowLong (pData->hBitmapWnd, GWL_STYLE); nVScroll = GetSystemMetrics (SM_CXVSCROLL) - GetSystemMetrics(SM_CXBORDER); nHScroll = GetSystemMetrics (SM_CYHSCROLL) - GetSystemMetrics(SM_CYBORDER); if (dwStyle & WS_VSCROLL) cxClient += nVScroll; if (dwStyle & WS_HSCROLL) cyClient += nHScroll; if (cxClient < nWidth) { cyClient -= nHScroll; if (cyClient < nHeight) cxClient -= nVScroll; } else if (cyClient < nHeight) { cxClient -= nVScroll; if (cxClient < nWidth) cyClient -= nHScroll; } pData->nVScrollMax = max (0, (L_INT) nHeight - (L_INT) cyClient /*- 1*/); pData->nHScrollMax = max (0, (L_INT) nWidth - (L_INT) cxClient /*- 1*/); pData->nVScrollStep = max (1, cyClient / SCROLL_RATIO); pData->nHScrollStep = max (1, cxClient / SCROLL_RATIO); if(RECTWIDTH(&pData->rcView)) pData->nHScrollPos = (L_INT) ((L_INT32) (x - pData->rcView.left) * nWidth / RECTWIDTH(&pData->rcView)) - (cxClient / 2); if(RECTHEIGHT(&pData->rcView)) pData->nVScrollPos = (L_INT) ((L_INT32) (y - pData->rcView.top) * nHeight / RECTHEIGHT(&pData->rcView)) - (cyClient / 2); pData->nVScrollPos = max (0, min (pData->nVScrollPos, pData->nVScrollMax)); pData->nHScrollPos = max (0, min (pData->nHScrollPos, pData->nHScrollMax)); pData->nZoom = nZoom; UNLOCKCHILDDATA (hWnd); return; } /*====(BitmapSizeChange)=================================================== Description: Determines the use of scroll bars when the image size changed. Syntax : L_VOID BitmapSizeChange(HWND hWnd, L_BOOL bDoPaint) Parameters : hWnd Handle of a window. bDoPaint Boolean for "should we paint?". Return Value: None. ==========================================================================*/ L_VOID BitmapSizeChange (HWND hWnd, L_BOOL bDoPaint) { RECT rcClient; LPCHILDDATA pData; pData = LOCKCHILDDATA (hWnd); GetClientRect (pData->hBitmapWnd, &rcClient); Child_ProcessSize (hWnd, IsIconic (hWnd) ? SIZEICONIC : SIZENORMAL, RECTWIDTH (&rcClient), RECTHEIGHT (&rcClient)); if(bDoPaint) InvalidateRect (pData->hBitmapWnd, NULL, TRUE); if( pData->bMagGlass ) { StopMagGlass( pData ); StartMagGlass( pData ); } UNLOCKCHILDDATA (hWnd); return; } /*====(InitBitmapProcess)================================================== Description: Initializes values when image processing is to occur. Syntax : static L_INT InitBitmapProcess (HWND hWnd, pBITMAPHANDLE FAR * ppBitmap, L_BOOL fCopy) Parameters : hWnd Handle of a window. ppBitmap Pointer to a Bitmaphandle pointer. fCopy Should the bitmap be copied? Return Value: SUCCESS The function was successful. nRet The return value from L_CopyBitmap. ==========================================================================*/ static L_INT InitBitmapProcess (HWND hWnd, pBITMAPHANDLE FAR * ppBitmap, L_BOOL fCopy) { LPCHILDDATA pData; L_INT nRet; hcurProcess = SetCursor (LoadCursor (NULL, IDC_WAIT)); pData = LOCKCHILDDATA (hWnd); if( pData->bMagGlass ) { pData->bWasMagGlass = TRUE; StopMagGlass( pData ); } else pData->bWasMagGlass = FALSE; *ppBitmap = &pData->ActiveBitmap; StatusBarBitmap.Flags.Allocated = FALSE; if (fUseProgress) { if (fCopy) { nRet = L_CopyBitmap (&StatusBarBitmap, &pData->ActiveBitmap, sizeof(BITMAPHANDLE)); if (nRet != SUCCESS) { UNLOCKCHILDDATA (hWnd); return (nRet); } *ppBitmap = &StatusBarBitmap; } EnableStatusDialog (hWnd, TRUE); } if(L_BitmapHasRgn(&pData->ActiveBitmap)) KillTimer(hWnd, ID_REGIONEVENT); return (SUCCESS); } /*====(TermBitmapProcess)================================================== Description: Restores previously initialized values when image processing is complete. Syntax : static L_INT TermBitmapProcess (HWND hWnd, L_INT nRet, L_BOOL fSize, L_BOOL fColor) Parameters : hWnd Handle of a window. nRet Return value of the processing. fSize Should the window size change? fColor Did the image colors change? Return Value: SUCCESS The function was successful. ==========================================================================*/ static L_INT TermBitmapProcess (HWND hWnd, L_INT nRet, L_BOOL fSize, L_BOOL fColor) { L_TCHAR szTitle[_MAX_PATH]; LPCHILDDATA pData; pData = LOCKCHILDDATA (hWnd); if(L_BitmapHasRgn(&pData->ActiveBitmap)) SetTimer(hWnd, ID_REGIONEVENT, REGIONEVENTDELAY, NULL); if (fUseProgress) { EnableStatusDialog (hWnd, FALSE); if ( nRet == SUCCESS && StatusBarBitmap.Flags.Allocated) { L_FreeBitmap (&pData->ActiveBitmap); _fmemcpy (&pData->ActiveBitmap, &StatusBarBitmap, sizeof (BITMAPHANDLE)); StatusBarBitmap.Flags.Allocated = FALSE; } } if (fColor) FORWARD_WM_QUERYNEWPALETTE (hWnd, SendMessage); if (fSize) { if (nRet == SUCCESS && !IsZoomed (hWnd) && !IsIconic (hWnd) && !pData->fFitImage) { InvalidateRect (pData->hBitmapWnd, NULL, TRUE); SizeClientRect (hWnd, MulDiv(BITMAPWIDTH(&pData->ActiveBitmap), pData->nZoom, 100), MulDiv(BITMAPHEIGHT(&pData->ActiveBitmap), pData->nZoom, 100)); } else BitmapSizeChange (hWnd, TRUE); } else InvalidateRect (pData->hBitmapWnd, NULL, FALSE); UpdateWindow(pData->hBitmapWnd); if(pData->bPanWindow) L_UpdatePanWindow(pData->hPanWindow, &pData->ActiveBitmap, pData->ulPanDisFlags|DISPLAYMODE_INVALIDATEPAN, RGB(255,0,0), TEXT("Pan Window"), &pData->rcView ); DisplayImageStatus(hWnd); if (nRet < 0 ) { GetChildTitle(hWnd, szTitle); L_FileError (hWndFrame, nRet, TEXT("Image Process"), szTitle); } SetCursor (hcurProcess); if( pData->bWasMagGlass ) StartMagGlass( pData ); UNLOCKCHILDDATA (hWnd); /* unlock twice */ UNLOCKCHILDDATA (hWnd); return (SUCCESS); } /*====(EnableStatusDialog)================================================== Description: Enables/Disables various elements associated with the Progress Bar. Syntax : static L_VOID EnableStatusDialog (HWND hWnd, L_BOOL fEnable) Parameters : hWnd Child window handle. fEnable Should the elements be enabled? Return Value: None. ==========================================================================*/ static L_VOID EnableStatusDialog (HWND hWnd, L_BOOL fEnable) { if (fEnable) { if (!fInProcess) { EnableFrameMenu (FALSE,TRUE); L_SetStatusCallBack (StatusCallBack, NULL, &lpfnOldStatusCB, NULL); fKillProgress = FALSE; SetStatusBarProgress(0); EnableStatusBarProgress(TRUE); fInProcess = TRUE; } } else { if (fInProcess) { L_SetStatusCallBack (lpfnOldStatusCB, NULL,NULL,NULL); EnableStatusBarProgress(FALSE); fInProcess = FALSE; EnableFrameMenu(TRUE,TRUE); } } return; } /*====(DisplayImageStatus)================================================= Description: Displays the vitals of the image in the child window currently with the focus in the Status Bar. Syntax : static L_VOID DisplayImageStatus (HWND hWnd) Parameters : hWnd Handle of the child window with the focus. Return Value: None. ==========================================================================*/ static L_VOID DisplayImageStatus (HWND hWnd) { L_TCHAR szTitle[_MAX_PATH]; LPCHILDDATA pData; HWND hWndChild; hWndChild = FORWARD_WM_MDIGETACTIVE (hWndClient, SendMessage); if(hWndChild == hWnd) { pData = LOCKCHILDDATA (hWnd); if( pData->bMagGlass ) { StopMagGlass( pData ); StartMagGlass( pData ); } GetChildTitle(hWnd, szTitle); SetStatusBarText(szTitle, &pData->ActiveBitmap, pData->fFitImage ? -1 : pData->nZoom, L_BitmapHasRgn(&pData->ActiveBitmap)); UNLOCKCHILDDATA (hWnd); } return; } L_VOID GetChildTitle(HWND hWnd, L_TCHAR* pszTitle) { LPCHILDDATA pData; pData = LOCKCHILDDATA (hWnd); if(pData->uTitleCount) strprintf(pszTitle, TEXT("%s:%d"), pData->szTitle, pData->uTitleCount); else lstrcpy(pszTitle, pData->szTitle); UNLOCKCHILDDATA (hWnd); return; } /*====(DisplayImageTitle)================================================== Description: Displays the title of the image. Syntax : L_VOID DisplayImageTitle(HWND hWnd) Prototype : demo.h Parameters : hWnd Handle of a window. Return Value: None. ==========================================================================*/ L_VOID DisplayImageTitle (HWND hWnd) { L_TCHAR szTitle[_MAX_PATH]; LPCHILDDATA pData; pData = LOCKCHILDDATA (hWnd); GetChildTitle(hWnd, szTitle); SetWindowText (hWnd, szTitle); DisplayImageStatus(hWnd); UNLOCKCHILDDATA (hWnd); return; } /*====(ColorResCallback)=================================================== Description: Performs as a callback for L_ColorResBitmap. Syntax : L_INT L_FAR L_EXPORT ColorResCallback (pBITMAPHANDLE pBitmap, L_UCHAR L_FAR *pBuffer, L_INT nLines, L_VOID L_FAR *pUserData) Prototype : demo.h Parameters : pBitmap Bitmaphandle being processed. pBuffer Buffer of image pData-> nLines Number of lines in the buffer. pUserData user Data. Return Value: Result of StatusCallBack. ==========================================================================*/ L_INT L_EXPORT ColorResCallback (pBITMAPHANDLE pBitmap, L_UCHAR L_FAR *pBuffer, L_INT nLines, L_VOID L_FAR *pUserData) { L_INT *pnCount = (L_INT *)pUserData; UNREFERENCED_PARAMETER(pBuffer); UNREFERENCED_PARAMETER(pUserData); (*pnCount) += nLines; return((StatusCallBack)(MulDiv(*pnCount, 100, pBitmap->Height),NULL)); } /*====(UpdateSaveFileOption)==================================================== Description: Update gloabal SaveFileOptions with FSPARAM returned from lead save dialog Syntax : void UpdateSaveFileOption(SAVEDLGPARAMS CONST *pFSParm,L_BOOL bList) Parameters : SAVEDLGPARAMS CONST *pFSParm File Save param structure (from save dialog) L_BOOL bList is it for List. Return Value: None. ==========================================================================*/ L_VOID UpdateSaveFileOption(SAVEDLGPARAMS CONST *pFSParm,L_BOOL bList) { 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 (!FSParm.bSaveInterlaced) SaveFileOption.Flags &= ~ESO_INTERLACED; else SaveFileOption.Flags |= ESO_INTERLACED; } if(!bList) { if(pFSParm->bSaveWithStamp) { SaveFileOption.Flags |= ESO_SAVEWITHSTAMP; SaveFileOption.StampWidth = FSParm.nStampWidth; SaveFileOption.StampHeight = FSParm.nStampHeight; SaveFileOption.StampBits = FSParm.nStampBits; } } } /*====(SaveBitmap)========================================================= Description: Save the image to file. Syntax : L_VOID SaveBitmap(HWND hWnd) Parameters : hWnd Handle of a window. Return Value: None. ==========================================================================*/ static L_VOID SaveBitmap(HWND hWnd) { LPCHILDDATA pData; HCURSOR hCursor; L_INT nRet; L_INT nSaveFormat; static OPENFILENAME OpenFileName; static L_UINT uSaveMulti = FALSE; static L_INT nPageNumber = 1 ; L_TCHAR szFileName[MAX_PATH]; L_UINT uResCount; pDIMENSION pOldResolutions=NULL; pDIMENSION pJBIGResolutions=NULL; memset(&OpenFileName,0,sizeof(OpenFileName)); pData = LOCKCHILDDATA(hWnd); OpenFileName.lStructSize = sizeof(OPENFILENAME); OpenFileName.lpstrInitialDir = NULL; OpenFileName.lpstrTitle = TEXT("Save a File"); OpenFileName.nFilterIndex = nSaveIndex; OpenFileName.Flags = 0 ; FSParm.uStructSize = sizeof(SAVEDLGPARAMS); FSParm.nPageNumber = nPageNumber ; FSParm.uSaveMulti = uSaveMulti; FSParm.uDlgFlags = (fShowResize?DLG_SAVE_ENABLESIZING:0) | DLG_SAVE_SHOW_FILEOPTIONS_MULTIPAGE| DLG_SAVE_SHOW_FILEOPTIONS_PROGRESSIVE | DLG_SAVE_SHOW_FILEOPTIONS_QFACTOR | DLG_SAVE_SHOW_FILEOPTIONS_STAMP| DLG_SAVE_SHOW_FILEOPTIONS_BASICJ2KOPTIONS| DLG_SAVE_SHOW_FILEOPTIONS_J2KOPTIONS| DLG_SAVE_SHOW_FILEOPTIONS_JBIG2OPTIONS; nRet = L_DlgSave( hWndFrame,&OpenFileName,&FSParm); if(nRet == SUCCESS_DLG_OK) { nRet = SUCCESS ; DisplayDICOMSaveMsg(hWndFrame, FSParm.nFormat); uSaveMulti = FSParm.uSaveMulti; nSaveIndex = OpenFileName.nFilterIndex; hCursor = SetCursor (LoadCursor (NULL, IDC_WAIT)); UpdateSaveFileOption(&FSParm,(L_BOOL)pData->hList); nSaveFormat = FSParm.nFormat; lstrcpy ( szFileName,FSParm.szFileName ) ; if(pData->hList) { if(pData->Bitmap.BitsPerPixel == FSParm.nBitsPerPixel) { if(pData->Bitmap.BitsPerPixel <= 8) { L_GetBitmapColors(&pData->Bitmap, 0, pData->Bitmap.nColors, SaveFileOption.GlobalPalette); SaveFileOption.Flags |= ESO_GLOBALPALETTE; } SaveFileOption.Flags |= ESO_GLOBALBACKGROUND; SaveFileOption.GlobalBackground = pData->Bitmap.Background; } else { SaveFileOption.Flags |= ESO_GLOBALBACKGROUND; if(pData->Bitmap.BitsPerPixel <= 8) L_GetBitmapColors(&pData->Bitmap, 0, pData->Bitmap.nColors, SaveFileOption.GlobalPalette); if(HIBYTE(HIWORD(pData->Bitmap.Background)) == 1) SaveFileOption.GlobalBackground = RGB(SaveFileOption.GlobalPalette[LOBYTE(LOWORD(pData->Bitmap.Background))].rgbRed, SaveFileOption.GlobalPalette[LOBYTE(LOWORD(pData->Bitmap.Background))].rgbGreen, SaveFileOption.GlobalPalette[LOBYTE(LOWORD(pData->Bitmap.Background))].rgbBlue); else SaveFileOption.GlobalBackground = pData->Bitmap.Background; } SaveFileOption.GlobalWidth = pData->Bitmap.Width; SaveFileOption.GlobalHeight = pData->Bitmap.Height; if(pData->fLoop) { SaveFileOption.Flags |= ESO_GLOBALLOOP; SaveFileOption.GlobalLoop = 0; } nRet = L_SaveBitmapList( szFileName, pData->hList, FSParm.nFormat, FSParm.nBitsPerPixel, FSParm.nQFactor, &SaveFileOption); } else { FILEJ2KOPTIONS FileJ2KOptions; FILEJBIG2OPTIONS FileJBIG2Options; if(nSaveFormat == FILE_RAS_PDF || nSaveFormat == FILE_RAS_PDF_G3_1D || nSaveFormat == FILE_RAS_PDF_G3_2D || nSaveFormat == FILE_RAS_PDF_G4 || nSaveFormat == FILE_RAS_PDF_JPEG || nSaveFormat == FILE_RAS_PDF_JPEG_422 || nSaveFormat == FILE_RAS_PDF_JPEG_411 || nSaveFormat == FILE_RAS_PDF_LZW || nSaveFormat == FILE_RAS_PDF_JBIG2) { if( 20 < pData->ActiveBitmap.XResolution && 20 < pData->ActiveBitmap.YResolution ) { SaveFileOption.Flags |= ESO_PDF_SAVE_USE_BITMAP_DPI; } else { SaveFileOption.Flags &= ~ESO_PDF_SAVE_USE_BITMAP_DPI; } } if(nSaveFormat == 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)*FSParm.nPasses); if(pJBIGResolutions) { /* largest resolution will be actual image size */ pJBIGResolutions[0].nWidth = pData->ActiveBitmap.Width; pJBIGResolutions[0].nHeight = pData->ActiveBitmap.Height; /* will save nPasses resolution layers */ L_SetSaveResolution (FSParm.nPasses, pJBIGResolutions); } } if((nSaveFormat == FILE_J2K)|| (nSaveFormat == FILE_JP2)|| (nSaveFormat == FILE_CMW)|| (nSaveFormat == FILE_TIF_J2K)|| (nSaveFormat == FILE_TIF_CMW)) { /*Restore the old J2K Options*/ L_GetJ2KOptions(&FileJ2KOptions,sizeof(FILEJ2KOPTIONS)); L_SetJ2KOptions(&FSParm.FileJ2KOptions); } if((nSaveFormat == FILE_JBIG2)|| (nSaveFormat == FILE_RAS_PDF_JBIG2)|| (nSaveFormat == FILE_TIF_JBIG2)) { /*Restore the old JBIG2 Options*/ L_GetJBIG2Options(&FileJBIG2Options, sizeof(FILEJBIG2OPTIONS)); L_SetJBIG2Options(&FSParm.FileJBIG2Options); } if ( nSaveFormat == FILE_GIF ) { if(FSParm.bSaveInterlaced) { SaveFileOption.Flags |= ESO_INTERLACED ; } else { SaveFileOption.Flags &= ~ESO_INTERLACED ; } } SaveFileOption.Flags |= ESO_JPEGSTAMP; /* force compressed stamps */ nRet = L_SaveBitmap( szFileName, &pData->ActiveBitmap, nSaveFormat, FSParm.nBitsPerPixel, FSParm.nQFactor, &SaveFileOption ); /* restore the old save dimensions */ if(pOldResolutions) { L_SetSaveResolution (uResCount, pOldResolutions); GlobalFreePtr(pOldResolutions); } if(pJBIGResolutions) GlobalFreePtr(pJBIGResolutions); if((nSaveFormat == FILE_J2K)|| (nSaveFormat == FILE_JP2)|| (nSaveFormat == FILE_CMW)|| (nSaveFormat == FILE_TIF_J2K)|| (nSaveFormat == FILE_TIF_CMW)) { /*Restore the old J2K Options*/ L_SetJ2KOptions(&FileJ2KOptions); } if((nSaveFormat == FILE_JBIG2)|| (nSaveFormat == FILE_RAS_PDF_JBIG2)|| (nSaveFormat == FILE_TIF_JBIG2)) { /*Restore the old JBIG2 Options*/ L_SetJBIG2Options(&FileJBIG2Options); } } } SetCursor (hCursor); if (nRet != SUCCESS) L_FileError (hWndFrame, nRet, TEXT("Save File"), szFileName); UNLOCKCHILDDATA(hWnd); return; } /*====(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; LPCHILDDATA 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(nRegionTool) { case IDM_TOOLRECT: 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 IDM_TOOLRNDRECT: 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 IDM_TOOLELLIPSE: Ellipse(hdc, pptRegion[0].x, pptRegion[0].y, pptRegion[1].x, pptRegion[1].y); break; case IDM_TOOLFREEHAND: 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); } /*====(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. ==========================================================================*/ static L_VOID OutlineBitmapRgn(HWND hWnd, HDC hdc) { LPCHILDDATA pData; HDC hdcDraw; RGNXFORM XForm; pData = LOCKCHILDDATA(hWnd); if(L_BitmapHasRgn(&pData->ActiveBitmap)) { if(hdc) hdcDraw = hdc; else hdcDraw = GetDC(pData->hBitmapWnd); XForm.uViewPerspective = TOP_LEFT; XForm.nXScalarNum = RECTWIDTH(&pData->rcView); XForm.nXScalarDen = BITMAPWIDTH(&pData->ActiveBitmap); XForm.nYScalarNum = RECTHEIGHT(&pData->rcView); XForm.nYScalarDen = BITMAPHEIGHT(&pData->ActiveBitmap); XForm.nXOffset = pData->rcView.left; XForm.nYOffset = pData->rcView.top; L_FrameBitmapRgn(hdcDraw, &pData->ActiveBitmap, &XForm, pData->uFrameType); if(!hdc) ReleaseDC(pData->hBitmapWnd, hdcDraw); } UNLOCKCHILDDATA(hWnd); } /*====(MoveFloater)======================================================== Description: Moves the floater when you drag it with the mouse. Syntax : VOID MoveFloater(HWND hWnd, LPCHILDDATA pData, int x, 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, LPCHILDDATA pData, int x, 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); } /*----[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; LPCHILDDATA pData; RECT rc; pData = LOCKCHILDDATA(hWnd); hdc = GetDC(pData->hBitmapWnd); /* get the position of the region in bitmap coordinates */ XForm.uViewPerspective = pData->ActiveBitmap.ViewPerspective; XForm.nXScalarNum = XForm.nXScalarDen = XForm.nYScalarNum = XForm.nYScalarDen = 1; XForm.nXOffset = XForm.nYOffset = 0; L_GetBitmapRgnBounds(&pData->ActiveBitmap,&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->ActiveBitmap, &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->ActiveBitmap); XForm.nYScalarDen = BITMAPHEIGHT(&pData->ActiveBitmap); XForm.nXOffset = pData->rcView.left; XForm.nYOffset = pData->rcView.top; L_GetBitmapRgnBounds(&pData->ActiveBitmap,&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->ActiveBitmap, &XForm, &pData->hrgnFloater ); /* clear the region from the source bitmap */ L_FreeBitmapRgn(&pData->ActiveBitmap); /* --------------- 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->ActiveBitmap, 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->ActiveBitmap, 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(&rc, pData->xSaveSrc, pData->ySaveSrc, pData->xMoveSrc + pData->nMoveWidth, pData->yMoveSrc + pData->nMoveHeight); L_RectFromBitmap(&pData->ActiveBitmap, TOP_LEFT, &rc); /* restore the background in the big bitmap */ L_CombineBitmap( &pData->ActiveBitmap, rc.left, rc.top, RECTWIDTH(&rc), RECTHEIGHT(&rc), &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->ActiveBitmap, 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; } /*---[FreeRegionBitmaps]----------------------------------------------------- Syntax: VOID FreeRegionBitmaps (LPCHILDDATA pData) Parameters: pData Child window's data. Notes: This procedure frees all the bitmaps associated with moving a floater. --------------------------------------------------------------------------*/ static VOID FreeRegionBitmaps (LPCHILDDATA 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; } } #define SWAP_VALUES(val1, val2) {L_INT val = val1; val1 = val2; val2 = val;} /*----[ChangeRegion]------------------------------------------------------ Syntax: L_INT ChangeRegion (HWND hWnd, L_INT id) Parameters: hWnd The window where the bitmap is drawn. id The menu id determining the processing to be done on the region Notes: This function will change the region, possibly changing its size. --------------------------------------------------------------------------*/ static L_INT ChangeRegion( HWND hWnd, L_INT id, LPCHILDDATA pData ) { L_INT nRet; L_INT nFloaterWidth, nFloaterHeight; L_INT nFloaterLeft, nFloaterTop; L_INT nWidth = 0; L_INT nHeight = 0; HCURSOR hOldCursor; RGNXFORM XForm; BOOL bSaveAllocated = pData->bmSave.Flags.Allocated; RECT rcRegion, rcNewRegion; L_INT nRegionLeft; L_INT nRegionTop; L_INT nRegionWidth; L_INT nRegionHeight; RECT rc; static COLORREF crBack = RGB(255,255,255); ROTATEDLGPARAMS RotateRgnParams ; SHEARDLGPARAMS ShearRgnParams ; RESIZEDLGPARAMS ResizeRgnParams ; AUTOTRIMDLGPARAMS AutoTrimRgnParams ; ZeroMemory(&RotateRgnParams,sizeof(ROTATEDLGPARAMS)) ; ZeroMemory(&ShearRgnParams,sizeof(SHEARDLGPARAMS)) ; ZeroMemory(&AutoTrimRgnParams,sizeof(AUTOTRIMDLGPARAMS)) ; ZeroMemory(&ResizeRgnParams,sizeof(RESIZEDLGPARAMS)) ; hOldCursor = SetCursor( LoadCursor(NULL, IDC_WAIT) ); /* get the region bounds */ XForm.uViewPerspective = pData->ActiveBitmap.ViewPerspective; XForm.nXScalarNum = XForm.nXScalarDen = XForm.nYScalarNum = XForm.nYScalarDen = 1; XForm.nXOffset = 0; XForm.nYOffset = 0; L_GetBitmapRgnBounds( &pData->ActiveBitmap, &XForm, &rcRegion ); pData->xMoveSrc = rcRegion.left; pData->yMoveSrc = rcRegion.top; pData->nMoveWidth = RECTWIDTH(&rcRegion); pData->nMoveHeight = RECTHEIGHT(&rcRegion); if( id == IDM_CANCELREGION ) { if( bSaveAllocated ) { SetRect(&rc, pData->xSaveSrc, pData->ySaveSrc, pData->xMoveSrc + pData->nMoveWidth, pData->yMoveSrc + pData->nMoveHeight); L_RectFromBitmap(&pData->ActiveBitmap, TOP_LEFT, &rc); L_CombineBitmap( &pData->ActiveBitmap, rc.left, rc.top, RECTWIDTH(&rc), RECTHEIGHT(&rc), &pData->bmSave, 0, 0, L_SRCCOPY ); } L_FreeBitmapRgn(&pData->ActiveBitmap); KillTimer(hWnd, ID_REGIONEVENT); InvalidateRect(pData->hBitmapWnd, NULL, FALSE); DisplayImageStatus (hWnd); SetCursor(hOldCursor); L_FreeBitmap (&pData->bmSave); return SUCCESS; } /* create the floater bitmaphandle */ SafeCopyBitmapRect( &pData->bmFloater, &pData->ActiveBitmap, &pData->xMoveSrc, &pData->yMoveSrc, &pData->nMoveWidth, &pData->nMoveHeight ); pData->xSaveSrc=pData->xMoveSrc; pData->ySaveSrc=pData->yMoveSrc; /* get the region and offset it to 0,0 */ XForm.nXOffset = -rcRegion.left; XForm.nYOffset = -rcRegion.top; if( pData->hrgnRegion ) DeleteObject(pData->hrgnRegion); L_GetBitmapRgnHandle( &pData->ActiveBitmap, &XForm, &pData->hrgnRegion ); /* set the region handle to the floater */ XForm.nXOffset = 0; XForm.nYOffset = 0; L_SetBitmapRgnHandle( &pData->bmFloater, &XForm, pData->hrgnRegion, L_RGN_SET ); SetCursor( hOldCursor ); /* transform the floater */ switch(id) { case IDM_ROTATE90: hOldCursor = SetCursor( LoadCursor(NULL, IDC_WAIT) ); nRet = L_RotateBitmap (&pData->bmFloater, 9000, ROTATE_RESIZE, RGB(0, 0, 0)); break; case IDM_ROTATE180: hOldCursor = SetCursor( LoadCursor(NULL, IDC_WAIT) ); nRet = L_RotateBitmap (&pData->bmFloater, 18000, ROTATE_RESIZE, RGB(0, 0, 0)); break; case IDM_ROTATE270: hOldCursor = SetCursor( LoadCursor(NULL, IDC_WAIT) ); nRet = L_RotateBitmap (&pData->bmFloater, 27000, ROTATE_RESIZE, RGB(0, 0, 0)); break; case IDM_SHEAR: if(ShowShearDialog ( hWnd, &pData->ActiveBitmap, &ShearRgnParams ) != SUCCESS_DLG_OK) return(0); hOldCursor = SetCursor( LoadCursor(NULL, IDC_WAIT) ); crBack = ShearRgnParams.crBack; nRet = L_ShearBitmap (&pData->bmFloater, (L_INT) ShearRgnParams.nAngle, ShearRgnParams.bHorizontal, ShearRgnParams.crBack); break; case IDM_ROTATE: { if(ShowRotateDialog ( hWnd, &pData->ActiveBitmap, &RotateRgnParams ) != SUCCESS_DLG_OK) return 0; hOldCursor = SetCursor( LoadCursor(NULL, IDC_WAIT) ); crBack = RotateRgnParams.crBack ; nRet = L_RotateBitmap( &pData->bmFloater, RotateRgnParams.nAngle, (RotateRgnParams.bResize ? ROTATE_RESIZE : 0), RotateRgnParams.crBack); break; } case IDM_FLIP: hOldCursor = SetCursor( LoadCursor(NULL, IDC_WAIT) ); nRet = L_FlipBitmap( &pData->bmFloater ); break; case IDM_REVERSE: hOldCursor = SetCursor( LoadCursor(NULL, IDC_WAIT) ); nRet = L_ReverseBitmap( &pData->bmFloater ); break; case IDM_AUTOTRIM: if(ShowAutoTrimDialog ( hWnd, &pData->bmFloater, &AutoTrimRgnParams )== SUCCESS_DLG_OK) { nRet = L_AutoTrimBitmap ( &pData->bmFloater, AutoTrimRgnParams.nThreshold ) ; } break; case IDM_RESIZE: if(ShowResizeDialog ( hWnd, &pData->bmFloater, &ResizeRgnParams ) != SUCCESS_DLG_OK) return 0; /* the user cancelled the dialog box */ hOldCursor = SetCursor( LoadCursor(NULL, IDC_WAIT) ); //if the floater is rotated, I need to swap the width and height if(ISROTATED(&pData->bmFloater)) SWAP_VALUES(nWidth, nHeight); nRet = L_SizeBitmap( &pData->bmFloater, ResizeRgnParams.uNewWidth, ResizeRgnParams.uNewHeight, ResizeRgnParams.uResize); break; } if( nRet != SUCCESS ) { MessageBox (hWnd, TEXT("ChangeRegion failed"), TEXT("ERROR"), MB_OK|MB_ICONHAND); SetCursor( hOldCursor ); return nRet; } /* Update the new region */ /* get the handle of the new region (almost) positioned to 0, 0 */ if( pData->hrgnRegion ) DeleteObject( pData->hrgnRegion ); L_GetBitmapRgnHandle( &pData->bmFloater, &XForm, &pData->hrgnRegion ); /* get the new region bounds */ L_GetBitmapRgnBounds( &pData->bmFloater, &XForm, &rcNewRegion ); L_FreeBitmapRgn( &pData->bmFloater); L_FreeBitmapRgn( &pData->ActiveBitmap); /* the size of the region has changed. Redo the bmSave bitmap */ /* Restore the Data.Bitmap bitmap. Now the screen doesn't accurately reflect the bitmap */ if( bSaveAllocated ) { SetRect(&rc, pData->xMoveSrc, pData->yMoveSrc, pData->xMoveSrc + pData->nMoveWidth, pData->yMoveSrc + pData->nMoveHeight); L_RectFromBitmap(&pData->ActiveBitmap, TOP_LEFT, &rc); L_CombineBitmap( &pData->ActiveBitmap, rc.left, rc.top, RECTWIDTH(&rc), RECTHEIGHT(&rc), &pData->bmSave, 0, 0, L_SRCCOPY ); } nFloaterWidth = pData->bmFloater.Width; nFloaterHeight = pData->bmFloater.Height; /* keep the center of the region in the same place */ nFloaterLeft = rcRegion.left + (RECTWIDTH(&rcRegion) - nFloaterWidth) / 2; nFloaterTop = rcRegion.top + (RECTHEIGHT(&rcRegion) - nFloaterHeight) / 2; if( bSaveAllocated ) /* free the old save bitmap */ L_FreeBitmap( &pData->bmSave ); /* Save the region background. Normally I would want to call L_CopyBitmapRect but I must make sure the parameters are within the bitmap boundaries. Just calling L_CopyBitmapRect(&bmSave,&Data.Bitmap,sizeof(BITMAPHANDLE),xMoveSrc,yMoveSrc,nMoveWidth,nMoveHeight) will not always work if I stepped outside the bitmap during resizing. I will have to allocate the bitmap myself and call L_CombineBitmap instead because it does more checks */ nRegionLeft = rcNewRegion.left + nFloaterLeft; nRegionTop = rcNewRegion.top + nFloaterTop; nRegionWidth = RECTWIDTH(&rcNewRegion); nRegionHeight = RECTHEIGHT(&rcNewRegion); nRet = SafeCopyBitmapRect( &pData->bmSave, &pData->ActiveBitmap, &nRegionLeft, &nRegionTop, &nRegionWidth, &nRegionHeight ); if( nRet != SUCCESS ) { SetCursor( hOldCursor ); MessageBox (hWnd, TEXT("Not enough memory to allocate background bitmap"), TEXT("ERROR"), MB_OK|MB_ICONHAND); return nRet; } pData->xSaveSrc=nRegionLeft; pData->ySaveSrc=nRegionTop; /* set the region in the original bitmap so that only the floater gets copied and the moving frame gets shown */ XForm.nXOffset = nFloaterLeft; XForm.nYOffset = nFloaterTop; L_SetBitmapRgnHandle( &pData->ActiveBitmap, &XForm, pData->hrgnRegion, L_RGN_SET ); SetRect(&rc, nFloaterLeft, nFloaterTop, nFloaterLeft + nFloaterWidth, nFloaterTop + nFloaterHeight); L_RectFromBitmap(&pData->ActiveBitmap, TOP_LEFT, &rc); /* blend the floater into the bitmap */ L_CombineBitmap( &pData->ActiveBitmap, rc.left, rc.top, RECTWIDTH(&rc), RECTHEIGHT(&rc), &pData->bmFloater, 0, 0, L_SRCCOPY ); /* repaint the whole image */ InvalidateRect(pData->hBitmapWnd, NULL, FALSE ); DisplayImageStatus (hWnd); SetCursor( hOldCursor ); return SUCCESS; } /*====(XClientToBitmap)=================================================== Description: Helps find the corresponding pixel in the bitmap for a point on the screen. Syntax : int XClientToBitmap(LPCHILDDATA pData, 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 int XClientToBitmap(LPCHILDDATA pData, int x, int y) { x = (L_INT)((L_INT32)(x-pData->rcView.left)*BITMAPWIDTH(&pData->ActiveBitmap)/RECTWIDTH(&pData->rcView)); y = (L_INT)((L_INT32)(y-pData->rcView.top)*BITMAPHEIGHT(&pData->ActiveBitmap)/RECTHEIGHT(&pData->rcView)); L_PointToBitmap(&pData->ActiveBitmap, TOP_LEFT, &x, &y); return x; } /*====(YClientToBitmap)=================================================== Description: Helps find the corresponding pixel in the bitmap for a point on the screen. Syntax : int YClientToBitmap(LPCHILDDATA pData, 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 int YClientToBitmap(LPCHILDDATA pData, int x, int y) { x = (L_INT)((L_INT32)(x-pData->rcView.left)*BITMAPWIDTH(&pData->ActiveBitmap)/RECTWIDTH(&pData->rcView)); y = (L_INT)((L_INT32)(y-pData->rcView.top)*BITMAPHEIGHT(&pData->ActiveBitmap)/RECTHEIGHT(&pData->rcView)); L_PointToBitmap(&pData->ActiveBitmap, TOP_LEFT, &x, &y); return y; } static HBITMAP ResizeToDDB( LPCHILDDATA pData, HDC hDisplay, pBITMAPHANDLE pBitmap, int xSrcLeft, int ySrcTop, int nNewWidth, int nNewHeight, int nClientWidth, 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); switch (nDitherMode) { case IDM_ORDEREDDITHERING: L_SetDisplayMode (DISPLAYMODE_ORDEREDDITHER, DISPLAYMODE_ORDEREDDITHER); break; case IDM_ERRORDIFFUSION: L_SetDisplayMode (DISPLAYMODE_ORDEREDDITHER, 0); break; } L_SetDisplayMode (DISPLAYMODE_FAVORBLACK|DISPLAYMODE_SCALETOGRAY, nBitonalFlags); // set the linear interpolation or bicubic resample during paint L_SetDisplayMode(DISPLAYMODE_RESAMPLE|DISPLAYMODE_BICUBIC, nPaintResizeFlags); if(nPaletteMode == IDM_PALETTEFIXED) L_SetDisplayMode (DISPLAYMODE_FIXEDPALETTE, DISPLAYMODE_FIXEDPALETTE); if(fNetscapePalette) L_SetDisplayMode (DISPLAYMODE_NETSCAPEPALETTE, DISPLAYMODE_NETSCAPEPALETTE); 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); } static 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 rc; /* 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(&rc, *nXSrc, *nYSrc, *nXSrc + *nWidth, *nYSrc + *nHeight); L_RectFromBitmap(pBitmapSrc, TOP_LEFT, &rc); L_CombineBitmap( pBitmapDst, 0, 0, RECTWIDTH(&rc), RECTHEIGHT(&rc), pBitmapSrc, rc.left, rc.top, L_SRCCOPY ); return SUCCESS; } L_VOID PreFrameChange(HWND hWnd) { LPCHILDDATA pData; pData = LOCKCHILDDATA(hWnd); ChangeRegion(hWnd, IDM_CANCELREGION, pData ); if(pData->fComposite || !pData->hList) pData->Bitmap = pData->ActiveBitmap; else L_SetBitmapListItem(pData->hList, pData->uFrame, &pData->ActiveBitmap); UNLOCKCHILDDATA (hWnd); } L_VOID PostFrameChange(HWND hWnd) { LPCHILDDATA pData; HPLAYBACK hPlayback; pData = LOCKCHILDDATA(hWnd); if(pData->hList) { if(pData->fComposite) { pData->ActiveBitmap = pData->Bitmap; L_CreatePlayback(&hPlayback, &pData->ActiveBitmap, pData->hList); L_SetPlaybackIndex(hPlayback, pData->uFrame + 1); L_DestroyPlayback(hPlayback, NULL); } else { L_GetBitmapListItem(pData->hList, pData->uFrame, &pData->ActiveBitmap,sizeof(BITMAPHANDLE)); } FORWARD_WM_QUERYNEWPALETTE (hWnd, SendMessage); BitmapSizeChange (hWnd, TRUE); DisplayImageStatus(hWnd); } UNLOCKCHILDDATA (hWnd); } static L_VOID PlayAnimation (HWND hWnd) { MSG msg; LPCHILDDATA pData; HPLAYBACK hPlayback; L_UINT uState; RECT rcClient; RECT rcUpdate; HDC hdc; HPALETTE hPalette = NULL; L_UINT32 ulFlags; L_INT nIndex; L_BOOL bWasMagGlass; hWndAnimation = hWnd; pData = LOCKCHILDDATA(hWnd); if( pData->bMagGlass ) { bWasMagGlass = TRUE; StopMagGlass( pData ); } else { bWasMagGlass = FALSE; } if(pData->bPanWindow) L_DestroyPanWindow(pData->hPanWindow); PreFrameChange(hWnd); if(!pData->fComposite) { pData->ActiveBitmap = pData->Bitmap; ChangeRegion(hWnd, IDM_CANCELREGION, pData ); FORWARD_WM_QUERYNEWPALETTE (hWnd, SendMessage); BitmapSizeChange (hWnd, TRUE); DisplayImageStatus(hWnd); } UpdateWindow(pData->hBitmapWnd); fKillProgress = FALSE; fInProcess = TRUE; pData->bAnimationExist=TRUE; EnableFrameMenu (FALSE,TRUE); SetStatusBarText(TEXT("Press ESC to stop Animation"), &pData->ActiveBitmap, pData->fFitImage ? -1 : pData->nZoom, L_BitmapHasRgn(&pData->ActiveBitmap) ); L_CreatePlayback(&hPlayback, &pData->ActiveBitmap, pData->hList); nIndex=pData->nCurrentPage-1; if(L_BitmapHasRgn(&pData->ActiveBitmap)) { KillTimer(hWnd, ID_REGIONEVENT); FreeRegionBitmaps(pData); L_FreeBitmapRgn(&pData->ActiveBitmap); } do { L_ProcessPlayback(hPlayback, &uState); switch(uState) { case PLAYSTATE_WAITINPUT: L_CancelPlaybackWait(hPlayback); break; case PLAYSTATE_POSTCLEAR: case PLAYSTATE_POSTRENDER: /* add PLAYSTATE_POSTDISPOSE to view the image after disposal case PLAYSTATE_POSTDISPOSE: */ L_GetPlaybackUpdateRect(hPlayback, &rcUpdate, TRUE); hdc = GetDC(pData->hBitmapWnd); if (pData->hPalette) { hPalette = SelectPalette (hdc, pData->hPalette, TRUE); RealizePalette(hdc); } ulFlags = L_GetDisplayMode (); switch (nDitherMode) { case IDM_ORDEREDDITHERING: L_SetDisplayMode (DISPLAYMODE_ORDEREDDITHER, DISPLAYMODE_ORDEREDDITHER); break; case IDM_ERRORDIFFUSION: L_SetDisplayMode (DISPLAYMODE_ORDEREDDITHER, 0); break; } L_SetDisplayMode (DISPLAYMODE_FAVORBLACK|DISPLAYMODE_SCALETOGRAY, nBitonalFlags); // set the linear interpolation or bicubic resample during paint L_SetDisplayMode(DISPLAYMODE_RESAMPLE|DISPLAYMODE_BICUBIC, nPaintResizeFlags); if(nPaletteMode == IDM_PALETTEFIXED) L_SetDisplayMode (DISPLAYMODE_FIXEDPALETTE, DISPLAYMODE_FIXEDPALETTE); if(fNetscapePalette) L_SetDisplayMode (DISPLAYMODE_NETSCAPEPALETTE, DISPLAYMODE_NETSCAPEPALETTE); GetClientRect(pData->hBitmapWnd, &rcClient); L_PaintDC (hdc, &pData->ActiveBitmap, NULL, &rcUpdate, &pData->rcView, &rcClient, SRCCOPY); if(IsWindowVisible(pData->hListBox)&&(L_GetPlaybackIndex(hPlayback,&nIndex)==SUCCESS)) SETTOPINDEX(pData->hListBox,nIndex); L_SetDisplayMode (DISPLAYMODE_RESETPOSITIONS, ulFlags); if (pData->hPalette) SelectPalette (hdc, hPalette, TRUE); ReleaseDC(pData->hBitmapWnd, hdc); break; } SetFocus(hWnd); while (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE)) { TranslateMessage (&msg); DispatchMessage (&msg); } } while(!fKillProgress && (pData->fLoop || uState != PLAYSTATE_END)); EnableFrameMenu(TRUE,TRUE); fInProcess = FALSE; DisplayImageStatus (hWnd); L_DestroyPlayback(hPlayback, NULL); PostFrameChange(hWnd); pData->bAnimationExist=FALSE; if(pData->hListBox) { SETCURSEL(pData->hListBox,nIndex); LoadBitmapPage(hWnd,nIndex+1,FALSE); } if( bWasMagGlass ) StartMagGlass( pData ); UNLOCKCHILDDATA (hWnd); return; } //FORPANWINDOW /////////////////////////////////////////////// L_VOID L_FAR L_EXPORT PanWindowCallback( HWND hPanWindow, HWND hWndParent, L_UINT uMsg, LPRECT prcPan, L_VOID L_FAR* pUserData ) { LPCHILDDATA pData; POINT Pt; L_INT dx, dy; /* get child window data */ pData = LOCKCHILDDATA (GetParent(hWndParent)); /* why are we being called? */ switch(uMsg) { case PANWIN_CREATED: /* Pan Window was created */ pData->hPanWindow = hPanWindow; break; case PANWIN_UPDATED: /* received notification that the Pan Window rect moved */ Pt.x = prcPan->left; Pt.y = prcPan->top; /* update the view rect */ dx = pData->rcView.right - pData->rcView.left; dy = pData->rcView.bottom - pData->rcView.top; pData->rcView.left = - min(pData->nHScrollMax, MulDiv( Pt.x, pData->nZoom, 100 )); pData->rcView.right = pData->rcView.left + dx; pData->rcView.top = - min(pData->nVScrollMax, MulDiv( Pt.y, pData->nZoom, 100 )); pData->rcView.bottom = pData->rcView.top + dy; /* don't want to re-update the Pan Window */ pData->bUpdatePan = FALSE; /* need to update the scrollbars */ pData->nHScrollPos = -pData->rcView.left; pData->nVScrollPos = -pData->rcView.top; SetScrollPos (pData->hBitmapWnd, SB_HORZ, pData->nHScrollPos >> pData->nHScrollFactor, TRUE); SetScrollPos (pData->hBitmapWnd, SB_VERT, pData->nVScrollPos >> pData->nVScrollFactor, TRUE); /* force a repaint */ InvalidateRect(pData->hBitmapWnd, NULL, FALSE); UpdateWindow (pData->hBitmapWnd); DisplayImageStatus (pData->hBitmapWnd); if( pData->bMagGlass ) { StopMagGlass( pData ); StartMagGlass( pData ); } break; case PANWIN_DESTROYED: pData->hPanWindow = NULL; pData->bPanWindow = FALSE; break; } UNLOCKCHILDDATA (GetParent(hWndParent)); return; } L_VOID StartMagGlass(LPCHILDDATA pData) { L_INT nRet; MAGGLASSOPTIONS MagglassOptions; ZeroMemory(&MagglassOptions,sizeof(MAGGLASSOPTIONS)); MagglassOptions.uStructSize = sizeof(MAGGLASSOPTIONS); MagglassOptions.nWidth = 150; MagglassOptions.nHeight = 100; MagglassOptions.nZoom = 400; MagglassOptions.clrPen = 0; MagglassOptions.hMagCursor = NULL; MagglassOptions.clrBack = RGB(128,128,128); MagglassOptions.bEllipse = FALSE; MagglassOptions.nBorderSize = 1; MagglassOptions.b3D = TRUE; MagglassOptions.uPaintFlags = (nPaletteMode == IDM_PALETTEFIXED ? DISPLAYMODE_FIXEDPALETTE : 0) | nBitonalFlags | nDitherMode | nPaintResizeFlags; MagglassOptions.pMask = NULL; MagglassOptions.uMaskCount = 0; MagglassOptions.nCrosshair = CROSSHAIR_FINE; MagglassOptions.bIgnoreRgn = TRUE; MagglassOptions.bCenter = TRUE; if(!pData->bMagGlass) { nRet = L_StartMagGlass(pData->hBitmapWnd, &pData->ActiveBitmap, &pData->rcView, &MagglassOptions, NULL, NULL); if(nRet!=SUCCESS) MessageBox(pData->hBitmapWnd, TEXT("Error Starting MagGlass!"), TEXT("Error"), MB_OK); else pData->bMagGlass = TRUE; } } L_VOID StopMagGlass(LPCHILDDATA pData) { if(pData->bMagGlass) { L_StopMagGlass(pData->hBitmapWnd); pData->bMagGlass = FALSE; } } L_INT GammaCorrect(pBITMAPHANDLE pBitmap, L_UINT uRed, L_UINT uGreen, L_UINT uBlue) { L_INT nReturn=FAILURE; if ( NULL == pBitmap ) { return nReturn ; } if ( pBitmap->Flags.Signed ) { nReturn = L_GammaCorrectBitmap ( pBitmap, uRed ); } else { BITMAPHANDLE ColorPlanes [ 3 ] ; pBITMAPHANDLE pColorPlanes [ 3 ] ; pColorPlanes [ 0 ] = &ColorPlanes [ 0 ] ; pColorPlanes [ 1 ] = &ColorPlanes [ 1 ] ; pColorPlanes [ 2 ] = &ColorPlanes [ 2 ] ; ZeroMemory(pColorPlanes [ 0 ],sizeof(BITMAPHANDLE)); ZeroMemory(pColorPlanes [ 1 ],sizeof(BITMAPHANDLE)); ZeroMemory(pColorPlanes [ 2 ],sizeof(BITMAPHANDLE)); pColorPlanes [ 0 ]->uStructSize = sizeof(BITMAPHANDLE); pColorPlanes [ 1 ]->uStructSize = sizeof(BITMAPHANDLE); pColorPlanes [ 2 ]->uStructSize = sizeof(BITMAPHANDLE); if ( SUCCESS == L_ColorSeparateBitmap ( pBitmap, pColorPlanes, sizeof ( BITMAPHANDLE ), COLORSEP_RGB ) ) { nReturn=L_GammaCorrectBitmap ( pColorPlanes [ 0 ], uBlue ); nReturn=L_GammaCorrectBitmap ( pColorPlanes [ 1 ], uGreen ); nReturn=L_GammaCorrectBitmap ( pColorPlanes [ 2 ], uRed ); L_ColorMergeBitmap ( pBitmap, pColorPlanes, sizeof ( BITMAPHANDLE ), COLORSEP_RGB ) ; } if ( pColorPlanes [ 0 ]->Flags.Allocated ) { L_FreeBitmap ( pColorPlanes [ 0 ] ) ; } if ( pColorPlanes [ 1 ]->Flags.Allocated ) { L_FreeBitmap ( pColorPlanes [ 1 ] ) ; } if ( pColorPlanes [ 2 ]->Flags.Allocated ) { L_FreeBitmap ( pColorPlanes [ 2 ] ) ; } } return nReturn ; }