#include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "tchar.h" #include "../../../include/ltnet.h" #include "../../../include/l_bitmap.h" /* LEADTOOLS main header file. */ #include "../../../include/l_error.h" /* LEADTOOLS error definition header file. */ #include "NetCmd.h" // generic window control classes #include "status.h" #define MAX_CONNECTIONS 5 #define LIST_SIZE 5 #define SCROLL_RATIO 10 // // Global Variables // // preferences BOOL gbStatusBar = TRUE; BOOL gbAutoSizeFrame; TCHAR gachAppName[] = TEXT("LEAD_CAPTURE") ; TCHAR gachIconName[] = TEXT("0") ; TCHAR gachMenuName[] = TEXT("MAIN_MENU") ; TCHAR gachChildClass[] = TEXT("LEAD_NETCMD_CHILD") ; TCHAR gachAppTitle[35]; TCHAR gszURL[100] = TEXT(""); TCHAR gachLoadRemote[_MAX_PATH] = TEXT(""); TCHAR gachSaveRemote[_MAX_PATH] = TEXT(""); TCHAR gszRegKeyPath[] = TEXT("Software\\LEAD Technologies, Inc.\\LEADTOOLS 14.0\\14\\NetCmd"); HINSTANCE ghInstApp; HINSTANCE ghPrevInstApp; HWND ghWndMain = NULL; HWND ghWndClient = NULL; HWND ghWndStatus; HWND hCtl; L_BOOL gbFlag = FALSE; L_BOOL gbExistsPath = FALSE; L_BOOL gbAttach = FALSE; L_BOOL gbWinCreated = FALSE; L_BOOL gbMAG = FALSE; L_BOOL gbUpdate = FALSE; L_BOOL gbLowQ = FALSE; L_COMP ghServer = (L_COMP)SOCKET_ERROR; L_COMP ghClient[MAX_CONNECTIONS + 2]; // handle to remote computer L_INT gnSlot=0; // next available slot L_COMP ghRemoteServer = (L_COMP)SOCKET_ERROR; L_INT gnBitmaps; L_COMP ghComputer; L_UINT guCommandID; BITMAPHANDLE gLoadedBitmap; HWND ghCreatedWin = NULL; HKEY ghResultKey = NULL; L_TCHAR gszKeyClass[] = TEXT("SERVER PATH"); L_TCHAR gszImageDir[L_MAXPATH]; HWND ghImageListDlg = NULL; L_INT gnImageIndex; L_TCHAR gnImageNameList[L_MAXPATH][80]; L_INT gnOldWidth = 0; L_INT gnOldHeight = 0; #ifdef UNICODE typedef struct _wfinddata_t FIND_STRUCT; #else typedef struct _finddata_t FIND_STRUCT; #endif #define FINDFIRST _findfirst #define FINDNEXT _tfindnext #define FINDCLOSE _findclose /* Local bitmap list variables. These are bitmap that have been loaded locally. The ID of each bitmap is the index in the list. */ HBITMAPLIST ghBitmapList; L_UINT guBitmapCount; L_BOOL gbInScroll; L_TCHAR szOpenFileFilter[] = { TEXT("ALL\0") TEXT("*.*\0") TEXT("LEAD\0") TEXT("*.cmp\0") TEXT("CALS\0") TEXT("*.cal\0") TEXT("GEM Image\0") TEXT("*.img\0") TEXT("CServe PNG\0") TEXT("*.png\0") TEXT("DICOM DIC\0") TEXT("*.dic\0") TEXT("Exif\0") TEXT("*.tif;*.jpg\0") TEXT("Flic Animation\0") TEXT("*.flc;*.fli\0") TEXT("FlashPix\0") TEXT("*.fpx\0") TEXT("GIF\0") TEXT("*.gif\0") TEXT("IOCA\0") TEXT("*.ica\0") TEXT("JPEG\0") TEXT("*.jpg;*.jff;*.jtf\0") TEXT("Mac PICTURE\0") TEXT("*.pct\0") TEXT("MacPaint\0") TEXT("*.mac\0") TEXT("MS Paint\0") TEXT("*.msp\0") TEXT("MS Fax\0") TEXT("*.awd\0") TEXT("Photo CD\0") TEXT("*.pcd\0") TEXT("PCX\0") TEXT("*.pcx\0") TEXT("PhotoShop PSD\0") TEXT("*.psd\0") TEXT("PostScript Raster\0") TEXT("*.eps\0") TEXT("SUN Raster\0") TEXT("*.ras\0") TEXT("TGA\0") TEXT("*.tga\0") TEXT("TIF\0") TEXT("*.tif\0") TEXT("Win Metafile\0") TEXT("*.wmf\0") TEXT("Win & OS/2\0") TEXT("*.bmp\0") TEXT("Winfax\0") TEXT("*.fxs\0") TEXT("WordPerfect\0") TEXT("*.wpg\0") TEXT("Win Icon\0") TEXT("*.ico\0") TEXT("Win Cursor\0") TEXT("*.cur\0") TEXT("Animated Cursor\0") TEXT("*.ani\0") TEXT("") }; #define LimitRange(Val,Low,Hi) (max(Low,(min(Val,Hi)))) // my user defined commands enum { CMD_FLIP = CMD_USER_CUSTOM, CMD_GET, CMD_GET_LOW, CMD_REVERSE, CMD_90, CMD_180, CMD_SHEAR, CMD_RESIZE, CMD_POSTERIZE, CMD_NOISE, CMD_OILIFY, CMD_RESOLUTION, CMD_INVERT, CMD_CONTRAST, CMD_SATURATION, CMD_GAMMA, CMD_LOADPATH, CMD_GETPATH }; // Defines/typedefs associated with the child window data #define CHILD_BITMAPIDVALID 0x0001000 // the bitmap ID is valid in CREATEDATA and CHILDDATA structures typedef struct { pBITMAPHANDLE pBitmap; L_UINT uBitmapID; // the ID associated with the bitmap L_UINT uFlags; L_TCHAR L_FAR *pszTitle; } CREATEDATA, L_FAR*pCREATEDATA; typedef struct tagCHILDDATA { BITMAPHANDLE Bitmap; // the bitmap handle associated with the bitmap L_UINT uBitmapID; // the ID associated with the bitmap L_UINT uFlags; L_COMP hRemote; RECT rcDest; // the bitmap rectangles (valid if the bitmap is valid) RECT rcDestClip; RECT rcSrc; RECT rcSrcClip; HPALETTE hPalette; L_INT cxClient; L_INT cyClient; L_INT nVScrollMax; L_INT nVScrollPos; L_INT nHScrollMax; L_INT nHScrollPos; L_INT nHScrollStep; L_INT nVScrollStep; MAGGLASSCALLBACK lpfn; } CHILDDATA, L_FAR*pCHILDDATA; #define GETCHILDDATA(hWnd) (pCHILDDATA)GetWindowLong(hWnd, GWL_USERDATA) // Defines/typedefs associated with the remote resources (bitmaps and windows) #define ITEM_BITMAPVALID 0x0001 // uBitmapID is valid #define ITEM_WINDOWVALID 0x0002 // uWindowID is valid typedef struct tagITEMLIST { L_UINT uFlags; L_UINT uBitmapID; L_UINT uWindowID; } ITEMLIST, L_FAR*pItemList; typedef struct tagITEMS { L_UINT uCount; L_UINT uMaxCount; ITEMLIST aItems[]; } ITEMS, L_FAR*pITEMS; // // Function prototypes // LONG FAR PASCAL MainWndProc(HWND, UINT, UINT, LONG); LONG FAR PASCAL ChildWndProc(HWND, UINT, UINT, LONG); LONG FAR PASCAL ImageListDlgProc(HWND, UINT, WPARAM, LONG); BOOL RegisterClasses(HINSTANCE hInstance, HINSTANCE hPrevInstance); BOOL CreateWindows(); L_INT EXT_CALLBACK InetCallback(L_COMP hComp,L_INT nMessage,L_INT nError, L_CHAR L_FAR *pBuffer,L_UINT32 lSize,L_VOID L_FAR*pUserData); L_INT EXT_CALLBACK InetCommandCallback ( L_COMP hComputer, CMDTYPE uCommand, L_UINT uCommandID, L_INT nError, L_UINT uParams, pPARAMETER pParams, L_UINT uExtra, L_CHAR L_FAR*pExtra, L_VOID L_FAR*pUserData ); L_INT GammaCorrect(pBITMAPHANDLE pBitmap, L_UINT uRed, L_UINT uGreen, L_UINT uBlue); L_VOID EXT_CALLBACK InetResponseCallback ( L_COMP hComputer, CMDTYPE uCommand, L_UINT uCommandID, L_INT nError, L_INT nStatus, L_UINT uParams, pPARAMETER pParam, L_UINT uExtra, L_CHAR L_FAR*pExtra, L_VOID L_FAR*pUserData ); L_VOID FreeRemoteList(L_COMP hComputer); HWND CreateChildWindow ( L_TCHAR L_FAR*pszClassName, L_TCHAR L_FAR*pszWindowName, L_UINT32 ulFlags, L_INT nLeft, L_INT nTop, L_INT nWidth, L_INT nHeight, HWND hwndParent, pBITMAPHANDLE pBitmap ); static VOID Child_ProcessSize (HWND hWnd, int cx, int cy); /////////////////////////////////////////////////////////////////////// // hInstance: handle for this instance // hPrevInstance: handle for possible previous instances // lpszCmdLine: long pointer to exec command line // nCmdShow: Show code for main window display /////////////////////////////////////////////////////////////////////// int PASCAL WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpszCmdLine, int nCmdShow) { MSG msg; DWORD dwType, dwData = L_MAXPATH; BYTE byData[L_MAXPATH]; memset(gszImageDir, 0, L_MAXPATH); UNLOCKSUPPORT(); ghInstApp = hInstance; ghPrevInstApp = hPrevInstance; // read the app title string - used in several message boxes LoadString(hInstance, IDS_APP_TITLE, gachAppTitle, sizeof(gachAppTitle)); if (!RegisterClasses(hInstance, hPrevInstance)) { MessageBoxID(IDS_ERR_REGISTER_CLASS, MB_ICONEXCLAMATION) ; return 0 ; } if (!CreateWindows()) return IDS_ERR_CREATE_WINDOW ; // Show the main window before connecting the hardware as this can be // time consuming and the user should see something happening first... ShowWindow(ghWndMain, nCmdShow); UpdateWindow(ghWndMain); // Open the NetCmd registry key. // Get the value of class SERVER PATH at the registry. // Copy the data to the image directory string variable. if(RegOpenKeyEx(HKEY_LOCAL_MACHINE, gszRegKeyPath, 0, KEY_ALL_ACCESS, &ghResultKey) == ERROR_SUCCESS && RegQueryValueEx(ghResultKey, gszKeyClass, NULL, &dwType, byData, &dwData) == ERROR_SUCCESS) { memcpy(gszImageDir, byData, strlen(byData)); gbExistsPath = TRUE; } L_InetStartUp(); L_DlgInit(DLG_INIT_COLOR); while (GetMessage(&msg, NULL, 0, 0)) { if( !TranslateMDISysAccel( ghWndClient, &msg ) ) { TranslateMessage(&msg) ; DispatchMessage(&msg) ; } } L_InetShutDown(); L_DlgFree(); return(msg.wParam); } BOOL RegisterClasses(HINSTANCE hInstance, HINSTANCE hPrevInstance) { WNDCLASS wc; if (!hPrevInstance) { // If it's the first instance, register the window class wc.lpszClassName = gachAppName ; wc.hInstance = hInstance ; wc.lpfnWndProc = MainWndProc ; wc.hCursor = LoadCursor(NULL, IDC_ARROW) ; wc.hIcon = LoadIcon(hInstance, gachIconName) ; wc.lpszMenuName = gachMenuName ; wc.hbrBackground = GetStockObject(GRAY_BRUSH) ; wc.style = 0 ; wc.cbClsExtra = 0 ; wc.cbWndExtra = 0 ; if (!RegisterClass(&wc)) return(FALSE); // If it's the first instance, register the window class wc.lpszClassName = gachChildClass ; wc.hInstance = hInstance ; wc.lpfnWndProc = ChildWndProc ; wc.hCursor = LoadCursor(NULL, IDC_ARROW) ; wc.hIcon = LoadIcon(hInstance, gachIconName) ; wc.lpszMenuName = NULL ; wc.hbrBackground = GetStockObject(GRAY_BRUSH) ; wc.style = 0 ; wc.cbClsExtra = 0 ; wc.cbWndExtra = 0 ; if (!RegisterClass(&wc)) return(FALSE); } if (!statusInit(hInstance, hPrevInstance)) return(FALSE); return(TRUE); } BOOL CreateWindows() { ghWndMain = CreateWindowEx(0,gachAppName,gachAppTitle,WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_THICKFRAME | WS_CLIPCHILDREN | WS_OVERLAPPED, CW_USEDEFAULT,CW_USEDEFAULT,400,340,NULL,NULL,ghInstApp,0) ; if (ghWndMain == NULL) return(FALSE); // create the status bar - let Layout do the positioning ghWndStatus = CreateWindowEx(0,szStatusClass,NULL,WS_CHILD|WS_BORDER|WS_VISIBLE|WS_CLIPSIBLINGS, 0,0,0,0,ghWndMain,NULL,ghInstApp,NULL); if (ghWndStatus == NULL) return(FALSE); return(TRUE); } /* * layout the main window. Put the status * line at the bottom, and then give all the rest to Frame, * - it will center or scroll the Capture window appropriately. */ L_INT32 Layout(HWND hwnd, L_UINT uState) { RECT rc; RECT rw; int cy; int cyBorder, cxBorder; int cyMenuAndCaption; /* for both the status bar window, * we want just one of the four borders. We do this * by setting the WS_BORDER style, and sizing and positioning * the window so that the 3 unwanted borders are outside the parent. */ cyBorder = GetSystemMetrics(SM_CYBORDER); cxBorder = GetSystemMetrics(SM_CXBORDER); // Figure out the height of the menu, and caption GetWindowRect (hwnd, &rw); GetClientRect (hwnd, &rc); ClientToScreen (hwnd, (LPPOINT) &rc); cyMenuAndCaption = (rc.top - rw.top); GetClientRect(hwnd, &rc); // status bar at the bottom if (gbStatusBar) { cy = statusGetHeight() + cyBorder; MoveWindow(ghWndStatus,-cxBorder, rc.bottom - cy,RECTWIDTH(rc) + (2 * cxBorder), cy + cyBorder,TRUE); rc.bottom -= cy; } else MoveWindow(ghWndStatus, 0, 0, 0, 0, TRUE); //MoveWindow(ghWndClient, rc.left, rc.top, RECTWIDTH(rc), RECTHEIGHT(rc), TRUE); return DefFrameProc (hwnd, ghWndClient, WM_SIZE, (WPARAM)uState, MAKELPARAM(RECTWIDTH(rc), RECTHEIGHT(rc))); } /* --- error/status functions -------------------------------------------*/ /* * put up a message box loading a string from the * resource file */ int MessageBoxID(UINT idString, UINT fuStyle) { TCHAR achMessage[256]; // max message length LoadString(ghInstApp, idString, achMessage, sizeof(achMessage)); return(MessageBox(ghWndMain, achMessage, gachAppTitle, fuStyle)); } /* * load a string from the string table and return * a pointer to it for temporary use. Each call * overwrites the previous */ LPTSTR tmpString(UINT idString) { static TCHAR ach[350]; LoadString(ghInstApp, idString, ach, sizeof(ach)); // ensure null terminated ach[sizeof(ach) - (1*sizeof(L_TCHAR))] = 0; return(ach); } L_VOID ShutdownConnections(L_BOOL bGraceful) { L_INT i; for(i = 0; i < gnSlot; i++) { if(!bGraceful) FreeRemoteList(ghClient[i]); L_InetClose(ghClient[i], bGraceful); } gnSlot = 0; } L_VOID ShutdownServer(L_BOOL bGraceful) { if(ghServer != (L_COMP)SOCKET_ERROR) { if(!bGraceful) FreeRemoteList(ghServer); L_InetClose(ghServer, bGraceful); ghServer = (L_COMP)SOCKET_ERROR; } } L_VOID DisconnectRemoteServer(L_BOOL bGraceful) { pCHILDDATA pData; if(ghRemoteServer != (L_COMP)SOCKET_ERROR) { if(!bGraceful) FreeRemoteList(ghRemoteServer); L_InetClose(ghRemoteServer, bGraceful); ghRemoteServer = (L_COMP)SOCKET_ERROR; ghCreatedWin = FORWARD_WM_MDIGETACTIVE(ghWndClient, SendMessage); if(IsWindow(ghCreatedWin)) { pData = GETCHILDDATA(ghCreatedWin); FreeProcInstance (pData->lpfn); L_StopMagGlass(ghCreatedWin); gbMAG = FALSE; pData->lpfn = NULL; } while(ghCreatedWin) { FORWARD_WM_MDIDESTROY(ghWndClient, ghCreatedWin, SendMessage); ghCreatedWin = FORWARD_WM_MDIGETACTIVE(ghWndClient, SendMessage); } } } // Return a computer that I am connected to extern L_COMP GetRemoteComputer() { // get the server we connected to, if possible if(ghRemoteServer != SOCKET_ERROR) return ghRemoteServer; // get the first client that connected to us if(gnSlot) return ghClient[0]; // I am not connected to any computer return (L_COMP)SOCKET_ERROR; } /****** Functions that manage the list of remotely allocated resources *****/ /* The list of items opened by a certain computer is kept into an pointer to an ITEMS structure. Return TRUE if we retrieved the Bitmap ID, false otherwise */ L_BOOL GetRemoteBitmap(L_COMP hComputer, L_UINT L_FAR*puBitmapID) { pITEMS pItems; L_UINT u; L_INT nBitmapIndex = -1; // I am interested only in the items list if(L_InetGetCallback(hComputer, NULL, &pItems) != SUCCESS) return FALSE; if(!pItems || !pItems->uCount) return FALSE; for(u = 0; u < pItems->uCount; u++) if(pItems->aItems[u].uFlags & ITEM_BITMAPVALID) { // avoid the windows that already have a bitmap attached /*if(!(pItems->aItems[u].uFlags & ITEM_WINDOWVALID)) { *puBitmapID = pItems->aItems[u].uBitmapID; return TRUE; }*/ // this bitmap is already attached to a window. Use it only if I have no choice nBitmapIndex = u; } if(nBitmapIndex >= 0) { *puBitmapID = pItems->aItems[nBitmapIndex].uBitmapID; return TRUE; } return FALSE; } L_INT AddRemoteBitmap(L_COMP hComputer, L_UINT uBitmapID) { INETCALLBACK pfnCallback; pITEMS pItems; // I might have to change the user data, so I need to retrieve the callback and the user data if(L_InetGetCallback(hComputer, &pfnCallback, &pItems) != SUCCESS) return ERROR_INV_PARAMETER; if(!pItems) { pItems = GlobalAllocPtr(GMEM_MOVEABLE, sizeof(ITEMS) + 10 * sizeof(ITEMLIST)); if(!pItems) return ERROR_NO_MEMORY; pItems->uCount = 0; pItems->uMaxCount = 10; } else if(pItems->uCount >= pItems->uMaxCount) { pITEMS p = GlobalReAllocPtr(pItems, sizeof(ITEMS) + (pItems->uMaxCount + 10) * sizeof(ITEMLIST), 0); if(!p) return ERROR_NO_MEMORY; pItems->uMaxCount += 10; } pItems->aItems[pItems->uCount].uFlags = ITEM_BITMAPVALID; pItems->aItems[pItems->uCount].uBitmapID = uBitmapID; pItems->uCount++; L_InetSetCallback(hComputer, pfnCallback, pItems); return SUCCESS; } /* The list of items opened by a certain computer is kept into an pointer to an ITEMS structure. Return TRUE if we retrieved the Window ID, false otherwise */ L_BOOL GetRemoteWindow(L_COMP hComputer, L_UINT L_FAR*puWindowID) { pITEMS pItems; L_UINT u; L_INT nWindowIndex = -1; // I am interested only in the items list if(L_InetGetCallback(hComputer, NULL, &pItems) != SUCCESS) return FALSE; if(!pItems || !pItems->uCount) return FALSE; for(u = 0; u < pItems->uCount; u++) if(pItems->aItems[u].uFlags & ITEM_WINDOWVALID) { // avoid the windows that already have a bitmap attached /*if(!(pItems->aItems[u].uFlags & ITEM_BITMAPVALID)) { *puWindowID = pItems->aItems[u].uWindowID; return TRUE; }*/ // this window is already attached to a bitmap. Use it only if I have no choice nWindowIndex = u; } if(nWindowIndex >= 0) { *puWindowID = pItems->aItems[nWindowIndex].uWindowID; return TRUE; } return FALSE; } // add a window to the list of resources allocated on hComputer L_INT AddRemoteWindow(L_COMP hComputer, L_UINT uWindowID) { INETCALLBACK pfnCallback; pITEMS pItems; // I might have to change the user data, so I need to retrieve the callback and the user data if(L_InetGetCallback(hComputer, &pfnCallback, &pItems) != SUCCESS) return ERROR_INV_PARAMETER; if(!pItems) { pItems = GlobalAllocPtr(GMEM_MOVEABLE, sizeof(ITEMS) + 10 * sizeof(ITEMLIST)); if(!pItems) return ERROR_NO_MEMORY; pItems->uCount = 0; pItems->uMaxCount = 10; } else if(pItems->uCount >= pItems->uMaxCount) { pITEMS p = GlobalReAllocPtr(pItems, sizeof(ITEMS) + (pItems->uMaxCount + 10) * sizeof(ITEMLIST), 0); if(!p) return ERROR_NO_MEMORY; pItems->uMaxCount += 10; } pItems->aItems[pItems->uCount].uFlags = ITEM_WINDOWVALID; pItems->aItems[pItems->uCount].uWindowID = uWindowID; pItems->uCount++; L_InetSetCallback(hComputer, pfnCallback, pItems); return SUCCESS; } L_VOID FreeRemoteList(L_COMP hComputer) { INETCALLBACK pfnCallback; pITEMS pList; if(L_InetGetCallback(hComputer, &pfnCallback, &pList) == SUCCESS) if(pList) { L_InetSetCallback(hComputer, pfnCallback, NULL); GlobalFreePtr(pList); } } L_VOID DeleteItem(pITEMS pItems, L_UINT uIndex) { if(uIndex + 1 < pItems->uCount) memcpy(pItems->aItems + uIndex, pItems->aItems + uIndex + 1, (pItems->uCount - (uIndex + 1)) * sizeof(ITEMLIST)); pItems->uCount--; } // call this function to avoid getting uBitmapID and uWindowID as // a pair to be attached L_VOID AvoidRemotePair(L_COMP hComputer, L_UINT uBitmapID, L_UINT uWindowID) { pITEMS pItems; L_UINT u; L_INT nBitmapIndex = -1; L_INT nWindowIndex = -1; // I am interested only in the items list if(L_InetGetCallback(hComputer, NULL, &pItems) != SUCCESS) return; if(!pItems || !pItems->uCount) return; for(u = 0; u < pItems->uCount; u++) { if((pItems->aItems[u].uFlags & ITEM_BITMAPVALID) && (pItems->aItems[u].uBitmapID == uBitmapID)) if(!(pItems->aItems[u].uFlags & ITEM_WINDOWVALID)) { nBitmapIndex = (L_INT)u; // have I found the window ID yet? if(nWindowIndex >= 0) { pItems->aItems[nWindowIndex].uFlags |= ITEM_BITMAPVALID; pItems->aItems[nWindowIndex].uBitmapID = uBitmapID; DeleteItem(pItems, u); // delete this item return; } } if((pItems->aItems[u].uFlags & ITEM_WINDOWVALID) && (pItems->aItems[u].uWindowID == uWindowID)) if(!(pItems->aItems[u].uFlags & ITEM_BITMAPVALID)) { nWindowIndex = (L_INT)u; // have I found the bitmap ID yet? if(nBitmapIndex >= 0) { pItems->aItems[nBitmapIndex].uFlags |= ITEM_WINDOWVALID; pItems->aItems[nBitmapIndex].uWindowID = uWindowID; DeleteItem(pItems, u); // delete this item return; } } } } L_VOID CleanOpenDlgParam(LPOPENDLGPARAMS pFOParam) { int i=0; if(pFOParam!=NULL && pFOParam->pFileData!= NULL ) { for(i=0; i < pFOParam->nNumOfFiles; ++i ) { if(pFOParam->pFileData[i].pBitmap != NULL) { L_FreeBitmap(pFOParam->pFileData[i].pBitmap); GlobalFreePtr(pFOParam->pFileData[i].pBitmap); } if(pFOParam->pFileData[i].pThumbnail != NULL) { L_FreeBitmap(pFOParam->pFileData[i].pThumbnail); GlobalFreePtr(pFOParam->pFileData[i].pThumbnail); } if(pFOParam->pFileData[i].pFileInfo != NULL) { GlobalFreePtr(pFOParam->pFileData[i].pFileInfo); } } GlobalFreePtr(pFOParam->pFileData); pFOParam->pFileData =NULL; pFOParam->nNumOfFiles = 0; } } /********** Functions that deal with the local resources */ static L_VOID LoadLocalBitmap(HWND hWnd) { static OPENFILENAME OpenFileName; L_INT nRet; L_TCHAR szTmp[_MAX_PATH + 100]; OPENDLGPARAMS FOParm; memset(&FOParm, 0, sizeof(FOParm)); memset(&OpenFileName,0,sizeof(OpenFileName)); FOParm.uStructSize = sizeof(FOParm); FOParm.uDlgFlags = DLG_OPEN_SHOW_PREVIEW | DLG_OPEN_SHOW_PROGRESSIVE | DLG_OPEN_SHOW_MULTIPAGE | DLG_OPEN_SHOW_LOADROTATED | DLG_OPEN_SHOW_LOADCOMPRESSED | DLG_OPEN_USEFILESTAMP; OpenFileName.lStructSize = sizeof(OPENFILENAME); OpenFileName.lpstrFilter = szOpenFileFilter; OpenFileName.lpstrCustomFilter = NULL; OpenFileName.nMaxCustFilter = 0; OpenFileName.nFilterIndex = 0; OpenFileName.lpstrInitialDir = NULL; OpenFileName.lpstrTitle = TEXT("Open Local File"); OpenFileName.lpstrDefExt = NULL; OpenFileName.Flags = 0; OpenFileName.hwndOwner = hWnd; nRet = L_DlgOpen( hWnd,&OpenFileName,&FOParm); if(nRet == SUCCESS_DLG_OK) { wsprintf(szTmp, TEXT("Local bitmap: %s"), FOParm.pFileData[ 0 ].szFileName); CreateChildWindow(NULL, szTmp, 0, 0, 0, CW_USEDEFAULT, CW_USEDEFAULT, NULL, FOParm.pFileData[ 0 ].pBitmap); CleanOpenDlgParam(&FOParm); } else if(nRet <0 ) statusUpdate(TEXT("Error %d loading local bitmap %s"), nRet, FOParm.pFileData[ 0 ].pBitmap); } static L_VOID SaveLocalBitmap(HWND hWnd) { HWND hWndChild = FORWARD_WM_MDIGETACTIVE(ghWndClient, SendMessage); pCHILDDATA pData = GETCHILDDATA(hWndChild); static OPENFILENAME OpenFileName; static SAVEDLGPARAMS FSParm; L_INT nRet; if(pData && pData->Bitmap.Flags.Allocated) { memset(&OpenFileName,0,sizeof(OPENFILENAME)); OpenFileName.lStructSize = sizeof(OPENFILENAME); OpenFileName.lpstrInitialDir = NULL; OpenFileName.lpstrTitle = TEXT("Save Local File"); OpenFileName.nFilterIndex = 0; OpenFileName.Flags = 0; memset(&FSParm, 0, sizeof(FSParm)); FSParm.uStructSize = sizeof(FSParm); FSParm.nQFactor = 2; FSParm.nPageNumber = 1; FSParm.uDlgFlags = DLG_SAVE_SHOW_FILEOPTIONS_MULTIPAGE| DLG_SAVE_SHOW_FILEOPTIONS_PROGRESSIVE | DLG_SAVE_SHOW_FILEOPTIONS_QFACTOR | DLG_SAVE_SHOW_FILEOPTIONS_STAMP | DLG_SAVE_SHOW_FILEOPTIONS_PROGRESSIVE ; FSParm.pBitmap = &pData->Bitmap; nRet = L_DlgSave( hWnd,&OpenFileName,&FSParm); if(nRet == SUCCESS_DLG_OK) statusUpdate(TEXT("Local bitmap was saved")); else if(nRet < 0 ) statusUpdate(TEXT("Error %d occured saving local bitmap"), nRet); } } L_BOOL CALLBACK CloseChildWindow (HWND hWnd, LPARAM lParam) { UNREFERENCED_PARAMETER(lParam); FORWARD_WM_MDIRESTORE (GetParent (hWnd), hWnd, SendMessage); FORWARD_WM_CLOSE (hWnd, SendMessage); return(TRUE); } L_BOOL CALLBACK DestroyRemoteWindow (HWND hWnd, LPARAM lParam) { pCHILDDATA pData = GETCHILDDATA(hWnd); if(!pData) return TRUE; // windows created by the remote have the bitmap id valid or have no bitmap if((pData->uFlags & CHILD_BITMAPIDVALID) || !pData->Bitmap.Flags.Allocated) CloseChildWindow(hWnd, lParam); return TRUE; } //////////////////////////////////////////////////////////////////////// // // MenuProc: Processes All Menu-based Operations // // hWnd: Application main window handle // hMenu: Application menu handle // wParam: Menu option // lParam: Additional info for any menu option //////////////////////////////////////////////////////////////////////// long FAR PASCAL MenuProc(HWND hWnd, UINT wParam, LONG lParam) { HMENU hMenu = GetMenu(hWnd); L_COMP hComputer; L_INT nRet; L_UINT uBitmapID; L_UINT uWindowID; HWND hWndChild; pCHILDDATA pData; switch (GET_WM_COMMAND_ID(wParam, lParam)) { case IDM_F_EXIT: return SendMessage(hWnd, WM_CLOSE, 0, 0); case IDM_S_STARTUP: { L_INT nRet; nRet = L_InetServerInit(1000,&ghServer,InetCallback,NULL); if(nRet==SUCCESS) { statusUpdate(TEXT("Server started.")); L_InetSetCommandCallback(ghServer, InetCommandCallback, NULL); L_InetSetResponseCallback(ghServer, InetResponseCallback, NULL); } else statusUpdate(TEXT("Error starting server")); } break; case IDM_S_CLOSEALL: ShutdownConnections(TRUE); break; case IDM_S_SHUTDOWN: ShutdownConnections(TRUE); ShutdownServer(TRUE); break; case IDM_S_IMAGESPATH: { L_INT nRet = SUCCESS_DLG_OK ; GETDIRECTORYDLGPARAMS DirectoryDlgParams ; ZeroMemory ( &DirectoryDlgParams, sizeof (GETDIRECTORYDLGPARAMS)) ; DirectoryDlgParams.uStructSize = sizeof (GETDIRECTORYDLGPARAMS); DirectoryDlgParams.pszDirectory = gszImageDir; DirectoryDlgParams.nBuffSize = sizeof(gszImageDir); DirectoryDlgParams.pszTitle = TEXT("Select the images path") ; DirectoryDlgParams.pszFilter = NULL ; DirectoryDlgParams.nFilterIndex = 1 ; nRet = L_DlgGetDirectory ( hWnd, &DirectoryDlgParams ) ; if ( nRet == SUCCESS_DLG_OK ) { if(RegCreateKeyEx(HKEY_LOCAL_MACHINE, gszRegKeyPath, 0, gszKeyClass, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &ghResultKey, NULL) != ERROR_SUCCESS) return 0; if(RegSetValueEx(ghResultKey, TEXT("Server Path"), 0, REG_SZ, (CONST BYTE*) gszImageDir, ( (lstrlen(gszImageDir) + 1)*sizeof(L_TCHAR))) != ERROR_SUCCESS) return 0; gbExistsPath = TRUE; } } break; case IDM_S_CONNECT: if(MyGetString(hWnd, TEXT("URL to connect to"), gszURL, sizeof(gszURL))) { L_COMP hComp; L_INT nRet = 0; #ifdef UNICODE { L_CHAR szTempURL[sizeof(gszURL)]; memset (szTempURL, 0, sizeof(szTempURL)); wcstombs(szTempURL, gszURL, sizeof(szTempURL)); nRet = L_InetConnect(szTempURL,1000,&hComp,InetCallback,NULL); } #else nRet = L_InetConnect(gszURL,1000,&hComp,InetCallback,NULL); #endif if(nRet == ERROR_HOST_RESOLVE) { statusUpdate(TEXT("Failed to connect - bad URL!")); } else if(nRet != SUCCESS) { statusUpdate(TEXT("Error %d trying to connect"), nRet); } else { statusUpdate(TEXT("Connecting to %s"), gszURL); L_InetSetCommandCallback(hComp, InetCommandCallback, NULL); L_InetSetResponseCallback(hComp, InetResponseCallback, NULL); } } break; case IDM_S_DISCONNECT: DisconnectRemoteServer(TRUE); break; /*case IDM_L_LOADBITMAP: LoadLocalBitmap(hWnd); break; case IDM_L_SAVEBITMAP: SaveLocalBitmap(hWnd); break;*/ case IDM_R_LOADBITMAP: hComputer = GetRemoteComputer(); if(hComputer != SOCKET_ERROR) if(MyGetString(hWnd, TEXT("Remote file to load"), gachLoadRemote, sizeof(gachLoadRemote))) { GetRemoteWindow(hComputer, &uWindowID); L_InetSendCloseWinCmd(hComputer, guCommandID++, uWindowID); ghCreatedWin = FORWARD_WM_MDIGETACTIVE(ghWndClient, SendMessage); if(IsWindow(ghCreatedWin)) { pData = GETCHILDDATA(ghCreatedWin); FreeProcInstance (pData->lpfn); L_StopMagGlass(ghCreatedWin); gbMAG = FALSE; pData->lpfn = NULL; } while(ghCreatedWin) { FORWARD_WM_MDIDESTROY(ghWndClient, ghCreatedWin, SendMessage); ghCreatedWin = FORWARD_WM_MDIGETACTIVE(ghWndClient, SendMessage); } nRet = L_InetSendLoadCmd(hComputer, guCommandID++, gachLoadRemote, 0, ORDER_BGR, LOADFILE_ALLOCATE|LOADFILE_STORE); if(nRet != SUCCESS && nRet != ERROR_DATA_QUEUED) statusUpdate(TEXT("ERROR %d calling L_InetSendLoadCmd"), nRet); } break; case IDM_R_FLIPBITMAP: hComputer = GetRemoteComputer(); if(hComputer != SOCKET_ERROR && GetRemoteBitmap(hComputer, &uBitmapID)) { HINETPACK hPacket; L_InetCreatePacket(&hPacket, 0, NULL, "%ud", uBitmapID); nRet = L_InetSendCmd(hComputer, CMD_FLIP, guCommandID++, hPacket); if(nRet != SUCCESS && nRet != ERROR_DATA_QUEUED) statusUpdate(TEXT("ERROR %d calling L_InetSendCmd"), nRet); L_InetFreePacket(hPacket); } break; case IDM_R_REVERSE: hComputer = GetRemoteComputer(); if(hComputer != SOCKET_ERROR && GetRemoteBitmap(hComputer, &uBitmapID)) { HINETPACK hPacket; L_InetCreatePacket(&hPacket, 0, NULL, "%ud", uBitmapID); nRet = L_InetSendCmd(hComputer, CMD_REVERSE, guCommandID++, hPacket); if(nRet != SUCCESS && nRet != ERROR_DATA_QUEUED) statusUpdate(TEXT("ERROR %d calling L_InetSendCmd"), nRet); L_InetFreePacket(hPacket); } break; case IDM_R_90CLOCKWISE: hComputer = GetRemoteComputer(); if(hComputer != SOCKET_ERROR && GetRemoteBitmap(hComputer, &uBitmapID)) { HINETPACK hPacket; L_InetCreatePacket(&hPacket, 0, NULL, "%ud%ud%ud%ud", uBitmapID, 9000, ROTATE_RESIZE, RGB(255, 0, 0)); nRet = L_InetSendCmd(hComputer, CMD_90, guCommandID++, hPacket); if(nRet != SUCCESS && nRet != ERROR_DATA_QUEUED) statusUpdate(TEXT("ERROR %d calling L_InetSendCmd"), nRet); L_InetFreePacket(hPacket); } break; case IDM_R_180CLOCKWISE: hComputer = GetRemoteComputer(); if(hComputer != SOCKET_ERROR && GetRemoteBitmap(hComputer, &uBitmapID)) { HINETPACK hPacket; L_InetCreatePacket(&hPacket, 0, NULL, "%ud%ud%ud%ud", uBitmapID, 18000, ROTATE_RESIZE, RGB(255, 255, 255)); nRet = L_InetSendCmd(hComputer, CMD_180, guCommandID++, hPacket); if(nRet != SUCCESS && nRet != ERROR_DATA_QUEUED) statusUpdate(TEXT("ERROR %d calling L_InetSendCmd"), nRet); L_InetFreePacket(hPacket); } break; case IDM_R_SHEAR: hComputer = GetRemoteComputer(); if(hComputer != SOCKET_ERROR && GetRemoteBitmap(hComputer, &uBitmapID)) { HINETPACK hPacket; L_InetCreatePacket(&hPacket, 0, NULL, "%ud%ud%ud%ud", uBitmapID, 4500, TRUE, RGB(255, 255, 255)); nRet = L_InetSendCmd(hComputer, CMD_SHEAR, guCommandID++, hPacket); if(nRet != SUCCESS && nRet != ERROR_DATA_QUEUED) statusUpdate(TEXT("ERROR %d calling L_InetSendCmd"), nRet); L_InetFreePacket(hPacket); } break; case IDM_R_RESIZE: case IDM_R_RESAMPLE: hComputer = GetRemoteComputer(); if(hComputer != SOCKET_ERROR && GetRemoteBitmap(hComputer, &uBitmapID)) { HINETPACK hPacket; RESIZEDLGPARAMS DlgParams ; memset (&DlgParams, 0, sizeof(RESIZEDLGPARAMS)) ; DlgParams.uStructSize = sizeof(RESIZEDLGPARAMS); DlgParams.uOriginalWidth = BITMAPWIDTH(&gLoadedBitmap); DlgParams.uOriginalHeight = BITMAPHEIGHT(&gLoadedBitmap); DlgParams.uOriginalBitsPerPixel = gLoadedBitmap.BitsPerPixel; DlgParams.uOriginalResolutionX = gLoadedBitmap.XResolution; DlgParams.uOriginalResolutionY = gLoadedBitmap.YResolution; DlgParams.uNewWidth = BITMAPWIDTH(&gLoadedBitmap); DlgParams.uNewHeight = BITMAPHEIGHT(&gLoadedBitmap); DlgParams.uNewResolutionX = gLoadedBitmap.XResolution; DlgParams.uNewResolutionY = gLoadedBitmap.YResolution; DlgParams.uResize = SIZE_NORMAL ; DlgParams.uDlgFlags = DLG_RESIZE_SHOW_PERCENTAGE | DLG_RESIZE_SHOW_IDENTICALVALUE | DLG_RESIZE_SHOW_MAINTAINASPECT | DLG_RESIZE_SHOW_RESOLUTIONGRP; if(L_DlgResize ( hWnd, &DlgParams ) != SUCCESS_DLG_OK) return 0; L_InetCreatePacket(&hPacket, 0, NULL, "%ud%d%d%ud", uBitmapID, DlgParams.uNewWidth, DlgParams.uNewHeight, DlgParams.uResize); nRet = L_InetSendCmd(hComputer, CMD_RESIZE, guCommandID++, hPacket); if(nRet != SUCCESS && nRet != ERROR_DATA_QUEUED) statusUpdate(TEXT("ERROR %d calling L_InetSendCmd"), nRet); L_InetFreePacket(hPacket); } break; case IDM_R_POSTERIZE: hComputer = GetRemoteComputer(); if(hComputer != SOCKET_ERROR && GetRemoteBitmap(hComputer, &uBitmapID)) { HINETPACK hPacket; POSTERIZEDLGPARAMS DlgParams; memset(&DlgParams,0,sizeof(POSTERIZEDLGPARAMS)); DlgParams.uStructSize = sizeof(POSTERIZEDLGPARAMS); DlgParams.pBitmap = &gLoadedBitmap; DlgParams.nLevels = 2; DlgParams.uDlgFlags = DLG_POSTERIZE_AUTOPROCESS | DLG_POSTERIZE_SHOW_PREVIEW| DLG_POSTERIZE_SHOW_TOOL_ZOOMLEVEL ; if(L_DlgPosterize ( hWnd, &DlgParams ) != SUCCESS_DLG_OK) return 0; L_InetCreatePacket(&hPacket, 0, NULL, "%ud%d", uBitmapID, DlgParams.nLevels); nRet = L_InetSendCmd(hComputer, CMD_POSTERIZE, guCommandID++, hPacket); if(nRet != SUCCESS && nRet != ERROR_DATA_QUEUED) statusUpdate(TEXT("ERROR %d calling L_InetSendCmd"), nRet); L_InetFreePacket(hPacket); } break; case IDM_R_ADDNOISE: hComputer = GetRemoteComputer(); if(hComputer != SOCKET_ERROR && GetRemoteBitmap(hComputer, &uBitmapID)) { HINETPACK hPacket; ADDNOISEDLGPARAMS DlgParams; memset(&DlgParams,0,sizeof(ADDNOISEDLGPARAMS)); DlgParams.uStructSize = sizeof(ADDNOISEDLGPARAMS); DlgParams.pBitmap = &gLoadedBitmap ; DlgParams.uRange = 100 ; DlgParams.uChannel = CHANNEL_MASTER ; DlgParams.uDlgFlags = DLG_ADDNOISE_AUTOPROCESS | DLG_ADDNOISE_SHOW_PREVIEW| DLG_ADDNOISE_SHOW_TOOL_ZOOMLEVEL; if(L_DlgAddNoise( hWnd, &DlgParams )!= SUCCESS_DLG_OK) return 0; L_InetCreatePacket(&hPacket, 0, NULL, "%ud%ud%ud", uBitmapID, DlgParams.uRange, DlgParams.uChannel); nRet = L_InetSendCmd(hComputer, CMD_NOISE, guCommandID++, hPacket); if(nRet != SUCCESS && nRet != ERROR_DATA_QUEUED) statusUpdate(TEXT("ERROR %d calling L_InetSendCmd"), nRet); L_InetFreePacket(hPacket); } break; case IDM_R_OILIFY: hComputer = GetRemoteComputer(); if(hComputer != SOCKET_ERROR && GetRemoteBitmap(hComputer, &uBitmapID)) { HINETPACK hPacket; OILIFYDLGPARAMS DlgParams ; memset(&DlgParams,0,sizeof(OILIFYDLGPARAMS)); DlgParams.uStructSize = sizeof(OILIFYDLGPARAMS); DlgParams.pBitmap = &gLoadedBitmap ; DlgParams.uDim = 3; DlgParams.uDlgFlags = DLG_OILIFY_AUTOPROCESS | DLG_OILIFY_SHOW_PREVIEW| DLG_OILIFY_SHOW_TOOL_ZOOMLEVEL ; if(L_DlgOilify ( hWnd, &DlgParams ) != SUCCESS_DLG_OK) return 0; L_InetCreatePacket(&hPacket, 0, NULL, "%ud%d", uBitmapID, DlgParams.uDim); nRet = L_InetSendCmd(hComputer, CMD_OILIFY, guCommandID++, hPacket); if(nRet != SUCCESS && nRet != ERROR_DATA_QUEUED) statusUpdate(TEXT("ERROR %d calling L_InetSendCmd"), nRet); L_InetFreePacket(hPacket); } break; case IDM_R_RESOLUTION: hComputer = GetRemoteComputer(); if(hComputer != SOCKET_ERROR && GetRemoteBitmap(hComputer, &uBitmapID)) { HINETPACK hPacket; COLORRESDLGPARAMS DlgParams; memset(&DlgParams,0,sizeof(COLORRESDLGPARAMS)); DlgParams.uStructSize = sizeof(COLORRESDLGPARAMS); DlgParams.pBitmap = &gLoadedBitmap; DlgParams.nBitsPerPixel = gLoadedBitmap.BitsPerPixel ; DlgParams.uColorResFlags = CRF_SLOWMATCH; DlgParams.uDlgFlags = DLG_COLORRES_SHOW_PREVIEW| DLG_COLORRES_SHOW_ORDER | DLG_COLORRES_SHOW_TOOL_ZOOMLEVEL ; DlgParams.uDlgFlagsEx = DLG_COLORRES_SHOW_BITALL | DLG_COLORRES_SHOW_DITHER_ALL | DLG_COLORRES_SHOW_PAL_FIXED | DLG_COLORRES_SHOW_PAL_IDENTITY | DLG_COLORRES_SHOW_PAL_NETSCAPE | DLG_COLORRES_SHOW_PAL_OPTIMIZED ; if(L_DlgColorRes ( hWnd, &DlgParams ) != SUCCESS_DLG_OK) return 0; L_InetCreatePacket(&hPacket, 0, NULL, "%ud%ud%d%ud%d%d%ud%d%d", uBitmapID, uBitmapID, DlgParams.nBitsPerPixel, DlgParams.uColorResFlags, NULL, NULL, 0, NULL, NULL); nRet = L_InetSendCmd(hComputer, CMD_RESOLUTION, guCommandID++, hPacket); if(nRet != SUCCESS && nRet != ERROR_DATA_QUEUED) statusUpdate(TEXT("ERROR %d calling L_InetSendCmd"), nRet); L_InetFreePacket(hPacket); } break; case IDM_R_INVERT: hComputer = GetRemoteComputer(); if(hComputer != SOCKET_ERROR && GetRemoteBitmap(hComputer, &uBitmapID)) { HINETPACK hPacket; L_InetCreatePacket(&hPacket, 0, NULL, "%ud", uBitmapID); nRet = L_InetSendCmd(hComputer, CMD_INVERT, guCommandID++, hPacket); if(nRet != SUCCESS && nRet != ERROR_DATA_QUEUED) statusUpdate(TEXT("ERROR %d calling L_InetSendCmd"), nRet); L_InetFreePacket(hPacket); } break; case IDM_R_CONTRAST: hComputer = GetRemoteComputer(); if(hComputer != SOCKET_ERROR && GetRemoteBitmap(hComputer, &uBitmapID)) { HINETPACK hPacket; CONTRASTDLGPARAMS DlgParams; memset(&DlgParams,0,sizeof(CONTRASTDLGPARAMS)); DlgParams.uStructSize = sizeof(CONTRASTDLGPARAMS); DlgParams.pBitmap = &gLoadedBitmap ; DlgParams.nChange = 0; DlgParams.uDlgFlags = DLG_CONTRAST_AUTOPROCESS | DLG_CONTRAST_SHOW_PREVIEW| DLG_CONTRAST_SHOW_TOOL_ZOOMLEVEL ; if(L_DlgContrast ( hWnd, &DlgParams ) != SUCCESS_DLG_OK) return 0; L_InetCreatePacket(&hPacket, 0, NULL, "%ud%d", uBitmapID, DlgParams.nChange); nRet = L_InetSendCmd(hComputer, CMD_CONTRAST, guCommandID++, hPacket); if(nRet != SUCCESS && nRet != ERROR_DATA_QUEUED) statusUpdate(TEXT("ERROR %d calling L_InetSendCmd"), nRet); L_InetFreePacket(hPacket); } break; case IDM_R_SATURATION: hComputer = GetRemoteComputer(); if(hComputer != SOCKET_ERROR && GetRemoteBitmap(hComputer, &uBitmapID)) { HINETPACK hPacket; SATURATIONDLGPARAMS DlgParams ; memset(&DlgParams,0,sizeof(SATURATIONDLGPARAMS)); DlgParams.uStructSize = sizeof(SATURATIONDLGPARAMS); DlgParams.pBitmap = &gLoadedBitmap ; DlgParams.nChange = 0; DlgParams.uDlgFlags = DLG_SATURATION_AUTOPROCESS | DLG_SATURATION_SHOW_PREVIEW | DLG_SATURATION_SHOW_TOOL_ZOOMLEVEL ; if(L_DlgSaturation ( hWnd, &DlgParams )!= SUCCESS_DLG_OK) return 0; L_InetCreatePacket(&hPacket, 0, NULL, "%ud%d", uBitmapID, DlgParams.nChange); nRet = L_InetSendCmd(hComputer, CMD_SATURATION, guCommandID++, hPacket); if(nRet != SUCCESS && nRet != ERROR_DATA_QUEUED) statusUpdate(TEXT("ERROR %d calling L_InetSendCmd"), nRet); L_InetFreePacket(hPacket); } break; case IDM_R_GAMMACORRECTION: hComputer = GetRemoteComputer(); if(hComputer != SOCKET_ERROR && GetRemoteBitmap(hComputer, &uBitmapID)) { HINETPACK hPacket; int nRet; GAMMAADJUSTMENTDLGPARAMS DlgParams; memset(&DlgParams,0,sizeof(GAMMAADJUSTMENTDLGPARAMS)); DlgParams.uStructSize = sizeof(GAMMAADJUSTMENTDLGPARAMS); DlgParams.pBitmap = &gLoadedBitmap; DlgParams.nRedValue = 150 ; DlgParams.nGreenValue = 150 ; DlgParams.nBlueValue = 150 ; DlgParams.uDlgFlags = DLG_GAMMAADJUSTMENT_SHOW_PREVIEW| DLG_GAMMAADJUSTMENT_SHOW_TOOL_ZOOMLEVEL | DLG_GAMMAADJUSTMENT_FORCELINKCHANNELS; nRet = L_DlgGammaAdjustment ( hWnd, &DlgParams ); if(nRet!= SUCCESS_DLG_OK) return 0; L_InetCreatePacket(&hPacket, 0, NULL, "%ud%ud%ud%ud", uBitmapID, DlgParams.nRedValue, DlgParams.nGreenValue, DlgParams.nBlueValue); nRet = L_InetSendCmd(hComputer, CMD_GAMMA, guCommandID++, hPacket); if(nRet != SUCCESS && nRet != ERROR_DATA_QUEUED) statusUpdate(TEXT("ERROR %d calling L_InetSendCmd"), nRet); L_InetFreePacket(hPacket); } break; case IDM_R_LOADPATH: { HINETPACK hPacket; hComputer = GetRemoteComputer(); GetRemoteWindow(hComputer, &uWindowID); L_InetSendCloseWinCmd(hComputer, guCommandID++, uWindowID); ghCreatedWin = FORWARD_WM_MDIGETACTIVE(ghWndClient, SendMessage); if(IsWindow(ghCreatedWin)) { pData = GETCHILDDATA(ghCreatedWin); FreeProcInstance (pData->lpfn); L_StopMagGlass(ghCreatedWin); gbMAG = FALSE; pData->lpfn = NULL; } while(ghCreatedWin) { FORWARD_WM_MDIDESTROY(ghWndClient, ghCreatedWin, SendMessage); ghCreatedWin = FORWARD_WM_MDIGETACTIVE(ghWndClient, SendMessage); } memset(gnImageNameList, 0, sizeof(gnImageNameList)); gnImageIndex = 0; if(IsWindow(ghImageListDlg)) DestroyWindow(ghImageListDlg); L_InetCreatePacket(&hPacket, 0, NULL, "%d", 1); nRet = L_InetSendCmd(hComputer, CMD_LOADPATH, guCommandID++, hPacket); if(nRet != SUCCESS && nRet != ERROR_DATA_QUEUED) statusUpdate(TEXT("ERROR %d calling L_InetSendCmd"), nRet); L_InetFreePacket(hPacket); } break; case IDM_R_SAVEBITMAP: hComputer = GetRemoteComputer(); if(hComputer != SOCKET_ERROR && GetRemoteBitmap(hComputer, &uBitmapID)) if(MyGetString(hWnd, TEXT("Remote file to save to"), gachSaveRemote, sizeof(gachSaveRemote))) { nRet = L_InetSendSaveCmd(hComputer, guCommandID++, gachSaveRemote, uBitmapID, FILE_TIF, 0, 0, SAVEFILE_OPTIMIZEDPALETTE); if(nRet != SUCCESS && nRet != ERROR_DATA_QUEUED) statusUpdate(TEXT("ERROR %d calling L_InetSendSaveCmd"), nRet); } break; case IDM_R_CREATEWINDOW: hComputer = GetRemoteComputer(); if(hComputer != SOCKET_ERROR) { nRet = L_InetSendCreateWinCmd(hComputer, guCommandID++, TEXT(""), TEXT("Window created by remote computer"), 0, 0, 0, 300, 150, 0); if(nRet != SUCCESS && nRet != ERROR_DATA_QUEUED) statusUpdate(TEXT("ERROR %d calling L_InetSendCreateWinCmd"), nRet); } break; case IDM_R_ATTACHBITMAP: hComputer = GetRemoteComputer(); if(hComputer != SOCKET_ERROR && GetRemoteBitmap(hComputer, &uBitmapID) && GetRemoteWindow(hComputer, &uWindowID)) { nRet = L_InetSendAttachBitmapCmd(hComputer, guCommandID++, uBitmapID, uWindowID); if(nRet != SUCCESS && nRet != ERROR_DATA_QUEUED) statusUpdate(TEXT("ERROR %d calling L_InetSendAttachBitmapCmd"), nRet); else // if I attached a bitmap to a window, mark them so I avoid attaching the same pair again AvoidRemotePair(hComputer, uBitmapID, uWindowID); } break; case IDM_R_LOWQUALITY: hComputer = GetRemoteComputer(); if(hComputer != SOCKET_ERROR && GetRemoteBitmap(hComputer, &uBitmapID)) { HINETPACK hPacket; L_InetCreatePacket(&hPacket, 0, NULL, "%ud", uBitmapID); nRet = L_InetSendCmd(hComputer, CMD_GET_LOW, guCommandID++, hPacket); if(nRet != SUCCESS && nRet != ERROR_DATA_QUEUED) statusUpdate(TEXT("ERROR %d calling L_InetSendCmd"), nRet); L_InetFreePacket(hPacket); gbLowQ = TRUE; } break; case IDM_R_MAGGLASS: hWndChild = FORWARD_WM_MDIGETACTIVE(ghWndClient, SendMessage); pData = GETCHILDDATA(hWndChild); if(pData && pData->Bitmap.Flags.Allocated) { MAGGLASSOPTIONS MagglassOptions; RECT Rect; if(!gbMAG) { if(pData->lpfn) { FreeProcInstance (pData->lpfn); pData->lpfn = NULL; } ZeroMemory(&MagglassOptions,sizeof(MAGGLASSOPTIONS)); MagglassOptions.uStructSize = sizeof(MAGGLASSOPTIONS); MagglassOptions.nWidth = 150; MagglassOptions.nHeight = 100; MagglassOptions.nZoom = 400; MagglassOptions.clrPen = 0; MagglassOptions.hMagCursor = NULL; MagglassOptions.clrBack = RGB(128,128,128); MagglassOptions.bEllipse = FALSE; MagglassOptions.nBorderSize = 1; MagglassOptions.b3D = TRUE; MagglassOptions.uPaintFlags = DISPLAYMODE_RESAMPLE; MagglassOptions.pMask = NULL; MagglassOptions.uMaskCount = 0; MagglassOptions.nCrosshair = CROSSHAIR_FINE; MagglassOptions.bIgnoreRgn = TRUE; MagglassOptions.bCenter = TRUE; pData->lpfn = MakeProcInstance(MagGlassCallback, hInst); GetClientRect(hWndChild, &Rect); nRet = L_StartMagGlass(hWndChild/*hWnd*/, &gLoadedBitmap, &Rect, &MagglassOptions, pData->lpfn, (L_VOID L_FAR *)pData); if(nRet!=SUCCESS) MessageBox(hWndChild, TEXT("Error Starting MagGlass!"), TEXT("Error"), MB_OK); else gbMAG = TRUE; } else { FreeProcInstance (pData->lpfn); L_StopMagGlass(hWndChild); gbMAG = FALSE; pData->lpfn = NULL; } } break; case IDM_W_CASCADE: FORWARD_WM_MDICASCADE(ghWndClient, 0, SendMessage); break; case IDM_W_TILE_VERT: FORWARD_WM_MDITILE(ghWndClient, MDITILE_VERTICAL, SendMessage); break; case IDM_W_TILE_HORZ: FORWARD_WM_MDITILE(ghWndClient, MDITILE_HORIZONTAL, SendMessage); break; case IDM_W_CLOSE: if(gbMAG) { L_StopMagGlass(FORWARD_WM_MDIGETACTIVE(ghWndClient, SendMessage)); gbMAG = FALSE; } FORWARD_WM_CLOSE (FORWARD_WM_MDIGETACTIVE(ghWndClient, SendMessage), SendMessage); break; case IDM_W_CLOSEALL: EnumChildWindows(ghWndClient, CloseChildWindow, 0); break; case IDM_R_GETBITMAP: gnOldWidth = 0; gnOldHeight = 0; hComputer = GetRemoteComputer(); if(hComputer != SOCKET_ERROR && GetRemoteBitmap(hComputer, &uBitmapID)) { HINETPACK hPacket; L_InetCreatePacket(&hPacket, 0, NULL, "%ud", uBitmapID); nRet = L_InetSendCmd(hComputer, CMD_GET, guCommandID++, hPacket); if(nRet != SUCCESS && nRet != ERROR_DATA_QUEUED) statusUpdate(TEXT("ERROR %d calling L_InetSendCmd"), nRet); L_InetFreePacket(hPacket); gbLowQ = FALSE; } break; case IDM_H_ABOUT: DoDialog(hWnd, IDD_HELPABOUTBOX, AboutProc, 0); break ; case IDM_H_INSTRUCTIONS: // use the AboutProc since it doesn't need any special function DoDialog(hWnd, IDD_INSTRUCTIONS, AboutProc, 0); break ; } return(0L); } /* --- menu help and enable/disable handling ------------------------ */ // write or clear status line help text when the user brings up or cancels a // menu. This depends on there being strings in the string table with // the same ID as the corresponding menu item. // Help text for the items along the menu bar (File, Edit etc) depends // on IDM_FILE, IDM_EDIT being defined with values 100 apart in the same // order as their index in the menu void MenuSelect(HWND hwnd, UINT cmd, UINT flags, HMENU hmenu) { if ((LOWORD(flags) == 0xffff) && (hmenu == NULL)) { //menu closing - remove message statusUpdate(NULL); } else if ( (flags & (MF_SYSMENU|MF_POPUP)) == (MF_SYSMENU|MF_POPUP)) { // the system menu itself statusUpdate(MAKEINTRESOURCE(IDM_SYSMENU)); } else if ((flags & MF_POPUP) == 0) { // a menu command item statusUpdate(MAKEINTRESOURCE(cmd)); } else { //a popup menu - we need to search to find which one. // note that the cmd item in Win16 will now have a // menu handle, whereas in Win32 it has an index. // NOTE: this code assumes that the menu items // are #defined 100 apart in the same order, starting // with IDM_FILE statusUpdate(MAKEINTRESOURCE(IDM_FILE + (cmd * 100))); } } // a popup menu is being selected - enable or disable menu items int InitMenuPopup(HWND hwnd,HMENU hmenu,int index) { int i = MF_ENABLED; L_UINT uBitmapID; L_COMP hComputer; HWND hWndChild = FORWARD_WM_MDIGETACTIVE(ghWndClient, SendMessage); pCHILDDATA pData; pData = hWndChild ? GETCHILDDATA(hWndChild) : NULL; if(IsZoomed(hWndChild)) index--; switch(index) { case 0: // IDM_FILE EnableMenuItem(hmenu, IDM_L_SAVEBITMAP, (pData && pData->Bitmap.Flags.Allocated) ? MF_ENABLED : MF_GRAYED); break; case 1: // IDM_SERVER hComputer = GetRemoteComputer(); EnableMenuItem(hmenu,IDM_S_STARTUP, ghServer == (L_COMP)SOCKET_ERROR && ghRemoteServer == (L_COMP)SOCKET_ERROR ? MF_ENABLED : MF_GRAYED); EnableMenuItem(hmenu,IDM_S_SHUTDOWN, ghServer == (L_COMP)SOCKET_ERROR ? MF_GRAYED : MF_ENABLED); EnableMenuItem(hmenu,IDM_S_CLOSEALL, gnSlot && ghRemoteServer == (L_COMP)SOCKET_ERROR ? MF_ENABLED : MF_GRAYED); EnableMenuItem(hmenu,IDM_S_DISCONNECT, ghRemoteServer == (L_COMP)SOCKET_ERROR ? MF_GRAYED : MF_ENABLED); EnableMenuItem(hmenu,IDM_S_CONNECT, (ghServer == (L_COMP)SOCKET_ERROR && ghRemoteServer == (L_COMP)SOCKET_ERROR) ? MF_ENABLED : MF_GRAYED); EnableMenuItem(hmenu,IDM_S_IMAGESPATH, (ghServer == (L_COMP)SOCKET_ERROR || ghRemoteServer != (L_COMP)SOCKET_ERROR) ? MF_GRAYED : MF_ENABLED); break; case 2: // IDM_REMOTE hComputer = GetRemoteComputer(); if(ghServer == (L_COMP)SOCKET_ERROR && hComputer) { i = GetRemoteBitmap(hComputer, &uBitmapID) ? MF_ENABLED : MF_GRAYED; EnableMenuItem(hmenu,IDM_R_LOADBITMAP, hComputer != SOCKET_ERROR ? MF_ENABLED : MF_GRAYED); EnableMenuItem(hmenu,IDM_R_LOADPATH,hComputer != SOCKET_ERROR ? MF_ENABLED : MF_GRAYED); EnableMenuItem(hmenu,IDM_R_GETBITMAP, i); EnableMenuItem(hmenu,IDM_R_LOWQUALITY, i); EnableMenuItem(hmenu,IDM_R_FLIPBITMAP, i); EnableMenuItem(hmenu,IDM_R_SAVEBITMAP, i); EnableMenuItem(hmenu,IDM_R_CREATEWINDOW, (GetRemoteBitmap(hComputer, &uBitmapID) && !gbWinCreated) ? MF_ENABLED : MF_GRAYED); EnableMenuItem(hmenu,IDM_R_ATTACHBITMAP, (gbAttach && gbWinCreated) ? MF_ENABLED : MF_GRAYED); ghCreatedWin = FORWARD_WM_MDIGETACTIVE(ghWndClient, SendMessage); i = IsWindow(ghCreatedWin) /*&& pData->uBitmapID != 0*/ ? MF_ENABLED : MF_GRAYED; EnableMenuItem(hmenu,MENU_IMAGE_POS, MF_BYPOSITION | i); EnableMenuItem(hmenu,MENU_COLOR_POS, MF_BYPOSITION | i); i = IsWindow(ghCreatedWin) /*&& pData->uBitmapID != 0*/ && gbLowQ ? MF_ENABLED : MF_GRAYED; CheckMenuItem(hmenu,IDM_R_MAGGLASS, gbMAG ? MF_CHECKED : MF_UNCHECKED); EnableMenuItem(hmenu,IDM_R_MAGGLASS, i); } else { EnableMenuItem(hmenu,IDM_R_LOADBITMAP, MF_GRAYED); EnableMenuItem(hmenu,IDM_R_LOADPATH, MF_GRAYED); EnableMenuItem(hmenu,IDM_R_GETBITMAP, MF_GRAYED); EnableMenuItem(hmenu,IDM_R_LOWQUALITY, MF_GRAYED); EnableMenuItem(hmenu,IDM_R_FLIPBITMAP, MF_GRAYED); EnableMenuItem(hmenu,IDM_R_SAVEBITMAP, MF_GRAYED); EnableMenuItem(hmenu,IDM_R_CREATEWINDOW, MF_GRAYED); EnableMenuItem(hmenu,IDM_R_ATTACHBITMAP, MF_GRAYED); EnableMenuItem(hmenu,IDM_R_MAGGLASS, MF_GRAYED); CheckMenuItem(hmenu,IDM_R_MAGGLASS, MF_UNCHECKED); EnableMenuItem(hmenu,MENU_IMAGE_POS, MF_BYPOSITION | MF_GRAYED); EnableMenuItem(hmenu,MENU_COLOR_POS, MF_BYPOSITION | MF_GRAYED); } break; case 3: // IDM_WINDOW EnableMenuItem(hmenu, IDM_W_CASCADE, hWndChild ? MF_ENABLED : MF_GRAYED); EnableMenuItem(hmenu, IDM_W_TILE_VERT, hWndChild ? MF_ENABLED : MF_GRAYED); EnableMenuItem(hmenu, IDM_W_TILE_HORZ, hWndChild ? MF_ENABLED : MF_GRAYED); EnableMenuItem(hmenu, IDM_W_CLOSE, hWndChild ? MF_ENABLED : MF_GRAYED); ghCreatedWin = FORWARD_WM_MDIGETACTIVE(ghWndClient, SendMessage); EnableMenuItem(hmenu, IDM_W_CLOSEALL, IsWindow(ghCreatedWin) ? MF_ENABLED : MF_GRAYED); break; } return(0); } L_BOOL CALLBACK PaletteChanged (HWND hWnd, LPARAM lParam) { FORWARD_WM_PALETTECHANGED (hWnd, (HWND) (UINT) (lParam), SendMessage); return(TRUE); } //////////////////////////////////////////////////////////////////////// // // MainWndProc: Application Main Window Procedure // // hWnd: Application main window handle // Message: Next message to be processed // wParam: WORD param for the message // lParam: LONG param for the message //////////////////////////////////////////////////////////////////////// LONG FAR PASCAL MainWndProc(HWND hWnd, UINT Message, UINT wParam, LONG lParam) { static BOOL fMinimized; switch (Message) { case WM_SYSCOMMAND: if ((wParam & 0xfff0) == SC_MAXIMIZE) fMinimized = FALSE; else if ((wParam & 0xfff0) == SC_RESTORE) fMinimized = FALSE; else if ((wParam & 0xfff0) == SC_MINIMIZE) fMinimized = TRUE; break; case WM_COMMAND: MenuProc(hWnd, wParam, lParam) ; break ; case WM_CREATE: { CLIENTCREATESTRUCT ClientStruct; ClientStruct.hWindowMenu = GetSubMenu (GetMenu (hWnd), MENU_WINDOW_POS); ClientStruct.idFirstChild = IDM_FIRSTCHILD; ghWndClient = 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, ghInstApp, (VOID FAR *) & ClientStruct); break; } case WM_NCHITTEST: { DWORD dw; dw = DefFrameProc(hWnd, ghWndClient, Message, wParam, lParam); // Don't allow border resize if autosizing if (gbAutoSizeFrame) { if (dw >= HTSIZEFIRST && dw <= HTSIZELAST) dw = HTCAPTION; } return dw; } case WM_SIZE: return Layout (hWnd, wParam); case WM_MENUSELECT: { UINT cmd = GET_WM_MENUSELECT_CMD(wParam, lParam); UINT flags = GET_WM_MENUSELECT_FLAGS(wParam, lParam); HMENU hmenu = GET_WM_MENUSELECT_HMENU(wParam, lParam); MenuSelect(hWnd, cmd, flags, hmenu); } break; case WM_INITMENUPOPUP: if (!(BOOL) HIWORD(lParam)) // not a system menu? return InitMenuPopup(hWnd, (HMENU) wParam, (int) LOWORD(lParam)); break; case WM_SYSCOLORCHANGE: // we don't use this ourselves, but we should pass // it on to all three children SendMessage(ghWndStatus, Message, wParam, lParam); return (TRUE); case WM_PALETTEISCHANGING: case WM_PALETTECHANGED: EnumChildWindows (ghWndClient, PaletteChanged, wParam); break; case WM_QUERYNEWPALETTE: { HWND hWndChild = FORWARD_WM_MDIGETACTIVE(ghWndClient, SendMessage); if(IsWindow(hWndChild)) FORWARD_WM_QUERYNEWPALETTE(hWndChild, SendMessage); break; } case WM_CLOSE: DestroyWindow(hWnd); break; case WM_DESTROY: ShutdownConnections(FALSE); ShutdownServer(FALSE); if(ghBitmapList) L_DestroyBitmapList(ghBitmapList); if(gLoadedBitmap.Flags.Allocated) L_FreeBitmap(&gLoadedBitmap); PostQuitMessage(0) ; break; } return DefFrameProc(hWnd, ghWndClient, Message, wParam, lParam); } int DoDialog(HWND hwndParent,int DialogID,DLGPROC fnDialog,long lParam) { return DialogBoxParam(ghInstApp,MAKEINTRESOURCE(DialogID),hwndParent, fnDialog,lParam); } L_BOOL AlreadyConnected(L_INT nSlot) { L_CHAR szLastAddress[100]; L_CHAR szAddress[100]; L_UINT32 ulLength = sizeof(szLastAddress); L_INT i; if(nSlot > 0 && L_InetGetHostName(ghClient[nSlot], szLastAddress, HOST_NAME_IP, &ulLength) == SUCCESS) { for(i = 0; i < nSlot; i++) { ulLength = sizeof(szAddress); if(L_InetGetHostName(ghClient[i], szAddress, HOST_NAME_IP, &ulLength) == SUCCESS) if(!strcmp(szAddress, szLastAddress)) return TRUE; } } return FALSE; } L_INT EXT_CALLBACK InetCallback(L_COMP hComp,L_INT nMessage,L_INT nError, L_CHAR L_FAR *pBuffer, L_UINT32 lSize, L_VOID L_FAR*pUserData) { TCHAR s[200]; pBITMAPHANDLE pBitmap; L_INT i; pCHILDDATA pData; switch(nMessage) { case INET_CONNECT_REQUEST: // somebody wants to connect with us if(gnSlot < MAX_CONNECTIONS) if(L_InetAcceptConnect(ghServer,&ghClient[gnSlot],InetCallback,NULL) == SUCCESS) { L_InetAutoProcess(ghClient[gnSlot],TRUE); L_InetSetCommandCallback(ghClient[gnSlot], InetCommandCallback, NULL); L_InetSetResponseCallback(ghClient[gnSlot], InetResponseCallback, NULL); //take the next line out if you don't mind having two sockets when you connect to yourself if(!AlreadyConnected(gnSlot)) { gnSlot++; statusUpdate(TEXT("Connection accepted. %d connections active"), gnSlot); } } else statusUpdate(TEXT("Error accepting a connection")); else statusUpdate(TEXT("Connection refused - too many connections!")); break; case INET_CONNECT: if(nError != SUCCESS) statusUpdate(TEXT("Error connecting to remote server")); else { L_UINT32 size; L_CHAR szTemp[100] ; memset (szTemp, 0, sizeof(szTemp)); size = sizeof(szTemp); if(L_InetGetHostName(hComp, szTemp, HOST_NAME_IP, &size) == SUCCESS) { wsprintf(s, TEXT("Connected to %hs"), szTemp); } else { wsprintf(s, TEXT("Connected to %s"), gszURL); } //statusUpdate(s); SetWindowText(ghWndMain, s); if(ghRemoteServer != SOCKET_ERROR) L_InetClose(ghRemoteServer, TRUE); // add the remote server to the list of clients as well // we will be sending to and receiving images from the remote server ghClient[gnSlot++] = ghRemoteServer = hComp; gnBitmaps = 0; } break; case INET_CLOSE: // is our connection to the remote server closed? if(hComp == ghRemoteServer) { SetWindowText(ghWndMain, TEXT("Connection to the remote server was closed")); ghRemoteServer = (L_COMP)SOCKET_ERROR; gbFlag = FALSE; gbExistsPath = FALSE; gbAttach = FALSE; gbWinCreated = FALSE; } // remove the closed handle from the list for(i = 0; i < gnSlot; i++) if(ghClient[i] == hComp) { L_INT j; for(j = i; j + 1 < gnSlot; j++) ghClient[j] = ghClient[j+1]; gnSlot--; break; } FreeRemoteList(hComp); statusUpdate(TEXT("Connection closed")); // if all the connections are closed, free all the bitmaps loaded by the remote // and close all the windows created by the remote if(!gnSlot && ghRemoteServer == (L_COMP)SOCKET_ERROR) { statusUpdate(TEXT("Last connection closed - freeing resources allocated by remote")); EnumChildWindows(ghWndClient, DestroyRemoteWindow, 0); if(ghBitmapList) { L_DestroyBitmapList(ghBitmapList); ghBitmapList = NULL; } } break; case INET_DATA_READY: statusUpdate(TEXT("%ld bytes are ready to be read! (AutoProcess is False)"), lSize); break; case INET_DATA_START: /* if(nError == SUCCESS) statusUpdate("A chunk of %ld bytes is being received!", lSize); else statusUpdate("Error %d occured while starting to receive data", nError); */ break; case INET_DATA_RECEIVING: /* if(nError == SUCCESS) statusUpdate("A chunk of %ld bytes has been received!", lSize); else statusUpdate("Error %d occured while receiving data", nError); */ break; case INET_IMAGE_RECEIVED: if(nError == SUCCESS) { wsprintf(s, TEXT("Received bitmap %d"), gnBitmaps++); statusUpdate(s); pBitmap = (pBITMAPHANDLE)pBuffer; if(IsWindow(hCtl)) { AddImage(pBitmap); } else if(!gbFlag) { if(gbLowQ && gnOldWidth && gnOldHeight) { L_SizeBitmap(pBitmap, gnOldWidth / 10, gnOldHeight/ 10, SIZE_RESAMPLE); L_SizeBitmap(pBitmap, gnOldWidth, gnOldHeight, SIZE_RESAMPLE); } ghCreatedWin = FORWARD_WM_MDIGETACTIVE(ghWndClient, SendMessage); if(IsWindow(ghCreatedWin)) { pData = GETCHILDDATA(ghCreatedWin); FreeProcInstance (pData->lpfn); L_StopMagGlass(ghCreatedWin); gbMAG = FALSE; pData->lpfn = NULL; } while(ghCreatedWin) { FORWARD_WM_MDIDESTROY(ghWndClient, ghCreatedWin, SendMessage); ghCreatedWin = FORWARD_WM_MDIGETACTIVE(ghWndClient, SendMessage); } if((ghCreatedWin = CreateChildWindow(TEXT(""), s, 0, 0, 0, CW_USEDEFAULT, CW_USEDEFAULT, NULL, pBitmap))) { memmove(&gLoadedBitmap, pBitmap, sizeof(BITMAPHANDLE)); memset(pBitmap, 0, sizeof(BITMAPHANDLE)); // prevent the LTNET.DLL from freeing the image } } else { memmove(&gLoadedBitmap, pBitmap, sizeof(BITMAPHANDLE)); gbFlag = FALSE; } } else { statusUpdate(TEXT("Error receiving bitmap %d"), gnBitmaps); } break; case INET_MMEDIA_RECEIVED: if(nError == SUCCESS) statusUpdate(TEXT("A %ld bytes Multimedia Object has been received successfully!"), lSize); else statusUpdate(TEXT("Error %d occured while receiving a Multimedia Object"), nError); break; case INET_USER2_RECEIVED: // an user-defined string has been received. Display it in the status bar. if(lSize > 0) { // display message in the form hh:mm:ss xxx.xxx.xxx.xxx message_text" L_UINT uMsgSize = 0; L_UINT uAddrSize; L_CHAR L_FAR*pMsg; L_InetGetHostName(hComp,NULL, HOST_NAME_DESCRP, &uMsgSize); uMsgSize = 8 + 1 + 16 + 1 + uMsgSize + 2 + lSize + 1; pMsg = GlobalAllocPtr(GHND, uMsgSize); // allocate annd initialize with 0s if(pMsg) { time_t mytime; struct tm *time_tm; time(&mytime); time_tm = localtime(&mytime); sprintf(pMsg, "%02d:%02d:%02d ", time_tm->tm_hour, time_tm->tm_min, time_tm->tm_sec); uAddrSize = uMsgSize - strlen(pMsg); if(L_InetGetHostName(hComp, pMsg + strlen(pMsg), HOST_NAME_IP, &uAddrSize) == SUCCESS) { strcat(pMsg, " <"); uAddrSize = uMsgSize - strlen(pMsg); L_InetGetHostName(hComp, pMsg + strlen(pMsg), HOST_NAME_DESCRP, &uAddrSize); strcat(pMsg, "> "); } lSize = min(lSize, uMsgSize - strlen(pMsg) - 1); _fmemcpy(pMsg + strlen(pMsg), pBuffer, lSize); // make sure this message is noticed statusUpdateA(pMsg); SetWindowTextA(ghWndMain, pMsg); GlobalFreePtr(pMsg); } else { // cannot allocate memory. No fancy formatting - just make sure the string is null-terminated pBuffer[lSize-1] = 0; statusUpdateA(pBuffer); } } break; case INET_USER1_RECEIVED: if(nError == SUCCESS) { L_INT len; wsprintf(s, TEXT("%ld bytes of user-defined data has been received! First bytes are:"), lSize); len = lstrlen(s); lSize = min(lSize, sizeof(s)-((len-1)*sizeof(L_TCHAR))); _fmemcpy(s + len, (L_TCHAR*)pBuffer, lSize); s[len + lSize] = 0; } else wsprintf(s, TEXT("Error %d occured while receiving user-defined data"), nError); statusUpdate(s); break; case INET_USER3_RECEIVED: if(nError == SUCCESS) if(gnImageIndex < L_MAXPATH) { lstrcpy(gnImageNameList[gnImageIndex++], (L_TCHAR*)pBuffer); } break; case INET_USER4_RECEIVED: if(nError == SUCCESS) { gbExistsPath = TRUE; if(*pBuffer == '1') gbFlag = TRUE; else if(*pBuffer == '2') { MessageBox(ghWndMain, TEXT("The server doesn't support any image folder"), TEXT("NetCmd"), MB_OK); gbExistsPath = FALSE; } else if(*pBuffer == '3') { ghImageListDlg = CreateDialogParam(ghInstApp, MAKEINTRESOURCE(IDD_IMAGELISTDLG), ghWndMain, (DLGPROC)ImageListDlgProc, (LPARAM)NULL); if(ghImageListDlg) ShowWindow(ghImageListDlg, SW_SHOW); EnableWindow(ghImageListDlg, FALSE); EnableWindow(ghWndMain, FALSE); } else if(*pBuffer == '4') { EnableWindow(ghImageListDlg, TRUE); if(SendMessage(hCtl, L_ILM_GETITEMCOUNT, 0, 0L) == 0) { MessageBox(ghWndMain, TEXT("There are no images in the server images path"), TEXT("NetCmd"), MB_OK); DestroyWindow(ghImageListDlg); } } else if(*pBuffer == '5') gbWinCreated = FALSE; else if(*pBuffer == 'A') gnOldWidth = (L_INT)lSize; else gnOldHeight = (L_INT)lSize; } break; } return(SUCCESS); } /* Add pBitmap to the list of bitmaps that have been loaded locally. Note that the index of the bitmap cannot change, so when I remove one bitmap I cannot move the others around. So the only time I will remove a bitmap is when I remove the last item in the bitmap list. Since I don't remove items in the list, I might have empty slots in the list. The empty slots are bitmaps that are not allocated. To eliminate the empty slots I will loop through all the entries in the bitmap list and check if they are available. Note: I have to add pBitmap to the list or free it! */ L_INT AddBitmap(pBITMAPHANDLE pBitmap, L_UINT L_FAR*puBitmapID) { L_INT nRet; L_UINT u; BITMAPHANDLE Bitmap; if(!ghBitmapList) { nRet = L_CreateBitmapList(&ghBitmapList); if(nRet != SUCCESS) { L_FreeBitmap(pBitmap); return nRet; } guBitmapCount = 0; } // check for empty slots for(u = 0; u < guBitmapCount; u++) { nRet = L_GetBitmapListItem(ghBitmapList, u, &Bitmap,sizeof(BITMAPHANDLE)); if(nRet == SUCCESS && !Bitmap.Flags.Allocated) break; } // i is the index where I should put my bitmap // if there is an empty slot, then i is the first empty slot // if there are no empty slot, then i is guBitmapCount, // which means that I have to add the bitmap to the end of the list if(u == guBitmapCount) { nRet = L_InsertBitmapListItem(ghBitmapList, u, pBitmap); if(nRet == SUCCESS) guBitmapCount++; } else nRet = L_SetBitmapListItem(ghBitmapList, u, pBitmap); if(nRet == SUCCESS) *puBitmapID = u; else L_FreeBitmap(pBitmap); return nRet; } /* The local bitmaps are identified by the index in the bitmap list. */ L_INT GetLocalBitmap(pBITMAPHANDLE pBitmap, L_UINT uBitmapID) { if(ghBitmapList) return L_GetBitmapListItem(ghBitmapList, uBitmapID, pBitmap,sizeof(BITMAPHANDLE)); return ERROR_INV_PARAMETER; } /* Callback used to signal all child windows that a local bitmap has been updated. */ L_BOOL CALLBACK BitmapUpdated (HWND hWnd, LPARAM lParam) { pCHILDDATA pData = GETCHILDDATA(hWnd); if(pData && (pData->uFlags & CHILD_BITMAPIDVALID) && pData->uBitmapID == (L_UINT)lParam) { GetLocalBitmap(&pData->Bitmap, lParam); InvalidateRect(hWnd, NULL, FALSE); FORWARD_WM_QUERYNEWPALETTE (hWnd, SendMessage); // reset the source rectangles SetRect(&pData->rcSrc, 0, 0, BITMAPWIDTH(&pData->Bitmap), BITMAPHEIGHT(&pData->Bitmap)); pData->rcSrcClip = pData->rcSrc; // reset the destination rectangles, if necessary if(RECTWIDTH(pData->rcDest) != BITMAPWIDTH(&pData->Bitmap) || RECTHEIGHT(pData->rcDest) != BITMAPHEIGHT(&pData->Bitmap)) { RECT rcClient; pData->rcDestClip.right += BITMAPWIDTH(&pData->Bitmap) - RECTWIDTH(pData->rcDest); pData->rcDest.right += BITMAPWIDTH(&pData->Bitmap) - RECTWIDTH(pData->rcDest); // update the scroll bars GetClientRect(hWnd, &rcClient); Child_ProcessSize(hWnd, RECTWIDTH(rcClient), RECTHEIGHT(rcClient)); } } return(TRUE); } L_INT UpdateLocalBitmap(pBITMAPHANDLE pBitmap, L_UINT uBitmapID) { L_INT nRet; if(ghBitmapList) { nRet = L_SetBitmapListItem(ghBitmapList, uBitmapID, pBitmap); if(nRet == SUCCESS) EnumChildWindows(ghWndClient, BitmapUpdated, uBitmapID); return nRet; } return ERROR_INV_PARAMETER; } /* This function will create a window and maybe attach a bitmap to it. */ HWND CreateChildWindow ( L_TCHAR L_FAR*pszClassName, L_TCHAR L_FAR*pszWindowName, L_UINT32 ulFlags, L_INT nLeft, L_INT nTop, L_INT nWidth, L_INT nHeight, HWND hwndParent, pBITMAPHANDLE pBitmap ) { MDICREATESTRUCT mdiCreateStruct; CREATEDATA CreateData; HWND hWndChild; if(!pszClassName || !*pszClassName) pszClassName = gachChildClass; if(!hwndParent) hwndParent = ghWndClient; CreateData.pszTitle = pszWindowName; CreateData.pBitmap = pBitmap; mdiCreateStruct.szClass = pszClassName; mdiCreateStruct.szTitle = pszWindowName; mdiCreateStruct.hOwner = ghInstApp; mdiCreateStruct.x = nLeft; mdiCreateStruct.y = nTop; if(pBitmap) { mdiCreateStruct.cx = pBitmap->Width; mdiCreateStruct.cy = pBitmap->Height; } else { mdiCreateStruct.cx = nWidth; mdiCreateStruct.cy = nHeight; } mdiCreateStruct.style = MDIS_ALLCHILDSTYLES|WS_CLIPCHILDREN; mdiCreateStruct.lParam = (LPARAM) &CreateData; hWndChild = FORWARD_WM_MDICREATE (ghWndClient, (LPMDICREATESTRUCT) & mdiCreateStruct, SendMessage); return hWndChild; } L_INT AttachBitmap(L_UINT uBitmapID, L_UINT uWindowID) { HWND hWndChild = (HWND)uWindowID; BITMAPHANDLE Bitmap; L_INT nRet; pCHILDDATA pData; RECT rcClient; if(!IsWindow(hWndChild)) return ERROR_INV_PARAMETER; nRet = GetLocalBitmap(&Bitmap, uBitmapID); if(nRet != SUCCESS) return nRet; pData = GETCHILDDATA(hWndChild); if(!pData) return ERROR_INV_PARAMETER; // does the child have an allocated bitmap already? if(pData->Bitmap.Flags.Allocated) if(pData->uFlags & CHILD_BITMAPIDVALID) { // it is a locally allocated bitmap. don't do anything if it is the same bitmap // as the one I am assigning if(pData->uBitmapID == uBitmapID) return SUCCESS; } else L_FreeBitmap(&pData->Bitmap); pData->Bitmap = Bitmap; pData->uFlags |= CHILD_BITMAPIDVALID; pData->uBitmapID = uBitmapID; // set rects for 1:1 zoom SetRect(&pData->rcDest, 0, 0, BITMAPWIDTH(&pData->Bitmap), BITMAPHEIGHT(&pData->Bitmap)); pData->rcDestClip = pData->rcDest; SetRect(&pData->rcSrc, 0, 0, pData->Bitmap.Width, pData->Bitmap.Height); pData->rcSrcClip = pData->rcSrc; FORWARD_WM_QUERYNEWPALETTE (hWndChild, SendMessage); InvalidateRect(hWndChild, NULL, FALSE); GetClientRect(hWndChild, &rcClient); Child_ProcessSize(hWndChild, RECTWIDTH(rcClient), RECTHEIGHT(rcClient)); return SUCCESS; } L_INT EXT_CALLBACK InetCommandCallback ( L_COMP hComputer, CMDTYPE uCommand, L_UINT uCommandID, L_INT nError, L_UINT uParams, pPARAMETER pParams, L_UINT uExtra, L_CHAR L_FAR* pExtra, L_VOID L_FAR*pUserData ) { L_INT nStatus = ERROR_FEATURE_NOT_SUPPORTED; BITMAPHANDLE Bitmap; L_UINT uBitmapID = (L_UINT)-1; L_CHAR cMessage = '1'; L_UINT uMsgSize = 1; HDC hDC; COLORREF L_FAR *pColor=NULL; L_UINT32 lColorSize=0; statusUpdate(TEXT("Command %d, id=%d, nError=%d, uParams=%d%s received"), uCommand, uCommandID, nError, uParams, uExtra ? TEXT(", uExtra") : TEXT("")); if(nError != SUCCESS) nStatus = ERROR_TRANSFER_ABORTED; else switch(uCommand) { case CMD_LOAD: // check the validity of the parameters if(uParams == 4 && pParams[0].uType == PARAM_STRING && pParams[1].uType == PARAM_INT32 && pParams[2].uType == PARAM_INT32 && pParams[3].uType == PARAM_UINT32) { nStatus = L_LoadFile((L_TCHAR*) pParams[0].pValue, &Bitmap,sizeof(BITMAPHANDLE), pParams[1].iValue, pParams[2].iValue, pParams[3].iValue, NULL, NULL, NULL, NULL); //nStatus = L_LoadFile(TEXT("f:\\images\\hh\\لل.cmp"), &Bitmap,sizeof(BITMAPHANDLE), pParams[1].iValue, pParams[2].iValue, pParams[3].iValue, NULL, NULL, NULL, NULL); if(nStatus == SUCCESS) { // add the bitmap to the list of currently open bitmaps nStatus = AddBitmap(&Bitmap, &uBitmapID); L_InetSendData(hComputer, &cMessage, &uMsgSize, IDATA_USER4); L_InetSendBitmap(hComputer, &Bitmap, FILE_CMP, 0, QS, NULL); } } else nStatus = ERROR_INV_PARAMETER; // invalid parameters return L_InetSendLoadRsp(hComputer, uCommandID, uBitmapID, 0, NULL, nStatus); case CMD_CLOSE_WIN: // check the validity of the parameters if(uParams == 1 && pParams->uType == PARAM_UINT32 && IsWindow((HWND)pParams->uiValue)) { ShowWindow((HWND)pParams->uiValue, SW_RESTORE); DestroyWindow((HWND)pParams->uiValue); } else nStatus = ERROR_INV_PARAMETER; // invalid parameters return L_InetSendCloseWinRsp(hComputer, uCommandID, 0, NULL, nStatus); case CMD_CREATE_WIN: // check the validity of the parameters if(uParams == 8 && pParams[0].uType == PARAM_STRING && pParams[1].uType == PARAM_STRING && pParams[2].uType == PARAM_UINT32 && pParams[3].uType == PARAM_INT32 && pParams[4].uType == PARAM_INT32 && pParams[5].uType == PARAM_INT32 && pParams[6].uType == PARAM_INT32 && pParams[7].uType == PARAM_UINT32) { HWND hwnd; ghComputer = hComputer; hwnd = ghCreatedWin = CreateChildWindow((L_TCHAR*)pParams[0].pValue, (L_TCHAR*)pParams[1].pValue, pParams[2].uiValue, pParams[3].iValue, pParams[4].iValue, pParams[5].iValue, pParams[6].iValue, (HWND)pParams[7].uiValue, NULL); if(hwnd) return L_InetSendCreateWinRsp(hComputer, uCommandID, (L_UINT)hwnd, 0, NULL, SUCCESS); nStatus = ERROR_INV_PARAMETER; } break; case CMD_ATTACH_BITMAP: if(uParams == 2 && pParams[0].uType == PARAM_UINT32 && pParams[1].uType == PARAM_UINT32) nStatus = AttachBitmap(pParams[0].uiValue, pParams[1].uiValue); else nStatus = ERROR_INV_PARAMETER; return L_InetSendAttachBitmapRsp(hComputer, uCommandID, 0, NULL, nStatus); case CMD_FLIP: if(uParams == 1 && pParams->uType == PARAM_UINT32) { uBitmapID = pParams->uiValue; // is it a valid bitmap ID? nStatus = GetLocalBitmap(&Bitmap, uBitmapID); if(nStatus == SUCCESS) { nStatus = L_FlipBitmap(&Bitmap); if(nStatus == SUCCESS) { L_InetSendBitmap(hComputer, &Bitmap, FILE_CMP, 0, QS, NULL); nStatus = UpdateLocalBitmap(&Bitmap, uBitmapID); } } } break; case CMD_REVERSE: if(uParams == 1 && pParams->uType == PARAM_UINT32) { uBitmapID = pParams->uiValue; // is it a valid bitmap ID? nStatus = GetLocalBitmap(&Bitmap, uBitmapID); if(nStatus == SUCCESS) { nStatus = L_ReverseBitmap(&Bitmap); if(nStatus == SUCCESS) { L_InetSendBitmap(hComputer, &Bitmap, FILE_CMP, 0, QS, NULL); nStatus = UpdateLocalBitmap(&Bitmap, uBitmapID); } } } break; case CMD_90: case CMD_180: if(uParams == 4 && pParams[0].uType == PARAM_UINT32 && pParams[1].uType == PARAM_UINT32 && pParams[2].uType == PARAM_UINT32 && pParams[3].uType == PARAM_UINT32) { uBitmapID = pParams[0].uiValue; // is it a valid bitmap ID? nStatus = GetLocalBitmap(&Bitmap, uBitmapID); if(nStatus == SUCCESS) { nStatus = L_RotateBitmap(&Bitmap, pParams[1].uiValue, pParams[2].uiValue, pParams[3].uiValue); if(nStatus == SUCCESS) { cMessage = 'A'; uMsgSize = BITMAPWIDTH(&Bitmap); L_InetSendData(hComputer, &cMessage, &uMsgSize, IDATA_USER4); cMessage = 'B'; uMsgSize = BITMAPHEIGHT(&Bitmap); L_InetSendData(hComputer, &cMessage, &uMsgSize, IDATA_USER4); L_InetSendBitmap(hComputer, &Bitmap, FILE_CMP, 0, QS, NULL); nStatus = UpdateLocalBitmap(&Bitmap, uBitmapID); } hDC = GetDC(ghCreatedWin); SendMessage(ghCreatedWin, WM_ERASEBKGND, (WPARAM)hDC, (LPARAM)NULL); } } break; case CMD_SHEAR: if(uParams == 4 && pParams[0].uType == PARAM_UINT32 && pParams[1].uType == PARAM_UINT32 && pParams[2].uType == PARAM_UINT32 && pParams[3].uType == PARAM_UINT32) { uBitmapID = pParams[0].uiValue; // is it a valid bitmap ID? nStatus = GetLocalBitmap(&Bitmap, uBitmapID); if(nStatus == SUCCESS) { nStatus = L_ShearBitmap(&Bitmap, pParams[1].uiValue, pParams[2].uiValue, pParams[3].uiValue); if(nStatus == SUCCESS) { cMessage = 'A'; uMsgSize = BITMAPWIDTH(&Bitmap); L_InetSendData(hComputer, &cMessage, &uMsgSize, IDATA_USER4); cMessage = 'B'; uMsgSize = BITMAPHEIGHT(&Bitmap); L_InetSendData(hComputer, &cMessage, &uMsgSize, IDATA_USER4); L_InetSendBitmap(hComputer, &Bitmap, FILE_CMP, 0, QS, NULL); nStatus = UpdateLocalBitmap(&Bitmap, uBitmapID); } } } break; case CMD_RESIZE: if(uParams == 4 && pParams[0].uType == PARAM_UINT32 && pParams[1].uType == PARAM_INT32 && pParams[2].uType == PARAM_INT32 && pParams[3].uType == PARAM_UINT32) { uBitmapID = pParams[0].uiValue; // is it a valid bitmap ID? nStatus = GetLocalBitmap(&Bitmap, uBitmapID); if(nStatus == SUCCESS) { nStatus = L_SizeBitmap(&Bitmap, pParams[1].iValue, pParams[2].iValue, pParams[3].uiValue); if(nStatus == SUCCESS) { cMessage = 'A'; uMsgSize = BITMAPWIDTH(&Bitmap); L_InetSendData(hComputer, &cMessage, &uMsgSize, IDATA_USER4); cMessage = 'B'; uMsgSize = BITMAPHEIGHT(&Bitmap); L_InetSendData(hComputer, &cMessage, &uMsgSize, IDATA_USER4); L_InetSendBitmap(hComputer, &Bitmap, FILE_CMP, 0, QS, NULL); nStatus = UpdateLocalBitmap(&Bitmap, uBitmapID); hDC = GetDC(ghCreatedWin); SendMessage(ghCreatedWin, WM_ERASEBKGND, (WPARAM)hDC, (LPARAM)NULL); } } } break; case CMD_POSTERIZE: if(uParams == 2 && pParams[0].uType == PARAM_UINT32 && pParams[1].uType == PARAM_INT32) { uBitmapID = pParams[0].uiValue; // is it a valid bitmap ID? nStatus = GetLocalBitmap(&Bitmap, uBitmapID); if(nStatus == SUCCESS) { nStatus = L_PosterizeBitmap(&Bitmap, pParams[1].iValue); if(nStatus == SUCCESS) { L_InetSendBitmap(hComputer, &Bitmap, FILE_CMP, 0, QS, NULL); nStatus = UpdateLocalBitmap(&Bitmap, uBitmapID); } } } break; case CMD_NOISE: if(uParams == 3 && pParams[0].uType == PARAM_UINT32 && pParams[1].uType == PARAM_UINT32 && pParams[2].uType == PARAM_UINT32) { uBitmapID = pParams[0].uiValue; // is it a valid bitmap ID? nStatus = GetLocalBitmap(&Bitmap, uBitmapID); if(nStatus == SUCCESS) { nStatus = L_AddBitmapNoise(&Bitmap, pParams[1].uiValue, pParams[2].uiValue); if(nStatus == SUCCESS) { L_InetSendBitmap(hComputer, &Bitmap, FILE_CMP, 0, QS, NULL); nStatus = UpdateLocalBitmap(&Bitmap, uBitmapID); } } } break; case CMD_OILIFY: if(uParams == 2 && pParams[0].uType == PARAM_UINT32 && pParams[1].uType == PARAM_INT32) { uBitmapID = pParams[0].uiValue; // is it a valid bitmap ID? nStatus = GetLocalBitmap(&Bitmap, uBitmapID); if(nStatus == SUCCESS) { nStatus = L_OilifyBitmap(&Bitmap, pParams[1].iValue); if(nStatus == SUCCESS) { L_InetSendBitmap(hComputer, &Bitmap, FILE_CMP, 0, QS, NULL); nStatus = UpdateLocalBitmap(&Bitmap, uBitmapID); } } } break; case CMD_RESOLUTION: if(uParams == 9 && pParams[0].uType == PARAM_UINT32 && pParams[1].uType == PARAM_UINT32 && pParams[2].uType == PARAM_INT32 && pParams[3].uType == PARAM_UINT32 && pParams[4].uType == PARAM_INT32 && pParams[5].uType == PARAM_INT32 && pParams[6].uType == PARAM_UINT32 && pParams[7].uType == PARAM_INT32 && pParams[8].uType == PARAM_INT32) { uBitmapID = pParams[0].uiValue; // is it a valid bitmap ID? nStatus = GetLocalBitmap(&Bitmap, uBitmapID); if(nStatus == SUCCESS) { nStatus = L_ColorResBitmap(&Bitmap, &Bitmap, sizeof(BITMAPHANDLE),pParams[2].iValue, pParams[3].uiValue, (LPRGBQUAD)pParams[4].iValue, (HPALETTE)pParams[5].iValue, pParams[6].uiValue, (COLORRESCALLBACK)pParams[7].iValue, (L_VOID L_FAR *)pParams[8].iValue); if(nStatus == SUCCESS) { L_InetSendBitmap(hComputer, &Bitmap, FILE_CMP, 0, QS, NULL); nStatus = UpdateLocalBitmap(&Bitmap, uBitmapID); } } } break; case CMD_INVERT: if(uParams == 1 && pParams[0].uType == PARAM_UINT32) { uBitmapID = pParams[0].uiValue; // is it a valid bitmap ID? nStatus = GetLocalBitmap(&Bitmap, uBitmapID); if(nStatus == SUCCESS) { nStatus = L_InvertBitmap(&Bitmap); if(nStatus == SUCCESS) { L_InetSendBitmap(hComputer, &Bitmap, FILE_CMP, 0, QS, NULL); nStatus = UpdateLocalBitmap(&Bitmap, uBitmapID); } } } break; case CMD_CONTRAST: if(uParams == 2 && pParams[0].uType == PARAM_UINT32 && pParams[1].uType == PARAM_INT32) { uBitmapID = pParams[0].uiValue; // is it a valid bitmap ID? nStatus = GetLocalBitmap(&Bitmap, uBitmapID); if(nStatus == SUCCESS) { nStatus = L_ChangeBitmapContrast(&Bitmap, pParams[1].iValue); if(nStatus == SUCCESS) { L_InetSendBitmap(hComputer, &Bitmap, FILE_CMP, 0, QS, NULL); nStatus = UpdateLocalBitmap(&Bitmap, uBitmapID); } } } break; case CMD_SATURATION: if(uParams == 2 && pParams[0].uType == PARAM_UINT32 && pParams[1].uType == PARAM_INT32) { uBitmapID = pParams[0].uiValue; // is it a valid bitmap ID? nStatus = GetLocalBitmap(&Bitmap, uBitmapID); if(nStatus == SUCCESS) { nStatus = L_ChangeBitmapSaturation(&Bitmap, pParams[1].iValue); if(nStatus == SUCCESS) { L_InetSendBitmap(hComputer, &Bitmap, FILE_CMP, 0, QS, NULL); nStatus = UpdateLocalBitmap(&Bitmap, uBitmapID); } } } break; case CMD_GAMMA: if(uParams == 4 && pParams[0].uType == PARAM_UINT32 && pParams[1].uType == PARAM_UINT32 && pParams[2].uType == PARAM_UINT32 && pParams[3].uType == PARAM_UINT32 ) { uBitmapID = pParams[0].uiValue; // is it a valid bitmap ID? nStatus = GetLocalBitmap(&Bitmap, uBitmapID); if(nStatus == SUCCESS) { nStatus = GammaCorrect(&Bitmap, pParams[1].uiValue, pParams[2].uiValue, pParams[3].uiValue); if(nStatus == SUCCESS) { L_InetSendBitmap(hComputer, &Bitmap, FILE_CMP, 0, QS, NULL); nStatus = UpdateLocalBitmap(&Bitmap, uBitmapID); } } } break; case CMD_LOADPATH: if(!gbExistsPath) { cMessage = '2'; L_InetSendData(hComputer, &cMessage, &uMsgSize, IDATA_USER4); return FAILURE; } else if(uParams == 1 && pParams[0].uType == PARAM_INT32) { cMessage = '3'; L_InetSendData(hComputer, &cMessage, &uMsgSize, IDATA_USER4); LoadAndSend(1, hComputer); LoadAndSend(2, hComputer); cMessage = '4'; L_InetSendData(hComputer, &cMessage, &uMsgSize, IDATA_USER4); } break; case CMD_SAVE: if(uParams == 6 && pParams[0].uType == PARAM_STRING && pParams[1].uType == PARAM_UINT32 && pParams[2].uType == PARAM_INT32 && pParams[3].uType == PARAM_INT32 && pParams[4].uType == PARAM_INT32 && pParams[5].uType == PARAM_UINT32) { uBitmapID = pParams[1].uiValue; // is it a valid bitmap ID? nStatus = GetLocalBitmap(&Bitmap, uBitmapID); if(nStatus == SUCCESS) nStatus = L_SaveFile((L_TCHAR*)pParams[0].pValue, &Bitmap, pParams[2].iValue, pParams[3].iValue, pParams[4].iValue, pParams[5].uiValue, NULL, NULL, NULL); } else nStatus = ERROR_INV_PARAMETER; return L_InetSendSaveRsp(hComputer, uCommandID, 0, NULL, nStatus); case CMD_GET: if(uParams == 1 && pParams->uType == PARAM_UINT32) { L_UINT uBitmapID = pParams->uiValue; // is it a valid bitmap ID? nStatus = GetLocalBitmap(&Bitmap, uBitmapID); if(nStatus == SUCCESS) nStatus = L_InetSendBitmap(hComputer, &Bitmap, FILE_CMP, 0, QS, NULL); } break; case CMD_GET_LOW: if(uParams == 1 && pParams->uType == PARAM_UINT32) { L_UINT uBitmapID = pParams->uiValue; // is it a valid bitmap ID? nStatus = GetLocalBitmap(&Bitmap, uBitmapID); if(nStatus == SUCCESS) { cMessage = 'A'; uMsgSize = BITMAPWIDTH(&Bitmap); L_InetSendData(hComputer, &cMessage, &uMsgSize, IDATA_USER4); cMessage = 'B'; uMsgSize = BITMAPHEIGHT(&Bitmap); L_InetSendData(hComputer, &cMessage, &uMsgSize, IDATA_USER4); nStatus = L_InetSendBitmap(hComputer, &Bitmap, FILE_CMP, 0, QS, NULL); } } break; case CMD_GET_MAGGLASS_DATA: if(uParams == 5 && pParams[0].uType == PARAM_UINT32 && pParams[1].uType == PARAM_UINT32 && pParams[2].uType == PARAM_USTRING && pParams[3].uType == PARAM_INT32 && pParams[4].uType == PARAM_INT32) { uBitmapID = pParams[0].uiValue; // is it a valid bitmap ID? nStatus = GetLocalBitmap(&Bitmap, uBitmapID); if(nStatus == SUCCESS) { nStatus = L_InetGetMagGlassData(&Bitmap, &lColorSize, NULL, pParams[2].puValue, pParams[3].iValue, pParams[4].iValue); if(nStatus == SUCCESS) { pColor = GlobalAllocPtr(GHND, lColorSize); nStatus = L_InetGetMagGlassData(&Bitmap, &lColorSize, pColor, pParams[2].puValue, pParams[3].iValue, pParams[4].iValue); } } } else nStatus = ERROR_INV_PARAMETER; L_InetSendGetMagGlassDataRsp(hComputer, uCommandID, lColorSize, pColor, pParams[1].uiValue, pParams[2].puValue, pParams[3].iValue, pParams[4].iValue, 0, NULL, nStatus); if(pColor) { GlobalFreePtr(pColor); pColor=NULL; } break; } return L_InetSendRsp(hComputer, uCommand, uCommandID, NULL, nStatus); } L_VOID EXT_CALLBACK InetResponseCallback ( L_COMP hComputer, CMDTYPE uCommand, L_UINT uCommandID, L_INT nError, L_INT nStatus, L_UINT uParams, pPARAMETER pParams, L_UINT uExtra, L_CHAR L_FAR*pExtra, L_VOID L_FAR*pUserData ) { statusUpdate(TEXT("Response to Command %d, id=%d, nError=%d, uParams=%d, nStatus=%d%s received"), uCommand, uCommandID, nError, uParams, nStatus, uExtra ? ", uExtra" : ""); if(nError != SUCCESS) return; switch(uCommand) { case CMD_LOAD: if(nStatus == SUCCESS) { if(uParams == 1 && pParams->uType == PARAM_UINT32) AddRemoteBitmap(hComputer, pParams->uiValue); statusUpdate(TEXT("Load SUCCEEDED!")); } else statusUpdate(TEXT("Load failed with error code %d!"), nStatus); break; case CMD_SAVE: if(nStatus == SUCCESS) statusUpdate(TEXT("Save SUCCEEDED!")); else statusUpdate(TEXT("Save failed with error code %d!"), nStatus); break; case CMD_CREATE_WIN: if(nStatus == SUCCESS) { gbAttach = TRUE; gbWinCreated = TRUE; if(uParams == 1 && pParams->uType == PARAM_UINT32) AddRemoteWindow(hComputer, pParams->uiValue); statusUpdate(TEXT("Create window SUCCEEDED!")); } else statusUpdate(TEXT("Create Window failed with error code %d!"), nStatus); break; case CMD_CLOSE_WIN: gbAttach = FALSE; gbWinCreated = FALSE; break; case CMD_ATTACH_BITMAP: if(nStatus == SUCCESS) { gbAttach = FALSE; statusUpdate(TEXT("Attach bitmap SUCCEEDED!")); } else statusUpdate(TEXT("Attach bitmap failed with error code %d!"), nStatus); break; case CMD_GET_MAGGLASS_DATA: if(nStatus == SUCCESS) { HWND hWndChild = FORWARD_WM_MDIGETACTIVE(ghWndClient, SendMessage); pCHILDDATA pData = GETCHILDDATA(hWndChild); if(uParams == 6 && pParams[0].uType == PARAM_UINT32 && pParams[1].uType == PARAM_USTRING && pParams[2].uType == PARAM_UINT32 && pParams[3].uType == PARAM_USTRING && pParams[4].uType == PARAM_INT32 && pParams[5].uType == PARAM_INT32) nStatus = L_UpdateMagGlass(hWndChild, (COLORREF L_FAR *)pParams[1].puValue, pParams[3].puValue, pParams[4].iValue, pParams[5].iValue, TRUE); } break; } } static BOOL Child_OnCreate (HWND hWnd, CREATESTRUCT FAR * lpCreateStruct) { pCREATEDATA pCreateData; pCHILDDATA pData; pCreateData = (pCREATEDATA)(((LPMDICREATESTRUCT)lpCreateStruct->lpCreateParams)->lParam); if(pCreateData) { pData = GlobalAllocPtr(GHND, sizeof(CHILDDATA)); if(pData) { pData->hRemote = ghComputer; ghComputer = 0; if(pCreateData->pBitmap) { pData->Bitmap = *pCreateData->pBitmap; if(pCreateData->uFlags & CHILD_BITMAPIDVALID) { pData->uFlags |= CHILD_BITMAPIDVALID; pData->uBitmapID = pCreateData->uBitmapID; } // set rects for 1:1 zoom SetRect(&pData->rcDest, 0, 0, BITMAPWIDTH(&pData->Bitmap), BITMAPHEIGHT(&pData->Bitmap)); pData->rcDestClip = pData->rcDest; SetRect(&pData->rcSrc, 0, 0, pData->Bitmap.Width, pData->Bitmap.Height); pData->rcSrcClip = pData->rcSrc; //pData->hRemote = ghComputer; //ghComputer = 0; } SetWindowLong(hWnd, GWL_USERDATA, (L_UINT32)pData); FORWARD_WM_QUERYNEWPALETTE (hWnd, PostMessage); return TRUE; } memset(&pData->Bitmap,0,sizeof(pData->Bitmap)); } return FALSE; } /* Child window message handlers */ static VOID Child_OnPaint (HWND hWnd) { PAINTSTRUCT ps; HPALETTE hPalette; L_UINT32 ulFlags; RECT rcDestClip; pCHILDDATA pData = GETCHILDDATA(hWnd); BeginPaint(hWnd, &ps); if(pData->Bitmap.Flags.Allocated) { if(pData->hPalette) { hPalette = SelectPalette (ps.hdc, pData->hPalette, TRUE); RealizePalette(ps.hdc); } IntersectRect(&rcDestClip, &pData->rcDestClip, &ps.rcPaint); ulFlags = L_GetDisplayMode (); L_SetDisplayMode (DISPLAYMODE_ORDEREDDITHER, DISPLAYMODE_ORDEREDDITHER); L_SetDisplayMode(DISPLAYMODE_RESAMPLE|DISPLAYMODE_BICUBIC, DISPLAYMODE_BICUBIC); L_PaintDC(ps.hdc, &pData->Bitmap, &pData->rcSrc, &pData->rcSrcClip, &pData->rcDest, &rcDestClip, SRCCOPY); L_SetDisplayMode (DISPLAYMODE_RESETPOSITIONS, ulFlags); if (pData->hPalette) SelectPalette (ps.hdc, hPalette, TRUE); } EndPaint(hWnd, &ps); } static VOID Child_OnDestroy (HWND hWnd) { pCHILDDATA pData = GETCHILDDATA(hWnd); L_CHAR cMessage = '5'; L_UINT uMsgSize = 1; // do not delete bitmaps that have an ID because they get deleted when // the bitmap list is destroyed if(pData->lpfn) FreeProcInstance(pData->lpfn); L_StopMagGlass(hWnd); gbMAG = FALSE; pData->lpfn = NULL; if(pData->hPalette) DeleteObject(pData->hPalette); ghCreatedWin = NULL; if(pData->hRemote != 0) L_InetSendData(pData->hRemote, &cMessage, &uMsgSize, IDATA_USER4); GlobalFreePtr(pData); pData=NULL; } static VOID Child_OnPaletteChanged (HWND hWnd, HWND hWndPaletteChange) { HDC hDC; HPALETTE hOldPalette; pCHILDDATA pData = GETCHILDDATA(hWnd); if (hWnd == hWndPaletteChange) return; if (pData->hPalette) { DeleteObject (pData->hPalette); pData->hPalette = NULL; } hDC = GetDC (hWnd); pData->hPalette = L_CreatePaintPalette (hDC, &pData->Bitmap); hOldPalette = SelectPalette (hDC, pData->hPalette, TRUE); RealizePalette (hDC); InvalidateRect (hWnd, 0, FALSE); SelectPalette (hDC, hOldPalette, TRUE); ReleaseDC (hWnd, hDC); } static BOOL Child_OnQueryNewPalette (HWND hWnd) { HDC hDC; HPALETTE hOldPalette; L_INT nNoColors = 0; pCHILDDATA pData = GETCHILDDATA(hWnd); if (pData->hPalette) { DeleteObject (pData->hPalette); pData->hPalette = NULL; } if (pData->Bitmap.Flags.Allocated) { hDC = GetDC (hWnd); pData->hPalette = L_CreatePaintPalette (hDC, &pData->Bitmap); if(pData->hPalette) { hOldPalette = SelectPalette (hDC, pData->hPalette, FALSE); nNoColors = RealizePalette (hDC); if (nNoColors) InvalidateRect (hWnd, NULL, FALSE); SelectPalette (hDC, hOldPalette, TRUE); } ReleaseDC (hWnd, hDC); } return(nNoColors); } /*====(Child_OnMDIActivate)================================================ Description: Informs the child window it is going to receive the focus. Syntax : VOID Child_OnMDIActivate(HWND hWnd, BOOL fActive, HWND hWndActivate, HWND hWndDeactivate) Parameters : hWnd Handle of a window. fActive Truth of "Is the window active". hWndActivate Handle to the window to be activated. hWndDeactivate Handle to the window to be deactivated. Return Value: None. ==========================================================================*/ static VOID Child_OnMDIActivate (HWND hWnd, BOOL fActive, HWND hWndActivate, HWND hWndDeactivate) { if(fActive) { Child_OnQueryNewPalette(hWnd); } } static VOID Child_ProcessSize (HWND hWnd, int cx, int cy) { pCHILDDATA pData; static BOOL bSizeInUse = FALSE; int nWidth, nHeight, nVScroll, nHScroll; DWORD dwStyle; SCROLLINFO si; if(bSizeInUse) return; pData = GETCHILDDATA(hWnd); if(!pData || !pData->Bitmap.Flags.Allocated) return; bSizeInUse = TRUE; nWidth = BITMAPWIDTH(&pData->Bitmap); nHeight = BITMAPHEIGHT(&pData->Bitmap); pData->cxClient = cx; pData->cyClient = cy; dwStyle = GetWindowLong (hWnd, GWL_STYLE); nVScroll = GetSystemMetrics (SM_CXVSCROLL) - GetSystemMetrics(SM_CXBORDER); nHScroll = GetSystemMetrics (SM_CYHSCROLL) - GetSystemMetrics(SM_CYBORDER); if (WS_VSCROLL & dwStyle) pData->cxClient += nVScroll; if (WS_HSCROLL & dwStyle) pData->cyClient += nHScroll; if (pData->cxClient < nWidth) { pData->cyClient -= nHScroll; if (pData->cyClient < nHeight) pData->cxClient -= nVScroll; } else if (pData->cyClient < nHeight) { pData->cxClient -= nVScroll; if (pData->cxClient < nWidth) pData->cyClient -= nHScroll; } pData->nHScrollStep = max (1, pData->cxClient / SCROLL_RATIO); pData->nVScrollStep = max (1, pData->cyClient / SCROLL_RATIO); pData->nVScrollMax = max (0, (nHeight - pData->cyClient /*- 1*/)); pData->nVScrollPos = max (0, min (pData->nVScrollPos, pData->nVScrollMax)); pData->nHScrollMax = max (0, (nWidth - pData->cxClient /*- 1*/)); pData->nHScrollPos = max (0, min (pData->nHScrollPos, pData->nHScrollMax)); SetRect (&pData->rcDest, 0, 0, nWidth, nHeight); OffsetRect (&pData->rcDest, -pData->nHScrollPos, -pData->nVScrollPos); pData->rcDestClip = pData->rcDest; if(gbMAG) L_UpdateMagGlassRect(hWnd, &pData->rcDestClip); si.cbSize = sizeof(si); si.fMask = SIF_ALL; si.nPage = max (pData->nHScrollStep, (pData->cxClient - pData->nHScrollStep)); si.nMin = 0; si.nMax = pData->nHScrollMax + si.nPage - 1; si.nPos = pData->nHScrollPos; SetScrollInfo (hWnd, SB_HORZ, &si, TRUE); si.nPage = max (pData->nVScrollStep, (pData->cyClient - pData->nVScrollStep)); si.nMin = 0; si.nMax = pData->nVScrollMax + si.nPage - 1; si.nPos = pData->nVScrollPos; SetScrollInfo (hWnd, SB_VERT, &si, TRUE); bSizeInUse = FALSE; //pData->hRemote = ghComputer; //ghComputer = 0; } static VOID Child_OnSize (HWND hWnd, UINT nState, int cx, int cy) { if(nState != SIZE_MINIMIZED) Child_ProcessSize(hWnd, cx, cy); FORWARD_WM_SIZE(hWnd,nState,cx,cy,DefMDIChildProc); InvalidateRect (hWnd, NULL, FALSE); } static VOID Child_OnHScroll (HWND hWnd, HWND hWndCtl, UINT nCode, int nPos) { L_INT nScrollInc; pCHILDDATA pData; UNREFERENCED_PARAMETER(hWndCtl); gbInScroll = TRUE; pData = GETCHILDDATA (hWnd); switch (nCode) { case SB_BOTTOM: nScrollInc = pData->nHScrollMax - pData->nHScrollPos; break; case SB_TOP: nScrollInc = -pData->nHScrollPos; break; case SB_LINEDOWN: nScrollInc = pData->nHScrollStep; break; case SB_LINEUP: nScrollInc = -pData->nHScrollStep; break; case SB_PAGEDOWN: nScrollInc = max (pData->nHScrollStep, (pData->cxClient - pData->nHScrollStep)); break; case SB_PAGEUP: nScrollInc = -max (pData->nHScrollStep, (pData->cxClient - pData->nHScrollStep)); break; case SB_THUMBTRACK: case SB_THUMBPOSITION: nScrollInc = nPos - pData->nHScrollPos; break; default: nScrollInc = 0; break; } nScrollInc = max (-pData->nHScrollPos, min (nScrollInc, (pData->nHScrollMax - pData->nHScrollPos))); if(nScrollInc) { pData->nHScrollPos += nScrollInc; OffsetRect (&pData->rcDest, -nScrollInc, 0); OffsetRect (&pData->rcDestClip, -nScrollInc, 0); ScrollWindow (hWnd, -nScrollInc, 0, NULL, NULL); SetScrollPos (hWnd, SB_HORZ, pData->nHScrollPos, TRUE); UpdateWindow (hWnd); if(gbMAG) L_UpdateMagGlassRect(hWnd, &pData->rcDestClip); } gbInScroll = FALSE; } static VOID Child_OnVScroll (HWND hWnd, HWND hWndCtl, UINT nCode, int nPos) { L_INT nScrollInc; pCHILDDATA pData; UNREFERENCED_PARAMETER(hWndCtl); gbInScroll = TRUE; pData = GETCHILDDATA (hWnd); switch (nCode) { case SB_BOTTOM: nScrollInc = pData->nVScrollMax - pData->nVScrollPos; break; case SB_TOP: nScrollInc = -pData->nVScrollPos; break; case SB_LINEDOWN: nScrollInc = pData->nVScrollStep; break; case SB_LINEUP: nScrollInc = -pData->nVScrollStep; break; case SB_PAGEDOWN: nScrollInc = max (pData->nVScrollStep, (pData->cyClient - pData->nVScrollStep)); break; case SB_PAGEUP: nScrollInc = -max (pData->nVScrollStep, (pData->cyClient - pData->nVScrollStep)); break; case SB_THUMBTRACK: case SB_THUMBPOSITION: nScrollInc = nPos - pData->nVScrollPos; break; default: nScrollInc = 0; break; } nScrollInc = max (-pData->nVScrollPos, min (nScrollInc, (pData->nVScrollMax - pData->nVScrollPos))); if(nScrollInc) { pData->nVScrollPos += nScrollInc; OffsetRect (&pData->rcDest, 0, -nScrollInc); OffsetRect (&pData->rcDestClip, 0, -nScrollInc); ScrollWindow (hWnd, 0, -nScrollInc, NULL, NULL); SetScrollPos (hWnd, SB_VERT, pData->nVScrollPos, TRUE); UpdateWindow (hWnd); if(gbMAG) L_UpdateMagGlassRect(hWnd, &pData->rcDestClip); } gbInScroll = FALSE; } //////////////////////////////////////////////////////////////////////// // // ChildWndProc: Application Child Window Procedure // // hWnd: Application main window handle // Message: Next message to be processed // wParam: WORD param for the message // lParam: LONG param for the message //////////////////////////////////////////////////////////////////////// LONG FAR PASCAL ChildWndProc(HWND hWnd, UINT Message, UINT wParam, LONG lParam) { switch(Message) { HANDLE_MSG (hWnd, WM_SIZE, Child_OnSize); HANDLE_MSG (hWnd, WM_CREATE, Child_OnCreate); HANDLE_MSG (hWnd, WM_PAINT, Child_OnPaint); HANDLE_MSG (hWnd, WM_DESTROY, Child_OnDestroy); HANDLE_MSG (hWnd, WM_PALETTECHANGED, Child_OnPaletteChanged); HANDLE_MSG (hWnd, WM_QUERYNEWPALETTE, Child_OnQueryNewPalette); HANDLE_MSG (hWnd, WM_MDIACTIVATE, Child_OnMDIActivate); HANDLE_MSG (hWnd, WM_VSCROLL, Child_OnVScroll); HANDLE_MSG (hWnd, WM_HSCROLL, Child_OnHScroll); } return(DefMDIChildProc (hWnd, Message, wParam, lParam)); } L_VOID LoadAndSend(L_INT nType, L_COMP hComputer) { // variables related to searching files HLOCAL InfoHandle; L_INT32 filehandle; FIND_STRUCT *pInfo; L_TCHAR szImageName[L_MAXPATH]; BITMAPHANDLE Bitmap; L_UINT32 uNameLength = sizeof(szImageName); /* allocate the local memory */ if(!(InfoHandle = LocalAlloc(LMEM_MOVEABLE, sizeof(FIND_STRUCT)))) return; if(!(pInfo = (FIND_STRUCT*)LocalLock(InfoHandle))) { LocalFree(InfoHandle); return; } // initialize the directory related variables PrepareDirectory(szImageName, TEXT("*.*")); if((filehandle = _tfindfirst(szImageName, pInfo)) == -1) { LocalFree(InfoHandle); return; } do { // Prepare image file name memset(szImageName, 0, sizeof ( szImageName ) ); PrepareDirectory(szImageName, pInfo->name); if(L_LoadBitmap(szImageName, &Bitmap, sizeof(BITMAPHANDLE),24, ORDER_RGB, NULL, NULL) == SUCCESS) { uNameLength = (lstrlen(szImageName)+1) * sizeof(L_TCHAR); if(nType == 1) L_InetSendData(hComputer, (L_CHAR*) szImageName, &uNameLength, IDATA_USER3); else L_InetSendBitmap(hComputer, &Bitmap, FILE_CMP, 0, QS, NULL); L_FreeBitmap(&Bitmap); } } while(FINDNEXT(filehandle, pInfo) != -1); FINDCLOSE(filehandle); LocalUnlock(InfoHandle); LocalFree(InfoHandle); } void PrepareDirectory(L_TCHAR L_FAR *pszDirName, L_TCHAR L_FAR *pszInit) { lstrcpy(pszDirName, gszImageDir); pszDirName += lstrlen(pszDirName) - 1; if(*pszDirName != '\\' && *pszDirName != ':') { pszDirName[1] = '\\'; pszDirName[2] = 0; } lstrcat(pszDirName, pszInit); } L_VOID AddImage(pBITMAPHANDLE pBitmap) { LILITEM Item; memset(&Item, 0, sizeof(Item)); Item.uStructSize = sizeof(LILITEM); Item.uMask = LILITEM_BITMAP | LILITEM_TEXT | LILITEM_DATA | LILITEM_SELECTED; Item.pBitmap = pBitmap; Item.uBitmapStructSize = sizeof(BITMAPHANDLE); Item.pText = (L_TCHAR L_FAR *)(LPCTSTR)gnImageNameList[L_ImgListGetItemCount(hCtl)]; Item.lData = 1; Item.bSelected = FALSE; if(L_ImgListInsert(hCtl, &Item) != SUCCESS) ListBox_DeleteString(GetDlgItem(ghImageListDlg, IDC_HIDDENLIST), SendMessage(hCtl, L_ILM_GETITEMCOUNT, 0, 0L) - 1); else L_ImgListEnsureVisible(hCtl, L_ImgListGetItemCount(hCtl) - 1); } L_INT EXT_CALLBACK MagGlassCallback(HWND hWnd, L_INT nMaskPlaneStart, L_INT nMaskPlaneEnd, L_UCHAR L_FAR *pMaskPlane, L_INT nMaskPlaneSize, L_VOID L_FAR *pUserData) { L_INT nRet; L_COMP hComputer; L_UINT uBitmapID; pCHILDDATA pData = (pCHILDDATA)pUserData; if(!pData) return FAILURE; hComputer = GetRemoteComputer(); if(hComputer != SOCKET_ERROR && GetRemoteBitmap(hComputer, &uBitmapID)) { nRet = L_InetSendGetMagGlassDataCmd(hComputer, guCommandID++, uBitmapID, nMaskPlaneSize, pMaskPlane, nMaskPlaneStart, nMaskPlaneEnd); if(nRet != SUCCESS && nRet != ERROR_DATA_QUEUED) statusUpdate(TEXT("ERROR %d calling L_InetSendGetMagGlassDataCmd"), nRet); } return nRet; } L_INT GammaCorrect(pBITMAPHANDLE pBitmap, L_UINT uRed, L_UINT uGreen, L_UINT uBlue) { L_INT nReturn=FAILURE; BITMAPHANDLE ColorPlanes [ 3 ] ; pBITMAPHANDLE pColorPlanes [ 3 ] ; pColorPlanes [ 0 ] = &ColorPlanes [ 0 ] ; pColorPlanes [ 1 ] = &ColorPlanes [ 1 ] ; pColorPlanes [ 2 ] = &ColorPlanes [ 2 ] ; ZeroMemory(pColorPlanes [ 0 ],sizeof(BITMAPHANDLE)); ZeroMemory(pColorPlanes [ 1 ],sizeof(BITMAPHANDLE)); ZeroMemory(pColorPlanes [ 2 ],sizeof(BITMAPHANDLE)); pColorPlanes [ 0 ]->uStructSize = sizeof(BITMAPHANDLE); pColorPlanes [ 1 ]->uStructSize = sizeof(BITMAPHANDLE); pColorPlanes [ 2 ]->uStructSize = sizeof(BITMAPHANDLE); if ( SUCCESS == L_ColorSeparateBitmap ( pBitmap, pColorPlanes, sizeof ( BITMAPHANDLE ), COLORSEP_RGB ) ) { nReturn=L_GammaCorrectBitmap ( pColorPlanes [ 0 ], uBlue ); nReturn=L_GammaCorrectBitmap ( pColorPlanes [ 1 ], uGreen ); nReturn=L_GammaCorrectBitmap ( pColorPlanes [ 2 ], uRed ); L_ColorMergeBitmap ( pBitmap, pColorPlanes, sizeof ( BITMAPHANDLE ), COLORSEP_RGB ) ; } if ( pColorPlanes [ 0 ]->Flags.Allocated ) { L_FreeBitmap ( pColorPlanes [ 0 ] ) ; } if ( pColorPlanes [ 1 ]->Flags.Allocated ) { L_FreeBitmap ( pColorPlanes [ 1 ] ) ; } if ( pColorPlanes [ 2 ]->Flags.Allocated ) { L_FreeBitmap ( pColorPlanes [ 2 ] ) ; } return nReturn ; }