/*[]=====================================================================[]*/ /*[] 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/l_bitmap.h" #include "../../../include/l_error.h" #include "../../../include/lttw2.h" #ifdef WIN32 #include "../../../include/lttmb.h" #include "../../../include/ltlst.h" #endif #include "demo.h" #ifdef WIN32 static L_INT L_EXPORT CaptureCallback(pBITMAPHANDLE pBitmap, pLEADCAPTUREINFO pCaptureInfo, L_VOID L_FAR* pUserData); static L_INT CheckCurrentCapture(L_INT nCaptureID); #endif /* External Functions */ extern L_INT ShowFileConvertDialog ( HWND hWnd, LPFILECONVERSIONDLGPARAMS pDlgParams ) ; extern L_INT ShowFilesAssociationDialog ( HWND hWnd, LPFILESASSOCIATIONDLGPARAMS pDlgParams ) ; extern L_INT ShowCustomizePaletteDialog ( HWND hWnd, LPCUSTOMIZEPALETTEDLGPARAMS pDlgParams ) ; extern L_INT ShowPrintStitchedImagesDialog ( HWND hWnd, LPPRINTSTITCHEDIMAGESDLGPARAMS pDlgParams ) ; extern L_INT ShowAddBitmapsDialog ( HWND hWnd, LPADDBITMAPSDLGPARAMS pDlgParams, LPDLGBITMAPLIST pBitmapList ) ; extern L_INT ShowStitchDialog ( HWND hWnd, pBITMAPHANDLE pBitmap, LPSTITCHDLGPARAMS pDlgParams ) ; extern L_INT ShowICCProfileLoadDialog ( HWND hWnd ) ; CUSTOMIZEPALETTEDLGPARAMS CustomizePaletteParams; FILECONVERSIONDLGPARAMS FileConversionParams ; FILESASSOCIATIONDLGPARAMS FilesAssociationParams; PRINTSTITCHEDIMAGESDLGPARAMS PrintStitchedImagesParams ; ADDBITMAPSDLGPARAMS AddBitmapsParams ; STITCHDLGPARAMS StitchParams ; OPENDLGOPTIONS_VECTORMISC OldVectorMisc; OPENDLGOPTIONS_DXF OldDXF; OPENDLGOPTIONS_PLT OldPLT; OPENDLGOPTIONS_METAFILE OldMetaFile; OPENDLGOPTIONS_PDF OldPDF; OPENDLGOPTIONS_RASTERMISC OldRasterMisc; /* Internal Functions */ static VOID LEADTOOLS_OnSize(HWND hWnd, UINT state, int cx, int cy); static VOID LEADTOOLS_OnClose (HWND hWnd); static VOID LEADTOOLS_OnCommand (HWND hWnd, int id, HWND hwndCtl, UINT codeNotify); static BOOL LEADTOOLS_OnQueryNewPalette (HWND hwnd); static VOID LEADTOOLS_OnPaletteChanged (HWND hwnd, HWND hwndPaletteChange); static VOID LEADTOOLS_OnPaletteChanging (HWND hwnd, HWND hwndPaletteChange); static VOID LEADTOOLS_SysColorChange(HWND hwnd); static VOID LEADTOOLS_OnDropFiles(HWND hwnd, HDROP hdrop); static VOID LEADTOOLS_OnInitMenuPopup (HWND hWnd, HMENU hMenu, L_INT nItem, BOOL fSystemMenu); static VOID LEADTOOLS_OnDestroy (HWND hWnd); static BOOL LEADTOOLS_OnCreate (HWND hWnd, CREATESTRUCT FAR * lpCreateStruct); static L_VOID LEADTOOLS_OnTimer(HWND hwnd, UINT id); static L_VOID RedrawChildren (L_BOOL fErase, L_BOOL fNewPalette); static L_VOID CaptureScreen (L_VOID); static L_VOID ClrMergeOpen(L_VOID); static L_VOID CreateAnimation(L_VOID); static L_VOID ConvertBitmap (L_VOID); static L_VOID OpenBitmap(L_VOID); static L_INT LoadFile(L_TCHAR szFileName[256], L_BOOL bAutoProcess, L_BOOL bDroped); static L_VOID Paste (L_VOID); static L_VOID TwainAcquire(L_VOID); static L_VOID ISISAcquire(L_VOID); static L_VOID ISISAcquireMulti(L_VOID); static L_INT PaintWhileLoad (HWND hWndChild, L_TCHAR L_FAR*szFile); static L_VOID SetUserBitmap(HWND hWnd, HWND hCtl); static L_VOID CheckFilter(HWND hWnd, L_TCHAR* szFileName); static L_VOID CmdOpenBitmap ( L_VOID ); static L_VOID EnableLoadVectorFiles (L_BOOL bEnable); static L_VOID EnableLoadTextFiles(L_BOOL bEnable); int WINAPI VectorFontMapperCallback ( pVECTORHANDLE pVector, LPLOGFONT pLogFont, L_VOID* pUserData ); void SetOpenLoadResolution ( pLOADFILEOPTION pLoadOptions); /* Internal Variables */ static HWND hCtl = NULL; static L_BOOL fInTwain = FALSE; static OPENDLGPARAMS FOParm; static SAVEDLGPARAMS FSParm; static FILEINFO foFileInfo; static L_BOOL bStopOnError = FALSE; static L_BOOL bIncludeSubD = TRUE; static L_BOOL bDisplayItemText = TRUE; static L_BOOL bKeyboard = TRUE; static L_BOOL bExpandMulti = FALSE; static L_INT iSortMethod = IMAGELIST_NOTSORTED; #ifdef WIN32 static L_UINT uSelectionStyle = SELECTIONSTYLE_SELECTCOLOR; static L_UINT uAllowSelection = ALLOWSELECTION_SINGLE; static L_UINT uScrollStyle = SCROLLSTYLE_VERTICAL; static LILSELOPTION Opt; static LILITEMOPTION MOpt; #endif static L_TCHAR szDBFile[L_MAXPATH]; L_VOID RegisterAppKey ( HINSTANCE hInstance ); static L_UINT16 aRegionMask[] = { 0x0F, 0x1E, 0x3C, 0x78, 0xF0, 0xE1, 0xC3, 0x87, 0x0F, 0x1E, 0x3C, 0x78, 0xF0, 0xE1, 0xC3, 0x87, }; L_BOOL fbTwnInstalled; L_BOOL fISIS = FALSE; L_BOOL g_bEnableMenu = TRUE; L_BOOL g_bAndCapture = TRUE; #ifdef WIN32 #define MAXNAMEOFCAPFILE 50 #define MAX_STRING 255 typedef struct tagTOOLCURVEDATA { L_DOUBLE dTension; L_INT nClose; } TOOLCURVEDATA, *lpTOOLCURVEDATA; typedef struct tagEXTSTRUCT { L_TCHAR szExt[5]; L_TCHAR szFilterName[14]; } EXTSTRUCT; EXTSTRUCT AllExtensions[] = { TEXT("cmp"), TEXT("lfcmp14n"), TEXT("jpg"), TEXT("lfcmp14n"), TEXT("jpeg"), TEXT("lfcmp14n"), TEXT("jtf"), TEXT("lfcmp14n"), TEXT("gif"), TEXT("lfgif14n"), TEXT("tif"), TEXT("lftif14n"), TEXT("bmp"), TEXT("lfbmp14n"), TEXT("cur"), TEXT("lfbmp14n"), TEXT("ico"), TEXT("lfbmp14n"), TEXT("icon"), TEXT("lfbmp14n"), TEXT("ani"), TEXT("lfani14n"), TEXT("avi"), TEXT("lfavi14n"), TEXT("awd"), TEXT("lfawd14n"), TEXT("cal"), TEXT("lfcal14n"), TEXT("cgm"), TEXT("lfcgm14n"), TEXT("clp"), TEXT("lfclp14n"), TEXT("cmw"), TEXT("lfcmw14n"), TEXT("cut"), TEXT("lfcut14n"), TEXT("eps"), TEXT("lfeps14n"), TEXT("fax"), TEXT("lffax14n"), TEXT("flc"), TEXT("lfflc14n"), TEXT("fli"), TEXT("lfflc14n"), TEXT("fpx"), TEXT("lffpx14n"), TEXT("ica"), TEXT("lfica14n"), TEXT("iff"), TEXT("lfiff14n"), TEXT("gem"), TEXT("lfimg14n"), TEXT("itg"), TEXT("lfitg14n"), TEXT("cit"), TEXT("lfitg14n"), TEXT("j2k"), TEXT("lfj2k14n"), TEXT("jp2"), TEXT("lfj2k14n"), TEXT("lma"), TEXT("lflma14n"),// TEXT("lmb"), TEXT("lflmb14n"),// TEXT("mac"), TEXT("lfmac14n"), TEXT("msp"), TEXT("lfmsp14n"), TEXT("pcd"), TEXT("lfpcd14n"), TEXT("pct"), TEXT("lfpct14n"), TEXT("pcx"), TEXT("lfpcx14n"), TEXT("pdf"), TEXT("lfpdf14n"), TEXT("png"), TEXT("lfpng14n"), TEXT("ppm"), TEXT("lfpnm14n"), TEXT("pbm"), TEXT("lfpnm14n"), TEXT("pgm"), TEXT("lfpnm14n"), TEXT("psd"), TEXT("lfpsd14n"), TEXT("ras"), TEXT("lfras14n"), TEXT("raw"), TEXT("lfraw14n"), TEXT("sgi"), TEXT("lfsgi14n"), TEXT("tga"), TEXT("lftga14n"), TEXT("wfx"), TEXT("lfwfx14n"), TEXT("wmf"), TEXT("lfwmf14n"), TEXT("wpg"), TEXT("lfwpg14n"), TEXT("xbm"), TEXT("lfxbm14n"), TEXT("xpm"), TEXT("lfxpm14n"), TEXT("xwd"), TEXT("lfxwd14n"), TEXT("afp"), TEXT("lfafp14n"), TEXT("pcl"), TEXT("lfpcl14n"), TEXT("plt"), TEXT("lfplt14n"), TEXT("hgl"), TEXT("lfplt14n"), TEXT("shp"), TEXT("lfshp14n"), TEXT("wbmp"),TEXT("lfwmp14n"), TEXT("ptk"), TEXT("lfptk14n"), TEXT("sct"), TEXT("lfsct14n"), TEXT("gbr"), TEXT("lfgbr14n"), TEXT("dgn"), TEXT("lfdgn14n"), TEXT("drw"), TEXT("lfdrw14n"), TEXT("dwf"), TEXT("lfdwf14n"), TEXT("dwg"), TEXT("lfdwg14n"), TEXT("dxf"), TEXT("lfdxf14n"), TEXT("smp"), TEXT("lfsmp14n"), TEXT("jbg"), TEXT("lfjbg14n") }; typedef struct tagVECTOREXT { L_TCHAR szExt[5]; } VECTOREXT; VECTOREXT szVectorExt[] = { TEXT("DXF"), TEXT("DWG"), TEXT("DWF"), TEXT("CGM"), TEXT("CMX"), TEXT("PLT"), TEXT("VEC"), TEXT("PCT"), TEXT("DRW"), TEXT("DGN"), TEXT("WMF"), TEXT("EMF"), TEXT("GBR"), TEXT("SHP"), TEXT("PCL"), TEXT("PRN"), TEXT("PRT"), TEXT("SVG"), TEXT("WPG"), TEXT("WMZ") }; LRESULT CALLBACK DlgToolCurve(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam) { L_TCHAR szTension[MAX_STRING]; lpTOOLCURVEDATA pToolCurveData = NULL; //L_TCHAR szMaxDotWidth[MAX_STRING], szMaxDotHeight[MAX_STRING], szMinDotWidth[MAX_STRING], szMinDotHeight[MAX_STRING]; pToolCurveData = (lpTOOLCURVEDATA)GetWindowLong(hDlg, GWL_USERDATA); switch (message) { case WM_INITDIALOG: SetWindowLong(hDlg, GWL_USERDATA, lParam); pToolCurveData = (lpTOOLCURVEDATA)lParam; strprintf(szTension, TEXT("%0.2f"), pToolCurveData->dTension); SetDlgItemText(hDlg, IDC_EDIT_TENSION, szTension); Button_SetCheck(GetDlgItem(hDlg,IDC_RADIO_LINE), (pToolCurveData->nClose == CURVE_PARTIAL_CLOSE) ); Button_SetCheck(GetDlgItem(hDlg,IDC_RADIO_CURVE), (pToolCurveData->nClose == CURVE_CLOSE) ); return TRUE; case WM_COMMAND: switch (LOWORD(wParam)) { case IDCANCEL: EndDialog(hDlg, IDCANCEL); return TRUE; break; case IDOK: { L_DOUBLE dVal = -1.0; L_TCHAR *pChar; GetDlgItemText(hDlg, IDC_EDIT_TENSION, szTension, sizeof(szTension)); dVal = stod(szTension, &pChar); if ((*pChar == '\0') && (dVal >= 0.0) && (dVal <= 1.0)) { pToolCurveData->dTension = dVal; } else { SetFocus(GetDlgItem(hDlg, IDC_EDIT_TENSION)); Edit_SetSel(GetDlgItem(hDlg, IDC_EDIT_TENSION), 0, -1); return FALSE; } pToolCurveData->nClose = CURVE_PARTIAL_CLOSE * Button_GetCheck(GetDlgItem(hDlg,IDC_RADIO_LINE)) + CURVE_CLOSE * Button_GetCheck(GetDlgItem(hDlg,IDC_RADIO_CURVE)); EndDialog(hDlg, IDOK); return TRUE; } break; } } return FALSE; } /*--------------------------------------------------------------------------+ | Function :CaptureCallback | Desc :the capture callback | Return : | Notes : +--------------------------------------------------------------------------*/ static L_INT L_EXPORT CaptureCallback(pBITMAPHANDLE pBitmap, pLEADCAPTUREINFO pCaptureInfo, L_VOID L_FAR* pUserData) { static L_TCHAR Buffer1[MAXNAMEOFCAPFILE]; static L_TCHAR *szCapFileNameType[11]={ TEXT("Capture Full Screen "), TEXT("Capture Client Window "), TEXT("Capture Active Window "), TEXT("Capture Window under Cursor"), TEXT("Capture Menu Under Cursor "), TEXT("Capture Selected Object "), TEXT("Capture Selected Area"), TEXT("Capture Mouse Cursor"), TEXT("Capture WallPaper"), TEXT("Capture From Exe Dlg Tree"), TEXT("Capture From Tabbed View"), }; static L_INT nCaptureItem[11]= { IDM_CAPTURE_FULLSCREEN, IDM_CAPTURE_ACTIVECLIENT, IDM_CAPTURE_ACTIVEWINDOW, IDM_CAPTURE_WINDOWUNDERCURSOR, IDM_CAPTURE_MENUUNDERCURSOR, IDM_CAPTURE_SELECTEDOBJECT, IDM_CAPTURE_SELECTEDAREA, IDM_CAPTURE_MOUSECURSOR, IDM_CAPTURE_WALLPAPER, IDM_CAPTURE_FROMEXEDLGTREE, IDM_CAPTURE_FROMEXEDLGTABBEDVIEW, }; L_INT i,nRet=FAILURE; if(pBitmap->Flags.Allocated) { MessageBeep (0xffffffff); memset(Buffer1,0,sizeof(Buffer1)); strprintf(Buffer1,TEXT("Captured Image")); for(i=0;i<11;i++) if(nCaptureType==nCaptureItem[i]) { strprintf(Buffer1,TEXT("%s[%d]"), szCapFileNameType[i], nCaptureNo); nCaptureNo++; } if(CreateChildWindow(Buffer1,pBitmap,0,0,0,0)!=0) nRet=SUCCESS; else L_FreeBitmap(pBitmap); } return(nRet); } /*--------------------------------------------------------------------------+ | Function :CheckCurrentCapture | Desc :checks the specified capture menu item | Return : | Notes : +--------------------------------------------------------------------------*/ static L_INT CheckCurrentCapture(L_INT nCaptureID) { HMENU hMenu=GetSubMenu(GetMenu(hWndFrame),MENU_CAPTURE_POS); if(nCaptureType!=nCaptureID) { CHECKMENUITEM(hMenu,nCaptureType,FALSE); if(nCaptureID) { CHECKMENUITEM(hMenu,nCaptureID,TRUE); nCaptureType=nCaptureID; } nCaptureNo=0; } return(SUCCESS); } #endif /*====(FrameWindowProc)=================================================== Description: Handles all messages dispatched to the Frame window. Other messages that cannot be processed will be dispatched to the Client window procedure. Syntax : LRESULT CALLBACK L_EXPORT FrameWindowProc(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam) Prototype : demo.h Parameters : hWnd Handle to a window. Msg Windows message structure. wParam Windows word parameter. lParam Windows long parameter. Return Value: This is specific for each message. See Windows Programmer's Reference Volume 3. ==========================================================================*/ LRESULT CALLBACK L_EXPORT FrameWindowProc (HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam) { switch (Msg) { HANDLE_MSG (hWnd, WM_CREATE, LEADTOOLS_OnCreate); HANDLE_MSG (hWnd, WM_INITMENUPOPUP, LEADTOOLS_OnInitMenuPopup); HANDLE_MSG (hWnd, WM_PALETTECHANGED, LEADTOOLS_OnPaletteChanged); HANDLE_MSG (hWnd, WM_PALETTEISCHANGING, LEADTOOLS_OnPaletteChanging); HANDLE_MSG (hWnd, WM_QUERYNEWPALETTE, LEADTOOLS_OnQueryNewPalette); HANDLE_MSG (hWnd, WM_SYSCOLORCHANGE, LEADTOOLS_SysColorChange); HANDLE_MSG (hWnd, WM_CLOSE, LEADTOOLS_OnClose); HANDLE_MSG (hWnd, WM_DESTROY, LEADTOOLS_OnDestroy); HANDLE_MSG (hWnd, WM_COMMAND, LEADTOOLS_OnCommand); HANDLE_MSG (hWnd, WM_SIZE, LEADTOOLS_OnSize); HANDLE_MSG (hWnd, WM_DROPFILES, LEADTOOLS_OnDropFiles); HANDLE_MSG (hWnd, WM_TIMER,LEADTOOLS_OnTimer) ; } return(DefFrameProc (hWnd, hWndClient, Msg, wParam, lParam)); } /*====(LEADTOOLS_OnDropFiles)================================================== Description: Handles the WM_DROPFILES message Syntax : VOID LEADTOOLS_OnDropFiles(HWND hwnd, HDROP hdrop) Parameters : hWnd Handle to the window. hdrop Handle to the dropped files Return Value: None. ==========================================================================*/ static VOID LEADTOOLS_OnDropFiles(HWND hwnd, HDROP hdrop) { L_TCHAR szDropedFileName[256]; L_INT nFilesCount, nFiles,nRet; memset(szDropedFileName, 0, 256); // Get draged files count nFilesCount = DragQueryFile(hdrop, 0xFFFFFFFF, NULL, 0); for (nFiles = 0; nFiles < nFilesCount; nFiles++) { // Get File Name DragQueryFile(hdrop, nFiles, szDropedFileName, 256); // Set the file info L_FileInfo(szDropedFileName, &foFileInfo, sizeof(FILEINFO), FILEINFO_TOTALPAGES, NULL); // Load the file nRet = LoadFile(szDropedFileName, FALSE, TRUE); if(nRet!=SUCCESS) L_FileError (hWndFrame, nRet, TEXT("Open File"), szDropedFileName); } } /*====(LEADTOOLS_OnTimer)================================================== Description: Handles the WM_TIMER message. Syntax : void LEADTOOLS_OnTimer(HWND hwnd, UINT id) Parameters : hWnd Handle to the window. id Timer Id Return Value: None. ==========================================================================*/ static L_VOID LEADTOOLS_OnTimer(HWND hWnd, UINT id) { KillTimer(hWnd,1); if ( bCommandLine ) { CmdOpenBitmap ( ) ; bCommandLine=FALSE; } } /*====(LEADTOOLS_OnSize)================================================== Description: Handles the WM_SIZE message. It positions the Status Bar and Client windows. Syntax : VOID LEADTOOLS_OnSize(HWND hWnd, UINT state, int cx, int cy) Parameters : hWnd Handle to the window. state Window state cx Client area width cy Client area height Return Value: None. ==========================================================================*/ static VOID LEADTOOLS_OnSize(HWND hWnd, UINT state, int cx, int cy) { RECT rc; L_INT cyStatus; GetWindowRect(hWndStatus, &rc); cyStatus = RECTHEIGHT(&rc); MoveWindow(hWndStatus, 0, cy - cyStatus, cx, cyStatus, TRUE); DefFrameProc (hWnd, hWndClient, WM_SIZE, (WPARAM)state, MAKELPARAM(cx, cy - cyStatus)); } /*====(LEADTOOLS_OnClose)================================================== Description: Handles the WM_CLOSE message. It sends IDM_CLOSEALL to close all open child windows and to destroy the frame window. Syntax : VOID LEADTOOLS_OnClose(HWND hWnd) Parameters : hWnd Handle to the window. Return Value: None. ==========================================================================*/ static VOID LEADTOOLS_OnClose (HWND hWnd) { if (!fInProcess) { FORWARD_WM_COMMAND (hWnd, IDM_CLOSEALL, 0, 0, SendMessage); DestroyWindow (hWnd); } return; } /*====(LEADTOOLS_OnCommand)================================================== Description: Translates the WM_COMMAND message sent to the frame window procedure. Other command messages that are specific to the child window will be forwarded to that window. Syntax : VOID LEADTOOLS_OnCommand(HWND hWnd, int id, HWND hwndCtl, UINT codeNotify) Parameters : hWnd Handle to the window. id Control or menu item identifier. hwndCtl Handle of control codeNotify Notification message Return Value: None. ==========================================================================*/ static VOID LEADTOOLS_OnCommand (HWND hWnd, int id, HWND hwndCtl, UINT codeNotify) { #ifdef WIN32 COLORREF TransparentColor; #endif FARPROC lpfn; L_BOOL bChecked=FALSE; ZeroMemory(&CustomizePaletteParams,sizeof(CUSTOMIZEPALETTEDLGPARAMS)); ZeroMemory (&FileConversionParams, sizeof ( FILECONVERSIONDLGPARAMS ) ) ; ZeroMemory(&FilesAssociationParams, sizeof(FILESASSOCIATIONDLGPARAMS)); ZeroMemory(&PrintStitchedImagesParams,sizeof(PRINTSTITCHEDIMAGESDLGPARAMS)); ZeroMemory(&AddBitmapsParams,sizeof(ADDBITMAPSDLGPARAMS)); ZeroMemory(&StitchParams,sizeof(STITCHDLGPARAMS)); switch (id) { case IDM_TOOLNONE: case IDM_TOOLRECT: case IDM_TOOLRNDRECT: case IDM_TOOLELLIPSE: case IDM_TOOLFREEHAND: nRegionTool = id; break; case IDM_TOOLBEZIER: nRegionTool = id; MessageBox(hWnd, TEXT("Left-click to draw points. The first four points determine the first Bezier curve.\nEach additional set of three points determines the next Bezier curve.\nRight-click when finished to generate the region."), TEXT("Bezier Region Tool"), MB_OK); break; case IDM_TOOLCURVE: { int nRet; TOOLCURVEDATA ToolCurveData; nRegionTool = id; ToolCurveData.dTension = dCurveTension; ToolCurveData.nClose = nCurveClose; nRet = DialogBoxParam( hInst, (LPCTSTR)IDD_CURVE, hWnd, (DLGPROC)DlgToolCurve, (LPARAM)(&ToolCurveData) ); if (nRet == IDOK) { dCurveTension = ToolCurveData.dTension; nCurveClose = ToolCurveData.nClose; } } break; case IDM_OPEN: OpenBitmap(); break; case IDM_CREATEANIMATION: CreateAnimation(); break; case IDM_CLRMERGE: ClrMergeOpen(); break; case IDM_FILEFORMATASSOCIATIONS: ShowFilesAssociationDialog ( hWnd, &FilesAssociationParams ) ; break; case IDM_PRINTSTITCHEDIMAGES: { HICON hIcon ; hIcon = (HICON) LoadImage( (HINSTANCE)GetWindowLong(hWnd,GWL_HINSTANCE), MAKEINTRESOURCE(IDI_MAIN), IMAGE_ICON, GetSystemMetrics( SM_CXSMICON ), GetSystemMetrics( SM_CYSMICON ), 0 ); PrintStitchedImagesParams.hWindowIcon = hIcon ; ShowPrintStitchedImagesDialog ( hWnd, &PrintStitchedImagesParams ) ; if ( NULL != PrintStitchedImagesParams.hDevMode ) { GlobalFree ( PrintStitchedImagesParams.hDevMode ) ; } if ( NULL != PrintStitchedImagesParams.hDevNames ) { GlobalFree ( PrintStitchedImagesParams.hDevNames ) ; } if ( NULL != hIcon ) { DeleteObject ( hIcon ) ; } break; } case IDM_PALETTEEDITOR: { L_BOOL fHasChild; HWND hWndChild ; LPCHILDDATA pData = NULL; hWndChild = FORWARD_WM_MDIGETACTIVE (hWndClient, SendMessage); fHasChild = IsWindow (hWndChild); if (fHasChild) { pData = LOCKCHILDDATA (hWndChild); CustomizePaletteParams.hpalUser = L_DupBitmapPalette ( &pData->ActiveBitmap ) ; } ShowCustomizePaletteDialog ( hWnd, &CustomizePaletteParams ) ; if(fHasChild) { UNLOCKCHILDDATA (hWndChild); if ( NULL != CustomizePaletteParams.hpalUser ) { DeleteObject ( CustomizePaletteParams.hpalUser ) ; } } break; } case IDM_ICCPROFILES: { ShowICCProfileLoadDialog ( hWnd ) ; break ; } case IDM_ADDBITMAPS: { L_INT nRet ; BITMAPHANDLE ResultingBitmap ; DLGBITMAPLIST BitmapList ; L_INT i = 0 ; ZeroMemory(&BitmapList,sizeof(DLGBITMAPLIST)); ZeroMemory(&ResultingBitmap,sizeof(BITMAPHANDLE)); nRet = ShowAddBitmapsDialog ( hWnd, &AddBitmapsParams, &BitmapList) ; if ( nRet == SUCCESS_DLG_OK ) { nRet = L_AddBitmaps ( &ResultingBitmap, sizeof(BITMAPHANDLE), AddBitmapsParams.hList, AddBitmapsParams.uAddBitmapsFlags); if(nRet==SUCCESS) { CreateChildWindow ( TEXT("Untitled"), &ResultingBitmap, NULL, 1, FALSE, FALSE ) ; } else { L_FileError (hWndFrame, nRet, TEXT("Add Bitmaps"), TEXT("Untitled")); } if ( NULL != AddBitmapsParams.hList ) { L_UINT uCount ; L_GetBitmapListCount ( AddBitmapsParams.hList, &uCount ) ; for ( i = uCount-1 ; i >= 0 ; i-- ) { L_RemoveBitmapListItem ( AddBitmapsParams.hList, i, NULL ) ; } L_DestroyBitmapList ( AddBitmapsParams.hList ) ; } } 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 ) ; } break; } case IDM_STITCH: { L_INT nRet ; BITMAPHANDLE ResultingBitmap ; HICON hIcon ; hIcon = (HICON) LoadImage( (HINSTANCE)GetWindowLong(hWnd,GWL_HINSTANCE), MAKEINTRESOURCE(IDI_MAIN), IMAGE_ICON, GetSystemMetrics( SM_CXSMICON ), GetSystemMetrics( SM_CYSMICON ), 0 ); StitchParams.hWindowIcon = hIcon ; nRet = ShowStitchDialog ( hWnd, &ResultingBitmap, &StitchParams ) ; if ( nRet == SUCCESS_DLG_EXPORTANDEXIT ) { CreateChildWindow ( TEXT("Untitled"), &ResultingBitmap, NULL, 1, FALSE, FALSE ) ; } break; } case IDM_TWAINSEL: L_TwainSelectSource(g_hTwainSession, NULL); break; case IDM_TWAINACQ: TwainAcquire(); break; #if defined(WIN32) && !defined(_ALPHA_) && !defined (UNICODE) case IDM_ISISSEL: L_ISISSelect(hWnd, NULL); /* L_ISISLoadDriver(NULL); L_ISISSetScanOptions(hWnd); L_ISISUnloadDriver(); */ break; case IDM_ISISACQ: ISISAcquire(); break; case IDM_ISISACQMUL: ISISAcquireMulti(); break; #endif case IDM_CONVERT: ConvertBitmap(); break; case IDM_EXIT: FORWARD_WM_CLOSE(hWnd, SendMessage); break; case IDM_PASTE: Paste(); break; case IDM_ABOUT: DoDialogBoxParam(IDD_ABOUT, hWnd, (DLGPROC) AboutDlgProc, 0); break; case IDM_PROGRESSBAR: fUseProgress = !fUseProgress; break; case IDM_FASTPRINT: fUseFastPrint = !fUseFastPrint; break; case IDM_BGR: fIsBGRDevice = fIsBGRDevice ? FALSE : TRUE; break; case IDM_PALETTENETSCAPE: fNetscapePalette = !fNetscapePalette; RedrawChildren(FALSE, TRUE); break; case IDM_LOADCOMPRESSED: fLoadCompressed = !fLoadCompressed; break; case IDM_LOADROTATED: fLoadRotated = !fLoadRotated; if(fLoadRotated) LoadFileOption.Flags |= ELO_ROTATED; else LoadFileOption.Flags &= ~ELO_ROTATED; break; case IDM_TOTALPAGES: bChecked=(GetMenuState(GetMenu(hWnd),id,MF_BYCOMMAND)&MF_CHECKED)!=0; CheckMenuItem(GetMenu(hWnd),id,MF_BYCOMMAND|((bChecked)? MF_UNCHECKED:MF_CHECKED)); fTotalPages = (bChecked) ? FALSE : TRUE; break; case IDM_SHOWPREVIEW: fShowPreview = !fShowPreview; break; case IDM_SHOWRESIZE: fShowResize = !fShowResize; break; case IDM_LOADVECTORFILES: fLoadVecFiles = !fLoadVecFiles; EnableLoadVectorFiles (fLoadVecFiles); break; case IDM_LOADTEXTFILES: fLoadTxtFiles = !fLoadTxtFiles; EnableLoadTextFiles (fLoadTxtFiles); break; case IDM_LOAD_RAW_FAX: fLoadRawFax = !fLoadRawFax; break; case IDM_PALETTEAUTO: case IDM_PALETTEFIXED: nPaletteMode = id; RedrawChildren(FALSE, TRUE); break; case IDM_ERRORDIFFUSION: case IDM_ORDEREDDITHERING: nDitherMode = id; RedrawChildren(FALSE, FALSE); break; case IDM_BITONALNORMAL: case IDM_SCALETOGRAY: case IDM_FAVORBLACK: nBitonalFlags = id == IDM_BITONALNORMAL ? 0 : id == IDM_FAVORBLACK ? DISPLAYMODE_FAVORBLACK : DISPLAYMODE_SCALETOGRAY; RedrawChildren(FALSE, TRUE); break; case IDM_PAINT_NORMAL: case IDM_PAINT_RESAMPLE: case IDM_PAINT_BICUBIC: nPaintResizeFlags = id == IDM_PAINT_NORMAL ? 0 : id == IDM_PAINT_RESAMPLE ? DISPLAYMODE_RESAMPLE : DISPLAYMODE_BICUBIC; RedrawChildren(FALSE, FALSE); break; case IDM_PAINTCALLBACK: fDoPaintWhileLoad = !fDoPaintWhileLoad; break; case IDM_CASCADE: FORWARD_WM_MDICASCADE(hWndClient, 0, SendMessage); break; case IDM_TILEHORZ: FORWARD_WM_MDITILE(hWndClient, MDITILE_HORIZONTAL, SendMessage); break; case IDM_TILEVERT: FORWARD_WM_MDITILE(hWndClient, MDITILE_VERTICAL, SendMessage); break; case IDM_ARRANGE: FORWARD_WM_MDIICONARRANGE(hWndClient, SendMessage); break; case IDM_CLOSEALL: lpfn = MakeProcInstance((FARPROC) CloseAll, hInst); EnumChildWindows(hWndClient, (WNDENUMPROC) lpfn, 0); FreeProcInstance(lpfn); break; case IDM_THUMBNAILS: bChecked=(GetMenuState(GetMenu(hWnd),id,MF_BYCOMMAND)&MF_CHECKED)!=0; CheckMenuItem(GetMenu(hWnd),id,MF_BYCOMMAND|((bChecked)? MF_UNCHECKED:MF_CHECKED)); AddChildThumbnails(!bChecked); break; case IDM_SHOWAPPLY: bChecked=(GetMenuState(GetMenu(hWnd),id,MF_BYCOMMAND)&MF_CHECKED)!=0; CheckMenuItem(GetMenu(hWnd),id,MF_BYCOMMAND|((bChecked)? MF_UNCHECKED:MF_CHECKED)); fShowApply=!bChecked; break; #ifdef WIN32 case IDM_IMAGESTOPONERRORS: bStopOnError = (GetMenuState(GetMenu(hWnd), id, MF_BYCOMMAND) & MF_CHECKED) == 0; CheckMenuItem(GetMenu(hWnd), id, MF_BYCOMMAND | ((bStopOnError) ? MF_CHECKED : MF_UNCHECKED)); break; case IDM_IMAGEINCLUDE: bIncludeSubD = (GetMenuState(GetMenu(hWnd), id, MF_BYCOMMAND) & MF_CHECKED) == 0; CheckMenuItem(GetMenu(hWnd), id, MF_BYCOMMAND | ((bIncludeSubD) ? MF_CHECKED : MF_UNCHECKED)); break; case IDM_EXPANDMULTIPAGE: bExpandMulti = (GetMenuState(GetMenu(hWnd), id, MF_BYCOMMAND) & MF_CHECKED) == 0; CheckMenuItem(GetMenu(hWnd), id, MF_BYCOMMAND | ((bExpandMulti) ? MF_CHECKED : MF_UNCHECKED)); break; case IDM_DISPTEXT: bDisplayItemText = (GetMenuState(GetMenu(hWnd), id, MF_BYCOMMAND) & MF_CHECKED) == 0; CheckMenuItem(GetMenu(hWnd), id, MF_BYCOMMAND | ((bDisplayItemText) ? MF_CHECKED : MF_UNCHECKED)); if(hCtl != NULL) { MOpt.bDisplayItemText = bDisplayItemText; MOpt.uStructSize = sizeof(LILITEMOPTION); L_ImgListSetItemOptions(hCtl, &MOpt); } break; case IDM_KEYBOARD: bKeyboard = (GetMenuState(GetMenu(hWnd), id, MF_BYCOMMAND) & MF_CHECKED) == 0; CheckMenuItem(GetMenu(hWnd), id, MF_BYCOMMAND | ((bKeyboard) ? MF_CHECKED : MF_UNCHECKED)); if(hCtl != NULL) L_ImgListEnableKeyboard(hCtl, bKeyboard); break; case IDM_SELCOLOR: if(uSelectionStyle != SELECTIONSTYLE_SELECTCOLOR) { uSelectionStyle = SELECTIONSTYLE_SELECTCOLOR; CheckMenuItem(GetMenu(hWnd), id, MF_BYCOMMAND | MF_CHECKED); CheckMenuItem(GetMenu(hWnd), IDM_SELBUTTON, MF_BYCOMMAND | MF_UNCHECKED); CheckMenuItem(GetMenu(hWnd), IDM_SELBITMAP, MF_BYCOMMAND | MF_UNCHECKED); if(hCtl != NULL) { Opt.uSelectionStyle = uSelectionStyle; Opt.uStructSize = sizeof(LILSELOPTION); L_ImgListSetSelOptions(hCtl, &Opt); RedrawWindow(hCtl, NULL, NULL, RDW_INVALIDATE | RDW_UPDATENOW | RDW_ERASE); } } break; case IDM_SELBUTTON: if(uSelectionStyle != SELECTIONSTYLE_PRESSEDBUTTON) { uSelectionStyle = SELECTIONSTYLE_PRESSEDBUTTON; CheckMenuItem(GetMenu(hWnd), id, MF_BYCOMMAND | MF_CHECKED); CheckMenuItem(GetMenu(hWnd), IDM_SELCOLOR, MF_BYCOMMAND | MF_UNCHECKED); CheckMenuItem(GetMenu(hWnd), IDM_SELBITMAP, MF_BYCOMMAND | MF_UNCHECKED); if(hCtl != NULL) { Opt.uSelectionStyle = uSelectionStyle; Opt.uStructSize = sizeof(LILSELOPTION); L_ImgListSetSelOptions(hCtl, &Opt); RedrawWindow(hCtl, NULL, NULL, RDW_INVALIDATE | RDW_UPDATENOW | RDW_ERASE); } } break; case IDM_SELBITMAP: if(uSelectionStyle != SELECTIONSTYLE_USERBITMAP) { SetUserBitmap(NULL, hCtl); uSelectionStyle = SELECTIONSTYLE_USERBITMAP; CheckMenuItem(GetMenu(hWnd), id, MF_BYCOMMAND | MF_CHECKED); CheckMenuItem(GetMenu(hWnd), IDM_SELCOLOR, MF_BYCOMMAND | MF_UNCHECKED); CheckMenuItem(GetMenu(hWnd), IDM_SELBUTTON, MF_BYCOMMAND | MF_UNCHECKED); if(hCtl != NULL) { Opt.uSelectionStyle = uSelectionStyle; Opt.uStructSize = sizeof(LILSELOPTION); L_ImgListSetSelOptions(hCtl, &Opt); RedrawWindow(hCtl, NULL, NULL, RDW_INVALIDATE | RDW_UPDATENOW | RDW_ERASE); } } break; case IDM_SELNONE: if(uAllowSelection != ALLOWSELECTION_NONE) { uAllowSelection = ALLOWSELECTION_NONE; CheckMenuItem(GetMenu(hWnd), id, MF_BYCOMMAND | MF_CHECKED); CheckMenuItem(GetMenu(hWnd), IDM_SELSINGLE, MF_BYCOMMAND | MF_UNCHECKED); CheckMenuItem(GetMenu(hWnd), IDM_SELMULTI, MF_BYCOMMAND | MF_UNCHECKED); if(hCtl != NULL) { Opt.uAllowSelection = uAllowSelection; Opt.uStructSize = sizeof(LILSELOPTION); L_ImgListSetSelOptions(hCtl, &Opt); RedrawWindow(hCtl, NULL, NULL, RDW_INVALIDATE | RDW_UPDATENOW | RDW_ERASE); } } break; case IDM_SELSINGLE: if(uAllowSelection != ALLOWSELECTION_SINGLE) { uAllowSelection = ALLOWSELECTION_SINGLE; CheckMenuItem(GetMenu(hWnd), id, MF_BYCOMMAND | MF_CHECKED); CheckMenuItem(GetMenu(hWnd), IDM_SELNONE, MF_BYCOMMAND | MF_UNCHECKED); CheckMenuItem(GetMenu(hWnd), IDM_SELMULTI, MF_BYCOMMAND | MF_UNCHECKED); if(hCtl != NULL) { Opt.uAllowSelection = uAllowSelection; Opt.uStructSize = sizeof(LILSELOPTION); L_ImgListSetSelOptions(hCtl, &Opt); RedrawWindow(hCtl, NULL, NULL, RDW_INVALIDATE | RDW_UPDATENOW | RDW_ERASE); } } break; case IDM_SELMULTI: if(uAllowSelection != ALLOWSELECTION_MULTI) { uAllowSelection = ALLOWSELECTION_MULTI; CheckMenuItem(GetMenu(hWnd), id, MF_BYCOMMAND | MF_CHECKED); CheckMenuItem(GetMenu(hWnd), IDM_SELNONE, MF_BYCOMMAND | MF_UNCHECKED); CheckMenuItem(GetMenu(hWnd), IDM_SELSINGLE, MF_BYCOMMAND | MF_UNCHECKED); if(hCtl != NULL) { Opt.uAllowSelection = uAllowSelection; Opt.uStructSize = sizeof(LILSELOPTION); L_ImgListSetSelOptions(hCtl, &Opt); RedrawWindow(hCtl, NULL, NULL, RDW_INVALIDATE | RDW_UPDATENOW | RDW_ERASE); } } break; case IDM_SCROLLVERT: if(uScrollStyle != SCROLLSTYLE_VERTICAL) { uScrollStyle = SCROLLSTYLE_VERTICAL; CheckMenuItem(GetMenu(hWnd), id, MF_BYCOMMAND | MF_CHECKED); CheckMenuItem(GetMenu(hWnd), IDM_SCROLLHORZ, MF_BYCOMMAND | MF_UNCHECKED); if(hCtl != NULL) L_ImgListSetScrollStyle(hCtl, uScrollStyle); } break; case IDM_SCROLLHORZ: if(uScrollStyle != SCROLLSTYLE_HORIZONTAL) { uScrollStyle = SCROLLSTYLE_HORIZONTAL; CheckMenuItem(GetMenu(hWnd), id, MF_BYCOMMAND | MF_CHECKED); CheckMenuItem(GetMenu(hWnd), IDM_SCROLLVERT, MF_BYCOMMAND | MF_UNCHECKED); if(hCtl != NULL) L_ImgListSetScrollStyle(hCtl, uScrollStyle); } break; case IDM_SORTASND: if(hCtl != NULL) { iSortMethod = IMAGELIST_SORTEDASD; CheckMenuItem(GetMenu(hWnd), id, MF_BYCOMMAND | MF_CHECKED); CheckMenuItem(GetMenu(hWnd), IDM_SORTDSND, MF_BYCOMMAND | MF_UNCHECKED); L_ImgListSort(hCtl, iSortMethod == IMAGELIST_SORTEDASD); } break; case IDM_SORTDSND: if(hCtl != NULL) { iSortMethod = IMAGELIST_SORTEDDSD; CheckMenuItem(GetMenu(hWnd), id, MF_BYCOMMAND | MF_CHECKED); CheckMenuItem(GetMenu(hWnd), IDM_SORTASND, MF_BYCOMMAND | MF_UNCHECKED); L_ImgListSort(hCtl, iSortMethod == IMAGELIST_SORTEDASD); } break; case IDM_INSERTIMAGE: InsertImage(); break; case IDM_REMOVEIMAGE: RemoveImage(); break; case IDM_SAVEDATABASE: SaveDatabase(); break; case IDM_LOADDATABASE: LoadDatabase(); break; #endif #ifdef WIN32 //capture API functions case IDM_CAPTURE_ACTIVEWINDOW: CheckCurrentCapture(id); EnableFrameMenu (FALSE,FALSE); bInCapture=TRUE; L_CaptureActiveWindow(&CapturedBitmap,sizeof(BITMAPHANDLE),NULL,0,CaptureCallback,0); EnableFrameMenu (TRUE,TRUE); bInCapture=FALSE; break; case IDM_CAPTURE_ACTIVECLIENT: CheckCurrentCapture(id); EnableFrameMenu (FALSE,FALSE); bInCapture=TRUE; L_CaptureActiveClient(&CapturedBitmap,sizeof(BITMAPHANDLE),NULL,0,CaptureCallback,0); EnableFrameMenu (TRUE,TRUE); bInCapture=FALSE; break; case IDM_CAPTURE_FULLSCREEN: CheckCurrentCapture(id); EnableFrameMenu (FALSE,FALSE); bInCapture=TRUE; L_CaptureFullScreen(&CapturedBitmap,sizeof(BITMAPHANDLE),NULL,0,CaptureCallback,0); EnableFrameMenu (TRUE,TRUE); bInCapture=FALSE; break; case IDM_CAPTURE_SELECTEDOBJECT: CheckCurrentCapture(id); EnableFrameMenu (FALSE,FALSE); bInCapture=TRUE; L_CaptureSelectedObject(&CapturedBitmap,sizeof(BITMAPHANDLE),&ObjectOptions,sizeof(ObjectOptions),NULL, 0,CaptureCallback,0); EnableFrameMenu (TRUE,TRUE); bInCapture=FALSE; break; case IDM_CAPTURE_MENUUNDERCURSOR: CheckCurrentCapture(id); EnableFrameMenu (FALSE,FALSE); bInCapture=TRUE; L_CaptureMenuUnderCursor(&CapturedBitmap,sizeof(BITMAPHANDLE),NULL,0,CaptureCallback,0); EnableFrameMenu (TRUE,TRUE); bInCapture=FALSE; break; case IDM_CAPTURE_SELECTEDAREA: CheckCurrentCapture(id); EnableFrameMenu (FALSE,FALSE); bInCapture=TRUE; L_CaptureArea(&CapturedBitmap,sizeof(BITMAPHANDLE),&CaptureAreaOption,sizeof(CaptureAreaOption),NULL, 0,CaptureCallback,0); EnableFrameMenu (TRUE,TRUE); bInCapture=FALSE; break; case IDM_CAPTURE_WALLPAPER: CheckCurrentCapture(id); EnableFrameMenu (FALSE,FALSE); bInCapture=TRUE; L_CaptureWallPaper(&CapturedBitmap,sizeof(BITMAPHANDLE),NULL,0,CaptureCallback,0); EnableFrameMenu (TRUE,TRUE); bInCapture=FALSE; break; case IDM_CAPTURE_MOUSECURSOR: CheckCurrentCapture(id); EnableFrameMenu (FALSE,FALSE); bInCapture=TRUE; L_CaptureMouseCursor(&CapturedBitmap,sizeof(BITMAPHANDLE),RGB(255, 255, 255),NULL,0,CaptureCallback,0); EnableFrameMenu (TRUE,TRUE); bInCapture=FALSE; break; case IDM_CAPTURE_WINDOWUNDERCURSOR: CheckCurrentCapture(id); EnableFrameMenu (FALSE,FALSE); bInCapture=TRUE; L_CaptureWindowUnderCursor(&CapturedBitmap,sizeof(BITMAPHANDLE),NULL,0,CaptureCallback,0); EnableFrameMenu (TRUE,TRUE); bInCapture=FALSE; break; case IDM_CAPTURE_FROMEXEDLGTREE: CheckCurrentCapture(id); EnableFrameMenu (FALSE,FALSE); bInCapture=TRUE; L_CaptureFromExeDlg(&CapturedBitmap, sizeof(BITMAPHANDLE), NULL, &TransparentColor, RESTYPE_BITMAP|RESTYPE_ICON|RESTYPE_CURSOR, LTCAPDLG_TREEVIEW, 0, NULL,0, CaptureCallback, NULL,NULL,NULL); EnableFrameMenu (TRUE,TRUE); bInCapture=FALSE; break; case IDM_CAPTURE_FROMEXEDLGTABBEDVIEW: CheckCurrentCapture(id); EnableFrameMenu (FALSE,FALSE); bInCapture=TRUE; L_CaptureFromExeDlg(&CapturedBitmap, sizeof(BITMAPHANDLE), NULL, &TransparentColor, RESTYPE_BITMAP|RESTYPE_ICON|RESTYPE_CURSOR, LTCAPDLG_TABVIEW, 0,NULL, 0, CaptureCallback, NULL, NULL, NULL); EnableFrameMenu (TRUE,TRUE); bInCapture=FALSE; break; case IDM_CAPTURE_STOP: L_StopCapture(); break; case IDM_CAPTURE_OPTIONS: L_SetCaptureOptionDlg(hWndFrame,0,NULL,NULL,NULL); break; case IDM_AREA_OPTIONS: L_CaptureAreaOptionDlg(hWndFrame,0,&CaptureAreaOption,sizeof(CaptureAreaOption),NULL,NULL); break; case IDM_OBJECT_OPTIONS: L_CaptureObjectOptionDlg(hWndFrame,0,&ObjectOptions,sizeof(ObjectOptions),NULL,NULL); break; case IDM_BROWSE: BrowseDir(); break; #endif default: { HWND hWndChild = FORWARD_WM_MDIGETACTIVE(hWndClient, SendMessage); if (IsWindow (hWndChild)) FORWARD_WM_COMMAND(hWndChild, id, hwndCtl, codeNotify, SendMessage); #ifdef WIN32 DefFrameProc(hWnd, hWndClient, WM_COMMAND, MAKEWPARAM((UINT)(id),(UINT)(codeNotify)), (LPARAM)(HWND)(hwndCtl)); #else DefFrameProc(hWnd, hWndClient, WM_COMMAND, (WPARAM) (int) (id), MAKELPARAM ((UINT) (hwndCtl), (codeNotify))); #endif } } return; } /*====(LEADTOOLS_OnQueryNewPalette)========================================= Description: Responds to a WM_QUERYNEWPALETTE message, forwarding to the child window that it will receive the focus and should realize any palette that it has. Syntax : BOOL LEADTOOLS_OnQueryNewPalette(HWND hwnd) Parameters : hwnd Handle to a window. Return Value: TRUE Function was successful, so respond to the message. ==========================================================================*/ static BOOL LEADTOOLS_OnQueryNewPalette (HWND hwnd) { HWND hWndChild = FORWARD_WM_MDIGETACTIVE (hWndClient, SendMessage); UNREFERENCED_PARAMETER(hwnd); if (IsWindow (hWndChild)) FORWARD_WM_QUERYNEWPALETTE (hWndChild, SendMessage); return(TRUE); } /*====(LEADTOOLS_OnPaletteChanged)========================================== Description: Enumerates all child windows and asks them to realize their logical palettes beside the physical palette. Syntax : VOID LEADTOOLS_OnPaletteChanged(HWND hwnd, HWND hWndPaletteChange) Parameters : hwnd Handle to a window. hWndPaletteChange Handle to a window that has the palette realized. Return Value: None. ==========================================================================*/ static VOID LEADTOOLS_OnPaletteChanged (HWND hWnd, HWND hWndPaletteChange) { FARPROC lpfn = MakeProcInstance ((FARPROC) PaletteChangedAll, hInst); UNREFERENCED_PARAMETER(hWnd); EnumChildWindows (hWndClient, (WNDENUMPROC) lpfn, (LPARAM) (UINT) hWndPaletteChange); FreeProcInstance (lpfn); return; } /*====(LEADTOOLS_OnPaletteChanging)========================================== Description: Enumerates all child windows and asks them to realize their logical palettes beside the physical palette. Syntax : VOID LEADTOOLS_OnPaletteChanging(HWND hwnd, HWND hWndPaletteChange) Parameters : hwnd Handle to a window. hWndPaletteChange Handle to a window that has the palette realized. Return Value: None. ==========================================================================*/ VOID LEADTOOLS_OnPaletteChanging(HWND hWnd, HWND hWndPaletteChange) { LEADTOOLS_OnPaletteChanged (hWnd, hWndPaletteChange); } L_BOOL CALLBACK L_EXPORT PaletteQueryAll(HWND hWnd, LPARAM lParam) { if(GetParent(hWnd)!=hWndClient) return(TRUE); FORWARD_WM_QUERYNEWPALETTE (hWnd, SendMessage); return(TRUE); } /*====(LEADTOOLS_SysColorChange)========================================== Syntax: static VOID LEADTOOLS_SysColorChange( HWND hWnd ) Parameters: hWnd Handle to a window. Prototype: Loadsave.h Notes: This procedure is responsible for handling WM_SYSCOLORCHANGE. ==========================================================================*/ static VOID LEADTOOLS_SysColorChange(HWND hwnd) { FARPROC lpfn = MakeProcInstance ((FARPROC) PaletteQueryAll, hInst); EnumChildWindows (hWndClient, (WNDENUMPROC) lpfn, 0); FreeProcInstance (lpfn); LEADTOOLS_OnQueryNewPalette (hwnd); return; } /*====(LEADTOOLS_OnInitMenuPopup)============================================ Description: Initializes the main popup menu when the user clicks on one of the menu items. Syntax : VOID LEADTOOLS_OnInitMenuPopup(HWND hWnd, HMENU hMenu, L_INT nItem, BOOL fSystemMenu) Parameters : hWnd Handle to the window using the popup menu. hMenu Handle to the menu to be used. nItem Number of items in the menu. fSystemMenu Truth of "Is the menu a system menu". Return Value: None. ==========================================================================*/ static VOID LEADTOOLS_OnInitMenuPopup (HWND hWnd, HMENU hMenu, L_INT nItem, BOOL fSystemMenu) { HWND hWndChild; LPCHILDDATA pData = NULL; L_BOOL fHasChild; FILEINFO FileInfo; hWndChild = FORWARD_WM_MDIGETACTIVE (hWndClient, SendMessage); if (!fSystemMenu && GetSubMenu (GetMenu (hWnd), nItem) == hMenu) { fHasChild = IsWindow (hWndChild); if (fHasChild) { pData = LOCKCHILDDATA (hWndChild); if (IsZoomed (hWndChild)) nItem--; } switch (nItem) { case MENU_FILE_POS: ENABLEMENUITEM (hMenu, IDM_SAVEAS, fHasChild); ENABLEMENUITEM (hMenu, IDM_TWAINSEL, !fInTwain & fbTwnInstalled); ENABLEMENUITEM (hMenu, IDM_TWAINACQ, !fInTwain & fbTwnInstalled); #ifdef UNICODE ENABLEMENUPOS (hMenu, (MENU_FILE_WEBTUNER_POS-5), fHasChild); #else ENABLEMENUITEM (hMenu, IDM_ISISSEL, !fInTwain & fISIS); ENABLEMENUITEM (hMenu, IDM_ISISACQ, !fInTwain & fISIS); ENABLEMENUITEM (hMenu, IDM_ISISACQMUL, !fInTwain & fISIS); ENABLEMENUPOS (hMenu, MENU_FILE_WEBTUNER_POS, fHasChild); #endif ENABLEMENUITEM (hMenu, IDM_IMAGEMAPPER, fHasChild); ENABLEMENUITEM (hMenu, IDM_PRINT, fHasChild); ENABLEMENUITEM (hMenu, IDM_PREVIEW, fHasChild); ENABLEMENUITEM (hMenu, IDM_EXIT, !fInTwain); ENABLEMENUITEM (hMenu, IDM_CLRMERGE, fHasChild); break; case MENU_EDIT_POS: ENABLEMENUITEM (hMenu, IDM_COPY, fHasChild); ENABLEMENUITEM (hMenu, IDM_COPYRGN, fHasChild && L_BitmapHasRgn(&pData->ActiveBitmap)); ENABLEMENUITEM (hMenu, IDM_PASTE, L_ClipboardReady ()); ENABLEMENUPOS (hMenu, MUNU_EDIT_SELECTREGION_POS , fHasChild); CHECKMENUITEM (hMenu, IDM_TOOLNONE, nRegionTool == IDM_TOOLNONE); CHECKMENUITEM (hMenu, IDM_TOOLRECT, nRegionTool == IDM_TOOLRECT); CHECKMENUITEM (hMenu, IDM_TOOLRNDRECT, nRegionTool == IDM_TOOLRNDRECT); CHECKMENUITEM (hMenu, IDM_TOOLELLIPSE, nRegionTool == IDM_TOOLELLIPSE); CHECKMENUITEM (hMenu, IDM_TOOLFREEHAND, nRegionTool == IDM_TOOLFREEHAND); CHECKMENUITEM (hMenu, IDM_TOOLCURVE, nRegionTool == IDM_TOOLCURVE); CHECKMENUITEM (hMenu, IDM_TOOLBEZIER, nRegionTool == IDM_TOOLBEZIER); ENABLEMENUITEM (hMenu, IDM_CANCELREGION, fHasChild && L_BitmapHasRgn(&pData->ActiveBitmap)); break; case MENU_ANIMATION_POS: ENABLEMENUITEM (hMenu, IDM_CREATEANIMATION, fHasChild); ENABLEMENUITEM (hMenu, IDM_ANICOMPOSITE, fHasChild && pData->hList); CHECKMENUITEM (hMenu, IDM_ANICOMPOSITE, fHasChild && pData->hList && pData->fComposite); ENABLEMENUITEM (hMenu, IDM_ANIPREVFRAME, fHasChild && pData->hList && pData->uFrame > 0); ENABLEMENUITEM (hMenu, IDM_ANIFIRSTFRAME, fHasChild && pData->hList && pData->uFrame > 0); ENABLEMENUITEM (hMenu, IDM_ANINEXTFRAME, fHasChild && pData->hList && pData->uFrame < pData->uLastFrame); ENABLEMENUITEM (hMenu, IDM_ANILASTFRAME, fHasChild && pData->hList && pData->uFrame < pData->uLastFrame); ENABLEMENUITEM (hMenu, IDM_ANIFRAMESETTINGS, fHasChild && pData->hList); ENABLEMENUITEM (hMenu, IDM_ANIBACKCOLOR, fHasChild && pData->hList); ENABLEMENUITEM (hMenu, IDM_ANICOLORRES, fHasChild && pData->hList); CHECKMENUITEM (hMenu, IDM_ANILOOP, fHasChild && pData->hList && pData->fLoop); ENABLEMENUITEM (hMenu, IDM_ANILOOP, fHasChild && pData->hList); ENABLEMENUITEM (hMenu, IDM_PLAYANIMATION, fHasChild && pData->hList); ENABLEMENUITEM (hMenu, IDM_INSERT_FRAME,fHasChild && pData->hList); ENABLEMENUITEM (hMenu, IDM_ADD_FRAME,fHasChild && pData->hList); ENABLEMENUITEM (hMenu, IDM_DELETE_FRAME,fHasChild && pData->hList); ENABLEMENUITEM (hMenu, IDM_REPLACE_FRAME,fHasChild && pData->hList); break; case MENU_PAGE_POS: if(pData) { fHasChild=(fHasChild&&(pData->hList==0)&&IsMultiPageSupportAvailable(pData->szTitle)); LoadFileOption.PageNumber = 32000; //get number of pages in the file L_FileInfo(pData->szTitle, &FileInfo, sizeof(FILEINFO), FILEINFO_TOTALPAGES,&LoadFileOption); } else fHasChild=FALSE; ENABLEMENUITEM (hMenu, IDM_INSERT_PAGE,(fHasChild && IsWindow(pData->hListBox)) ); ENABLEMENUITEM (hMenu, IDM_ADD_PAGE,(fHasChild && IsWindow(pData->hListBox))); ENABLEMENUITEM (hMenu, IDM_REPLACE_PAGE,(fHasChild && IsWindow(pData->hListBox)) ); ENABLEMENUITEM (hMenu, IDM_DELETE_PAGE,(fHasChild && IsWindow(pData->hListBox) &&(FileInfo.TotalPages>1))); break; case MENU_VIEW_POS: ENABLEMENUITEM (hMenu, IDM_NORMAL, fHasChild); ENABLEMENUITEM (hMenu, IDM_ZOOM, fHasChild); ENABLEMENUITEM (hMenu, IDM_FITIMAGE, fHasChild); ENABLEMENUITEM (hMenu, IDM_EFFECTS, fHasChild); CHECKMENUITEM (hMenu, IDM_NORMAL, fHasChild && !pData->fFitImage && pData->nZoom == 100); CHECKMENUITEM (hMenu, IDM_ZOOM, fHasChild && !pData->fFitImage && pData->nZoom != 100); CHECKMENUITEM (hMenu, IDM_FITIMAGE, fHasChild && pData->fFitImage); ENABLEMENUITEM (hMenu, IDM_SNAPWINDOW, fHasChild && !pData->fFitImage && !IsIconic(hWndChild) && !IsZoomed(hWndChild)); ENABLEMENUITEM (hMenu, IDM_ELEMENTS, fHasChild); ENABLEMENUITEM (hMenu, IDM_PANWINDOW, fHasChild); ENABLEMENUITEM (hMenu, IDM_MAGGLASS, fHasChild); CHECKMENUITEM (hMenu, IDM_PANWINDOW, fHasChild && pData->bPanWindow); CHECKMENUITEM (hMenu, IDM_MAGGLASS, fHasChild && pData->bMagGlass); ENABLEMENUITEM (hMenu, IDM_VIEWPALETTE, pData && pData->ActiveBitmap.BitsPerPixel <= 8); ENABLEMENUITEM (hMenu, IDM_VIEWINTENSITY, fHasChild); ENABLEMENUITEM (hMenu, IDM_VIEWCONTRAST, fHasChild); ENABLEMENUITEM (hMenu, IDM_VIEWGAMMA, fHasChild); break; case MENU_IMAGE_POS: ENABLEMENUITEM (hMenu, IDM_FLIP, fHasChild); ENABLEMENUITEM (hMenu, IDM_REVERSE, fHasChild); ENABLEMENUITEM (hMenu, IDM_FASTFLIP, fHasChild); ENABLEMENUITEM (hMenu, IDM_FASTREVERSE, fHasChild); ENABLEMENUPOS (hMenu, MENU_IMAGE_ROTATE_POS, fHasChild); ENABLEMENUITEM (hMenu, IDM_FASTROTATE90, fHasChild && !L_BitmapHasRgn(&pData->ActiveBitmap)); ENABLEMENUITEM (hMenu, IDM_FASTROTATE180, fHasChild && !L_BitmapHasRgn(&pData->ActiveBitmap)); ENABLEMENUITEM (hMenu, IDM_FASTROTATE270, fHasChild && !L_BitmapHasRgn(&pData->ActiveBitmap)); ENABLEMENUITEM (hMenu, IDM_SHEAR, fHasChild); ENABLEMENUITEM (hMenu, IDM_DESKEW, fHasChild && (VersionInfo.Level == TOOLKIT_LEVEL_DOCUMENT||VersionInfo.Level == TOOLKIT_LEVEL_MEDICAL) && !L_BitmapHasRgn(&pData->ActiveBitmap)); ENABLEMENUITEM (hMenu, IDM_AUTOTRIM, fHasChild); ENABLEMENUITEM (hMenu, IDM_RESIZE, fHasChild); ENABLEMENUITEM (hMenu, IDM_CANVASSIZE, fHasChild); ENABLEMENUITEM (hMenu, IDM_HISTOGRAM, fHasChild); ENABLEMENUITEM (hMenu, IDM_REMOVEREDEYE, fHasChild); ENABLEMENUPOS (hMenu, MENU_IMAGE_ADD_POS, fHasChild); ENABLEMENUPOS (hMenu, MENU_IMAGE_IMAGEDOC_POS, fHasChild && (VersionInfo.Level == TOOLKIT_LEVEL_DOCUMENT||VersionInfo.Level == TOOLKIT_LEVEL_MEDICAL) && (pData->ActiveBitmap.BitsPerPixel == 1)); ENABLEMENUITEM (hMenu, IDM_DESPECKLE, fHasChild && (VersionInfo.Level == TOOLKIT_LEVEL_DOCUMENT||VersionInfo.Level == TOOLKIT_LEVEL_MEDICAL)); ENABLEMENUITEM (hMenu, IDM_EDGEENHANCE, fHasChild && pData->ActiveBitmap.BitsPerPixel > 8); ENABLEMENUITEM (hMenu, IDM_SLICE, fHasChild); break; case MENU_EFFECTS_POS: ENABLEMENUPOS (hMenu, MENU_EFFECTS_BLUR_POS, fHasChild); ENABLEMENUPOS (hMenu, MENU_EFFECTS_NOISE_POS, fHasChild); ENABLEMENUPOS (hMenu, MENU_EFFECTS_SHARPEN_POS, fHasChild); ENABLEMENUITEM (hMenu, IDM_MULTIPLY, fHasChild); ENABLEMENUPOS (hMenu, MENU_EFFECTS_DISTORT_POS, fHasChild); ENABLEMENUPOS (hMenu, MENU_EFFECTS_3DEFFECTS_POS, fHasChild); ENABLEMENUPOS (hMenu, MENU_EFFECTS_ARTISTIC_POS, fHasChild); ENABLEMENUPOS (hMenu, MENU_EFFECTS_TEXTURE_POS, fHasChild); ENABLEMENUPOS (hMenu, MENU_EFFECTS_PIXELATE_POS, fHasChild); ENABLEMENUPOS (hMenu, MENU_EFFECTS_EDGE_POS, fHasChild); ENABLEMENUPOS (hMenu, MENU_EFFECTS_SPATIALFILTERS_POS, fHasChild); break; case MENU_COLOR_POS: ENABLEMENUITEM (hMenu, IDM_INVERT, fHasChild); ENABLEMENUITEM (hMenu, IDM_GRAYSCALE8, fHasChild); ENABLEMENUITEM (hMenu, IDM_GRAYSCALE12, fHasChild && VersionInfo.Level == TOOLKIT_LEVEL_MEDICAL); ENABLEMENUITEM (hMenu, IDM_GRAYSCALE16, fHasChild && VersionInfo.Level == TOOLKIT_LEVEL_MEDICAL); ENABLEMENUITEM (hMenu, IDM_WINDOWLEVEL, fHasChild && (pData->ActiveBitmap.BitsPerPixel==12 || pData->ActiveBitmap.BitsPerPixel==16)&& L_IsGrayScaleBitmap ( &pData->ActiveBitmap )); ENABLEMENUITEM (hMenu, IDM_DETECT, fHasChild); ENABLEMENUITEM (hMenu, IDM_SOLARIZE, fHasChild); ENABLEMENUITEM (hMenu, IDM_POSTERIZE, fHasChild); ENABLEMENUPOS (hMenu, MENU_COLOR_ADJUST_POS, fHasChild); ENABLEMENUITEM (hMenu, IDM_BALANCECOLORS, (fHasChild && (SUCCESS != L_IsGrayScaleBitmap(&pData->ActiveBitmap)))); ENABLEMENUPOS (hMenu, MENU_COLOR_TRANSFORM_POS, fHasChild); ENABLEMENUPOS (hMenu, MENU_COLOR_REMAP_POS, fHasChild); ENABLEMENUPOS (hMenu, MENU_COLOR_HISTOGRAM_POS, fHasChild); ENABLEMENUPOS (hMenu, MENU_COLOR_FILL_POS, fHasChild); ENABLEMENUPOS (hMenu, MENU_COLOR_SEPARATION_POS, fHasChild); ENABLEMENUITEM (hMenu, IDM_COUNTCOLORS, fHasChild);; break; #ifdef WIN32 //capture API functions case MENU_CAPTURE_POS: ENABLEMENUITEM (hMenu, IDM_CAPTURE_FULLSCREEN,!bInCapture); ENABLEMENUITEM (hMenu, IDM_CAPTURE_ACTIVECLIENT,!bInCapture); ENABLEMENUITEM (hMenu, IDM_CAPTURE_ACTIVEWINDOW,!bInCapture); ENABLEMENUITEM (hMenu, IDM_CAPTURE_WINDOWUNDERCURSOR,!bInCapture); ENABLEMENUITEM (hMenu, IDM_CAPTURE_MENUUNDERCURSOR,!bInCapture); ENABLEMENUITEM (hMenu, IDM_CAPTURE_SELECTEDOBJECT,!bInCapture); ENABLEMENUITEM (hMenu, IDM_CAPTURE_SELECTEDAREA,!bInCapture); ENABLEMENUITEM (hMenu, IDM_CAPTURE_MOUSECURSOR,!bInCapture); ENABLEMENUITEM (hMenu, IDM_CAPTURE_WALLPAPER,!bInCapture); ENABLEMENUITEM (hMenu, IDM_CAPTURE_FROMEXEDLGTREE,!bInCapture); ENABLEMENUITEM (hMenu, IDM_CAPTURE_FROMEXEDLGTABBEDVIEW,!bInCapture); ENABLEMENUITEM (hMenu, IDM_CAPTURE_STOP,bInCapture); ENABLEMENUITEM (hMenu, IDM_CAPTURE_OPTIONS,!bInCapture); ENABLEMENUITEM (hMenu, IDM_AREA_OPTIONS,!bInCapture); ENABLEMENUITEM (hMenu, IDM_OBJECT_OPTIONS,!bInCapture); ENABLEMENUITEM (hMenu, IDM_OBJECT_OPTIONS,!bInCapture); break; #endif case MENU_PREFERENCE_POS: CHECKMENUITEM (hMenu, IDM_BGR, fIsBGRDevice ? TRUE : FALSE); CHECKMENUITEM (hMenu, IDM_PAINTCALLBACK, fDoPaintWhileLoad); CHECKMENUITEM (hMenu, IDM_PROGRESSBAR, fUseProgress ? TRUE : FALSE); CHECKMENUITEM (hMenu, IDM_FASTPRINT, fUseFastPrint ? TRUE : FALSE); CHECKMENUITEM (hMenu, IDM_ORDEREDDITHERING, nDitherMode == IDM_ORDEREDDITHERING); CHECKMENUITEM (hMenu, IDM_ERRORDIFFUSION, nDitherMode == IDM_ERRORDIFFUSION); CHECKMENUITEM (hMenu, IDM_BITONALNORMAL, nBitonalFlags == 0); ENABLEMENUITEM (hMenu, IDM_SCALETOGRAY, (VersionInfo.Level == TOOLKIT_LEVEL_DOCUMENT||VersionInfo.Level == TOOLKIT_LEVEL_MEDICAL)); ENABLEMENUITEM (hMenu, IDM_FAVORBLACK, (VersionInfo.Level == TOOLKIT_LEVEL_DOCUMENT||VersionInfo.Level == TOOLKIT_LEVEL_MEDICAL)); CHECKMENUITEM (hMenu, IDM_SCALETOGRAY, nBitonalFlags == DISPLAYMODE_SCALETOGRAY); CHECKMENUITEM (hMenu, IDM_FAVORBLACK, nBitonalFlags == DISPLAYMODE_FAVORBLACK); CHECKMENUITEM (hMenu, IDM_PALETTEAUTO, nPaletteMode == IDM_PALETTEAUTO); CHECKMENUITEM (hMenu, IDM_PALETTEFIXED, nPaletteMode == IDM_PALETTEFIXED); CHECKMENUITEM (hMenu, IDM_PALETTENETSCAPE, fNetscapePalette); CHECKMENUITEM (hMenu, IDM_LOADCOMPRESSED, fLoadCompressed); ENABLEMENUITEM (hMenu, IDM_LOADROTATED, (VersionInfo.Level == TOOLKIT_LEVEL_DOCUMENT||VersionInfo.Level == TOOLKIT_LEVEL_MEDICAL)); CHECKMENUITEM (hMenu, IDM_LOADROTATED, fLoadRotated); CHECKMENUITEM (hMenu, IDM_TOTALPAGES, fTotalPages ); CHECKMENUITEM (hMenu, IDM_SHOWPREVIEW, fShowPreview); CHECKMENUITEM (hMenu, IDM_SHOWRESIZE, fShowResize); CHECKMENUITEM (hMenu, IDM_LOADVECTORFILES, fLoadVecFiles); CHECKMENUITEM (hMenu, IDM_LOADTEXTFILES, fLoadTxtFiles); CHECKMENUITEM (hMenu, IDM_LOAD_RAW_FAX, fLoadRawFax); CHECKMENUITEM (hMenu, IDM_PAINT_NORMAL, nPaintResizeFlags == 0); CHECKMENUITEM (hMenu, IDM_PAINT_RESAMPLE, nPaintResizeFlags == DISPLAYMODE_RESAMPLE); CHECKMENUITEM (hMenu, IDM_PAINT_BICUBIC, nPaintResizeFlags == DISPLAYMODE_BICUBIC); break; #ifdef WIN32 case MENU_IMAGELIST_POS: CHECKMENUITEM (hMenu, IDM_IMAGEINCLUDE, bIncludeSubD); CHECKMENUITEM (hMenu, IDM_EXPANDMULTIPAGE, bExpandMulti); CHECKMENUITEM (hMenu, IDM_DISPTEXT, bDisplayItemText); CHECKMENUITEM (hMenu, IDM_SELCOLOR, uSelectionStyle == SELECTIONSTYLE_SELECTCOLOR); CHECKMENUITEM (hMenu, IDM_SELSINGLE, uAllowSelection == ALLOWSELECTION_SINGLE); CHECKMENUITEM (hMenu, IDM_SCROLLVERT, uScrollStyle == SCROLLSTYLE_VERTICAL); CHECKMENUITEM (hMenu, IDM_KEYBOARD, bKeyboard); ENABLEMENUITEM (hMenu, IDM_INSERTIMAGE, hCtl != NULL); ENABLEMENUITEM (hMenu, IDM_REMOVEIMAGE, hCtl != NULL && uAllowSelection != ALLOWSELECTION_MULTI); ENABLEMENUITEM (hMenu, IDM_SAVEDATABASE, hCtl != NULL); // ENABLEMENUITEM (hMenu, IDM_LOADDATABASE, hCtl != NULL); ENABLEMENUITEM (hMenu, IDM_LOADDATABASE, TRUE); break; #endif case MENU_WINDOW_POS: ENABLEMENUITEM (hMenu, IDM_CASCADE, fHasChild); ENABLEMENUITEM (hMenu, IDM_TILEHORZ, fHasChild); ENABLEMENUITEM (hMenu, IDM_TILEVERT, fHasChild); ENABLEMENUITEM (hMenu, IDM_ARRANGE, fHasChild); ENABLEMENUITEM (hMenu, IDM_CLOSEALL, fHasChild); break; } if (fHasChild) UNLOCKCHILDDATA (hWndChild); } return; } /*====(LEADTOOLS_OnDestroy)================================================= Description: Performs cleanup for the program, and posts WM_QUIT to terminate the application. Syntax : VOID LEADTOOLS_OnDestroy(HWND hWnd) Parameters : hWnd Handle to a window. Return Value: None. ==========================================================================*/ static VOID LEADTOOLS_OnDestroy (HWND hWnd) { UNREFERENCED_PARAMETER(hWnd); if(hWndStatus) DestroyWindow(hWndStatus); if(lpfnStatusBar) FreeProcInstance(lpfnStatusBar); if(g_hTwainSession) L_TwainEndSession(&g_hTwainSession); L_DlgFree(); PostQuitMessage (0); return; } /*====(LEADTOOLS_OnCreate)======================================================== Description: Creates a client window in response to WM_CREATE from the frame window. Syntax : BOOL LEADTOOLS_OnCreate(HWND hWnd, CREATESTRUCT FAR* lpCreateStruct) Parameters : hWnd Handle to current window. lpCreateStruct pointer to CREATESTRUCT Return Value: TRUE The function was successful in creating window. FALSE The function was not successful. ==========================================================================*/ static BOOL LEADTOOLS_OnCreate (HWND hWnd, CREATESTRUCT FAR * lpCreateStruct) { L_INT nRet; #ifdef WIN32 L_UINT32 dwVersion; #endif CLIENTCREATESTRUCT ClientStruct; APPLICATIONDATA AppData; L_DlgInit(DLG_INIT_COLOR); RegisterAppKey(hInst); AppData.hWnd = hWnd; lstrcpy (AppData.szManufacturerName, TEXT("LEAD Technologies, Inc.")); lstrcpy (AppData.szAppProductFamily, TEXT("LEAD Test Applications")); lstrcpy (AppData.szVersionInfo, TEXT("Version 1.0")); lstrcpy (AppData.szAppName, TEXT("TWAIN Test Application")); AppData.uStructSize = sizeof(APPLICATIONDATA); UNREFERENCED_PARAMETER(lpCreateStruct); ClientStruct.hWindowMenu = GetSubMenu (GetMenu (hWnd), MENU_WINDOW_POS); ClientStruct.idFirstChild = IDM_FIRSTCHILD; hWndClient = CreateWindow (TEXT("MDICLIENT"), NULL, WS_CHILD | WS_CLIPCHILDREN | WS_VISIBLE | WS_VSCROLL | WS_HSCROLL, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, hWnd, (HMENU) 1, hInst, (VOID FAR *) & ClientStruct); if (!hWndClient) return(FALSE); #ifdef WIN32 hBrowseDlg=NULL; #endif lpfnStatusBar = MakeProcInstance((FARPROC)StatusBarProc, hInst); #ifdef WIN32 dwVersion = GetVersion(); if(LOBYTE(LOWORD(dwVersion)) < 4) hWndStatus = CreateDialog(hInst, MAKEINTRESOURCE(IDD_STATUSBAR), hWnd, (DLGPROC) lpfnStatusBar); else hWndStatus = CreateDialog(hInst, MAKEINTRESOURCE(IDD_STATUSBAR95), hWnd, (DLGPROC) lpfnStatusBar); #else hWndStatus = CreateDialog(hInst, MAKEINTRESOURCE(IDD_STATUSBAR), hWnd, (DLGPROC) lpfnStatusBar); #endif /* Assign the bitmaphandles to pointers for L_ColorSeparateBitmap. */ pColorPlanes[0] = &ColorPlanes[0]; pColorPlanes[1] = &ColorPlanes[1]; pColorPlanes[2] = &ColorPlanes[2]; pColorPlanes[3] = &ColorPlanes[3]; /* Enable Drag and Drop Files */ DragAcceptFiles(hWnd, TRUE); /* Create twain session */ nRet = L_TwainInitSession (&g_hTwainSession, &AppData); fbTwnInstalled = L_IsTwainAvailable(hWnd); if( bCommandLine ) SetTimer (hWnd,1,10,NULL); EnableLoadVectorFiles (FALSE); return(TRUE); } /*====(CloseAll)=========================================================== Description: Performs as a callback. Used by EnumChildWindows to send WM_CLOSE to each child window. Syntax : L_BOOL CloseAll(HWND hWnd, LPARAM lParam) Prototype : demo.h Parameters : hWnd Handle to a window. lParam long parameter. Return Value: TRUE Function was successful, goto to next child. ==========================================================================*/ L_BOOL CALLBACK L_EXPORT CloseAll (HWND hWnd, LPARAM lParam) { UNREFERENCED_PARAMETER(lParam); if(GetParent(hWnd)!=hWndClient) return(TRUE); if (GetWindow (hWnd, GW_OWNER)) return(TRUE); FORWARD_WM_MDIRESTORE (GetParent (hWnd), hWnd, SendMessage); FORWARD_WM_CLOSE (hWnd, SendMessage); return(TRUE); } /*====(RedrawChildrenCB)=================================================== Description: Forces painting of the window. Syntax : L_BOOL CALLBACK L_EXPORT RedrawChildrenCB (HWND hWnd, LPARAM lParam) Prototype : demo.h Parameters : hWnd Window to redraw. lParam Windows long parameter. Return Value: TRUE Function was succcessful. ==========================================================================*/ L_BOOL CALLBACK L_EXPORT RedrawChildrenCB (HWND hWnd, LPARAM lParam) { LPCHILDDATA pData = NULL; if(GetParent(hWnd) == hWndClient) { if (GetWindow (hWnd, GW_OWNER)) return(TRUE); if(HIWORD(lParam)) FORWARD_WM_QUERYNEWPALETTE (hWnd, SendMessage); } else { pData = LOCKCHILDDATA(GetParent(hWnd)); if(pData->bMagGlass)/* need to reset to get new paint flags */ { StopMagGlass(pData); StartMagGlass(pData); } RedrawWindow(hWnd,0,0,RDW_INVALIDATE|RDW_ALLCHILDREN|(LOWORD(lParam) ? RDW_ERASE:0)); UNLOCKCHILDDATA(GetParent(hWnd)); } return(TRUE); } /*====(RedrawChildren)==================================================== Description: Enumerates all child windows and makes them repaint. Syntax : static L_VOID RedrawChildren (L_BOOL fErase, L_BOOL fNewPalette) Parameters : fErase Erase the backGround? fNewPalette Is there a new palette? Return Value: None. ==========================================================================*/ static L_VOID RedrawChildren (L_BOOL fErase, L_BOOL fNewPalette) { FARPROC lpfn = MakeProcInstance ((FARPROC) RedrawChildrenCB, hInst); EnumChildWindows (hWndClient, (WNDENUMPROC) lpfn, MAKELONG (fErase, fNewPalette)); FreeProcInstance (lpfn); return; } /*====(EnableFrameMenu)==================================================== Description: Enables Frame menu items. Syntax : L_VOID EnableFrameMenu (L_BOOL fEnable) Prototype : demo.h Parameters : fEnable Should items be enabled? Return Value: None. ==========================================================================*/ L_VOID EnableFrameMenu (L_BOOL fEnable,L_BOOL bAndCapture) { HWND hWndChild; HMENU hMenu; LONG ulWndStyle; L_INT nItem; LPCHILDDATA pData = NULL; hMenu = GetMenu (hWndFrame); nItem = 0; hWndChild = FORWARD_WM_MDIGETACTIVE(hWndClient, SendMessage); if (IsWindow (hWndChild)) { pData = LOCKCHILDDATA (hWndChild); if (pData->bAnimationExist) hWndChild = hWndAnimation; UNLOCKCHILDDATA (hWndChild); if (IsZoomed (hWndChild)) nItem = 1; } ENABLEMENUPOS (hMenu, MENU_FILE_POS + nItem, fEnable); ENABLEMENUPOS (hMenu, MENU_EDIT_POS + nItem, fEnable); ENABLEMENUPOS (hMenu, MENU_ANIMATION_POS + nItem, fEnable); ENABLEMENUPOS (hMenu, MENU_PAGE_POS + nItem, fEnable); ENABLEMENUPOS (hMenu, MENU_VIEW_POS + nItem, fEnable); ENABLEMENUPOS (hMenu, MENU_IMAGE_POS + nItem, fEnable); ENABLEMENUPOS (hMenu, MENU_EFFECTS_POS + nItem, fEnable); ENABLEMENUPOS (hMenu, MENU_COLOR_POS + nItem, fEnable); #ifdef WIN32 if(bAndCapture) ENABLEMENUPOS (hMenu, MENU_CAPTURE_POS + nItem, fEnable); #endif ENABLEMENUPOS (hMenu, MENU_IMAGELIST_POS + nItem, fEnable); ENABLEMENUPOS (hMenu, MENU_PREFERENCE_POS + nItem, fEnable); ENABLEMENUPOS (hMenu, MENU_WINDOW_POS + nItem, fEnable); ENABLEMENUPOS (hMenu, MENU_HELP_POS + nItem, fEnable); hMenu = GetSystemMenu (hWndFrame, FALSE); ENABLEMENUITEM (hMenu, SC_MINIMIZE, fEnable); ENABLEMENUITEM (hMenu, SC_CLOSE, fEnable); if(bAndCapture) { hMenu = GetSystemMenu (hWndChild , FALSE); ENABLEMENUITEM (hMenu, SC_MINIMIZE, fEnable); ENABLEMENUITEM (hMenu, SC_CLOSE, fEnable); ulWndStyle = GetWindowLong(hWndChild,GWL_STYLE); SetWindowLong(hWndChild,GWL_STYLE, fEnable ? (ulWndStyle | WS_MINIMIZEBOX) :(ulWndStyle & ~(WS_MINIMIZEBOX))); } DrawMenuBar(hWndChild ); SendMessage(hWndChild,WM_MDIREFRESHMENU,0,0); DrawMenuBar (hWndFrame); SetWindowPos(hWndChild,HWND_TOP,0,0,0,0, SWP_FRAMECHANGED|SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE); return; } /*====(PaletteChangedAll)================================================== Description: Performs as a callback. Used by EnumChildWindows to realize logical palettes. Syntax : L_BOOL CALLBACK L_EXPORT PaletteChangedAll(HWND hwnd, LPARAM lParam) Prototype : demo.h Parameters : hwnd Handle to a window. lParam LEAD parameter structure. Return Value: TRUE Function is successful. ==========================================================================*/ L_BOOL CALLBACK L_EXPORT PaletteChangedAll (HWND hWnd, LPARAM lParam) { if(GetParent(hWnd)!=hWndClient) return(TRUE); if (GetWindow (hWnd, GW_OWNER)) return(TRUE); FORWARD_WM_PALETTECHANGED (hWnd, (HWND) (UINT) (lParam), SendMessage); return(TRUE); } /*====(AboutDlgProc)====================================================== Description: Processes messages for the about dialog box. Syntax : L_BOOL CALLBACK L_EXPORT AboutDlgProc (HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam) Prototype : demo.h Parameters : hWnd Handle to the window using the popup menu. hMenu Handle to the menu to be used. nItem Number of items in the menu. fSystemMenu Truth of "Is the menu a system menu". Return Value: TRUE WM_INITDIALOG and WM_COMMAND (IDOK or IDCANCEL) messages processed. FALSE A different message was processed. ==========================================================================*/ L_BOOL CALLBACK L_EXPORT AboutDlgProc (HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam) { L_TCHAR szText[_MAX_PATH]; L_TCHAR szTemp[_MAX_PATH]; memset (&szTemp, 0, sizeof(szTemp)); UNREFERENCED_PARAMETER(lParam); switch (message) { case WM_INITDIALOG: strprintf(szText, TEXT("%s\\%s"), szImageDir, TEXT("image1.cmp")); SetDlgItemText(hDlg, IDC_ABOUTIMAGE, szText); #ifdef UNICODE MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, VersionInfo.Product, -1, szText, sizeof(szText)); #else lstrcpy(szText, (LPSTR)VersionInfo.Product); #endif SetDlgItemText(hDlg, IDC_PRODUCTNAME, szText); if(VersionInfo.Level == TOOLKIT_LEVEL_DOCUMENT) lstrcpy(szText, TEXT("Express Edition.")); else if(VersionInfo.Level == TOOLKIT_LEVEL_MEDICAL) lstrcpy(szText, TEXT("Medical Express Edition.")); else lstrcpy(szText, TEXT("Professional Edition.")); SetDlgItemText(hDlg, IDC_TOOLKITLEVEL, szText); strprintf(szText, TEXT("Version %d.%d"), VersionInfo.MajorNumber, VersionInfo.MinorNumber); SetDlgItemText(hDlg, IDC_VERSION, szText); #ifdef UNICODE MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, VersionInfo.Date, -1, szTemp, sizeof(szTemp)); #else lstrcpy(szTemp, (LPSTR)VersionInfo.Date); #endif strprintf(szText, TEXT("Date: %s"), szTemp); SetDlgItemText(hDlg, IDC_DATE, szText); memset (&szTemp, 0, sizeof(szTemp)); #ifdef UNICODE MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, VersionInfo.Time, -1, szTemp, sizeof(szTemp)); #else lstrcpy(szTemp, (LPSTR)VersionInfo.Time); #endif strprintf(szText, TEXT("Time: %s"), szTemp); SetDlgItemText(hDlg, IDC_TIME, szText); return(TRUE); case WM_COMMAND: switch (CTLID(wParam, lParam)) { case IDOK: case IDCANCEL: EndDialog (hDlg, 0); return(TRUE); } } return(FALSE); } /*====(CreateChildWindow)================================================== Description: Sets up data for MDI child window creation. Syntax : HWND CreateChildWindow (LPSTR pszTitle, pBITMAPHANDLE pBitmap) Prototype : demo.h Parameters : pszTitle Title for the window. pBitmap Image to set in the window. Return Value: hWndChild Window handle of the child window. ==========================================================================*/ HWND CreateChildWindow (L_TCHAR* pszTitle, pBITMAPHANDLE pBitmap, HBITMAPLIST hList, L_BOOL fLoop,L_BOOL bIsFile,L_BOOL bGifAnimationFile) { MDICREATESTRUCT mdiCreateStruct; CREATEDATA CreateData; HWND hWndChild,hParent; HICON hIcon; CreateData.pszTitle = pszTitle; CreateData.pBitmap = pBitmap; CreateData.hList = hList; CreateData.fLoop = fLoop; CreateData.bIsFile=bIsFile; CreateData.bGifAnimationFile = bGifAnimationFile; mdiCreateStruct.szClass = szChildClass; mdiCreateStruct.szTitle = pszTitle; mdiCreateStruct.hOwner = hInst; mdiCreateStruct.x = CW_USEDEFAULT; mdiCreateStruct.y = CW_USEDEFAULT; mdiCreateStruct.cx = CW_USEDEFAULT; mdiCreateStruct.cy = CW_USEDEFAULT; mdiCreateStruct.style = MDIS_ALLCHILDSTYLES|WS_CLIPCHILDREN; mdiCreateStruct.lParam = (LPARAM) (LPCREATEDATA) & CreateData; hWndChild = FORWARD_WM_MDICREATE (hWndClient, (LPMDICREATESTRUCT) & mdiCreateStruct, SendMessage); hParent=GetParent(hWndChild); hIcon = (HICON) LoadImage( (HINSTANCE)GetWindowLong(hParent,GWL_HINSTANCE), MAKEINTRESOURCE(IDI_MAIN), IMAGE_ICON, GetSystemMetrics( SM_CXSMICON ), GetSystemMetrics( SM_CYSMICON ), 0 ); /* Set the applilcation small and big icons */ SendMessage( hWndChild, WM_SETICON, ICON_SMALL, (LPARAM) hIcon ); return hWndChild; } /*====(Paste)============================================================== Description: Pastes the image from the clipboard. Syntax : static L_VOID Paste (L_VOID) Parameters : None. Return Value: None. ==========================================================================*/ static L_VOID Paste (L_VOID) { BITMAPHANDLE Bitmap; HCURSOR hCursor; L_INT nRet; hCursor = SetCursor (LoadCursor (NULL, IDC_WAIT)); nRet = L_CopyFromClipboard(hWndFrame, &Bitmap,sizeof(BITMAPHANDLE)); if(nRet == SUCCESS) CreateChildWindow (TEXT("Clipboard Data"), &Bitmap, NULL, 1,0,FALSE); SetCursor (hCursor); if (nRet != SUCCESS) L_FileError (hWndFrame, nRet, TEXT("Paste"), TEXT("")); return; } /*====(TwainCallBack)====================================================== Description: Calls the CreateChildWindow function during Twain Acquire. Syntax : L_INT L_FAR L_EXPORT TwainCallBack (HTWAINSESSION hSession, pBITMAPHANDLE pBitmap, L_VOID L_FAR * pUserData) Prototype : demo.h Parameters : hSession The twain session. pBitmap Bitmap to be placed in the window. pUserData Required parameter for toolkit, but not used here. Return Value: SUCCESS ==========================================================================*/ L_INT L_FAR L_EXPORT TwainCallBack (HTWAINSESSION hSession, pBITMAPHANDLE pBitmap, L_VOID L_FAR * pUserData) { UNREFERENCED_PARAMETER(pUserData); CreateChildWindow (TEXT("Twain Data"), pBitmap, NULL, 1,0,FALSE); return(SUCCESS); } /*====(TwainAcquire)====================================================== Description: Calls toolkit function to acquire an image from Twain. Syntax : static L_VOID TwainAcquire(L_VOID) Parameters : None. Return Value: None. ==========================================================================*/ static L_VOID TwainAcquire(L_VOID) { BITMAPHANDLE Bitmap; HCURSOR hCursor; HMENU hMenu; L_INT nRet; LTWAINPROPERTIES TwainProps; // set the app name to LEADTOOLS demo nRet = L_TwainGetProperties(g_hTwainSession, &TwainProps, LTWAINPROPERTIESSIZE, LTWAIN_PROPERTIES_GETCURRENT); lstrcpy(TwainProps.DataTransfer.szFileName, TEXT("LEADTOOLS Demo")); TwainProps.uStructSize = LTWAINPROPERTIESSIZE; nRet = L_TwainSetProperties(g_hTwainSession, &TwainProps, LTWAIN_PROPERTIES_SET, NULL, NULL); hCursor = SetCursor (LoadCursor (NULL, IDC_WAIT)); hMenu = GetSystemMenu (hWndFrame, FALSE); ENABLEMENUITEM (hMenu, SC_CLOSE, FALSE); fInTwain = TRUE; nRet = L_TwainAcquire ( g_hTwainSession, &Bitmap, sizeof(BITMAPHANDLE), TwainCallBack, LTWAIN_SHOW_USER_INTERFACE | LTWAIN_MODAL_USER_INTERFACE, NULL, NULL); ENABLEMENUITEM (hMenu, SC_CLOSE, TRUE); fInTwain = FALSE; SetCursor (hCursor); if (nRet != SUCCESS) L_FileError (hWndFrame, nRet, TEXT("Twain Acquire"), TEXT("")); return; } #if defined(WIN32) && !defined(_ALPHA_) && !defined (UNICODE) /*====(ISISAcquire)====================================================== Description: Calls toolkit function to acquire an image from ISIS. Syntax : static L_VOID ISISAcquire(L_VOID) Parameters : None. Return Value: None. ==========================================================================*/ static L_VOID ISISAcquire(L_VOID) { BITMAPHANDLE Bitmap; HCURSOR hCursor; HMENU hMenu; L_INT nRet; hCursor = SetCursor (LoadCursor (NULL, IDC_WAIT)); hMenu = GetSystemMenu (hWndFrame, FALSE); ENABLEMENUITEM (hMenu, SC_CLOSE, FALSE); fInTwain = TRUE; nRet = L_ISISLoadDriver(NULL); if (nRet == SUCCESS) { nRet = L_ISISAcquire (hWndFrame, &Bitmap, sizeof(BITMAPHANDLE), ISIS_SHOWUI); L_ISISUnloadDriver(); } ENABLEMENUITEM (hMenu, SC_CLOSE, TRUE); fInTwain = FALSE; SetCursor (hCursor); if (nRet != SUCCESS) L_FileError (hWndFrame, nRet, TEXT("ISIS Acquire"), TEXT("")); else CreateChildWindow (TEXT("ISIS Data"), &Bitmap, NULL, 1,0,FALSE); return; } /*====(ISISAcquireMulti)====================================================== Description: Calls toolkit function to acquire one or more images from ISIS and save to file on disk. Syntax : static L_VOID ISISAcquireMulti(L_VOID) Parameters : None. Return Value: None. ==========================================================================*/ static L_VOID ISISAcquireMulti(L_VOID) { L_TCHAR buf[2*_MAX_PATH]; HCURSOR hCursor; HMENU hMenu; L_INT nRet; L_INT nSaveFormat; static OPENFILENAME OpenFileName; static L_TCHAR szFileName[_MAX_PATH]=TEXT(""); static L_UINT uSaveMulti = TRUE; SAVEDLGPARAMS ISISFSParm; L_INT nMaxPages=1; L_INT nPagesDiscarded; OpenFileName.lStructSize = sizeof(OPENFILENAME); OpenFileName.lpstrInitialDir = NULL; OpenFileName.lpstrTitle = TEXT("Select Base Filename"); OpenFileName.nFilterIndex = 0; OpenFileName.lpstrFile = szFileName; OpenFileName.nMaxFile = sizeof(szFileName)/sizeof (L_TCHAR); OpenFileName.lpstrFileTitle = ISISFSParm.szFileName; OpenFileName.nMaxFileTitle = sizeof(ISISFSParm.szFileName)/sizeof (L_TCHAR); OpenFileName.Flags = 0; memset(&ISISFSParm, 0, sizeof(SAVEDLGPARAMS)); ISISFSParm.uStructSize = sizeof(SAVEDLGPARAMS); ISISFSParm.uSaveMulti = uSaveMulti; ISISFSParm.uDlgFlags = (fShowResize?DLG_SAVE_ENABLESIZING:0) | DLG_SAVE_SHOW_FILEOPTIONS_MULTIPAGE| DLG_SAVE_SHOW_FILEOPTIONS_JBIG2OPTIONS; /* get the name of the file(s) to save */ nRet = L_DlgSave( hWndFrame, &OpenFileName, &ISISFSParm ); if(nRet != SUCCESS_DLG_OK) return; DisplayDICOMSaveMsg(hWndFrame, FSParm.nFormat); uSaveMulti = ISISFSParm.uSaveMulti; nSaveFormat = ISISFSParm.nFormat; hCursor = SetCursor (LoadCursor (NULL, IDC_WAIT)); hMenu = GetSystemMenu (hWndFrame, FALSE); ENABLEMENUITEM (hMenu, SC_CLOSE, FALSE); fInTwain = TRUE; nRet = L_ISISLoadDriver(NULL); if(nRet == SUCCESS) { /* let's set the ScanAhead to 1/2 the max. # of pages the ADF can hold for SPEED */ nRet = L_ISISSetTagShort(TAG_SCANAHEAD, TAG_SCANAHEAD_YES); if(nRet == SUCCESS) { nRet=L_ISISGetTagShort(TAG_MAXPAGES, &nMaxPages); nRet=L_ISISSetTagShort(TAG_SCANAHEAD_MAXPAGES, (L_INT)(nMaxPages/2)); } /* try setting scanner compression to match file output type */ switch(nSaveFormat) { case FILE_CCITT: nRet=L_ISISSetTagShort(TAG_COMPRESSION, TAG_COMPRESSION_MG3); break; case FILE_CCITT_GROUP3_1DIM: nRet=L_ISISSetTagShort(TAG_COMPRESSION, TAG_COMPRESSION_G3); break; case FILE_CCITT_GROUP4: nRet=L_ISISSetTagShort(TAG_COMPRESSION, TAG_COMPRESSION_G4); break; case FILE_TIFLZW: nRet=L_ISISSetTagShort(TAG_COMPRESSION, TAG_COMPRESSION_LZW); break; case FILE_TIF_PACKBITS: nRet=L_ISISSetTagShort(TAG_COMPRESSION, TAG_COMPRESSION_32771); break; default: nRet=L_ISISSetTagShort(TAG_COMPRESSION, TAG_COMPRESSION_NONE); break; } nRet = L_ISISAcquireMulti (hWndFrame, szFileName, ISIS_SHOWUI, nSaveFormat, uSaveMulti, &nPagesDiscarded, ISISCallBack, NULL); L_ISISUnloadDriver(); } ENABLEMENUITEM (hMenu, SC_CLOSE, TRUE); fInTwain = FALSE; SetCursor (hCursor); if (nRet == ERROR_USER_ABORT) { strprintf(buf, TEXT("Scanning canceled; %d pages ScannedAhead but aborted!"), nPagesDiscarded ); MessageBox(hWndFrame, buf, TEXT("ISIS Acquire Multi"), MB_OK); strprintf(buf, TEXT("Image(s) acquired to file(s): %s"), szFileName); MessageBox(hWndFrame, buf, TEXT("ISIS Acquire Multi"), MB_OK); } else if (nRet != SUCCESS) L_FileError (hWndFrame, nRet, TEXT("ISIS Acquire Multi"), TEXT("")); else { strprintf(buf, TEXT("Image(s) acquired to file(s): %s"), szFileName); MessageBox(hWndFrame, buf, TEXT("ISIS Acquire Multi"), MB_OK); } return; } #endif /*====(ConvertBitmap)====================================================== Description: Converts a file from one format to a file of a different format. Syntax : static L_VOID ConvertBitmap (L_VOID) Parameters : None. Return Value: None. ==========================================================================*/ static L_VOID ConvertBitmap (L_VOID) { L_INT nRet = SUCCESS; nRet = ShowFileConvertDialog (hWndFrame, &FileConversionParams ); if (DLGFAILED(nRet)) MessageBox ( hWndFrame, TEXT("Convert File dialog error"), TEXT("Error"), MB_OK ); } /*====(FileReadCallBack)=================================================== Description: Performs painting while loading. Syntax : L_INT L_FAR L_EXPORT FileReadCallBack(pFILEINFO pFileInfo, pBITMAPHANDLE pBitmap, L_UCHAR L_FAR *pBuffer, L_UINT uFlags, L_INT nRow, L_INT nLines, CALLBACKDATA L_FAR * pData) Prototype : demo.h Parameters : pBitmap Bitmap describing image being loaded. pBuffer Lines of image data needing to be painted. nLines Number of lines in pBuffer. pData User data providing additional info that may be needed by this function. This packet is setup prior to calling the load function, and is passed to the load function for this purpose. Return Value: SUCCESS Required by the toolkit, else loading will end. ==========================================================================*/ L_INT L_FAR L_EXPORT FileReadCallBack(pFILEINFO pFileInfo, pBITMAPHANDLE pBitmap, L_UCHAR L_FAR *pBuffer, L_UINT uFlags, L_INT nRow, L_INT nLines, CALLBACKDATA L_FAR * pData) { L_UINT32 ulFlags; RECT rcView; ulFlags = L_SetDisplayMode (DISPLAYMODE_FIXEDPALETTE | DISPLAYMODE_ORDEREDDITHER | DISPLAYMODE_NETSCAPEPALETTE | DISPLAYMODE_RESAMPLE|DISPLAYMODE_BICUBIC, DISPLAYMODE_ORDEREDDITHER | (nPaletteMode == IDM_PALETTEFIXED ? DISPLAYMODE_FIXEDPALETTE : 0) | (fNetscapePalette ? DISPLAYMODE_NETSCAPEPALETTE : 0) | nPaintResizeFlags); if ((uFlags & FILEREAD_FIRSTPASS) && (uFlags & FILEREAD_FIRSTROW)) { FORWARD_WM_QUERYNEWPALETTE (pData->hWnd, SendMessage); if (!pData->pData->hPalette) pData->pData->hPalette = L_CreatePaintPalette(pData->hDC, pBitmap); if (pData->pData->hPalette) { pData->hPalette = SelectPalette (pData->hDC, pData->pData->hPalette, TRUE); RealizePalette (pData->hDC); } if( uFlags & FILEREAD_COMPRESSED ) { pData->nRows = nLines; if( (pData->pLineBuffer = GlobalAllocPtr(GHND, (L_UINT32)pBitmap->BytesPerLine * nLines)) == NULL ) return ERROR_NO_MEMORY; } else pData->pLineBuffer = NULL; } /* convert the compressed 1 bit run lengths to uncompressed format. You can pass the compressed buffer to the L_PaintDCBuffer and use -nLines as the number of lines to indicate that you are passing a compressed buffer but allocating the buffer and expanding it before passing it to the paint routine is faster because there are fewer GlobalAlloc/GlobalFree calls to be made. */ if( uFlags & FILEREAD_COMPRESSED ) { if(pData->nRows < nLines) { L_UCHAR L_FAR*p = GlobalReAllocPtr(pData->pLineBuffer, (L_UINT32)pBitmap->BytesPerLine * nLines, 0); if(!p) return ERROR_NO_MEMORY; pData->pLineBuffer = p; pData->nRows = nLines; } L_ExpandRows((L_UINT16 L_FAR*)pBuffer, pData->pLineBuffer, pBitmap->Width, nLines); pBuffer = pData->pLineBuffer; } SetRect(&rcView, 0, 0, pBitmap->Width, pBitmap->Height); L_PaintDCBuffer(pData->hDC, pBitmap, NULL, NULL, &rcView, &pData->rcPaint, SRCCOPY, pBuffer, nRow, nLines); L_SetDisplayMode (DISPLAYMODE_ORDEREDDITHER, ulFlags); return(SUCCESS); } /*====(PaintWhileLoad)====================================================== Description: Loads the image with paint-while-load occurring. Syntax : static L_INT PaintWhileLoad (HWND hWndChild) Parameters : hWndChild Window handle of the window to contain the image. Return Value: nRet The value returned by the load function. ==========================================================================*/ static L_INT PaintWhileLoad (HWND hWndChild, L_TCHAR L_FAR*szFile) { L_INT nRet; CALLBACKDATA CBData; CBData.pData = LOCKCHILDDATA (hWndChild); CBData.hWnd = CBData.pData->hBitmapWnd; CBData.hDC = GetDC (CBData.pData->hBitmapWnd); CBData.hPalette = NULL; GetClientRect (CBData.pData->hBitmapWnd, &CBData.rcPaint); CBData.Pass = 0; CBData.nRows = 0; CBData.pLineBuffer = NULL; fInLoadFile = TRUE; nRet = L_LoadFile (szFile, &CBData.pData->ActiveBitmap, sizeof(BITMAPHANDLE),0, (fIsBGRDevice ? ORDER_BGRORGRAY : ORDER_RGBORGRAY), LOADFILE_ALLOCATE | LOADFILE_STORE | (fLoadCompressed?LOADFILE_COMPRESSED:0), FileReadCallBack, &CBData, &LoadFileOption, NULL); fInLoadFile = FALSE; CBData.pData->Bitmap = CBData.pData->ActiveBitmap; if(CBData.hPalette) SelectPalette(CBData.hDC, CBData.hPalette, FALSE); ReleaseDC (CBData.pData->hBitmapWnd, CBData.hDC); if(CBData.pLineBuffer) GlobalFreePtr(CBData.pLineBuffer); if(nBitonalFlags || nDitherMode != IDM_ORDEREDDITHERING) { FORWARD_WM_QUERYNEWPALETTE (hWndChild, SendMessage); InvalidateRect(CBData.pData->hBitmapWnd, NULL, FALSE); } else { ValidateRect(CBData.pData->hBitmapWnd, NULL); } BitmapSizeChange(hWndChild, TRUE); UNLOCKCHILDDATA (hWndChild); DisplayImageTitle (hWndChild); return(nRet); } typedef struct tagPLAYCALLBACKDATA { LPCHILDDATA pChild; HPALETTE hPalette; /* old palette saved from callback */ HWND hWnd; /* window to paint */ HDC hDC; /* hdc of window to paint */ RECT rcPaint; /* windows client rectangle */ HPLAYBACK hPlayback; } PLAYCALLBACKDATA; static L_VOID PlayProcessing(PLAYCALLBACKDATA L_FAR *pData, L_BOOL fLoop) { L_UINT uState; L_UINT32 ulFlags; RECT rcUpdate; L_GetPlaybackState(pData->hPlayback, &uState); while(uState != PLAYSTATE_END) { L_ProcessPlayback(pData->hPlayback, &uState); switch(uState) { case PLAYSTATE_WAITINPUT: L_CancelPlaybackWait(pData->hPlayback); break; case PLAYSTATE_POSTCLEAR: case PLAYSTATE_POSTRENDER: L_GetPlaybackUpdateRect(pData->hPlayback, &rcUpdate, TRUE); 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); 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); L_PaintDC (pData->hDC, &pData->pChild->ActiveBitmap, NULL, &rcUpdate, &pData->pChild->rcView, &pData->rcPaint, SRCCOPY); L_SetDisplayMode (DISPLAYMODE_RESETPOSITIONS, ulFlags); break; } if(!fLoop) break; } } L_INT L_FAR L_EXPORT PlayCallBack(pFILEINFO pFileInfo, pBITMAPHANDLE pBitmap, L_UCHAR L_FAR *pBuffer, L_UINT uFlags, L_INT nRow, L_INT nLines, PLAYCALLBACKDATA L_FAR * pData) { L_INT nRet; if (uFlags & FILEREAD_FIRSTROW) { nRet = L_AppendPlayback(pData->hPlayback, pBitmap); if(nRet != SUCCESS) return(nRet); } L_ValidatePlaybackLines(pData->hPlayback, nRow, nLines); PlayProcessing(pData, FALSE); return(SUCCESS); } static L_INT PlayWhileLoad (HWND hWndChild, L_TCHAR L_FAR*szFile) { L_INT nRet; PLAYCALLBACKDATA Data; BITMAPHANDLE Bitmap; Data.pChild = LOCKCHILDDATA (hWndChild); Data.hWnd = Data.pChild->hBitmapWnd; Data.hDC = GetDC (Data.pChild->hBitmapWnd); Data.hPalette = NULL; GetClientRect (Data.pChild->hBitmapWnd, &Data.rcPaint); if (Data.pChild->hPalette) { Data.hPalette = SelectPalette (Data.hDC, Data.pChild->hPalette, TRUE); RealizePalette (Data.hDC); } L_CreatePlayback(&Data.hPlayback, &Data.pChild->ActiveBitmap, NULL); fInLoadFile = TRUE; // ??? nRet = L_LoadFile (szFile, &Bitmap, sizeof(BITMAPHANDLE),0, (fIsBGRDevice ? ORDER_BGRORGRAY : ORDER_RGBORGRAY), LOADFILE_ALLOCATE | LOADFILE_STORE | LOADFILE_ALLPAGES, PlayCallBack, &Data, &LoadFileOption, NULL); PlayProcessing(&Data, TRUE); fInLoadFile = FALSE; Data.pChild->Bitmap = Data.pChild->ActiveBitmap; if(Data.hPalette) SelectPalette(Data.hDC, Data.hPalette, FALSE); ReleaseDC (Data.pChild->hBitmapWnd, Data.hDC); L_DestroyPlayback(Data.hPlayback, &Data.pChild->hList); PostFrameChange(hWndChild); UNLOCKCHILDDATA (hWndChild); return(nRet); } /*====(OpenBitmap)======================================================== Description: Loads the image from file and creates a child window for the image. Syntax : static L_VOID OpenBitmap(L_VOID) Parameters : None. Return Value: None. ==========================================================================*/ static L_VOID OpenBitmap(L_VOID) { static BITMAPHANDLE Bitmap; L_INT nRet; HWND hWndChild = NULL; L_BOOL fLoadInfo; L_BOOL fAutoProcess = FALSE; static OPENFILENAME OpenFileName; static L_BOOL bEnablePreview=TRUE; _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) | (fShowPreview?DLG_OPEN_SHOW_PREVIEW:0) | (fShowPreview?DLG_OPEN_USEFILESTAMP:0) | DLG_OPEN_SHOW_PROGRESSIVE | DLG_OPEN_SHOW_MULTIPAGE | DLG_OPEN_SHOW_DELPAGE | DLG_OPEN_SHOW_LOADROTATED | DLG_OPEN_SHOW_LOADCOMPRESSED | DLG_OPEN_SHOW_LOADOPTIONS | DLG_OPEN_SHOW_FILEINFO | DLG_OPEN_SHOW_PDFOPTIONS | DLG_OPEN_SHOW_RASTEROPTIONS | DLG_OPEN_SHOW_VECTOROPTIONS | (fLoadRotated ?DLG_OPEN_ALWAYSLOADROTATED:0) | (fLoadCompressed?DLG_OPEN_ALWAYSLOADCOMPRESSED:0) | (fTotalPages?DLG_OPEN_VIEWTOTALPAGES:0); if(fDoPaintWhileLoad) fAutoProcess = FALSE; OpenFileName.lStructSize = sizeof(OPENFILENAME); OpenFileName.hwndOwner = hWndFrame; OpenFileName.nFilterIndex = nOpenIndex; OpenFileName.lpstrTitle = TEXT("Open a File"); fLoadInfo = EnableLoadInfo(TRUE); nRet = L_DlgOpen( hWndFrame,&OpenFileName,&FOParm ); if (nRet == SUCCESS_DLG_OK) { if ( ( FOParm.pFileData != NULL ) && ( FOParm.nNumOfFiles > 0 ) ) { fLoadRotated = FOParm.pFileData[0].bLoadRotated ; fLoadCompressed = FOParm.pFileData[0].bLoadCompressed ; nRet = LoadFile(FOParm.pFileData[0].szFileName, fAutoProcess, FALSE); if(nRet !=SUCCESS) { if (nRet == -9) CheckFilter(hWndFrame, FOParm.pFileData[0].szFileName); else L_FileError (hWndFrame, nRet, TEXT("Open File"), FOParm.pFileData[0].szFileName); } } CleanOpenDlgParam(&FOParm); } else L_FileError (hWndFrame, nRet, TEXT("Open File"), TEXT("")); EnableLoadInfo(fLoadInfo); return; } static L_INT LoadFile(L_TCHAR szFileName[256], L_BOOL bAutoProcess, L_BOOL bDroped) { pBITMAPHANDLE pBitmap; BITMAPHANDLE Bitmap; HICON hIcon; HCURSOR hCursor; L_INT nRet = FAILURE; HWND hWndChild = NULL; HBITMAPLIST hList; L_BOOL fLoadAsList = FALSE; L_BOOL fSupportMultiOp = TRUE; // support multipage operations(Append\replace\insert) FILEINFO FileInfo; L_INT nOldPage; static OPENFILENAME OpenFileName; static L_BOOL bEnablePreview=TRUE; L_INT nFormat=0; if ( ( FOParm.pFileData != NULL ) && ( FOParm.nNumOfFiles > 0 ) ) { { if ( FOParm.pFileData[ 0 ].pBitmap != NULL ) { if ( FOParm.pFileData[ 0 ].pBitmap->Flags.Allocated ) { foFileInfo = *FOParm.pFileData[ 0 ].pFileInfo; Bitmap = *FOParm.pFileData[ 0 ].pBitmap; memset(FOParm.pFileData[ 0 ].pBitmap,0,sizeof(BITMAPHANDLE)); nRet=SUCCESS; } } } } if(bAutoProcess) { if ( nRet != SUCCESS ) { return nRet; } } pBitmap = &Bitmap; hIcon = (HICON) LoadImage( hInst, MAKEINTRESOURCE(IDI_MAIN), IMAGE_ICON, GetSystemMetrics( SM_CXSMICON ), GetSystemMetrics( SM_CYSMICON ), 0 ); /* Set the applilcation small and big icons */ SendMessage( hWndChild, WM_SETICON, ICON_SMALL, (LPARAM) hIcon ); bEnablePreview = FOParm.bPreviewEnabled; nOpenIndex = OpenFileName.nFilterIndex; LoadFileOption.Flags &= ~ELO_ROTATED; if(FOParm.pFileData) { LoadFileOption.Passes = FOParm.pFileData[0].nPasses ; if(FOParm.pFileData[0].bLoadRotated) LoadFileOption.Flags |= ELO_ROTATED; nCurrentPage = FOParm.pFileData[0].nPageNumber; LoadFileOption.PageNumber = FOParm.pFileData[0].nPageNumber; nFormat = FOParm.pFileData[0].pFileInfo->Format; } else nFormat = foFileInfo.Format; hCursor = SetCursor (LoadCursor (NULL, IDC_WAIT)); switch(nFormat) { case FILE_GIF: /* Load as lists only multipage GIF files */ if((FOParm.pFileData)) nOldPage = FOParm.pFileData[0].nPageNumber; else nOldPage = LoadFileOption.PageNumber; LoadFileOption.PageNumber = 2; if((nRet = L_FileInfo(szFileName, &FileInfo, sizeof(FILEINFO), 0, &LoadFileOption)) == SUCCESS && FileInfo.PageNumber > 1) { if (!bDroped) L_FreeBitmap(pBitmap); /* free the single page that was AutoLoaded */ fLoadAsList = TRUE; } LoadFileOption.PageNumber = nOldPage; break; case FILE_FLC: case FILE_FLI: case FILE_ANI: fSupportMultiOp = FALSE; case FILE_AVI: // AVI filter does not support file multipage operation (Append\replace\insert). if (!bDroped) L_FreeBitmap(pBitmap); /* free the single page that was AutoLoaded */ fLoadAsList = TRUE; break; } if(fDoPaintWhileLoad) { if(fLoadAsList) { nRet = L_CreateBitmap(pBitmap, sizeof(BITMAPHANDLE), TYPE_CONV, foFileInfo.GlobalWidth, foFileInfo.GlobalHeight, foFileInfo.BitsPerPixel, fIsBGRDevice ? ORDER_BGR : ORDER_RGB, NULL, foFileInfo.ViewPerspective, NULL, 0); if(nRet == SUCCESS) { if(foFileInfo.Flags & FILEINFO_HAS_GLOBALBACKGROUND) { pBitmap->Background = foFileInfo.GlobalBackground; if(HIBYTE(HIWORD(pBitmap->Background)) == 1) pBitmap->Background = RGB(foFileInfo.GlobalPalette[LOBYTE(LOWORD(pBitmap->Background))].rgbRed, foFileInfo.GlobalPalette[LOBYTE(LOWORD(pBitmap->Background))].rgbGreen, foFileInfo.GlobalPalette[LOBYTE(LOWORD(pBitmap->Background))].rgbBlue); } /* Note: GIF and AVI files do not have rotated ViewPerspectives so we don't have to worry about that */ hWndChild = CreateChildWindow (szFileName, pBitmap, NULL, 1,1,fSupportMultiOp); nRet = PlayWhileLoad(hWndChild, szFileName); } } else { /* If we load files with an extended ViewPerspective, I have to update the Bitmap's ViewPerspective so that the zoom factors are calculated correctly */ pBitmap->ViewPerspective = foFileInfo.ViewPerspective; if ( FOParm.pFileData != NULL ) { pBitmap->Width =FOParm.pFileData[0].pFileInfo->Width; pBitmap->Height =FOParm.pFileData[0].pFileInfo->Height; } hWndChild = CreateChildWindow (szFileName, pBitmap, NULL, 1,1,FALSE); nRet = PaintWhileLoad(hWndChild, szFileName); } } else { if(fLoadAsList) { nRet = L_LoadBitmapList (szFileName, &hList, 0, fIsBGRDevice ? ORDER_BGRORGRAY : ORDER_RGBORGRAY, &LoadFileOption, NULL); if(nRet == SUCCESS) { L_GetBitmapListItem(hList, 0, pBitmap,sizeof(BITMAPHANDLE)); L_GetBitmapColors(pBitmap, 0, pBitmap->nColors, foFileInfo.GlobalPalette); if(FOParm.pFileData) nRet = L_CreateBitmap( pBitmap, sizeof(BITMAPHANDLE), TYPE_CONV, FOParm.pFileData[0].pFileInfo->GlobalWidth, FOParm.pFileData[0].pFileInfo->GlobalHeight, FOParm.pFileData[0].pFileInfo->BitsPerPixel, fIsBGRDevice ? ORDER_BGR : ORDER_RGB, FOParm.pFileData[0].pFileInfo->GlobalPalette, FOParm.pFileData[0].pFileInfo->ViewPerspective, NULL, 0); else nRet = L_CreateBitmap( pBitmap, sizeof(BITMAPHANDLE), TYPE_CONV, foFileInfo.GlobalWidth, foFileInfo.GlobalHeight, foFileInfo.BitsPerPixel, fIsBGRDevice ? ORDER_BGR : ORDER_RGB, foFileInfo.GlobalPalette, foFileInfo.ViewPerspective, NULL, 0); if(nRet == SUCCESS) { if(FOParm.pFileData) { if(FOParm.pFileData[0].pFileInfo->Flags & FILEINFO_HAS_GLOBALBACKGROUND) pBitmap->Background = FOParm.pFileData[0].pFileInfo->GlobalBackground; CreateChildWindow (szFileName, pBitmap, hList, (FOParm.pFileData[0].pFileInfo->Flags & FILEINFO_HAS_GLOBALLOOP) != 0,1,fSupportMultiOp ); } else { if(foFileInfo.Flags & FILEINFO_HAS_GLOBALBACKGROUND) pBitmap->Background = foFileInfo.GlobalBackground; CreateChildWindow (szFileName, pBitmap, hList, (foFileInfo.Flags & FILEINFO_HAS_GLOBALLOOP) != 0,1,fSupportMultiOp ); } } else { L_DestroyBitmapList(hList); hList = NULL; } } } else { if(!bAutoProcess) { SetOpenLoadResolution ( &LoadFileOption ) ; if( fLoadCompressed ) nRet = L_LoadFile (szFileName, pBitmap, sizeof(BITMAPHANDLE), 0, fIsBGRDevice ? ORDER_BGRORGRAY : ORDER_RGBORGRAY, LOADFILE_ALLOCATE | LOADFILE_STORE | LOADFILE_COMPRESSED, NULL, NULL, &LoadFileOption, NULL); else nRet = L_LoadFile (szFileName, pBitmap, sizeof(BITMAPHANDLE), 0, fIsBGRDevice ? ORDER_BGRORGRAY : ORDER_RGBORGRAY, LOADFILE_ALLOCATE | LOADFILE_STORE, NULL, NULL, &LoadFileOption, NULL); if(nRet != SUCCESS) { return nRet; } } if( FOParm.pFileData) DisplayDICOMLoadMsg(hWndFrame, FOParm.pFileData[0].pFileInfo, szFileName); CreateChildWindow (szFileName, pBitmap, NULL, 1,1,FALSE); } } SetCursor (hCursor); if (nRet != SUCCESS) { if(fDoPaintWhileLoad && hWndChild) FORWARD_WM_CLOSE (hWndChild, SendMessage); } return nRet; } static L_VOID CheckFilter(HWND hWnd, L_TCHAR* szFileName) { L_TCHAR* pszExt = 0; L_TCHAR szMessage[50] = TEXT("You need the "); L_TCHAR szTmpFilterName[15] = TEXT(""); L_INT i; pszExt = srchr(szFileName, '.'); if (pszExt != NULL) { pszExt++; for (i = 0; i < (sizeof(AllExtensions) / sizeof(EXTSTRUCT)); i++) { if (!scmp(pszExt, AllExtensions[i].szExt)) { lstrcpy (szTmpFilterName, AllExtensions[i].szFilterName); #ifdef UNICODE lstrcat (szTmpFilterName, TEXT("u.dll")); #else lstrcat (szTmpFilterName, TEXT(".dll")); #endif if (!LoadLibrary(szTmpFilterName)) { lstrcat(szMessage, szTmpFilterName); lstrcat(szMessage, TEXT(" file filter.")); MessageBox(NULL, szMessage, NULL, MB_ICONEXCLAMATION); return; } break; } } } L_FileError (hWnd, ERROR_FILE_FORMAT, TEXT("Open File"), szFileName); } static L_VOID ClrMergeOpen(L_VOID) { HCURSOR hCursor; BITMAPHANDLE Bitmap; CLRMERGEPARM Parm; pBITMAPHANDLE apBitmap[4]; L_INT nRet; Parm.nFlag = COLORSEP_RGB; if(GetClrMergeParm(hWndFrame, &Parm)) { hCursor = SetCursor (LoadCursor (NULL, IDC_WAIT)); apBitmap[0] = &LOCKCHILDDATA(Parm.ahWnd[0])->ActiveBitmap; apBitmap[1] = &LOCKCHILDDATA(Parm.ahWnd[1])->ActiveBitmap; apBitmap[2] = &LOCKCHILDDATA(Parm.ahWnd[2])->ActiveBitmap; if(Parm.nFlag == COLORSEP_CMYK) apBitmap[3] = &LOCKCHILDDATA(Parm.ahWnd[3])->ActiveBitmap; nRet = L_ColorMergeBitmap (&Bitmap, apBitmap, sizeof(BITMAPHANDLE), Parm.nFlag); UNLOCKCHILDDATA(Parm.ahWnd[0]); UNLOCKCHILDDATA(Parm.ahWnd[1]); UNLOCKCHILDDATA(Parm.ahWnd[2]); if(Parm.nFlag == COLORSEP_CMYK) UNLOCKCHILDDATA(Parm.ahWnd[3]); if(nRet == SUCCESS) CreateChildWindow (TEXT("Color Merged Data"), &Bitmap, NULL, 1,0,FALSE); SetCursor (hCursor); if (nRet != SUCCESS) L_FileError (hWndFrame, nRet, TEXT("Color Merge"), TEXT("")); } return; } static L_VOID CreateAnimation(L_VOID) { HCURSOR hCursor; ANIMATIONPARM Parm; if(GetAnimationParm(hWndFrame, &Parm)) { hCursor = SetCursor (LoadCursor (NULL, IDC_WAIT)); CreateChildWindow (TEXT("Animation"), &Parm.Bitmap, Parm.hList, 1,0,TRUE); SetCursor (hCursor); } return; } #ifdef WIN32 /*====(ISISCallBack)====================================================== Description: Performs as a callback for the ISISAcquireMulti function Syntax : ISISCALLBACK L_EXPORT ISISCallBack( pBITMAPHANDLE pBitmap, L_INT32 nPage, L_TCHAR L_FAR* pszFilename ); Prototype : demo.h Parameters : nPercent Percent of operation complete. Return Value: SUCCESS The function was successful. ERROR_USER_ABORT User wants to cancel the operation. ==========================================================================*/ L_INT L_EXPORT ISISCallBack( pBITMAPHANDLE pBitmap, L_INT32 nPage, L_TCHAR L_FAR* pszFilename, L_VOID * pVoid ) { MSG msg; UNREFERENCED_PARAMETER(pBitmap); while (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE)) { if(msg.message == WM_KEYDOWN) { if(msg.wParam == VK_ESCAPE) { fKillProgress = TRUE; MessageBox(NULL, TEXT("ISIS Scanning Canceled!"), TEXT("Stop"), MB_OK); } } TranslateMessage (&msg); DispatchMessage (&msg); } if (fKillProgress) return (ERROR_USER_ABORT); else return (SUCCESS); } #endif #ifdef WIN32 /*====(BrowseDir)====================================================== Description: browse a directory for images Syntax : L_VOID BrowseDir(L_VOID); Prototype : demo.h ==========================================================================*/ L_VOID BrowseDir(L_VOID) { L_INT nRet; L_INT nIndex=1; GETDIRECTORYDLGPARAMS GetDirectoryParams ; memset ( &GetDirectoryParams, 0, sizeof ( GETDIRECTORYDLGPARAMS ) ) ; GetDirectoryParams.uStructSize = sizeof ( GETDIRECTORYDLGPARAMS ) ; GetDirectoryParams.nBuffSize = _MAX_PATH ; GetDirectoryParams.pszDirectory = szImageDir ; GetDirectoryParams.pszFilter = TEXT("ALL\0*.*\0\0") ; GetDirectoryParams.nFilterIndex = nIndex ; GetDirectoryParams.pszTitle = TEXT("Select a Directory to Browse") ; nRet = L_DlgGetDirectory(hWndFrame, &GetDirectoryParams); if(nRet == SUCCESS_DLG_OK) { if (IsWindow(hBrowseDlg)) DestroyWindow(hBrowseDlg); hBrowseDlg = CreateDialogParam(hInst, MAKEINTRESOURCE(IDD_BROWSEDLG), hWndFrame, (DLGPROC) BrowseDlgProc, (LPARAM)szImageDir); if(!hBrowseDlg) { MessageBox(hWndFrame, TEXT("Error Creating Dialog"), TEXT("Error"), MB_OK); return; } ShowWindow(hBrowseDlg, SW_SHOW); SendMessage(hBrowseDlg, WM_BROWSE, 0, 0L); } return; } /*====(BrowseDlgProc)====================================================== Description: dialog function for the Browse Dialog Syntax : L_BOOL CALLBACK L_EXPORT AboutDlgProc (HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam) Prototype : demo.h Parameters : hWnd Handle to the window message the message wParam 1st message param wParam 2nd message param Return Value: TRUE WM_INITDIALOG and WM_COMMAND (IDOK or IDCANCEL) messages processed. FALSE A different message was processed. ==========================================================================*/ L_BOOL CALLBACK L_EXPORT BrowseDlgProc (HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam) { RECT rcWin; L_INT nRet; /* selection options structure */ LILITEMSEL L_FAR* pSel=NULL; BITMAPHANDLE Bitmap; THUMBOPTIONS ThumbOptions; L_TCHAR szFileName[_MAX_PATH]; L_INT nID; L_TCHAR szCaption[_MAX_PATH+40]; L_INT iCount; L_INT iSelCount; L_TCHAR *pszText1, *pszText2; int iIdx = 0; HBITMAPLIST hList; ZeroMemory(&ThumbOptions,sizeof(THUMBOPTIONS)); switch(message) { case WM_PALETTECHANGED: /* forward the message to the ImageList Control */ if(hCtl) SendMessage(hCtl, WM_PALETTECHANGED, wParam, lParam); break; case WM_INITDIALOG: /* create the LEAD ImageList Control */ L_UseImageListControl(); GetClientRect(hDlg, &rcWin); hCtl = L_CreateImageListControl(L_ILS_ACCEPTDROPFILES|WS_CHILD|WS_VISIBLE|WS_BORDER, 0, /* x location */ 0, /* y location */ RECTWIDTH(&rcWin), /* width */ RECTHEIGHT(&rcWin),/* height */ hDlg, /* parent window */ IDC_LEADIMAGELIST, /* control ID */ RGB(128,128,128)); /* background color */ if(!IsWindow(hCtl)) { MessageBox(hDlg, TEXT("Error creating control"), TEXT("Error"), MB_OK); DestroyWindow(hDlg); } // Set LEADTOOLS icon to the dialog SendMessage(hDlg, WM_SETICON, (WPARAM)ICON_SMALL, (LPARAM)LoadIcon(hInst, MAKEINTRESOURCE(IDI_MAIN))); // Enable / Disable selection style & method according to the flag at preferences Opt.uStructSize = sizeof(LILSELOPTION); L_ImgListGetSelOptions(hCtl, &Opt); Opt.uAllowSelection = uAllowSelection; Opt.uSelectionStyle = uSelectionStyle; L_ImgListSetSelOptions(hCtl, &Opt); // Enable / Disable display text according to the flag at preferences memset(&MOpt, 0, sizeof(MOpt)); MOpt.uStructSize = sizeof(LILITEMOPTION); L_ImgListGetItemOptions(hCtl, &MOpt); MOpt.bDisplayItemText = bDisplayItemText; L_ImgListSetItemOptions(hCtl, &MOpt); // Enable / Disable keyboard according to the flag at preferences L_ImgListEnableKeyboard(hCtl, bKeyboard); // Set scroll style Vert. / Horz according to the flags at preferences L_ImgListSetScrollStyle(hCtl, uScrollStyle); SetFocus(hCtl); return(FALSE); case WM_DESTROY: if(IsWindow(hCtl)) { L_ImgListClear(hCtl); DestroyWindow(hCtl); hCtl = NULL; iSortMethod = IMAGELIST_NOTSORTED; CheckMenuItem(GetMenu(hWndFrame), IDM_SORTASND, MF_BYCOMMAND | MF_UNCHECKED); CheckMenuItem(GetMenu(hWndFrame), IDM_SORTDSND, MF_BYCOMMAND | MF_UNCHECKED); } break; case WM_SIZE: GetClientRect(hDlg, &rcWin); MoveWindow(hCtl, 0, 0, RECTWIDTH(&rcWin), RECTHEIGHT(&rcWin), TRUE); break; case WM_COMMAND: nID = CTLID(wParam, lParam); switch (CTLID(wParam, lParam)) { case IDOK: case IDCANCEL: DestroyWindow(hDlg); hBrowseDlg = NULL; return(TRUE); case IDC_LEADIMAGELIST: if(HIWORD(wParam) == L_ILN_DROPFILES) { if(lParam) { BITMAPHANDLE Bitmap; LILITEM Item; L_INT nResult; THUMBOPTIONS to; L_TCHAR L_FAR* pTemp; memset (&Bitmap, 0, sizeof (BITMAPHANDLE)); Bitmap.uStructSize = sizeof (BITMAPHANDLE); pTemp = srchr((L_TCHAR L_FAR*)lParam, '\\'); pTemp++; memset (&to, 0, sizeof (THUMBOPTIONS)); to.uStructSize = sizeof (THUMBOPTIONS); to.nWidth = 80; to.nHeight = 80; to.nBits = 24; to.uCRFlags = 0; to.bMaintainAspect = TRUE; to.bForceSize = FALSE; to.crBackColor = 0; to.bLoadStamp = FALSE; to.bResample = TRUE; nResult = L_CreateThumbnailFromFile((L_TCHAR L_FAR*)lParam, &Bitmap, sizeof(BITMAPHANDLE), &to, NULL, NULL, NULL, NULL); if(nResult == SUCCESS) { memset(&Item, 0, sizeof(LILITEM)); Item.uStructSize = sizeof(LILITEM); Item.pText = pTemp; Item.pTextExt = (L_TCHAR L_FAR*)lParam; Item.pBitmap = &Bitmap; Item.uBitmapStructSize = sizeof(BITMAPHANDLE); Item.bSelected = FALSE; Item.lData = 1; Item.uMask = LILITEM_ALL; ListBox_AddString(GetDlgItem(hBrowseDlg, IDC_HIDDENLIST), (L_TCHAR L_FAR*)lParam); L_ImgListInsert(hCtl, &Item); L_ImgListEnsureVisible(hCtl, L_ImgListGetItemCount(hCtl)-1); } } } if(HIWORD(wParam) == L_ILN_LOADDBSTATUS) { LILITEM Item; L_INT nIndex; nIndex = (L_INT)lParam; memset(&Item, 0, sizeof(LILITEM)); Item.uStructSize = sizeof(LILITEM); Item.uMask = LILITEM_TEXTEXT; L_ImgListGetItem(hCtl, nIndex, &Item); if(Item.pTextExt && lstrlen(Item.pTextExt)) ListBox_AddString(GetDlgItem(hBrowseDlg, IDC_HIDDENLIST), Item.pTextExt); else { //file probably was not really a ImgList DB ListBox_AddString(GetDlgItem(hBrowseDlg, IDC_HIDDENLIST), szDBFile); } L_ImgListEnsureVisible(hCtl, nIndex); } if(HIWORD(wParam) == L_ILN_ITEMSEL) { if(!fInProcess) { iSelCount = L_ImgListGetSelCount(hCtl); iCount = L_ImgListGetItemCount(hCtl); if(iSelCount > 0) { pLILITEM pItems = NULL; L_INT i; pItems = (pLILITEM) GlobalAllocPtr(GHND, sizeof(LILITEM) * iSelCount); for(i=0;iPageNumber; Item.uMask = LILITEM_BITMAP | LILITEM_TEXT | LILITEM_TEXTEXT | LILITEM_DATA | LILITEM_SELECTED; ListBox_AddString(GetDlgItem(hBrowseDlg, IDC_HIDDENLIST), pszFile); L_ImgListInsert(hCtl, &Item); L_ImgListEnsureVisible(hCtl, L_ImgListGetItemCount(hCtl)-1); } else if(nStatusCode == BROWSE_LOADING)/* in the process of loading an image */ return SUCCESS; return SUCCESS; } L_VOID InsertImage() { LILITEM Item; L_INT nRet; OPENDLGPARAMS FOParm; BITMAPHANDLE hBitmap; OPENFILENAME OFN; L_TCHAR szFilter[] = {TEXT("ALL\0 *.*\0\0")}; L_TCHAR szFile[L_MAXPATH] = TEXT("\0"); LOADFILEOPTION LFO; L_TCHAR szFileTitle[L_MAXPATH] = TEXT("\0"); L_TCHAR szTemp[L_MAXPATH] = TEXT("\0"); memset(&Item, 0, sizeof(Item)); memset(&FOParm, 0, sizeof(FOParm)); memset(&OFN, 0, sizeof(OFN)); memset(&LFO, 0, sizeof(LFO)); L_InitBitmap(&hBitmap, sizeof(BITMAPHANDLE), 0, 0, 0); OFN.lStructSize = sizeof(OPENFILENAME); OFN.hwndOwner = hWndFrame; OFN.lpstrFilter = szFilter; OFN.lpstrCustomFilter = NULL; OFN.lpstrFileTitle = NULL; OFN.lpstrTitle = TEXT("Select an Image"); OFN.lpstrDefExt = NULL; OFN.lpfnHook = NULL; FOParm.uStructSize = sizeof(OPENDLGPARAMS); FOParm.uDlgFlags = (fShowResize?DLG_OPEN_ENABLESIZING:0) | (fShowPreview?DLG_OPEN_SHOW_PREVIEW:0)| DLG_OPEN_SHOW_LOADOPTIONS| DLG_OPEN_SHOW_MULTIPAGE| DLG_OPEN_SHOW_LOADROTATED | DLG_OPEN_SHOW_LOADCOMPRESSED | DLG_OPEN_SHOW_FILEINFO; nRet = L_DlgOpen(hWndFrame, &OFN, &FOParm); if(nRet == SUCCESS_DLG_OK) { if((FOParm.pFileData != NULL)&&(FOParm.nNumOfFiles > 0)) { Item.uStructSize = sizeof(LILITEM); Item.uBitmapStructSize = sizeof(BITMAPHANDLE); L_ImgListGetSelItems(hCtl, &Item); if((ListBox_AddString(GetDlgItem(hBrowseDlg, IDC_HIDDENLIST), FOParm.pFileData[0].szFileName)) != LB_ERR) { L_GetDefaultLoadFileOption(&LFO, sizeof(LOADFILEOPTION)); LFO.Flags = FOParm.pFileData[0].bLoadRotated; LFO.PageNumber = FOParm.pFileData[0].nPageNumber; if(L_LoadBitmap(FOParm.pFileData[0].szFileName, &hBitmap, sizeof(BITMAPHANDLE), 24, ORDER_BGRORGRAY, &LFO, NULL) == SUCCESS) { GetFileName(FOParm.pFileData[0].szFileName, szFileTitle); memset(&Item, 0, sizeof(Item)); Item.uStructSize = sizeof(LILITEM); Item.uMask = LILITEM_BITMAP | LILITEM_TEXT | LILITEM_DATA | LILITEM_SELECTED; Item.pBitmap = &hBitmap; Item.uBitmapStructSize = sizeof(BITMAPHANDLE); Item.pText = (L_TCHAR L_FAR *)(LPCTSTR)szFileTitle; Item.lData = FOParm.pFileData[0].nPageNumber; Item.bSelected = FALSE; if(L_ImgListInsert(hCtl, &Item) != SUCCESS) { ListBox_DeleteString(GetDlgItem(hBrowseDlg, IDC_HIDDENLIST), ListBox_GetCount(GetDlgItem(hBrowseDlg, IDC_HIDDENLIST)) - 1); } else { if(hBitmap.Flags.Allocated) L_FreeBitmap(&hBitmap); L_ImgListEnsureVisible(hCtl, L_ImgListGetItemCount(hCtl) - 1); } } } } CleanOpenDlgParam(&FOParm); } else L_FileError (hWndFrame, nRet, TEXT("Open File"), TEXT("")); if(hBitmap.Flags.Allocated) L_FreeBitmap(&hBitmap); } L_VOID RemoveImage() { LILITEM Item; L_INT iCount = 0 ; L_TCHAR *pszText1 = NULL; L_TCHAR *pszText2 = NULL; L_TCHAR szFileName[L_MAXPATH]; int iIdx = 0; memset(&Item, 0, sizeof(LILITEM)); Item.uStructSize = sizeof(LILITEM); Item.uBitmapStructSize = sizeof(BITMAPHANDLE); iCount = L_ImgListGetSelItems(hCtl, &Item); if(iCount <=0) return; memset(szFileName, 0, sizeof(szFileName)); iCount = L_ImgListGetItemCount(hCtl); for(iIdx=0; iIdx < iCount; iIdx++) { L_TCHAR strTemp[L_MAXPATH]; memset(strTemp, 0, sizeof(strTemp)); if (Item.pText[0]=='\0') { return; } lstrcpy(strTemp, TEXT("\\")); lstrcat(strTemp, Item.pText); pszText1 = supr(strTemp); ListBox_GetText(GetDlgItem(hBrowseDlg, IDC_HIDDENLIST), iIdx, szFileName); pszText2 = supr(szFileName); // You should keep the statments in the same order. if((sstr(pszText2, pszText1) != NULL) && (ListBox_DeleteString(GetDlgItem(hBrowseDlg, IDC_HIDDENLIST), iIdx) != LB_ERR )&& (ListBox_AddString(GetDlgItem(hBrowseDlg, IDC_HIDDENLIST), pszText2))&& (L_ImgListRemove(hCtl, Item.lIndex) != SUCCESS ) ) break; pszText1 = NULL; pszText2 = NULL; memset(szFileName, 0, sizeof(szFileName)); } } L_VOID SaveDatabase() { L_INT nRet; OPENFILENAME OFN; L_TCHAR szFilter[] = {TEXT("TIFF\0 *.tif\0\0")}; L_TCHAR szFile[L_MAXPATH] = TEXT("\0"); memset(&OFN, 0, sizeof(OFN)); OFN.lStructSize = sizeof(OPENFILENAME); OFN.hwndOwner = hWndFrame; OFN.lpstrFilter = szFilter; OFN.lpstrCustomFilter = NULL; OFN.lpstrFile = szFile; OFN.nMaxFile = sizeof(szFile)/sizeof (L_TCHAR); OFN.lpstrFileTitle = NULL; OFN.lpstrTitle = TEXT("Save Database"); OFN.lpstrDefExt = NULL; OFN.lpfnHook = NULL; if(GetSaveFileName(&OFN)) { nRet = L_ImgListSaveDatabase(hCtl, FALSE, szFile); if(nRet != SUCCESS) MessageBox(hWndFrame, TEXT("Error saving file!"), TEXT("Error"), MB_OK); } } L_VOID LoadDatabase() { L_INT nRet; OPENFILENAME OFN; L_TCHAR szFilter[] = {TEXT("ImgListDB\0 *.tif\0\0")}; L_TCHAR szFile[L_MAXPATH] = TEXT("\0"); memset(&OFN, 0, sizeof(OFN)); OFN.lStructSize = sizeof(OPENFILENAME); OFN.hwndOwner = hWndFrame; OFN.lpstrFilter = szFilter; OFN.lpstrCustomFilter = NULL; OFN.lpstrFile = szFile; OFN.nMaxFile = sizeof(szFile)/sizeof (L_TCHAR); OFN.lpstrFileTitle = NULL; OFN.lpstrTitle = TEXT("Load Database"); OFN.lpstrDefExt = NULL; OFN.lpfnHook = NULL; if(GetOpenFileName(&OFN)) { if (IsWindow(hBrowseDlg)) DestroyWindow(hBrowseDlg); lstrcpy(szDBFile, szFile); hBrowseDlg = CreateDialogParam(hInst, MAKEINTRESOURCE(IDD_BROWSEDLG), hWndFrame, (DLGPROC) BrowseDlgProc, (LPARAM)szImageDir); if(!hBrowseDlg) { MessageBox(hWndFrame, TEXT("Error Creating Dialog"), TEXT("Error"), MB_OK); return; } ShowWindow(hBrowseDlg, SW_SHOW); nRet = L_ImgListLoadDatabase(hCtl, szFile); if(nRet != SUCCESS) MessageBox(hWndFrame, TEXT("Error loading file!"), TEXT("Error"), MB_OK); } } L_VOID GetFileName(const L_TCHAR *pszFullFileName, L_TCHAR *pszFN) { // This function split the full path file name into // Drive, path, file name, extention. L_TCHAR szFileName[51]; L_TCHAR szFileExtension[5]; memset(szFileName, 0, sizeof(szFileName)); memset(szFileExtension, 0, sizeof(szFileExtension)); splitpath(pszFullFileName, NULL, NULL, szFileName, szFileExtension); lstrcat(szFileName, szFileExtension); lstrcpy(pszFN, szFileName); } L_VOID SetUserBitmap(HWND hWnd, HWND hCtl) { HBITMAP hBitmap=NULL; BITMAPHANDLE Bitmap; HDC hDC=NULL; LILSELOPTION Opt; if(IsWindow(hCtl)) { /* get current selection options */ SendMessage(hCtl, L_ILM_GETSELOPTIONS, 0, (LPARAM)&Opt); hBitmap = LoadBitmap(hInst, MAKEINTRESOURCE(IDB_FLAG)); if(hBitmap) { hDC = GetDC(hWnd); if(L_ConvertFromDDB(hDC, &Bitmap, sizeof(BITMAPHANDLE), hBitmap, NULL)==SUCCESS) { SendMessage(hCtl, L_ILM_SETSELBITMAP, (WPARAM)RGB(0,255,0), (LPARAM)&Bitmap); L_FreeBitmap(&Bitmap); } DeleteObject(hBitmap); ReleaseDC(hWnd, hDC); } Opt.uSelectionStyle = SELECTIONSTYLE_USERBITMAP; SendMessage(hCtl, L_ILM_SETSELOPTIONS, 0, (LPARAM)&Opt); RedrawWindow(hCtl, NULL, NULL, RDW_INVALIDATE | RDW_UPDATENOW | RDW_ERASE); } } #endif static L_BOOL CreateStandardServerRegisteryEntry ( L_TCHAR L_FAR * pszServerName, L_TCHAR L_FAR * pszCommand, L_TCHAR L_FAR * pszDefaultIcon ) { DWORD dwDispos ; LONG lRet ; HKEY hKey ; BOOL fRet = TRUE ; L_TCHAR L_FAR *szRegisterKey [ REG_KEYS ] = { TEXT ( "\\shell\\open\\command" ), TEXT ( "\\DefaultIcon" ) } ; L_TCHAR L_FAR *szRegisterKeyDefaultValues [ REG_KEYS ] = { pszCommand, pszDefaultIcon } ; {// CREATE SERVER NODE lRet = RegCreateKeyEx ( HKEY_CLASSES_ROOT, pszServerName, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hKey, &dwDispos ) ; if ( lRet != ERROR_SUCCESS ) { return FALSE ; } RegCloseKey ( hKey ) ; }// CREATE SERVER NODE {// CREATE STANDARD SUB NODES & VALUSE L_INT k = 0 ; for ( ; k < REG_KEYS; k++ ) { L_TCHAR szKey [ L_MAXPATH * 2 ] = { 0 } ; //compose full key _stprintf ( szKey, TEXT("%s%s"), REGISTRYKEY_SERVER_NAME, szRegisterKey [ k ] ) ; // create... lRet = RegCreateKeyEx ( HKEY_CLASSES_ROOT, szKey, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hKey, &dwDispos ) ; // set default value if ( lRet == ERROR_SUCCESS ) { RegSetValueEx ( hKey, TEXT(""), 0, REG_SZ, ( BYTE* CONST ) ( szRegisterKeyDefaultValues [ k ] ), ( lstrlen ( szRegisterKeyDefaultValues [ k ] ) + 1 ) * sizeof ( L_TCHAR ) ) ; } else { fRet = FALSE ; } // close key handle RegCloseKey ( hKey ) ; } }// CREATE STANDARD SUB NODES & VALUSE return fRet ; } L_VOID RegisterAppKey ( HINSTANCE hInstance ) { L_TCHAR szFullFileName [L_MAXPATH] = {0} ; L_TCHAR szShortFileName [L_MAXPATH] = {0} ; L_TCHAR* pszPathName = NULL ; {// RETRIEVE PATH NAME DWORD dwRet ; // full file name GetModuleFileName ( hInstance, szFullFileName, L_MAXPATH ) ; dwRet = GetShortPathName ( szFullFileName, szShortFileName, L_MAXPATH ) ; if ( ERROR_INVALID_PARAMETER == dwRet ) { pszPathName = szFullFileName ; } else { pszPathName = szShortFileName ; } }// RETRIEVE PATH NAME {// REGISTER [BASIC] SERVER NAME L_TCHAR szDefaultIcon [L_MAXPATH*2] = {0}; L_TCHAR szOpen [L_MAXPATH*2] = {0}; // Open STRING strprintf ( szOpen, TEXT ( "\"%s\" %%1"), pszPathName ) ; // default icon strprintf ( szDefaultIcon, TEXT("%s,%d"), pszPathName, -IDI_MAIN ) ; CreateStandardServerRegisteryEntry ( REGISTRYKEY_SERVER_NAME, szOpen, szDefaultIcon ) ; }// REGISTER [BASIC] SERVER NAME } static L_VOID CmdOpenBitmap ( L_VOID ) { HICON hIcon; HCURSOR hCursor; static BITMAPHANDLE Bitmap; L_INT nRet; HWND hWndChild = NULL; L_BOOL fLoadInfo; L_BOOL fLoadAsList = FALSE; L_BOOL fSupportMultiOp = TRUE; // support multipage operations(Append\replace\insert) FILEINFO FileInfo; LOADFILEOPTION LoadFileOption; L_INT nOldPage; L_TCHAR szFileName[L_MAXPATH]=TEXT("\0"); _fmemset(&FOParm, 0, sizeof(OPENDLGPARAMS)); _fmemset(&LoadFileOption, 0, sizeof(LOADFILEOPTION)); _fmemset(&FileInfo, 0, sizeof(FILEINFO)); FOParm.uStructSize = sizeof(OPENDLGPARAMS); LoadFileOption.uStructSize = sizeof(LOADFILEOPTION); FileInfo.uStructSize = sizeof (FILEINFO) ; if ( bCommandLine ) { lstrcpy ( szFileName, szCommandLine ) ; bCommandLine = FALSE ; } else { return; } if(IsDir(szFileName)) return; L_GetDefaultLoadFileOption (&LoadFileOption, sizeof(LOADFILEOPTION)); foFileInfo.uStructSize = sizeof (FILEINFO) ; nRet = L_FileInfo ( szFileName, &foFileInfo, sizeof (FILEINFO), 0, NULL) ; fLoadInfo = EnableLoadInfo(TRUE); if (nRet == SUCCESS) { hIcon = (HICON) LoadImage( hInst, MAKEINTRESOURCE(IDI_MAIN), IMAGE_ICON, GetSystemMetrics( SM_CXSMICON ), GetSystemMetrics( SM_CYSMICON ), 0 ); /* Set the applilcation small and big icons */ SendMessage( hWndChild, WM_SETICON, ICON_SMALL, (LPARAM) hIcon ); hCursor = SetCursor (LoadCursor (NULL, IDC_WAIT)); switch(foFileInfo.Format) { case FILE_GIF: /* Load as lists only multipage GIF files */ nOldPage = LoadFileOption.PageNumber; LoadFileOption.PageNumber = 2; if((nRet = L_FileInfo(szFileName, &FileInfo, sizeof (FILEINFO), 0, &LoadFileOption)) == SUCCESS && FileInfo.PageNumber > 1) { L_FreeBitmap(&Bitmap); /* free the single page that was AutoLoaded */ fLoadAsList = TRUE; } LoadFileOption.PageNumber = nOldPage; break; case FILE_FLC: case FILE_FLI: case FILE_ANI: fSupportMultiOp = FALSE; case FILE_AVI: // AVI filter does not support file multipage operation (Append\replace\insert). L_FreeBitmap(&Bitmap); /* free the single page that was AutoLoaded */ fLoadAsList = TRUE; break; } //if(fDoPaintWhileLoad) { if(fLoadAsList) { nRet = L_CreateBitmap( &Bitmap, sizeof (BITMAPHANDLE), TYPE_CONV, foFileInfo.GlobalWidth, foFileInfo.GlobalHeight, foFileInfo.BitsPerPixel, fIsBGRDevice ? ORDER_BGR : ORDER_RGB, NULL, foFileInfo.ViewPerspective, NULL, 0); if(nRet == SUCCESS) { if(foFileInfo.Flags & FILEINFO_HAS_GLOBALBACKGROUND) { Bitmap.Background = foFileInfo.GlobalBackground; if(HIBYTE(HIWORD(Bitmap.Background)) == 1) Bitmap.Background = RGB( foFileInfo.GlobalPalette[LOBYTE(LOWORD(Bitmap.Background))].rgbRed, foFileInfo.GlobalPalette[LOBYTE(LOWORD(Bitmap.Background))].rgbGreen, foFileInfo.GlobalPalette[LOBYTE(LOWORD(Bitmap.Background))].rgbBlue); } /* Note: GIF and AVI files do not have rotated ViewPerspectives so we don't have to worry about that */ hWndChild = CreateChildWindow (szFileName, &Bitmap, NULL, 1,1,fSupportMultiOp); nRet = PlayWhileLoad(hWndChild, szFileName); } } else { L_InitBitmap(&Bitmap,sizeof(BITMAPHANDLE), foFileInfo.Width, foFileInfo.Height, foFileInfo.BitsPerPixel); /* If we load files with an extended ViewPerspective, I have to update the Bitmap's ViewPerspective so that the zoom factors are calculated correctly */ Bitmap.ViewPerspective = foFileInfo.ViewPerspective; hWndChild = CreateChildWindow (szFileName, &Bitmap, NULL, 1,1,FALSE); nRet = PaintWhileLoad(hWndChild, szFileName); } } SetCursor (hCursor); if (nRet != SUCCESS) { if(fDoPaintWhileLoad && hWndChild) FORWARD_WM_CLOSE (hWndChild, SendMessage); L_FileError (hWndFrame, nRet, TEXT("Open File"), szFileName); } } else L_FileError (hWndFrame, nRet, TEXT("Open File"), szFileName); EnableLoadInfo(fLoadInfo); return; } L_VOID EnableLoadVectorFiles (L_BOOL bEnable) { L_INT nVecFormatsCount, i, nRet; L_TCHAR szFilters[L_MAXPATH]; memset (szFilters, 0, sizeof (szFilters)); nVecFormatsCount = sizeof (szVectorExt) / sizeof (VECTOREXT); for ( i=0; i < nVecFormatsCount; i++ ) { lstrcat(szFilters, szVectorExt[i].szExt); if (i != nVecFormatsCount - 1) // we don't want to add colon after the last item lstrcat(szFilters, TEXT(", ")); } if (bEnable) nRet = L_IgnoreFilters( TEXT("") ); else nRet = L_IgnoreFilters(szFilters); } L_VOID EnableLoadTextFiles(L_BOOL bEnable) { L_INT nRet; FILETXTOPTIONS TxtOptions; nRet = L_GetTXTOptions( &TxtOptions, sizeof( TxtOptions ) ); if( SUCCESS == nRet ) { TxtOptions.bEnabled = bEnable; L_SetTXTOptions( &TxtOptions ); } } void SetOpenLoadResolution ( pLOADFILEOPTION pLoadOptions) { if (FOParm.pFileData == NULL) { return ; } switch ( FOParm.pFileData->FileOptions.nType ) { case FILE_DWF: case FILE_CGM: case FILE_CMX: case FILE_PCL: case FILE_VECTOR_DUMP: case FILE_PCT: case FILE_DRW: case FILE_INTERGRAPH_VECTOR: case FILE_GERBER: case FILE_SHP: case FILE_SVG: case FILE_VWPG: { ZeroMemory ( &OldVectorMisc, sizeof ( OPENDLGOPTIONS_VECTORMISC ) ) ; // GET the Old setting to reset it again after loading L_2DGetViewport ( &OldVectorMisc.nViewportWidth, &OldVectorMisc.nViewportHeight ) ; OldVectorMisc.uViewportMode = L_2DGetViewMode ( ) ; // SET the new settings. L_2DSetViewport ( ( ( LPOPENDLGOPTIONS_VECTORMISC ) FOParm.pFileData [ 0 ].FileOptions.pOptions )->nViewportWidth, ( ( LPOPENDLGOPTIONS_VECTORMISC ) FOParm.pFileData [ 0 ].FileOptions.pOptions )->nViewportHeight ) ; L_2DSetViewMode ( ( ( LPOPENDLGOPTIONS_VECTORMISC ) FOParm.pFileData [ 0 ].FileOptions.pOptions )->uViewportMode ) ; if ( NULL != ( ( LPOPENDLGOPTIONS_VECTORMISC ) FOParm.pFileData [ 0 ].FileOptions.pOptions )->szFont ) { L_VecAddFontMapper ( VectorFontMapperCallback, ( ( LPOPENDLGOPTIONS_VECTORMISC ) FOParm.pFileData [ 0 ].FileOptions.pOptions )->szFont ) ; } break ; } case FILE_DXF: case FILE_DXF_R13: case FILE_DWG: { ZeroMemory ( &OldDXF, sizeof ( OPENDLGOPTIONS_DXF ) ) ; // GET the Old setting to reset it again after loading L_2DGetViewport ( &OldDXF.nViewportWidth, &OldDXF.nViewportHeight ) ; OldDXF.uViewportMode = L_2DGetViewMode ( ) ; L_GetAutoCADFilesColorScheme ( &OldDXF.uAutoCADColorScheme ) ; // SET the new settings. L_2DSetViewport ( ( ( LPOPENDLGOPTIONS_DXF ) FOParm.pFileData [ 0 ].FileOptions.pOptions )->nViewportWidth, ( ( LPOPENDLGOPTIONS_DXF ) FOParm.pFileData [ 0 ].FileOptions.pOptions )->nViewportHeight ) ; L_2DSetViewMode ( ( ( LPOPENDLGOPTIONS_DXF ) FOParm.pFileData [ 0 ].FileOptions.pOptions )->uViewportMode ) ; if ( NULL != ( ( LPOPENDLGOPTIONS_DXF ) FOParm.pFileData [ 0 ].FileOptions.pOptions )->szFont ) { L_VecAddFontMapper ( VectorFontMapperCallback, ( ( LPOPENDLGOPTIONS_DXF ) FOParm.pFileData [ 0 ].FileOptions.pOptions )->szFont ) ; } L_SetAutoCADFilesColorScheme ( ( ( LPOPENDLGOPTIONS_DXF ) FOParm.pFileData [ 0 ].FileOptions.pOptions )->uAutoCADColorScheme ) ; break ; } case FILE_PLT: { ZeroMemory ( &OldPLT, sizeof ( OPENDLGOPTIONS_PLT ) ) ; // GET the Old setting to reset it again after loading L_2DGetViewport ( &OldPLT.nViewportWidth, &OldPLT.nViewportHeight ) ; OldPLT.uViewportMode = L_2DGetViewMode ( ) ; L_GetPLTOptions ( &OldPLT.PLTOptions, sizeof ( FILEPLTOPTIONS ) ) ; // SET the new settings. L_2DSetViewport ( ( ( LPOPENDLGOPTIONS_PLT ) FOParm.pFileData [ 0 ].FileOptions.pOptions )->nViewportWidth, ( ( LPOPENDLGOPTIONS_PLT ) FOParm.pFileData [ 0 ].FileOptions.pOptions )->nViewportHeight ) ; L_2DSetViewMode ( ( ( LPOPENDLGOPTIONS_PLT ) FOParm.pFileData [ 0 ].FileOptions.pOptions )->uViewportMode ) ; if ( NULL != ( ( LPOPENDLGOPTIONS_PLT ) FOParm.pFileData [ 0 ].FileOptions.pOptions )->szFont ) { L_VecAddFontMapper ( VectorFontMapperCallback, ( ( LPOPENDLGOPTIONS_PLT ) FOParm.pFileData [ 0 ].FileOptions.pOptions )->szFont ) ; } L_SetPLTOptions ( &( ( LPOPENDLGOPTIONS_PLT ) FOParm.pFileData [ 0 ].FileOptions.pOptions )->PLTOptions ) ; break ; } case FILE_WMF: case FILE_EMF: case FILE_WMZ: { ZeroMemory ( &OldMetaFile, sizeof ( OPENDLGOPTIONS_METAFILE ) ) ; // GET the Old setting to reset it again after loading L_GetWMFResolution ( &OldMetaFile.nXResolution, &OldMetaFile.nYResolution ) ; // SET the new settings. L_SetWMFResolution ( ( ( LPOPENDLGOPTIONS_METAFILE ) FOParm.pFileData [ 0 ].FileOptions.pOptions )->nXResolution, ( ( LPOPENDLGOPTIONS_METAFILE ) FOParm.pFileData [ 0 ].FileOptions.pOptions )->nYResolution ) ; L_FileInfo ( FOParm.pFileData [ 0 ].szFileName, FOParm.pFileData [ 0 ].pFileInfo, sizeof ( FILEINFO ), 0, pLoadOptions ) ; FOParm.pFileData [ 0 ].pFileInfo->Flags = FILEINFO_FORMATVALID ; break ; } case FILE_PCD: { // SET the new settings. L_SetPCDResolution ( ( ( LPOPENDLGOPTIONS_PCD ) FOParm.pFileData [ 0 ].FileOptions.pOptions )->nResolution ) ; FOParm.pFileData [ 0 ].pFileInfo->Flags = FILEINFO_FORMATVALID ; break ; } case FILE_RAS_PDF: case FILE_EPSPOSTSCRIPT: case FILE_POSTSCRIPT: { ZeroMemory ( &OldPDF, sizeof ( OPENDLGOPTIONS_PDF ) ) ; // GET the old settings. L_GetPDFOptions ( &OldPDF.PDFOptions, sizeof ( FILEPDFOPTIONS ) ) ; // SET the new settings. L_SetPDFOptions ( &( ( LPOPENDLGOPTIONS_PDF ) FOParm.pFileData [ 0 ].FileOptions.pOptions )->PDFOptions ) ; break ; } case FILE_CMW: case FILE_JP2: case FILE_J2K: case FILE_JBIG: case FILE_FPX: case FILE_FPX_SINGLE_COLOR: case FILE_FPX_JPEG: case FILE_FPX_JPEG_QFACTOR: { ZeroMemory ( &OldRasterMisc, sizeof ( OPENDLGOPTIONS_RASTERMISC ) ) ; // GET the Old setting to reset it again after loading L_GetLoadResolution ( FOParm.pFileData [ 0 ].FileOptions.nType, &OldRasterMisc.uXResolution, &OldRasterMisc.uYResolution, pLoadOptions ) ; // SET the new settings. L_SetLoadResolution ( FOParm.pFileData [ 0 ].FileOptions.nType, ( ( LPOPENDLGOPTIONS_RASTERMISC ) FOParm.pFileData [ 0 ].FileOptions.pOptions )->uXResolution, ( ( LPOPENDLGOPTIONS_RASTERMISC ) FOParm.pFileData [ 0 ].FileOptions.pOptions )->uYResolution ) ; FOParm.pFileData [ 0 ].pFileInfo->Flags = FILEINFO_FORMATVALID ; break ; } } } int WINAPI VectorFontMapperCallback ( pVECTORHANDLE pVector, LPLOGFONT pLogFont, L_VOID* pUserData ) { UNREFERENCED_PARAMETER ( pVector ) ; lstrcpy ( pLogFont->lfFaceName, ( LPTSTR ) pUserData ) ; return SUCCESS; }