// INCLUSION PREVENTION DEFINITIONS #define NOMETAFILE #define NOMINMAX #define NOSOUND #define NOPROFILER #define NODEFERWINDOWPOS #define NODRIVERS #define NOCOMM #define NOBITMAP #define NOSCROLL #define NOWINOFFSETS #define NOWH #define NORASTEROPS #define NOOEMRESOURCE #define NOGDICAPMASKS #define NOKEYSTATES #define NOSYSCOMMANDS #define NOATOM #define NOLOGERROR #define NOSYSTEMPARAMSINFO // WINDOWS includes #include #include #ifdef RLWIN16 //#include #endif #include #include // CRT includes #include #include // RL TOOLS SET includes #include "windefs.h" #include "toklist.h" #include "RESTOK.H" #include "RLEDIT.H" #include "update.h" #include "custres.h" #include "exe2res.h" #include "exeNTres.h" #include "commbase.h" #include "wincomon.h" #include "resread.h" #include "projdata.h" #include "showerrs.h" #include "resource.h" // Global Variables: static CHAR * gszHelpFile = "rltools.hlp"; extern MSTRDATA gMstr; extern PROJDATA gProj; extern BOOL bRLGui; #ifdef RLWIN32 HINSTANCE hInst; /* Instance of the main window */ #else HWND hInst; /* Instance of the main window */ #endif int nUpdateMode = 0; BOOL fCodePageGiven = FALSE; //... Set to TRUE if -p arg given HWND hMainWnd; // handle to main window HWND hListWnd; // handle to tok list window HWND hStatusWnd; // handle to status windows CHAR szFileTitle[MAXFILENAME] = ""; // holds base name of latest opened file CHAR szCustFilterSpec[MAXCUSTFILTER] = ""; extern CHAR szDHW[]; //... used in debug strings extern BOOL fInThirdPartyEditer; extern BOOL gfReplace; static TCHAR szSearchType[80] = TEXT(""); static TCHAR szSearchText[4096] = TEXT(""); static WORD wSearchStatus = 0; static WORD wSearchStatusMask = 0; static BOOL fSearchDirection; static BOOL fSearchStarted = FALSE; #ifndef UNICODE BOOL PASCAL _loadds WatchTask(WORD wID, DWORD dwData); #endif #ifdef RLWIN16 static FARPROC lpfnWatchTask = NULL; #endif static void CleanDeltaList(void); static int ExecResEditor(HWND, CHAR *, CHAR *, CHAR *); static void DrawLBItem(LPDRAWITEMSTRUCT lpdis); static void SetNames( HWND hDlg, int iLastBox, LPSTR szNewFile); // File IO vars static OPENFILENAMEA ofn; static CHAR szFilterSpec [60] = ""; static CHAR szPRJFilterSpec [60] = ""; static CHAR szResFilterSpec [60] = ""; static CHAR szExeFilterSpec [60] = ""; static CHAR szDllFilterSpec [60] = ""; static CHAR szExeResFilterSpec [180] = ""; static CHAR szTokFilterSpec [60] = ""; static CHAR szMPJFilterSpec [60] = ""; static CHAR szGlossFilterSpec[60] = ""; static CHAR szTempFileName[MAXFILENAME] = ""; static CHAR szFileName[MAXFILENAME] = ""; // holds full name of latest opened file static TCHAR szString[256] = TEXT(""); // variable to load resource strings static TCHAR tszAppName[100] = TEXT(""); static CHAR szAppName[100] = ""; static TCHAR szClassName[]=TEXT("RLEditClass"); static TCHAR szStatusClass[]=TEXT("RLEditStatus"); static BOOL gbNewProject = FALSE; // indicates to prompt for auto translate static BOOL fTokChanges = FALSE; // set to true when toke file is out of date static BOOL fTokFile = FALSE; static BOOL fEditing = FALSE; static BOOL fPrjChanges = FALSE; static BOOL fMPJOutOfDate = FALSE; static BOOL fPRJOutOfDate = FALSE; static CHAR szOpenDlgTitle[80] = ""; // title of File open dialog static CHAR szSaveDlgTitle[80] = ""; // title of File saveas dialog // linked list of token deta info static TOKENDELTAINFO FAR *pTokenDeltaInfo = NULL; static LONG lFilePointer[30]= {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}; // circular doubly linked list of translations static TRANSLIST *pTransList = NULL; // Window vars static BOOL fWatchEditor; static CHAR szTempRes[MAXFILENAME] = ""; // temp file for resource editor // set true if a resource editer has been launched static HCURSOR hHourGlass; /* handle to hourglass cursor */ static HCURSOR hSaveCursor; /* current cursor handle */ static HACCEL hAccTable; static RECT Rect; /* dimension of the client window */ static int cyChildHeight; /* height of status windows */ // NOTIMPLEMENTED is a macro that displays a "Not implemented" dialog #define NOTIMPLEMENTED {TCHAR sz[80];\ LoadString( hInst, \ IDS_NOT_IMPLEMENTED, \ sz, TCHARSIN( sizeof(sz)));\ MessageBox(hMainWnd, sz, tszAppName, \ MB_ICONEXCLAMATION | MB_OK);} // Edit Tok Dialog #ifndef RLWIN32 //static DLGPROC lpTokEditDlg; #endif static HWND hTokEditDlgWnd = 0; /** * * * Function: InitApplication * Regsiters the main window, which is a list box composed of tokens * read from the token file. Also register the status window. * * * Arguments: * hInstance, instance handle of program in memory. * * Returns: * * Errors Codes: * TRUE, windows registered correctly. * FALSE, error during register of one of the windows. * * History: * 9/91, Implemented. TerryRu * * **/ BOOL InitApplication(HINSTANCE hInstance) { WNDCLASS wc; CHAR sz[60] = ""; CHAR sztFilterSpec[120] = ""; LoadStrIntoAnsiBuf(hInstance, IDS_PRJSPEC, sz, sizeof(sz)); szFilterSpecFromSz1Sz2(szFilterSpec, sz, "*.PRJ"); szFilterSpecFromSz1Sz2(szPRJFilterSpec, sz, "*.PRJ"); LoadStrIntoAnsiBuf(hInstance, IDS_RESSPEC, sz, sizeof(sz)); szFilterSpecFromSz1Sz2(szResFilterSpec, sz, "*.RES"); LoadStrIntoAnsiBuf(hInstance, IDS_EXESPEC, sz, sizeof(sz)); szFilterSpecFromSz1Sz2(szExeFilterSpec, sz, "*.EXE"); LoadStrIntoAnsiBuf(hInstance, IDS_DLLSPEC, sz, sizeof(sz)); szFilterSpecFromSz1Sz2(szDllFilterSpec, sz, "*.DLL"); CatSzFilterSpecs(sztFilterSpec, szExeFilterSpec, szDllFilterSpec); CatSzFilterSpecs(szExeResFilterSpec, sztFilterSpec, szResFilterSpec); LoadStrIntoAnsiBuf(hInstance, IDS_TOKSPEC, sz, sizeof(sz)); szFilterSpecFromSz1Sz2(szTokFilterSpec, sz, "*.TOK"); LoadStrIntoAnsiBuf(hInstance, IDS_MPJSPEC, sz, sizeof(sz)); szFilterSpecFromSz1Sz2(szMPJFilterSpec, sz, "*.MPJ"); LoadStrIntoAnsiBuf(hInstance, IDS_GLOSSSPEC, sz, sizeof(sz)); szFilterSpecFromSz1Sz2(szGlossFilterSpec, sz, "*.TXT"); LoadStrIntoAnsiBuf(hInstance, IDS_OPENTITLE, szOpenDlgTitle, sizeof(szOpenDlgTitle)); LoadStrIntoAnsiBuf(hInstance, IDS_SAVETITLE, szSaveDlgTitle, sizeof(szSaveDlgTitle)); wc.style = 0; wc.lpfnWndProc = StatusWndProc; wc.cbClsExtra = 0; wc.cbWndExtra = 0; wc.hInstance = hInstance; wc.hIcon = LoadIcon((HINSTANCE) NULL, IDI_APPLICATION); wc.hCursor = LoadCursor((HINSTANCE) NULL, IDC_ARROW); wc.hbrBackground = (HBRUSH)GetStockObject(LTGRAY_BRUSH); wc.lpszMenuName = NULL; wc.lpszClassName = szStatusClass; if (! RegisterClass((CONST WNDCLASS *)&wc)) { return (FALSE); } wc.style = 0; wc.lpfnWndProc = MainWndProc; wc.cbClsExtra = 0; wc.cbWndExtra = 0; wc.hInstance = hInstance; wc.hIcon = LoadIcon(hInstance, TEXT("RLEditIcon")); wc.hCursor = LoadCursor((HINSTANCE) NULL, IDC_ARROW); wc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH); wc.lpszMenuName = TEXT("RLEdit"); wc.lpszClassName = szClassName; if (!RegisterClass((CONST WNDCLASS *)&wc)) { return (FALSE); } // Windows register return sucessfully return (TRUE); } /** * * * Function: InitInstance * Creates the main, and status windows for the program. * The status window is sized according to the main window * size. InitInstance also loads the acclerator table, and prepares * the global openfilename structure for later use. * * * Errors Codes: * TRUE, windows created correctly. * FALSE, error on create windows calls. * * History: * 9/11, Implemented TerryRu * * **/ BOOL InitInstance(HINSTANCE hInstance, int nCmdShow) { RECT Rect = { 0,0,0,0}; hAccTable = LoadAccelerators(hInst, TEXT("RLEdit")); hMainWnd = CreateWindow(szClassName, tszAppName, WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, (HWND) NULL, (HMENU) NULL, hInstance, (LPVOID) NULL); if (!hMainWnd) { // clean up after errors. return ( FALSE); } DragAcceptFiles(hMainWnd, TRUE); GetClientRect(hMainWnd, (LPRECT) &Rect); // Create a child list box window hListWnd = CreateWindow(TEXT("LISTBOX"), NULL, WS_CHILD | LBS_WANTKEYBOARDINPUT | LBS_NOTIFY | LBS_NOINTEGRALHEIGHT | LBS_OWNERDRAWFIXED | WS_VSCROLL | WS_HSCROLL | WS_BORDER, 0, 0, (Rect.right-Rect.left), (Rect.bottom-Rect.top), hMainWnd, (HMENU)IDC_LIST, // Child control i.d. hInstance, NULL); if (!hListWnd) { // clean up after errors. DeleteObject((HGDIOBJ)hMainWnd); return ( FALSE); } // Creat a child status window hStatusWnd = CreateWindow(szStatusClass, NULL, WS_CHILD | WS_BORDER | WS_VISIBLE, 0, 0, 0, 0, hMainWnd, NULL, hInstance, NULL); if (! hStatusWnd) { // clean up after errors. DeleteObject((HGDIOBJ)hListWnd); DeleteObject((HGDIOBJ)hMainWnd); return ( FALSE); } hHourGlass = LoadCursor((HINSTANCE) NULL, IDC_WAIT); // Fill in non-variant fields of OPENFILENAMEA struct. ofn.lStructSize = sizeof( OPENFILENAMEA); ofn.hwndOwner = hMainWnd; ofn.lpstrFilter = szFilterSpec; ofn.lpstrCustomFilter = szCustFilterSpec; ofn.nMaxCustFilter = MAXCUSTFILTER; ofn.nFilterIndex = 1; ofn.lpstrFile = szFileName; ofn.nMaxFile = sizeof( szFileName); ofn.lpstrInitialDir = NULL; ofn.lpstrFileTitle = szFileTitle; ofn.nMaxFileTitle = sizeof( szFileTitle); ofn.lpstrTitle = NULL; ofn.lpstrDefExt = "PRJ"; ofn.Flags = 0; ShowWindow(hMainWnd, nCmdShow); UpdateWindow(hMainWnd); return ( TRUE); } /** * * * Function: WinMain * Calls the intialization functions, to register, and create the * application windows. Once the windows are created, the program * enters the GetMessage loop. * * * Arguements: * hInstace, handle for this instance * hPrevInstanc, handle for possible previous instances * lpszCmdLine, LONG pointer to exec command line. * nCmdShow, code for main window display. * * * Errors Codes: * IDS_ERR_REGISTER_CLASS, error on windows register * IDS_ERR_CREATE_WINDOW, error on create windows * otherwise, status of last command. * * History: * * **/ INT WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpszCmdLine, int nCmdShow) { MSG msg; HWND FirstWnd = NULL; HWND FirstChildWnd = NULL; WORD wRC = SUCCESS; bRLGui = TRUE; //... used in rlcommon.lib if (FirstWnd = FindWindow(szClassName, NULL)) { // checking for previous instance FirstChildWnd = GetLastActivePopup(FirstWnd); BringWindowToTop(FirstWnd); ShowWindow(FirstWnd, SW_SHOWNORMAL); if (FirstWnd != FirstChildWnd) { BringWindowToTop(FirstChildWnd); } return (FALSE); } hInst = hInstance; GetModuleFileNameA( hInst, szDHW, DHWSIZE); GetInternalName( szDHW, szAppName, sizeof( szAppName)); szFileName[0] = '\0'; lFilePointer[0] = (LONG)-1; #ifdef UNICODE _MBSTOWCS( tszAppName, szAppName, WCHARSIN( sizeof( tszAppName)), ACHARSIN( strlen( szAppName) + 1)); #else strcpy( tszAppName, szAppName); #endif // register window classes if first instance of application if ( ! hPrevInstance ) { if ( ! InitApplication( hInstance) ) { /* Registering one of the windows failed */ LoadString( hInst, IDS_ERR_REGISTER_CLASS, szString, TCHARSIN( sizeof( szString))); MessageBox( NULL, szString, NULL, MB_ICONEXCLAMATION); return IDS_ERR_REGISTER_CLASS; } } // Create windows for this instance of application if ( ! InitInstance(hInstance, nCmdShow) ) { LoadString( hInst, IDS_ERR_CREATE_WINDOW, szString, TCHARSIN( sizeof(szString))); MessageBox( NULL, szString, NULL, MB_ICONEXCLAMATION); return IDS_ERR_CREATE_WINDOW; } // Main Message Loop while ( GetMessage( &msg, NULL, 0, 0) ) { if ( hTokEditDlgWnd ) { if ( IsDialogMessage( hTokEditDlgWnd, &msg)) { continue; } } if ( TranslateAccelerator( hMainWnd, hAccTable, &msg) ) { continue; } TranslateMessage( (CONST MSG *)&msg); DispatchMessage( (CONST MSG *)&msg); } return (INT)msg.wParam; } /** * Function: MainWndProc * Process the windows messages for the main window of the application. * All user inputs go through this window procedure. * See cases in the switch table for a description of each message type. * * * Arguments: * * Returns: * * Errors Codes: * * History: * **/ INT_PTR APIENTRY MainWndProc( HWND hWnd, UINT wMsg, WPARAM wParam, LPARAM lParam) { // if it's a list box message process it in DoListBoxCommand if ( fInThirdPartyEditer ) { //... only process messages sent by the editor switch (wMsg) { case WM_EDITER_CLOSED: { CHAR szDlgToks[MAXFILENAME] = ""; static WORD wSavedIndex; #ifdef RLWIN16 NotifyUnRegister( NULL); FreeProcInstance( lpfnWatchTask); #endif ShowWindow(hWnd, SW_SHOW); { TCHAR tsz[80] = TEXT(""); LoadString( hInst, IDS_REBUILD_TOKENS, tsz, TCHARSIN( sizeof(tsz))); if ( MessageBox( hWnd, tsz, tszAppName, MB_ICONQUESTION | MB_YESNO) == IDYES) { HCURSOR hOldCursor; BOOL bUpdated = FALSE; hOldCursor = SetCursor(hHourGlass); LoadCustResDescriptions(gMstr.szRdfs); // szTempRes returned from resource editor MyGetTempFileName(0, "TOK", 0, szDlgToks); GenerateTokFile(szDlgToks, szTempRes, &bUpdated, 0); InsDlgToks(gProj.szTok, szDlgToks, ID_RT_DIALOG); remove(szDlgToks); ClearResourceDescriptions(); // gProj.szTok, now contains the latest tokens SetCursor(hOldCursor); //Rledit doesn't save when changed tokens by Dialog Editor. fTokChanges = TRUE; } } fInThirdPartyEditer = FALSE; remove(szTempRes); // UNDONE - delete all temp files with the same root in case // the editor created additional files like DLGs and RCs. // (DLGEDIT does this.) // For now I'm just going to tack a .DLG // at the end of the file name // and delete it. { int i; for (i = strlen(szTempRes); i > 0 && szTempRes[i]!='.'; i--) { } if (szTempRes[i] == '.') { szTempRes[++i]='D'; szTempRes[++i]='L'; szTempRes[++i]='G'; szTempRes[++i]='\0'; remove(szTempRes); } } wSavedIndex = (UINT)SendMessage( hListWnd, LB_GETCURSEL, (WPARAM)0, (LPARAM)0); SendMessage( hWnd, WM_LOADTOKENS, (WPARAM)0, (LPARAM)0); SendMessage( hListWnd, LB_SETCURSEL, (WPARAM)wSavedIndex, (LPARAM)0); } return ( DefWindowProc( hWnd, wMsg, wParam, lParam)); } } // Not a third party edit command. DoListBoxCommand (hWnd, wMsg, wParam, lParam); switch (wMsg) { case WM_DROPFILES: { CHAR sz[MAXFILENAME] = ""; DragQueryFileA( (HDROP) wParam, 0, sz, MAXFILENAME); if ( SendMessage( hWnd, WM_SAVEPROJECT, (WPARAM)0, (LPARAM)0)) { GetProjectData( sz, NULL, NULL, FALSE, FALSE); } DragFinish( (HDROP) wParam); return ( TRUE); } case WM_COMMAND: if (DoMenuCommand(hWnd, wMsg, wParam, lParam)) { return TRUE; } break; case WM_CLOSE: SendMessage( hWnd, WM_SAVEPROJECT, (WPARAM)0, (LPARAM)0); DestroyWindow(hMainWnd); DestroyWindow(hListWnd); DestroyWindow(hStatusWnd); _fcloseall(); FreeLangList(); #ifdef _DEBUG { FILE *pLeakList = fopen( "C:\\LEAKLIST.TXT", "wt"); FreeMemList( pLeakList); fclose( pLeakList); } #endif // _DEBUG break; case WM_CREATE: { HDC hdc; int cyBorder; TEXTMETRIC tm; hdc = GetDC (hWnd); GetTextMetrics(hdc, &tm); ReleaseDC(hWnd, hdc); cyBorder = GetSystemMetrics(SM_CYBORDER); cyChildHeight = tm.tmHeight + 6 + cyBorder * 2; break; } case WM_DESTROY: WinHelpA(hWnd, gszHelpFile, HELP_QUIT, (DWORD)0); // remove translation list if (pTransList) { // so we can find the end of the list pTransList->pPrev->pNext = NULL; } while (pTransList) { TRANSLIST *pTemp; pTemp = pTransList; pTransList = pTemp->pNext; RLFREE( pTemp->sz); RLFREE( pTemp); } PostQuitMessage(0); break; case WM_INITMENU: // Enable or Disable the Paste menu item // based on available Clipboard Text data if (wParam == (WPARAM) GetMenu(hMainWnd)) { if (OpenClipboard(hWnd)) { #if defined(UNICODE) if ((IsClipboardFormatAvailable(CF_UNICODETEXT) || IsClipboardFormatAvailable(CF_OEMTEXT)) && fTokFile) #else // not UNICODE if ((IsClipboardFormatAvailable(CF_TEXT) || IsClipboardFormatAvailable(CF_OEMTEXT)) && fTokFile) #endif // UNICODE { EnableMenuItem((HMENU) wParam, IDM_E_PASTE, MF_ENABLED); } else { EnableMenuItem((HMENU)wParam, IDM_E_PASTE, MF_GRAYED); } CloseClipboard(); return (TRUE); } } break; case WM_QUERYENDSESSION: /* message: to end the session? */ if ( SendMessage( hWnd, WM_SAVEPROJECT, (WPARAM)0, (LPARAM)0) ) { return TRUE; } else { return FALSE; } case WM_SETFOCUS: SetFocus (hListWnd); break; case WM_DRAWITEM: DrawLBItem((LPDRAWITEMSTRUCT) lParam); break; case WM_DELETEITEM: { HGLOBAL hTokData; LPTOKDATA lpTokData; hTokData = ((HGLOBAL)((LPDELETEITEMSTRUCT)lParam)->itemData); if ( hTokData ) { lpTokData = (LPTOKDATA)GlobalLock( hTokData ); GlobalFree( lpTokData->hToken ); GlobalUnlock( hTokData ); GlobalFree( hTokData ); } } break; case WM_SIZE: { int cxWidth; int cyHeight; int xChild; int yChild; cxWidth = LOWORD(lParam); cyHeight = HIWORD(lParam); xChild = 0; yChild = cyHeight - cyChildHeight + 1; MoveWindow(hListWnd, 0, 0, cxWidth, yChild, TRUE); MoveWindow(hStatusWnd, xChild, yChild, cxWidth, cyChildHeight, TRUE); break; } case WM_READMPJDATA: { OFSTRUCT Of = { 0, 0, 0, 0, 0, ""}; if ( OpenFile( gProj.szMpj, &Of, OF_EXIST) == HFILE_ERROR ) { // file doesn't exist LoadStrIntoAnsiBuf( hInst, IDS_MPJERR, szDHW, DHWSIZE); MessageBoxA( hWnd, gProj.szMpj, szDHW, MB_ICONSTOP | MB_OK); } else if ( GetMasterProjectData( gProj.szMpj, NULL, NULL, FALSE) == SUCCESS ) { OFSTRUCT Of = { 0, 0, 0, 0, 0, ""}; gProj.fSourceEXE = IsExe( gMstr.szSrc); gProj.fTargetEXE = (!IsRes( gProj.szBld)); if ( gProj.fTargetEXE && !gProj.fSourceEXE ) { int i = lstrlenA( gProj.szBld) - 3; LoadStrIntoAnsiBuf( hInst, IDS_RLE_CANTSAVEASEXE, szDHW, DHWSIZE); lstrcpyA( gProj.szBld+i, "RES"); MessageBoxA( hWnd, szDHW, gProj.szBld, MB_ICONHAND|MB_OK); gProj.fTargetEXE = FALSE; } SzDateFromFileName( szDHW, gMstr.szSrc); fMPJOutOfDate = FALSE; if ( OpenFile( gProj.szTok, &Of, OF_EXIST) == HFILE_ERROR ) { // file doesn't exist, create it Update( gMstr.szMtk, gProj.szTok); lstrcpyA( gProj.szTokDate, gMstr.szMpjLastRealUpdate); fPrjChanges = TRUE; fPRJOutOfDate = FALSE; } else { if ( lstrcmpA( gMstr.szMpjLastRealUpdate, gProj.szTokDate) ) { HCURSOR hOldCursor; fPRJOutOfDate = TRUE; hOldCursor = SetCursor( hHourGlass); Update( gMstr.szMtk, gProj.szTok); SetCursor( hOldCursor); lstrcpyA( gProj.szTokDate, gMstr.szMpjLastRealUpdate); fPrjChanges = TRUE; fPRJOutOfDate = FALSE; } else { fPRJOutOfDate = FALSE; } } // New code to do auto-translate SendMessage( hWnd, WM_LOADTOKENS, (WPARAM)0, (LPARAM)0); if ( gProj.szGlo[0] // file name given exists? && OpenFile( gProj.szGlo, &Of, OF_EXIST) != HFILE_ERROR ) { // Yes HCURSOR hOldCursor = SetCursor( hHourGlass); MakeGlossIndex( lFilePointer); SetCursor( hOldCursor); } } //... END case WM_READMPJDATA } //... END switch (wMsg) break; case WM_LOADTOKENS: { HMENU hMenu = NULL; FILE *f = NULL; // Remove the current token list SendMessage( hListWnd, LB_RESETCONTENT, (LPARAM)0, (LPARAM)0); CleanDeltaList(); // Hide token list, while we add new tokens ShowWindow(hListWnd, SW_HIDE); if (f = FOPEN(gProj.szTok, "rt")) { HCURSOR hOldCursor; hOldCursor = SetCursor(hHourGlass); // Insert tokens from token file into the list box { FILE *fm; if ( !(fm = fopen((CHAR *)gMstr.szMtk,"rt")) ) return TRUE; pTokenDeltaInfo = InsertTokMtkList(f, fm ); FCLOSE( fm ); } FCLOSE(f); // Make list box visible ShowWindow(hListWnd, SW_SHOW); hMenu=GetMenu(hWnd); EnableMenuItem(hMenu, IDM_P_CLOSE, MF_ENABLED|MF_BYCOMMAND); EnableMenuItem(hMenu, IDM_P_VIEW, MF_ENABLED|MF_BYCOMMAND); EnableMenuItem(hMenu, IDM_P_EDIT, MF_ENABLED|MF_BYCOMMAND); EnableMenuItem(hMenu, IDM_P_SAVE, MF_ENABLED|MF_BYCOMMAND); EnableMenuItem(hMenu, IDM_E_FIND, MF_ENABLED|MF_BYCOMMAND); EnableMenuItem(hMenu, IDM_E_FINDUP, MF_ENABLED|MF_BYCOMMAND); EnableMenuItem(hMenu, IDM_E_FINDDOWN, MF_ENABLED|MF_BYCOMMAND); EnableMenuItem(hMenu, IDM_E_REVIEW, MF_ENABLED|MF_BYCOMMAND); EnableMenuItem(hMenu, IDM_E_ALLREVIEW, MF_ENABLED|MF_BYCOMMAND); EnableMenuItem(hMenu, IDM_E_COPY, MF_ENABLED|MF_BYCOMMAND); EnableMenuItem(hMenu, IDM_E_COPYTOKEN, MF_ENABLED|MF_BYCOMMAND); EnableMenuItem(hMenu, IDM_E_PASTE, MF_ENABLED|MF_BYCOMMAND); if ((!fMPJOutOfDate) && (!fPRJOutOfDate)) { int i; EnableMenuItem(hMenu, IDM_O_GENERATE, MF_ENABLED|MF_BYCOMMAND); for (i = IDM_FIRST_EDIT; i <= IDM_LAST_EDIT;i++) { EnableMenuItem(hMenu, i, MF_ENABLED|MF_BYCOMMAND); } } fTokFile = TRUE; fTokChanges = FALSE; SetCursor(hOldCursor); } return TRUE; } break; case WM_SAVEPROJECT: { HCURSOR hOldCursor; hOldCursor = SetCursor( hHourGlass); _fcloseall(); if ( fPrjChanges ) { // Generate PRJ file if ( PutProjectData( gProj.szPRJ) != SUCCESS ) { SetCursor( hOldCursor); LoadStrIntoAnsiBuf (hInst, IDS_FILESAVEERR, szDHW, DHWSIZE); MessageBoxA( hWnd,szDHW, gProj.szPRJ, MB_ICONHAND | MB_OK); return FALSE; } fPrjChanges = FALSE; } fTokFile = FALSE; if (fTokChanges) { FILE *f = FOPEN( gProj.szTok, "wt"); if ( f ) { SaveTokList(hWnd, f); FCLOSE(f); fTokChanges = FALSE; } else { SetCursor( hOldCursor); LoadStrIntoAnsiBuf(hInst, IDS_FILESAVEERR, szDHW, DHWSIZE); MessageBoxA( hWnd, szDHW, gProj.szTok, MB_ICONHAND | MB_OK); return FALSE; } } SetCursor( hOldCursor); return TRUE; // everything saved ok } default: break; } return ( DefWindowProc(hWnd, wMsg, wParam, lParam)); } static void GetTextFromMTK( HWND hWnd, TOKEN *pTok, long lMtkPointer ) { FILE *fp = FOPEN( gMstr.szMtk, "rt"); if ( fp ) { TOKEN cTok, ccTok; BOOL fFound; pTok->wReserved = 0; if ( lMtkPointer >= 0 ) { fseek( fp, lMtkPointer, SEEK_SET); if ( !GetToken(fp,&cTok) ) { fFound = ((cTok.wType == pTok->wType) && (cTok.wName == pTok->wName) && (cTok.wID == pTok->wID) && (cTok.wFlag == pTok->wFlag) && (lstrcmp((TCHAR *)cTok.szName, (TCHAR *)pTok->szName) == 0)); if ( fFound ) { // any changed old token SetDlgItemText( hWnd, IDD_TOKCURTEXT, (LPTSTR)cTok.szText); if ( ! GetToken( fp,&ccTok) ) { fFound = ((cTok.wType == ccTok.wType) && (cTok.wName == ccTok.wName) && (cTok.wID == ccTok.wID) && (cTok.wFlag == ccTok.wFlag) && (lstrcmp((TCHAR *)cTok.szName, (TCHAR *)ccTok.szName) == 0) && (cTok.wReserved & ST_CHANGED) ); if ( fFound ) { SetDlgItemText( hWnd, IDD_TOKPREVTEXT, (LPTSTR)ccTok.szText); } else { // should this ever happen?? SetDlgItemText( hWnd, IDD_TOKPREVTEXT, (LPTSTR)TEXT("")); } } else { // should this ever happen?? SetDlgItemText( hWnd, IDD_TOKPREVTEXT, (LPTSTR)TEXT("")); } FCLOSE( fp); return; } } } pTok->wReserved = 0; if (FindToken(fp, pTok, 0)) { // any changed old token SetDlgItemText(hWnd, IDD_TOKCURTEXT, (LPTSTR)pTok->szText); } else { SetDlgItemText(hWnd, IDD_TOKCURTEXT, (LPTSTR)TEXT("")); } pTok->wReserved = ST_CHANGED; if (FindToken(fp, pTok, ST_CHANGED)) { // any old token SetDlgItemText(hWnd, IDD_TOKPREVTEXT, (LPTSTR)pTok->szText); } else { // should this ever happen?? SetDlgItemText(hWnd, IDD_TOKPREVTEXT, (LPTSTR)TEXT("")); } FCLOSE(fp); } } /** * Function: DoListBoxCommand * Processes the messages sent to the list box. If the message is * not reconized as a list box message, it is ignored and not processed. * As the user scrolls through the tokens WM_UPDSTATLINE messages are * sent to the status window to indicate the current selected token. * The list box goes into Edit Mode by pressing the enter key, or * by double clicking on the list box. After the edit is done, a WM_TOKEDIT * message is sent back to the list box to update the token. The * list box uses control ID IDC_LIST. * * Arguments: * wMsg List Box message ID * wParam Either IDC_LIST, or VK_RETURN depending on wMsg * lParam LPTSTR to selected token during WM_TOKEDIT message. * * Returns: * * Errors Codes: * TRUE. Message processed. * FALSE. Message not processed. * * History: * 01/92 Implemented. TerryRu. * 01/92 Fixed problem with DblClick, and Enter processing. TerryRu. * **/ INT_PTR DoListBoxCommand(HWND hWnd, UINT wMsg, WPARAM wParam, LPARAM lParam) { TOKEN tok; // structure to hold token read from token list TCHAR szName[32] = TEXT(""); // buffer to hold token name CHAR szTmpBuf[32] = ""; // buffer to hold token name TCHAR szID[7] = TEXT(""); // buffer to hold token id TCHAR sz[256] = TEXT(""); // buffer to hold messages static UINT wIndex; LONG lListParam = 0L; HWND hCtl = NULL; HGLOBAL hMem = NULL; LPTSTR lpstrToken = NULL; LPTOKDATA lpTokData; LONG lMtkPointer; // this is the WM_COMMAND switch (wMsg) { case WM_VIEW: { TCHAR *szBuffer; // Message sent by TOkEdigDlgProc to fill IDD_TOKCURTEXT // and IDD_TOKPREVTEXT fields in dialog box hMem = (HGLOBAL)SendMessage( hListWnd, LB_GETITEMDATA, (WPARAM)wIndex, (LPARAM)0); lpTokData = (LPTOKDATA)GlobalLock( hMem ); lpstrToken = (LPTSTR)GlobalLock( lpTokData->hToken ); lMtkPointer = lpTokData->lMtkPointer; szBuffer = (TCHAR *)FALLOC( MEMSIZE( lstrlen( lpstrToken) + 1)); lstrcpy( szBuffer, lpstrToken); GlobalUnlock( lpTokData->hToken ); GlobalUnlock( hMem); ParseBufToTok( szBuffer, &tok); RLFREE( szBuffer); GetTextFromMTK(hTokEditDlgWnd, &tok, lMtkPointer ); RLFREE( tok.szText); return TRUE; } case WM_TRANSLATE: { // Message sent by TokEditDlgProc to build a translation list HWND hDlgItem = NULL; int cTextLen = 0; TCHAR *szKey = NULL; TCHAR *szText = NULL; hDlgItem = GetDlgItem( hTokEditDlgWnd, IDD_TOKCURTEXT); cTextLen = GetWindowTextLength( hDlgItem); szKey = (TCHAR *)FALLOC( MEMSIZE( cTextLen + 1)); szKey[0] = 0; GetDlgItemText( hTokEditDlgWnd, IDD_TOKCURTEXT, szKey, cTextLen + 1); hDlgItem = GetDlgItem( hTokEditDlgWnd, IDD_TOKCURTRANS); cTextLen = GetWindowTextLength( hDlgItem); szText = (TCHAR *)FALLOC( MEMSIZE( cTextLen + 1)); *szText = 0; GetDlgItemText( hTokEditDlgWnd, IDD_TOKCURTRANS, szText, cTextLen + 1); TransString( szKey, szText, &pTransList, lFilePointer); RLFREE( szKey); RLFREE( szText); break; } case WM_TOKEDIT: { TCHAR *szBuffer; int cTextLen; // Message sent by TokEditDlgProc to // indicate change in the token text. // Response to the message by inserting // new token text into list box // Insert the selected token into token struct hMem = (HGLOBAL)SendMessage( hListWnd, LB_GETITEMDATA, (WPARAM)wIndex, (LPARAM)0); lpTokData = (LPTOKDATA)GlobalLock( hMem ); lpstrToken = (LPTSTR)GlobalLock( lpTokData->hToken ); cTextLen = lstrlen( lpstrToken); szBuffer = (TCHAR *)FALLOC( MEMSIZE( cTextLen + 1)); lstrcpy( szBuffer, lpstrToken); lMtkPointer = lpTokData->lMtkPointer; GlobalUnlock( lpTokData->hToken ); GlobalUnlock( hMem); ParseBufToTok( szBuffer, &tok); RLFREE( szBuffer); RLFREE( tok.szText); // Copy new token text from edit box into the token struct cTextLen = lstrlen( (LPTSTR)lParam); tok.szText = (TCHAR *)FALLOC( MEMSIZE( cTextLen + 1)); lstrcpy( tok.szText, (LPTSTR)lParam); // Mark token as clean #ifdef RLWIN32 tok.wReserved = (WORD) ST_TRANSLATED | (WORD) wParam; #else tok.wReserved = ST_TRANSLATED | (WORD) wParam; #endif // should we clean up the delta token information?? szBuffer = (TCHAR *)FALLOC( MEMSIZE( TokenToTextSize( &tok))); ParseTokToBuf( szBuffer, &tok); RLFREE( tok.szText); // Now remove old token SendMessage( hListWnd, WM_SETREDRAW, (WPARAM)FALSE, (LPARAM)0); SendMessage( hListWnd, LB_DELETESTRING, (WPARAM)wIndex, (LPARAM)0); // Replacing with the new token hMem = GlobalAlloc( GMEM_MOVEABLE, sizeof(TOKDATA) ); lpTokData = (LPTOKDATA)GlobalLock( hMem ); lpTokData->hToken = GlobalAlloc(GMEM_MOVEABLE, MEMSIZE(lstrlen((TCHAR *)szBuffer)+1)); lpstrToken = (LPTSTR) GlobalLock( lpTokData->hToken ); lstrcpy((TCHAR *)lpstrToken, (TCHAR *)szBuffer); GlobalUnlock( lpTokData->hToken ); lpTokData->lMtkPointer = lMtkPointer; //MtkPointer GlobalUnlock( hMem); RLFREE( szBuffer); SendMessage( hListWnd, LB_INSERTSTRING, (WPARAM)wIndex, (LPARAM)hMem); // Now put focus back on the current string SendMessage( hListWnd, LB_SETCURSEL, (WPARAM)wIndex, (LPARAM)0); SendMessage( hListWnd, WM_SETREDRAW, (WPARAM)TRUE, (LPARAM)0); InvalidateRect(hListWnd, NULL, TRUE); return TRUE; } case WM_CHARTOITEM: case WM_VKEYTOITEM: { #ifdef RLWIN16 LONG lListParam = 0; #endif // Messages sent to list box when keys are depressed. // Check for Return key pressed. switch (GET_WM_COMMAND_ID(wParam, lParam)) { case VK_RETURN: #ifdef RLWIN16 lListParam = (LONG) MAKELONG(NULL, LBN_DBLCLK); SendMessage(hMainWnd, WM_COMMAND, IDC_LIST, lListParam); #else SendMessage( hMainWnd, WM_COMMAND, MAKEWPARAM( IDC_LIST, LBN_DBLCLK), (LPARAM)0); #endif return TRUE; default: break; } break; } case WM_COMMAND: switch (GET_WM_COMMAND_ID(wParam, lParam)) { case IDC_LIST: { /* * * This is where we process the list box messages. * The TokEditDlgProc is used to * edit the token selected in LBS_DBLCLK message * */ switch (GET_WM_COMMAND_CMD(wParam, lParam)) { case (UINT) LBN_ERRSPACE: LoadString( hInst, IDS_ERR_NO_MEMORY, sz, TCHARSIN( sizeof( sz))); MessageBox( hWnd, sz, tszAppName, MB_ICONHAND | MB_OK); return TRUE; case LBN_DBLCLK: { LPTSTR CurText = NULL; LPTSTR PreText = NULL; TCHAR szResIDStr[20] = TEXT(""); TCHAR *szBuffer; wIndex = (UINT)SendMessage( hListWnd, LB_GETCURSEL, (WPARAM)0, (LPARAM)0); if (wIndex == (UINT) -1) { return TRUE; } // double click, or Return entered, // go into token edit mode. if (!hTokEditDlgWnd) { // set up modaless dialog box to edit token #ifdef RLWIN32 hTokEditDlgWnd = CreateDialog(hInst, TEXT("RLEdit"), hWnd, TokEditDlgProc); #else //lpTokEditDlg = //(DLGPROC) MakeProcInstance(TokEditDlgProc, // hInst); //hTokEditDlgWnd = CreateDialog(hInst, // TEXT("RLEdit"), // hWnd, // lpTokEditDlg); hTokEditDlgWnd = CreateDialog(hInst, TEXT("RLEdit"), hWnd, TokEditDlgProc); #endif } // Get token info from listbox, and place in token struct hMem = (HGLOBAL)SendMessage( hListWnd, LB_GETITEMDATA, (WPARAM)wIndex, (LPARAM)0); lpTokData = (LPTOKDATA)GlobalLock( hMem ); lpstrToken = (LPTSTR)GlobalLock( lpTokData->hToken ); lMtkPointer = lpTokData->lMtkPointer; szBuffer = (LPTSTR)FALLOC( MEMSIZE( lstrlen( lpstrToken) + 1)); lstrcpy( szBuffer, lpstrToken); GlobalUnlock( lpTokData->hToken ); GlobalUnlock( hMem); ParseBufToTok(szBuffer, &tok); RLFREE( szBuffer); // Now get the token name // Its either a string, or ordinal number if (tok.szName[0]) { lstrcpy( szName, tok.szName); } else { #ifdef UNICODE _itoa(tok.wName, szTmpBuf, 10); _MBSTOWCS( szName, szTmpBuf, WCHARSIN( sizeof( szName)), ACHARSIN( strlen(szTmpBuf) + 1)); #else _itoa(tok.wName, szName, 10); #endif } // Now get the token id #ifdef UNICODE _itoa(tok.wID, szTmpBuf, 10); _MBSTOWCS( szID, szTmpBuf, WCHARSIN( sizeof( szID)), ACHARSIN( strlen(szTmpBuf) + 1)); #else _itoa(tok.wID, szID, 10); #endif if ( tok.wType <= 16 || tok.wType == ID_RT_DLGINIT ) { LoadString(hInst, IDS_RESOURCENAMES+tok.wType, szResIDStr, TCHARSIN( sizeof( szResIDStr))); } else { #ifdef UNICODE _itoa(tok.wType, szTmpBuf, 10); _MBSTOWCS(szResIDStr, szTmpBuf, WCHARSIN( sizeof( szResIDStr)), ACHARSIN( strlen(szTmpBuf) + 1)); #else _itoa(tok.wType, szResIDStr, 10); #endif } // Now insert token info in TokEdit Dialog Box SetDlgItemText(hTokEditDlgWnd, IDD_TOKTYPE, (LPTSTR) szResIDStr); SetDlgItemText(hTokEditDlgWnd, IDD_TOKNAME, (LPTSTR) szName); SetDlgItemText(hTokEditDlgWnd, IDD_TOKID, (LPTSTR) szID); SetDlgItemText(hTokEditDlgWnd, IDD_TOKCURTRANS, (LPTSTR) tok.szText); SetDlgItemText(hTokEditDlgWnd, IDD_TOKPREVTRANS, (LPTSTR) tok.szText); CheckDlgButton(hTokEditDlgWnd, IDD_DIRTY, 0); if (tok.wReserved & ST_READONLY) { CheckDlgButton(hTokEditDlgWnd, IDD_READONLY, 1); EnableWindow(GetDlgItem(hTokEditDlgWnd, IDD_TOKCURTRANS), FALSE); SetFocus(GetDlgItem(hTokEditDlgWnd, IDCANCEL)); } else { CheckDlgButton(hTokEditDlgWnd, IDD_READONLY, 0); EnableWindow(GetDlgItem(hTokEditDlgWnd, IDD_TOKCURTRANS), TRUE); } // we did not find anything in the delta info, // so we need to read it from the master token. GetTextFromMTK(hTokEditDlgWnd, &tok, lMtkPointer ); RLFREE( tok.szText); // Disable OK button. // User must enter text before it is enabled hCtl = GetDlgItem(hTokEditDlgWnd, IDOK); SendMessage( hMainWnd, WM_TRANSLATE, (LPARAM)0, (LPARAM)0); EnableWindow(hCtl, FALSE); SetActiveWindow(hTokEditDlgWnd); wIndex = (UINT)SendMessage( hListWnd, LB_GETCURSEL, (WPARAM)0, (LPARAM)0); return TRUE; } // let these messages fall through, default: break; } } default: return FALSE; } break; // WM_COMMAND Case } // Main List Box Switch return FALSE; } /** * Function: DoMenuCommand. * Processes the Menu Command messages. * * Errors Codes: * TRUE. Message processed. * FALSE. Message not processed. * * History: * 01/92. Implemented. TerryRu. * **/ INT_PTR DoMenuCommand(HWND hWnd, UINT wMsg, WPARAM wParam, LPARAM lParam) { static BOOL fListBox = FALSE; TCHAR sz[256]=TEXT(""); #ifndef RLWIN32 WNDPROC lpNewDlg, lpViewDlg; #endif int rc; LPTOKDATA lpTokData; long lMtkPointer; // Commands entered from the application menu, or child windows. switch (GET_WM_COMMAND_ID(wParam, lParam)) { case IDM_P_NEW: fEditing = FALSE; //... We are *not* editing an existing .PRJ if ( SendMessage( hWnd, WM_SAVEPROJECT, (WPARAM)0, (LPARAM)0) ) { CHAR szFile[MAXFILENAME] = ""; if ( GetFileNameFromBrowse( hWnd, gProj.szPRJ, MAXFILENAME, szSaveDlgTitle, szFilterSpec, "PRJ")) { strcpy( szFile, gProj.szPRJ); } else { break; // user cancelled } #ifdef RLWIN32 if ( DialogBox( hInst, TEXT("PROJECT"), hWnd, NewDlgProc) == IDOK ) #else //lpNewDlg = MakeProcInstance(NewDlgProc, hInst); // //if ( DialogBox( hInst, TEXT("PROJECT"), hWnd, lpNewDlg) == IDOK ) if ( DialogBox( hInst, TEXT("PROJECT"), hWnd, NewDlgProc) == IDOK ) #endif { sprintf( szDHW, "%s - %s", szAppName, szFile); SetWindowTextA( hWnd, szDHW); gbNewProject = TRUE; gProj.szTokDate[0] = 0; strcpy( gProj.szPRJ, szFile); fPrjChanges = TRUE; SendMessage( hWnd, WM_READMPJDATA, (WPARAM)0, (LPARAM)0); } gbNewProject = FALSE; #ifndef RLWIN32 //FreeProcInstance(lpNewDlg); #endif break; } case IDM_P_EDIT: fEditing = TRUE; //... We *are* editing an existing .PRJ if ( SendMessage( hWnd, WM_SAVEPROJECT, (WPARAM)0, (LPARAM)0) ) { CHAR szOldMpj[ MAXFILENAME]; // Save old Master Project name lstrcpyA( szOldMpj, gProj.szMpj); #ifdef RLWIN32 if ( DialogBox( hInst, TEXT("PROJECT"), hWnd, NewDlgProc) == IDOK ) #else //lpNewDlg = MakeProcInstance(NewDlgProc, hInst); // //if ( DialogBox( hInst, TEXT("PROJECT"), hWnd, lpNewDlg) == IDOK ) if ( DialogBox( hInst, TEXT("PROJECT"), hWnd, NewDlgProc) == IDOK ) #endif { fPrjChanges = TRUE; // Still same Master Project referenced? if ( lstrcmpiA( szOldMpj, gProj.szMpj) != 0 ) { gbNewProject = TRUE; // No gProj.szTokDate[0] = 0; SendMessage( hWnd, WM_READMPJDATA, (WPARAM)0, (LPARAM)0); } } gbNewProject = FALSE; #ifndef RLWIN32 //FreeProcInstance(lpNewDlg); #endif break; } case IDM_P_OPEN: if ( SendMessage( hWnd, WM_SAVEPROJECT, (WPARAM)0, (LPARAM)0) ) { szTempFileName[0] = 0; if ( GetFileNameFromBrowse( hWnd, szTempFileName, MAXFILENAME, szOpenDlgTitle, szFilterSpec, "PRJ") ) { if ( GetProjectData( szTempFileName, NULL, NULL, FALSE, FALSE) == SUCCESS ) { SendMessage( hWnd, WM_READMPJDATA, (WPARAM)0, (LPARAM)0); sprintf( szDHW, "%s - %s", szAppName, szTempFileName); SetWindowTextA( hMainWnd, szDHW); strcpy( gProj.szPRJ, szTempFileName); SendMessage( hMainWnd, WM_LOADTOKENS, (WPARAM)0, (LPARAM)0); } } } break; case IDM_P_VIEW: #ifdef RLWIN32 DialogBox(hInst, TEXT("VIEWPROJECT"), hWnd, ViewDlgProc); #else //lpViewDlg = (WNDPROC) MakeProcInstance((WNDPROC)ViewDlgProc, hInst); //DialogBox(hInst, TEXT("VIEWPROJECT"), hWnd, lpViewDlg); DialogBox(hInst, TEXT("VIEWPROJECT"), hWnd, ViewDlgProc); #endif break; case IDM_P_CLOSE: { HMENU hMenu; hMenu=GetMenu(hWnd); if ( SendMessage( hWnd, WM_SAVEPROJECT, (WPARAM)0, (LPARAM)0) ) { int i; // Remove file name from window title SetWindowTextA(hMainWnd, szAppName); // Hide token list since it's going to be empty ShowWindow(hListWnd, SW_HIDE); // Remove the current token list SendMessage( hListWnd, LB_RESETCONTENT, (WPARAM)0, (LPARAM)0); CleanDeltaList(); // Force Repaint of status Window InvalidateRect(hStatusWnd, NULL, TRUE); EnableMenuItem(hMenu, IDM_P_CLOSE, MF_GRAYED|MF_BYCOMMAND); EnableMenuItem(hMenu, IDM_P_VIEW, MF_GRAYED|MF_BYCOMMAND); EnableMenuItem(hMenu, IDM_P_EDIT, MF_GRAYED|MF_BYCOMMAND); EnableMenuItem(hMenu, IDM_P_SAVE, MF_GRAYED|MF_BYCOMMAND); EnableMenuItem(hMenu, IDM_E_FIND, MF_GRAYED|MF_BYCOMMAND); EnableMenuItem(hMenu, IDM_E_FINDUP, MF_GRAYED|MF_BYCOMMAND); EnableMenuItem(hMenu, IDM_E_FINDDOWN, MF_GRAYED|MF_BYCOMMAND); EnableMenuItem(hMenu, IDM_E_REVIEW, MF_GRAYED|MF_BYCOMMAND); EnableMenuItem(hMenu, IDM_E_ALLREVIEW, MF_GRAYED|MF_BYCOMMAND); EnableMenuItem(hMenu, IDM_E_COPY, MF_GRAYED|MF_BYCOMMAND); EnableMenuItem(hMenu, IDM_E_COPYTOKEN, MF_GRAYED|MF_BYCOMMAND); EnableMenuItem(hMenu, IDM_E_PASTE, MF_GRAYED|MF_BYCOMMAND); EnableMenuItem(hMenu, IDM_O_GENERATE, MF_GRAYED|MF_BYCOMMAND); for (i = IDM_FIRST_EDIT; i <= IDM_LAST_EDIT;i++) { EnableMenuItem(hMenu, i, MF_GRAYED|MF_BYCOMMAND); } } break; } case IDM_P_SAVE: if (fTokChanges || fPrjChanges) { CHAR szPrjName[MAXFILENAME]; strcpy(szPrjName, gProj.szPRJ); if ( SendMessage(hWnd, WM_SAVEPROJECT, (WPARAM)0, (LPARAM)0) ) { GetProjectData( szPrjName, NULL, NULL, FALSE, FALSE); } } else { LoadString( hInst, IDS_NOCHANGESYET, sz, TCHARSIN( sizeof( sz))); MessageBox( hWnd, sz, tszAppName, MB_ICONHAND | MB_OK); } break; case IDM_P_EXIT: SendMessage( hWnd, WM_SAVEPROJECT, (WPARAM)0, (LPARAM)0); PostMessage( hMainWnd, WM_CLOSE, (WPARAM)0, (LPARAM)0); break; case IDM_E_COPYTOKEN: { HANDLE hStringMem; LPTSTR lpString; int nIndex = 0; int nLength = 0; LPTSTR lpstrToken; // Is anything selected in the listbox if ( (nIndex = (int)SendMessage( hListWnd, LB_GETCURSEL, (WPARAM)0, (LPARAM)0)) != LB_ERR ) { HGLOBAL hMem = (HGLOBAL)SendMessage( hListWnd, LB_GETITEMDATA, (WPARAM)nIndex, (LPARAM)0); lpTokData = (LPTOKDATA)GlobalLock( hMem ); lpstrToken = (LPTSTR)GlobalLock( lpTokData->hToken ); nLength = lstrlen(lpstrToken); // Allocate memory for the string if ( (hStringMem = GlobalAlloc(GHND, (DWORD) MEMSIZE(nLength + 1))) != NULL ) { if ( (lpString = (LPTSTR)GlobalLock(hStringMem)) != NULL ) { // Get the selected text lstrcpy( lpString, lpstrToken); GlobalUnlock( lpTokData->hToken ); GlobalUnlock( hMem); // Unlock the block GlobalUnlock( hStringMem); // Open the Clipboard and clear its contents OpenClipboard( hWnd); EmptyClipboard(); // Give the Clipboard the text data #if defined(UNICODE) SetClipboardData( CF_UNICODETEXT, hStringMem); #else // not UNICODE SetClipboardData( CF_TEXT, hStringMem); #endif // UNICODE CloseClipboard(); hStringMem = NULL; } else { GlobalUnlock( lpTokData->hToken ); GlobalUnlock( hMem); LoadString( hInst, IDS_ERR_NO_MEMORY, sz, TCHARSIN( sizeof( sz))); MessageBox( hWnd, sz, tszAppName, MB_ICONHAND | MB_OK); } } else { GlobalUnlock( lpTokData->hToken ); GlobalUnlock( hMem); LoadString( hInst, IDS_ERR_NO_MEMORY, sz, TCHARSIN( sizeof(sz))); MessageBox( hWnd, sz, tszAppName, MB_ICONHAND | MB_OK); } } break; } case IDM_E_COPY: { HANDLE hStringMem; LPTSTR lpString; int nIndex = 0; int nLength = 0; int nActual = 0; TOKEN tok; LPTSTR lpstrToken; // Is anything selected in the listbox if ( (nIndex = (int)SendMessage( hListWnd, LB_GETCURSEL, (WPARAM)0, (LPARAM)0)) != LB_ERR ) { HGLOBAL hMem = (HGLOBAL)SendMessage( hListWnd, LB_GETITEMDATA, (WPARAM)nIndex, (LPARAM)0); lpTokData = (LPTOKDATA)GlobalLock( hMem ); lpstrToken = (LPTSTR)GlobalLock( lpTokData->hToken ); lstrcpy( szString, lpstrToken); GlobalUnlock( lpTokData->hToken ); GlobalUnlock( hMem); ParseBufToTok( szString, &tok); nLength = lstrlen( tok.szText); // Allocate memory for the string if ( (hStringMem = GlobalAlloc( GHND, (DWORD)MEMSIZE( nLength + 1))) != NULL ) { if ( (lpString = (LPTSTR)GlobalLock( hStringMem)) != NULL) { // Get the selected text #ifdef RLWIN32 lstrcpy( lpString, tok.szText); #else _fstrcpy( lpString, tok.szText); #endif // Unlock the block GlobalUnlock(hStringMem); // Open the Clipboard and clear its contents OpenClipboard( hWnd); EmptyClipboard(); // Give the Clipboard the text data #if defined(UNICODE) SetClipboardData(CF_UNICODETEXT, hStringMem); #else // not UNICODE SetClipboardData( CF_TEXT, hStringMem); #endif // UNICODE CloseClipboard(); hStringMem = NULL; } else { LoadString( hInst, IDS_ERR_NO_MEMORY, sz, TCHARSIN( sizeof( sz))); MessageBox( hWnd, sz, tszAppName, MB_ICONHAND | MB_OK); } } else { LoadString( hInst, IDS_ERR_NO_MEMORY, sz, TCHARSIN( sizeof( sz))); MessageBox( hWnd, sz, tszAppName, MB_ICONHAND | MB_OK); } RLFREE( tok.szText); } break; } case IDM_E_PASTE: { HANDLE hClipMem = NULL; LPTSTR lpClipMem = NULL; HGLOBAL hMem = NULL; TCHAR *szString; int nIndex = 0; TOKEN tok; LPTSTR lpstrToken; if ( OpenClipboard( hWnd) ) { #if defined(UNICODE) if (IsClipboardFormatAvailable(CF_UNICODETEXT) || IsClipboardFormatAvailable(CF_OEMTEXT)) #else // not UNICODE if ( IsClipboardFormatAvailable( CF_TEXT) || IsClipboardFormatAvailable( CF_OEMTEXT)) #endif // UNICODE { // Check for current position and change that token's text nIndex = (int)SendMessage( hListWnd, LB_GETCURSEL, (WPARAM)0, (LPARAM)0); if (nIndex == LB_ERR) { #if defined(UNICODE) //if no select, just ignore break; #else // not UNICODE nIndex = -1; #endif // UNICODE } #if defined(UNICODE) hClipMem = GetClipboardData(CF_UNICODETEXT); #else // not UNICODE hClipMem = GetClipboardData( CF_TEXT); #endif // UNICODE lpClipMem = (LPTSTR)GlobalLock( hClipMem); hMem = (HGLOBAL)SendMessage( hListWnd, LB_GETITEMDATA, (WPARAM)nIndex, (LPARAM)0); lpTokData = (LPTOKDATA)GlobalLock( hMem ); lpstrToken = (LPTSTR)GlobalLock( lpTokData->hToken ); if ( lpstrToken ) { #if defined(UNICODE) szString = (TCHAR *)FALLOC( MEMSIZE(lstrlen(lpstrToken)+1) ); #else // not UNICODE szString = (TCHAR *) FALLOC( lstrlen( lpstrToken) + 1); #endif // UNICODE lstrcpy( szString, lpstrToken); GlobalUnlock( lpTokData->hToken ); lMtkPointer = lpTokData->lMtkPointer; //Save GlobalUnlock( hMem); // copy the string to the token ParseBufToTok(szString, &tok); RLFREE( szString); RLFREE( tok.szText); tok.szText = (TCHAR *) FALLOC( MEMSIZE( lstrlen( lpClipMem) + 1)); #ifdef RLWIN32 lstrcpy( tok.szText, lpClipMem); #else _fstrcpy(tok.szText, lpClipMem); #endif GlobalUnlock(hClipMem); szString = (TCHAR *) FALLOC( MEMSIZE( TokenToTextSize( &tok))); ParseTokToBuf(szString, &tok); RLFREE( tok.szText); // Paste the text SendMessage( hListWnd, WM_SETREDRAW, (WPARAM)FALSE, (LPARAM)0); SendMessage( hListWnd, LB_DELETESTRING, (WPARAM)nIndex, (LPARAM)0); hMem = GlobalAlloc( GMEM_MOVEABLE, sizeof(TOKDATA) ); lpTokData = (LPTOKDATA)GlobalLock( hMem ); lpTokData->hToken = GlobalAlloc ( GMEM_MOVEABLE, MEMSIZE(lstrlen(szString)+1) ); lpstrToken = (LPTSTR)GlobalLock( lpTokData->hToken ); lstrcpy( lpstrToken, szString); RLFREE( szString); GlobalUnlock( lpTokData->hToken ); lpTokData->lMtkPointer = lMtkPointer; GlobalUnlock( hMem); SendMessage( hListWnd, LB_INSERTSTRING, (WPARAM)nIndex, (LPARAM)hMem); SendMessage( hListWnd, LB_SETCURSEL, (WPARAM)nIndex, (LPARAM)0); fTokChanges = TRUE; // Set Dirty Flag } SendMessage( hListWnd, WM_SETREDRAW, (WPARAM)TRUE, (LPARAM)0); InvalidateRect(hListWnd, FALSE, TRUE); // Close the Clipboard CloseClipboard(); SetFocus(hListWnd); } } CloseClipboard(); break; } case IDM_E_FINDDOWN: if (fSearchStarted) { if (!DoTokenSearchForRledit(szSearchType, szSearchText, wSearchStatus, wSearchStatusMask, 0, TRUE)) { TCHAR sz1[80], sz2[80]; LoadString( hInst, IDS_FIND_TOKEN, sz1, TCHARSIN( sizeof( sz1))); LoadString( hInst, IDS_TOKEN_NOT_FOUND, sz2, TCHARSIN( sizeof( sz2))); MessageBox( hWnd, sz2, sz1, MB_ICONINFORMATION | MB_OK); } break; } case IDM_E_FINDUP: if (fSearchStarted) { if (!DoTokenSearchForRledit(szSearchType, szSearchText, wSearchStatus, wSearchStatusMask, 1, TRUE)) { TCHAR sz1[80], sz2[80]; LoadString( hInst, IDS_FIND_TOKEN, sz1, TCHARSIN( sizeof( sz1))); LoadString( hInst, IDS_TOKEN_NOT_FOUND, sz2, TCHARSIN( sizeof( sz2))); MessageBox( hWnd, sz2, sz1, MB_ICONINFORMATION | MB_OK); } break; } case IDM_E_FIND: { #ifndef RLWIN32 //WNDPROC lpfnTOKFINDMsgProc; // //lpfnTOKFINDMsgProc = MakeProcInstance( (WNDPROC)TOKFINDMsgProc, // hInst); // //if ( DialogBox( hInst, TEXT("TOKFIND"), hWnd, lpfnTOKFINDMsgProc) == -1) if ( DialogBox( hInst, TEXT("TOKFIND"), hWnd, TOKFINDMsgProc) == -1) #else if ( DialogBox( hInst, TEXT("TOKFIND"), hWnd, TOKFINDMsgProc) == -1) #endif { #ifndef DBCS // 'Token Not Found' is strange because user selected cancel TCHAR sz1[80], sz2[80]; LoadString( hInst, IDS_FIND_TOKEN, sz1, TCHARSIN( sizeof( sz1))); LoadString( hInst, IDS_TOKEN_NOT_FOUND, sz2, TCHARSIN( sizeof( sz2))); MessageBox( hWnd, sz2, sz1, MB_ICONINFORMATION | MB_OK); #endif //DBCS } #ifndef RLWIN32 FreeProcInstance( lpfnTOKFINDMsgProc); #endif return TRUE; } case IDM_E_REVIEW: { int wSaveSelection; nUpdateMode = 1; // set listbox selection to begining of the token list wSaveSelection = (UINT)SendMessage( hListWnd, LB_GETCURSEL, (WPARAM)0, (LPARAM)0); // Selection for REVIEW starts with the user-selected line, (PW) // not at the top of the token list. (PW) // SendMessage(hListWnd, LB_SETCURSEL, 0, 0L); (PW) if ( DoTokenSearchForRledit( NULL, NULL, ST_TRANSLATED | ST_DIRTY, ST_TRANSLATED | ST_DIRTY, FALSE, FALSE) ) { #ifdef RLWIN16 LONG lListParam; lListParam = MAKELONG(NULL, LBN_DBLCLK); SendMessage( hMainWnd, WM_COMMAND, (WPARAM)IDC_LIST, (LPARAM)lListParam); #else SendMessage( hMainWnd, WM_COMMAND, MAKEWPARAM( IDC_LIST, LBN_DBLCLK), (LPARAM)0); #endif } break; } case IDM_E_ALLREVIEW: { UINT wListParam; UINT wIndex, wcTokens; wIndex = (UINT)SendMessage( hListWnd, LB_GETCURSEL, 0, 0L); wcTokens = (UINT)SendMessage( hListWnd, LB_GETCOUNT, 0, 0L ); if ( wcTokens == wIndex ) break; nUpdateMode = 2; SendMessage( hListWnd, LB_SETCURSEL, wIndex, 0L); wListParam = (UINT) MAKELONG(IDC_LIST, LBN_DBLCLK); SendMessage(hMainWnd, WM_COMMAND, wListParam, (LPARAM)0); break; } case IDM_O_GENERATE: if ( SendMessage( hWnd, WM_SAVEPROJECT, (WPARAM)0, (LPARAM)0) ) { HCURSOR hOldCursor; hOldCursor = SetCursor( hHourGlass); rc = GenerateImageFile( gProj.szBld, gMstr.szSrc, gProj.szTok, gMstr.szRdfs, 0); SetCursor( hOldCursor); } break; case IDM_H_CONTENTS: { OFSTRUCT Of = { 0, 0, 0, 0, 0, ""}; if ( OpenFile( gszHelpFile, &Of, OF_EXIST) == HFILE_ERROR ) { LoadString( hInst, IDS_ERR_NO_HELP, sz, TCHARSIN( sizeof( sz))); MessageBox( hWnd, sz, NULL, MB_OK); } else { WinHelpA( hWnd, gszHelpFile, HELP_KEY, (DWORD_PTR)(LPSTR)"RLEdit"); } break; } case IDM_H_ABOUT: { #ifndef RLWIN32 //WNDPROC lpProcAbout; //lpProcAbout = MakeProcInstance(About, hInst); //DialogBox(hInst, TEXT("ABOUT"), hWnd, lpProcAbout); //FreeProcInstance(lpProcAbout); DialogBox(hInst, TEXT("ABOUT"), hWnd, About); #else DialogBox(hInst, TEXT("ABOUT"), hWnd, About); #endif break; } break; default: if (wParam <= IDM_LAST_EDIT && wParam >= IDM_FIRST_EDIT) { // USER IS INVOKING AN EDITOR CHAR szEditor[MAXFILENAME] = ""; if ( LoadStrIntoAnsiBuf(hInst, (UINT)wParam, szEditor, sizeof(szEditor))) { if ( SendMessage( hWnd, WM_SAVEPROJECT, (WPARAM)0, (LPARAM)0) ) { HCURSOR hOldCursor; hOldCursor = SetCursor(hHourGlass); MyGetTempFileName(0, "RES", 0, szTempRes); fInThirdPartyEditer = TRUE; if (gProj.fSourceEXE) { // we need to first extract the .RES from the .EXE CHAR sz[MAXFILENAME] = ""; MyGetTempFileName(0, "RES", 0, sz); ExtractResFromExe32A( gMstr. szSrc, sz, 0); GenerateRESfromRESandTOKandRDFs( szTempRes, sz, gProj.szTok, gMstr.szRdfs, ID_RT_DIALOG); remove(sz); } else { GenerateRESfromRESandTOKandRDFs( szTempRes, gMstr.szSrc, gProj.szTok, gMstr.szRdfs, ID_RT_DIALOG); } SetCursor( hOldCursor); ExecResEditor( hWnd, szEditor, szTempRes, ""); } } } break; // default } return FALSE; } #ifdef RLWIN16 static int ExecResEditor(HWND hWnd, CHAR *szEditor, CHAR *szFile, CHAR *szArgs) { CHAR szExecCmd[256]; int RetCode; // generate command line lstrcpy( szExecCmd, szEditor); lstrcat( szExecCmd, " "); lstrcat( szExecCmd, szArgs); lstrcat( szExecCmd, " "); lstrcat( szExecCmd, szFile); lpfnWatchTask = MakeProcInstance(WatchTask, hInst); NotifyRegister(NULL, (LPFNNOTIFYCALLBACK)lpfnWatchTask, NF_NORMAL); fWatchEditor = TRUE; // exec resource editor RetCode = WinExec(szExecCmd, SW_SHOWNORMAL); if (RetCode > 31) { // successful execution ShowWindow(hWnd, SW_HIDE); } else { // unsuccessful execution CHAR sz[80]; NotifyUnRegister(NULL); FreeProcInstance(lpfnWatchTask); remove(szFile); fInThirdPartyEditer = FALSE; SendMessage( hWnd, WM_LOADTOKENS, (WPARAM)0, (LPARAM)0); LoadString( hInst, IDS_GENERALFAILURE, sz, TCHARSIN( sizeof( sz))); MessageBox( hWnd, sz, tszAppName, MB_OK); } return RetCode; } #endif #ifdef RLWIN32 static int ExecResEditor(HWND hWnd, CHAR *szEditor, CHAR *szFile, CHAR *szArgs) { TCHAR wszExecCmd[256]; CHAR szExecCmd[256]; DWORD dwRetCode = 0; DWORD dwExitCode = 0; BOOL fSuccess = FALSE; BOOL fExit = FALSE; PROCESS_INFORMATION ProcessInfo; STARTUPINFO StartupInfo; StartupInfo.cb = sizeof(STARTUPINFO); StartupInfo.lpReserved = NULL; StartupInfo.lpDesktop = NULL; StartupInfo.lpTitle = TEXT("Resize Dialogs"); StartupInfo.dwX = 0L; StartupInfo.dwY = 0L; StartupInfo.dwXSize = 0L; StartupInfo.dwYSize = 0L; StartupInfo.dwFlags = STARTF_USESHOWWINDOW; StartupInfo.wShowWindow = SW_SHOWDEFAULT; StartupInfo.lpReserved2 = NULL; StartupInfo.cbReserved2 = 0; // generate command line strcpy(szExecCmd, szEditor); strcat(szExecCmd, " "); strcat(szExecCmd, szArgs); strcat(szExecCmd, " "); strcat(szExecCmd, szFile); #ifdef UNICODE _MBSTOWCS( wszExecCmd, szExecCmd, WCHARSIN( sizeof( wszExecCmd)), ACHARSIN( strlen(szExecCmd) + 1)); #else strcpy(wszExecCmd, szExecCmd); #endif fSuccess = CreateProcess( (LPTSTR) NULL, wszExecCmd, NULL, NULL, FALSE, NORMAL_PRIORITY_CLASS, NULL, NULL, &StartupInfo, &ProcessInfo); /* try to create a process */ if ( fSuccess ) { // wait for the editor to complete */ dwRetCode = WaitForSingleObject( ProcessInfo.hProcess, 0xFFFFFFFF) ; if ( ! dwRetCode ) { // editor terminated, check exit code fExit = GetExitCodeProcess( ProcessInfo.hProcess, &dwExitCode) ; } else { fExit = FALSE; } // close the editor object handles CloseHandle( ProcessInfo.hThread) ; CloseHandle( ProcessInfo.hProcess) ; if ( fExit ) { // successful execution ShowWindow(hWnd, SW_HIDE); SendMessage(hMainWnd, WM_EDITER_CLOSED, 0, 0); } else { // unsuccessful execution remove( szFile); fInThirdPartyEditer = FALSE; SendMessage( hWnd, WM_LOADTOKENS, (WPARAM)0, (LPARAM)0); LoadStrIntoAnsiBuf( hInst, IDS_GENERALFAILURE, szDHW, DHWSIZE); MessageBoxA( hWnd, szDHW, szEditor, MB_ICONSTOP|MB_OK); } } else { CHAR szText[ 80] = ""; LPSTR pszMsg = szText; dwRetCode = GetLastError(); if ( dwRetCode == ERROR_PATH_NOT_FOUND ) { pszMsg = ", Path not found."; } else if ( dwRetCode == ERROR_FILE_NOT_FOUND ) { OFSTRUCT Of = { 0, 0, 0, 0, 0, ""}; sprintf( szText, ", File \"%s\" not found.", OpenFile( szFile, &Of, OF_EXIST) != HFILE_ERROR ? szEditor : szFile); } sprintf( szDHW, "Command \"%s\" failed.\nSystem error code = %d%s", szExecCmd, dwRetCode, pszMsg); MessageBoxA( hWnd, szDHW, szAppName, MB_ICONEXCLAMATION|MB_OK); fExit = FALSE; } return ( fExit); } #endif /** * Function: WatchTask * A callback function installed by a NotifyRegister function. * This function is installed by the dialog editer command and is used * to tell RLEDIT when the dialog editer has been closed by the user. * * To use this function, set fWatchEditor to TRUE and install this * callback function by using NotifyRegister. The next task initiated * (in our case via a WinExec call) will be watched for termination. * * When WatchTask sees that the task being watched has terminated it * posts a WM_EDITER_CLOSED message to RLEDITs main window. * * History: * 2/92, implemented SteveBl */ #ifdef RLWIN16 BOOL PASCAL _loadds WatchTask(WORD wID, DWORD dwData) { static HTASK htWatchedTask; static BOOL fWatching = FALSE; switch (wID) { case NFY_STARTTASK: if (fWatchEditor) { htWatchedTask = GetCurrentTask(); fWatching = TRUE; fWatchEditor = FALSE; } break; case NFY_EXITTASK: if (fWatching) { if (GetCurrentTask() == htWatchedTask) { PostMessage(hMainWnd, WM_EDITER_CLOSED, 0, 0); fWatching = FALSE; } } break; } return FALSE; } #endif /** * * * Function: TokEditDlgProc * Procedure for the edit mode dialog window. Loads the selected token * info into the window, and allows the user to change the token text. * Once the edit is complete, the procedure sends a message to the * list box windows to update the current token info. * * * Arguments: * * Returns: NA. * * Errors Codes: * TRUE, carry out edit, and update token list box. * FALSE, cancel edit. * * History: * * **/ INT_PTR CALLBACK TokEditDlgProc( HWND hDlg, UINT wMsg, WPARAM wParam, LPARAM lParam) { HWND hCtl = NULL; HWND hParentWnd = NULL; UINT static wcTokens = 0; UINT wNotifyCode = 0; UINT wIndex = 0; #ifdef RLWIN16 LONG lListParam = 0; #endif switch ( wMsg ) { case WM_INITDIALOG: cwCenter( hDlg, 0); wcTokens = (UINT)SendMessage( hListWnd, LB_GETCOUNT, (WPARAM)0, (LPARAM)0); wcTokens--; // only allow skip button if in update mode if ( ! nUpdateMode ) { if ( (hCtl = GetDlgItem( hDlg, IDD_SKIP)) ) { EnableWindow( hCtl, FALSE); } } else { if ( (hCtl = GetDlgItem( hDlg, IDD_SKIP)) ) { EnableWindow( hCtl, TRUE); } } // disallow auto translate if we don't have a glossary file if ( *gProj.szGlo == '\0' ) { hCtl = GetDlgItem( hDlg, IDD_TRANSLATE); EnableWindow( hCtl, FALSE); hCtl = GetDlgItem( hDlg, IDD_ADD); EnableWindow( hCtl, FALSE); } return ( TRUE); case WM_COMMAND: switch ( GET_WM_COMMAND_ID( wParam, lParam) ) { case IDD_TOKCURTRANS: wNotifyCode = GET_WM_COMMAND_CMD( wParam, lParam); hCtl = GET_WM_COMMAND_HWND( wParam, lParam); if ( wNotifyCode == EN_CHANGE ) { if ( hCtl = GetDlgItem( hDlg, IDOK) ) { EnableWindow( hCtl, TRUE); } } break; case IDD_ADD: { TCHAR *szUntranslated = NULL; TCHAR *szTranslated = NULL; TCHAR *sz = NULL; TCHAR szMask[80] = TEXT(""); HWND hDlgItem = NULL; int cCurTextLen = 0; int cTotalTextLen = 80; hDlgItem = GetDlgItem( hDlg, IDD_TOKCURTEXT); cCurTextLen = GetWindowTextLength( hDlgItem); cTotalTextLen += cCurTextLen; szUntranslated = (TCHAR *)FALLOC( MEMSIZE( cCurTextLen + 1)); GetDlgItemText( hDlg, IDD_TOKCURTEXT, szUntranslated, cCurTextLen + 1); hDlgItem = GetDlgItem( hDlg, IDD_TOKCURTRANS); cCurTextLen = GetWindowTextLength( hDlgItem); cTotalTextLen += cCurTextLen; szTranslated = (TCHAR *)FALLOC( MEMSIZE( cCurTextLen + 1)); GetDlgItemText( hDlg, IDD_TOKCURTRANS, szTranslated, cCurTextLen + 1); LoadString( hInst, IDS_ADDGLOSS, szMask, TCHARSIN( sizeof(szMask))); sz = (TCHAR *)FALLOC( MEMSIZE( cTotalTextLen + 1)); wsprintf( sz, szMask, szTranslated, szUntranslated); if ( MessageBox( hDlg, sz, tszAppName, MB_ICONQUESTION | MB_YESNO) == IDYES) { HCURSOR hOldCursor = SetCursor( hHourGlass); AddTranslation( szUntranslated, szTranslated, lFilePointer); TransString( szUntranslated, szTranslated, &pTransList, lFilePointer); SetCursor( hOldCursor); } RLFREE( sz); RLFREE( szUntranslated); RLFREE( szTranslated); break; } case IDD_UNTRANSLATE: { int cTextLen = 0; TCHAR *sz = NULL; HWND hDlgItem = NULL; hDlgItem = GetDlgItem( hDlg, IDD_TOKCURTEXT); cTextLen = GetWindowTextLength( hDlgItem); sz = (TCHAR *)FALLOC( MEMSIZE( cTextLen + 1)); GetDlgItemText( hDlg, IDD_TOKCURTEXT, sz, cTextLen + 1); SetDlgItemText( hDlg, IDD_TOKCURTRANS, sz); RLFREE( sz); break; } case IDD_TRANSLATE: // Get next thing in the translation list if ( pTransList ) { pTransList = pTransList->pNext; SetDlgItemText( hDlg, IDD_TOKCURTRANS, pTransList->sz); } break; case IDD_SKIP: wIndex = (UINT)SendMessage( hListWnd, LB_GETCURSEL, (LPARAM)0, (LPARAM)0); if ( nUpdateMode == 2 && wIndex < wcTokens ) { wIndex++; SendMessage( hListWnd, LB_SETCURSEL, wIndex, 0L ); SendMessage( hMainWnd, WM_COMMAND, MAKEWPARAM( IDC_LIST, LBN_DBLCLK), (LPARAM)0); return ( TRUE ); } else if ( nUpdateMode == 1 && (wIndex < wcTokens) ) { wIndex++; SendMessage( hListWnd, LB_SETCURSEL, (WPARAM)wIndex, (LPARAM)0); if ( DoTokenSearchForRledit( NULL, NULL, ST_TRANSLATED | ST_DIRTY, ST_TRANSLATED | ST_DIRTY, FALSE, FALSE) ) { // go into edit mode wIndex = (UINT)SendMessage( hListWnd, LB_GETCURSEL, (WPARAM)0, (LPARAM)0); #ifdef RLWIN16 SendMessage( hMainWnd, WM_COMMAND, IDC_LIST, MAKELONG( NULL, LBN_DBLCLK)); #else SendMessage( hMainWnd, WM_COMMAND, MAKEWPARAM( IDC_LIST, LBN_DBLCLK), (LPARAM)0); #endif return TRUE; } } nUpdateMode = 0; // remove edit dialog box DestroyWindow( hDlg); #ifndef RLWIN32 //FreeProcInstance( (FARPROC)lpTokEditDlg); #endif hTokEditDlgWnd = 0; break; case IDD_READONLY: if ( IsDlgButtonChecked( hDlg, IDD_READONLY) ) { EnableWindow( GetDlgItem( hDlg, IDD_TOKCURTRANS), FALSE); } else { EnableWindow( GetDlgItem( hDlg, IDD_TOKCURTRANS), TRUE); } break; case IDOK: { int cTokenTextLen = 0; TCHAR *szTokTextBuf = NULL; HWND hDlgItem = NULL; wIndex = (UINT)SendMessage( hListWnd, LB_GETCURSEL, (WPARAM)0, (LPARAM)0); fTokChanges = TRUE; // set flag to show token list has changed // Extract String from IDD_TOKTEXT edit control hDlgItem = GetDlgItem( hDlg, IDD_TOKCURTRANS); cTokenTextLen = GetWindowTextLength( hDlgItem); szTokTextBuf = (TCHAR *)FALLOC( MEMSIZE( cTokenTextLen + 1)); GetDlgItemText( hDlg, IDD_TOKCURTRANS, szTokTextBuf, cTokenTextLen+1); hParentWnd = GetParent( hDlg); SendMessage( hParentWnd, WM_TOKEDIT, (WPARAM)((IsDlgButtonChecked( hDlg, IDD_READONLY) ? ST_READONLY : 0) | (IsDlgButtonChecked( hDlg, IDD_DIRTY) ? ST_DIRTY : 0)), (LPARAM)szTokTextBuf); RLFREE( szTokTextBuf); // Exit, or goto to next changed token if in update mode if ( nUpdateMode == 2 && wIndex < wcTokens ) { wIndex++; SendMessage( hListWnd, LB_SETCURSEL, wIndex, 0L ); SendMessage( hMainWnd, WM_COMMAND, MAKEWPARAM( IDC_LIST, LBN_DBLCLK), (LPARAM)0); return ( TRUE ); } else if ( nUpdateMode == 1 && (wIndex < wcTokens) ) { wIndex++; SendMessage( hListWnd, LB_SETCURSEL, (WPARAM)wIndex, (LPARAM)0); if ( DoTokenSearchForRledit( NULL, NULL, ST_TRANSLATED | ST_DIRTY, ST_TRANSLATED | ST_DIRTY, FALSE, FALSE) ) { // go into edit mode #ifdef RLWIN16 lListParam = MAKELONG(NULL, LBN_DBLCLK); SendMessage( hMainWnd, WM_COMMAND, IDC_LIST, lListParam); #else SendMessage( hMainWnd, WM_COMMAND, MAKEWPARAM(IDC_LIST, LBN_DBLCLK), (LPARAM)0); #endif return ( TRUE); } } } // fall through to IDCANCEL case IDCANCEL: nUpdateMode = 0; // remove edit dialog box DestroyWindow( hDlg); #ifndef RLWIN32 //FreeProcInstance( lpTokEditDlg); #endif hTokEditDlgWnd = 0; break; } // GET_WM_COMMAND_ID return ( TRUE); default: if ( (hCtl = GetDlgItem(hDlg, IDOK)) ) { EnableWindow( hCtl, TRUE); } return ( FALSE); } // Main Switch } /** * * Function: TOKFINDMsgProc * * Arguments: * * Returns: * NA. * * Errors Codes: * * History: * **/ //#ifdef RLWIN32 //BOOL CALLBACK TOKFINDMsgProc(HWND hWndDlg, UINT wMsg, UINT wParam, LONG lParam) //#else INT_PTR CALLBACK TOKFINDMsgProc( HWND hWndDlg, UINT wMsg, WPARAM wParam, LPARAM lParam) //#endif { HWND hCtl; int rgiTokenTypes[]= { ID_RT_MENU, ID_RT_DIALOG, ID_RT_STRING, ID_RT_ACCELERATORS, ID_RT_RCDATA, ID_RT_ERRTABLE, ID_RT_NAMETABLE, ID_RT_VERSION, ID_RT_DLGINIT }; TCHAR szTokenType[20] = TEXT(""); WORD i; DWORD rc; switch (wMsg) { case WM_INITDIALOG: CheckDlgButton(hWndDlg, IDD_READONLY, 2); CheckDlgButton(hWndDlg, IDD_DIRTY, 2); CheckDlgButton(hWndDlg, IDD_FINDDOWN, 1); hCtl = GetDlgItem(hWndDlg, IDD_TYPELST); for (i = 0; i < sizeof(rgiTokenTypes)/sizeof(int); i ++) { LoadString( hInst, IDS_RESOURCENAMES + rgiTokenTypes[i], szTokenType, TCHARSIN( sizeof( szTokenType))); SendMessage( hCtl, CB_ADDSTRING, (WPARAM)0, (LPARAM)szTokenType); } return TRUE; break; case WM_COMMAND: switch (GET_WM_COMMAND_ID(wParam, lParam)) { case IDOK: /* Button text: "Okay" */ GetDlgItemText(hWndDlg, IDD_TYPELST, szSearchType, 40); GetDlgItemText(hWndDlg, IDD_FINDTOK, szSearchText, 256); wSearchStatus = ST_TRANSLATED; wSearchStatusMask = ST_TRANSLATED ; switch (IsDlgButtonChecked(hWndDlg, IDD_READONLY)) { case 1: wSearchStatus |= ST_READONLY; case 0: wSearchStatusMask |= ST_READONLY; } switch (IsDlgButtonChecked(hWndDlg, IDD_DIRTY)) { case 1: wSearchStatus |= ST_DIRTY; case 0: wSearchStatusMask |= ST_DIRTY; } fSearchStarted = TRUE; fSearchDirection = IsDlgButtonChecked(hWndDlg, IDD_FINDUP); EndDialog( hWndDlg, DoTokenSearchForRledit( szSearchType, szSearchText, wSearchStatus, wSearchStatusMask, fSearchDirection, FALSE)); return TRUE; case IDCANCEL: /* and dismiss the dialog window returning FALSE */ EndDialog( hWndDlg, -1); return TRUE; } break; /* End of WM_COMMAND */ default: return FALSE; } return FALSE; } /** * Function: NewDlgProc * Procedure for the new project dialog window. * * Arguments: * * Returns: NA. * * Errors Codes: * TRUE, carry out edit, and update token list box. * FALSE, cancel edit. * * History: **/ static CHAR szPrompt[80] = ""; static CHAR *szFSpec = NULL; static CHAR *szExt = NULL; static int iLastBox = IDD_MPJ; INT_PTR CALLBACK NewDlgProc( HWND hDlg, UINT wMsg, WPARAM wParam, LPARAM lParam) { static PROJDATA OldProj; static CHAR szNewFileName[ MAXFILENAME] = ""; switch ( wMsg ) { case WM_INITDIALOG: { int nSel = 0; LPTSTR pszLangName = NULL; // Save the old .PRJ CopyMemory( &OldProj, &gProj, sizeof( PROJDATA)); if ( (pszLangName = GetLangName( (WORD)(PRIMARYLANGID( gMstr.wLanguageID)), (WORD)(SUBLANGID( gMstr.wLanguageID)))) == NULL ) { SetDlgItemText( hDlg, IDD_MSTR_LANG_NAME, TEXT("UNKNOWN")); } else { SetDlgItemText( hDlg, IDD_MSTR_LANG_NAME, pszLangName); } FillListAndSetLang( hDlg, IDD_PROJ_LANG_NAME, &gProj.wLanguageID, NULL); if ( gProj.uCodePage == CP_ACP ) gProj.uCodePage = GetACP(); else if ( gProj.uCodePage == CP_OEMCP ) gProj.uCodePage = GetOEMCP(); if ( ! IsValidCodePage( gProj.uCodePage) ) { static TCHAR szMsg[ 256]; CHAR *pszCP[1]; pszCP[0] = UlongToPtr(gProj.uCodePage); LoadString( hInst, IDS_NOCPXTABLE, szMsg, 256); FormatMessage( FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY, szMsg, 0, 0, (LPTSTR)szDHW, DHWSIZE/sizeof(TCHAR), (va_list *)pszCP); MessageBox( hDlg, (LPCTSTR)szDHW, tszAppName, MB_ICONHAND|MB_OK); } SetDlgItemInt( hDlg, IDD_PROJ_TOK_CP, gProj.uCodePage, FALSE); if ( fEditing ) { SetDlgItemTextA( hDlg, IDD_MPJ, gProj.szMpj); SetDlgItemTextA( hDlg, IDD_TOK, gProj.szTok); SetDlgItemTextA( hDlg, IDD_BUILTRES, gProj.szBld); SetDlgItemTextA( hDlg, IDD_GLOSS, gProj.szGlo); } else { // fill in suggested name for the token file SetDlgItemTextA( hDlg, IDD_TOK, ".TOK"); SetDlgItemTextA( hDlg, IDD_BUILTRES, ".EXE"); SetDlgItemTextA( hDlg, IDD_GLOSS, ".TXT"); iLastBox = IDD_MPJ; PostMessage( hDlg, WM_COMMAND, IDD_BROWSE, 0); } CheckRadioButton( hDlg, IDC_REPLACE, IDC_APPEND, gfReplace ? IDC_REPLACE : IDC_APPEND); return TRUE; } case WM_COMMAND: switch ( GET_WM_COMMAND_ID( wParam, lParam) ) { case IDD_MPJ: case IDD_TOK: case IDD_BUILTRES: case IDD_GLOSS: iLastBox = GET_WM_COMMAND_ID( wParam, lParam); break; case IDD_BROWSE: { switch ( iLastBox ) { case IDD_MPJ: szFSpec = szMPJFilterSpec; szExt = "MPJ"; LoadStrIntoAnsiBuf( hInst, IDS_MPJ, szPrompt, sizeof( szPrompt)); break; case IDD_BUILTRES: szFSpec = szExeResFilterSpec; szExt = "EXE"; LoadStrIntoAnsiBuf( hInst, IDS_RES_BLD, szPrompt, sizeof( szPrompt)); break; case IDD_TOK: szFSpec = szTokFilterSpec; szExt = "TOK"; LoadStrIntoAnsiBuf( hInst, IDS_TOK, szPrompt, sizeof( szPrompt)); break; case IDD_GLOSS: szFSpec = szGlossFilterSpec; szExt ="TXT"; LoadStrIntoAnsiBuf( hInst, IDS_GLOSS, szPrompt, sizeof( szPrompt)); break; } // END switch ( iLastBox ) if ( GetFileNameFromBrowse( hDlg, szNewFileName, MAXFILENAME, szPrompt, szFSpec, szExt) ) { SetDlgItemTextA( hDlg, iLastBox, szNewFileName); SetNames( hDlg, iLastBox, szNewFileName); } break; } // END case IDD_BROWSE: case IDC_REPLACE: case IDC_APPEND: CheckRadioButton( hDlg, IDC_REPLACE, IDC_APPEND, GET_WM_COMMAND_ID( wParam, lParam)); break; case IDD_PROJ_LANG_NAME: if ( GET_WM_COMMAND_CMD( wParam, lParam) == CBN_SELENDOK ) { //... Get the selected language name //... then set the appropriate lang id vals INT_PTR nSel = SendDlgItemMessage( hDlg, IDD_PROJ_LANG_NAME, CB_GETCURSEL, (WPARAM)0, (LPARAM)0); if ( nSel != CB_ERR && SendDlgItemMessage( hDlg, IDD_PROJ_LANG_NAME, CB_GETLBTEXT, (WPARAM)nSel, (LPARAM)(LPTSTR)szDHW) != CB_ERR ) { WORD wPri = 0; WORD wSub = 0; if ( GetLangIDs( (LPTSTR)szDHW, &wPri, &wSub) ) { gProj.wLanguageID = MAKELANGID( wPri, wSub); } } } break; case IDOK: { PROJDATA stProject = { "", "", "", "", "", "", CP_ACP, MAKELANGID( LANG_ENGLISH, SUBLANG_ENGLISH_US), FALSE, FALSE }; BOOL fTranslated = FALSE; UINT uCP = GetDlgItemInt( hDlg, IDD_TOK_CP, &fTranslated, FALSE); if ( uCP == CP_ACP ) uCP = GetACP(); else if ( uCP == CP_OEMCP ) uCP = GetOEMCP(); if ( IsValidCodePage( uCP) ) { gProj.uCodePage = uCP; } else { static TCHAR szMsg[ 256]; CHAR *pszCP[1]; pszCP[0] = UlongToPtr(uCP); LoadString( hInst, IDS_NOCPXTABLE, szMsg, 256); FormatMessage( FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY, szMsg, 0, 0, (LPTSTR)szDHW, DHWSIZE/sizeof(TCHAR), (va_list *)pszCP); MessageBox( hDlg, (LPCTSTR)szDHW, tszAppName, MB_ICONHAND|MB_OK); SetDlgItemInt( hDlg, IDD_TOK_CP, gProj.uCodePage, FALSE); return ( TRUE); } GetDlgItemTextA( hDlg, IDD_MPJ, stProject.szMpj, MAXFILENAME); GetDlgItemTextA( hDlg, IDD_BUILTRES, stProject.szBld, MAXFILENAME); GetDlgItemTextA( hDlg, IDD_TOK, stProject.szTok, MAXFILENAME); GetDlgItemTextA( hDlg, IDD_GLOSS, stProject.szGlo, MAXFILENAME); //Why don't allow the partial path? if ( stProject.szMpj[0] && stProject.szBld[0] && stProject.szTok[0] ) { _fullpath( gProj.szMpj, stProject.szMpj, sizeof( gProj.szMpj)); _fullpath( gProj.szBld, stProject.szBld, sizeof( gProj.szBld)); _fullpath( gProj.szTok, stProject.szTok, sizeof( gProj.szTok)); if ( stProject.szGlo[0] != '\0' ) { _fullpath( gProj.szGlo, stProject.szGlo, sizeof( gProj.szGlo)); } gfReplace = IsDlgButtonChecked( hDlg, IDC_REPLACE); EndDialog( hDlg, TRUE); return ( TRUE); } else { break; } } // END case ID_OK: case IDCANCEL: CopyMemory( &gProj, &OldProj, sizeof( PROJDATA)); EndDialog( hDlg, FALSE); return ( TRUE); } // END switch ( GET_WM_COMMAND_ID( wParam, lParam) ) break; } // END switch ( wMsg ) return ( FALSE); } /** * Function: ViewDlgProc * Procedure for the View project dialog window. * * Arguments: * * Returns: NA. * * Errors Codes: * TRUE, carry out edit, and update token list box. * FALSE, cancel edit. * * History: **/ INT_PTR CALLBACK ViewDlgProc( HWND hDlg, UINT wMsg, WPARAM wParam, LPARAM lParam) { static int iLastBox = IDD_MPJ; switch (wMsg) { case WM_INITDIALOG: { LPTSTR pszLangName = NULL; if ( (pszLangName = GetLangName( (WORD)(PRIMARYLANGID( gMstr.wLanguageID)), (WORD)(SUBLANGID( gMstr.wLanguageID)))) == NULL ) { sprintf( szDHW, "Unknown LANGID %#06hx", gMstr.wLanguageID); SetDlgItemTextA( hDlg, IDD_MSTR_LANG_NAME, szDHW); } else { SetDlgItemText( hDlg, IDD_MSTR_LANG_NAME, pszLangName); } if ( (pszLangName = GetLangName( (WORD)(PRIMARYLANGID( gProj.wLanguageID)), (WORD)(SUBLANGID( gProj.wLanguageID)))) == NULL ) { sprintf( szDHW, "Unknown LANGID %#06hx", gProj.wLanguageID); SetDlgItemTextA( hDlg, IDD_PROJ_LANG_NAME, szDHW); } else { SetDlgItemText( hDlg, IDD_PROJ_LANG_NAME, pszLangName); } SetDlgItemTextA( hDlg, IDD_VIEW_SOURCERES, gMstr.szSrc); SetDlgItemTextA( hDlg, IDD_VIEW_MTK, gMstr.szMtk); SetDlgItemTextA( hDlg, IDD_VIEW_RDFS, gMstr.szRdfs); SetDlgItemTextA( hDlg, IDD_VIEW_MPJ, gProj.szMpj); SetDlgItemTextA( hDlg, IDD_VIEW_TOK, gProj.szTok); SetDlgItemTextA( hDlg, IDD_VIEW_TARGETRES, gProj.szBld); SetDlgItemTextA( hDlg, IDD_VIEW_GLOSSTRANS, gProj.szGlo); if ( gProj.uCodePage == CP_ACP ) gProj.uCodePage = GetACP(); else if ( gProj.uCodePage == CP_OEMCP ) gProj.uCodePage = GetOEMCP(); SetDlgItemInt( hDlg, IDD_PROJ_TOK_CP, gProj.uCodePage, FALSE); LoadString( hInst, gfReplace ? IDS_WILLREPLACE : IDS_WILLAPPEND, (LPTSTR)szDHW, TCHARSIN( DHWSIZE)); SetDlgItemText( hDlg, IDC_APPENDREPLACE, (LPTSTR)szDHW); return TRUE; } case WM_COMMAND: switch (GET_WM_COMMAND_ID(wParam, lParam)) { case IDOK: EndDialog(hDlg, TRUE); return TRUE; } } return FALSE; } /** * Function: * * Arguments: * * Returns: * * Errors Codes: * * History: **/ static void DrawLBItem(LPDRAWITEMSTRUCT lpdis) { LPRECT lprc = (LPRECT) &(lpdis->rcItem); DWORD rgbOldText = 0; DWORD rgbOldBack = 0; HBRUSH hBrush; static DWORD rgbHighlightText; static DWORD rgbHighlightBack; static HBRUSH hBrushHilite = NULL; static HBRUSH hBrushNormal = NULL; static DWORD rgbDirtyText; static DWORD rgbBackColor; static DWORD rgbCleanText; static DWORD rgbReadOnlyText; TCHAR *szToken; TOKEN tok; LPTSTR lpstrToken; LPTOKDATA lpTokData; if (lpdis->itemAction & ODA_FOCUS) { DrawFocusRect(lpdis->hDC, (CONST RECT *)lprc); } else { HANDLE hMem = (HANDLE)SendMessage( lpdis->hwndItem, LB_GETITEMDATA, (WPARAM)lpdis->itemID, (LPARAM)0); lpTokData = (LPTOKDATA)GlobalLock( hMem ); lpstrToken = (LPTSTR)GlobalLock( lpTokData->hToken ); szToken = (TCHAR *)FALLOC( MEMSIZE( lstrlen( lpstrToken) + 1)); lstrcpy( szToken, lpstrToken); GlobalUnlock( lpTokData->hToken ); GlobalUnlock( hMem); ParseBufToTok(szToken, &tok); RLFREE( szToken); if (lpdis->itemState & ODS_SELECTED) { if (!hBrushHilite) { rgbHighlightText = GetSysColor(COLOR_HIGHLIGHTTEXT); rgbHighlightBack = GetSysColor(COLOR_HIGHLIGHT); hBrushHilite = CreateSolidBrush(rgbHighlightBack); } GenStatusLine(&tok); rgbOldText = SetTextColor(lpdis->hDC, rgbHighlightText); rgbOldBack = SetBkColor(lpdis->hDC, rgbHighlightBack); hBrush = hBrushHilite; } else { if (!hBrushNormal) { rgbDirtyText = RGB(255, 0, 0); rgbBackColor = RGB(192, 192, 192); rgbCleanText = RGB(0, 0, 0); rgbReadOnlyText = RGB(127, 127, 127); hBrushNormal = CreateSolidBrush(rgbBackColor); } if (tok.wReserved & ST_READONLY) { rgbOldText = SetTextColor(lpdis->hDC, rgbReadOnlyText); } else { if (tok.wReserved & ST_DIRTY) { rgbOldText = SetTextColor(lpdis->hDC, rgbDirtyText); } else { rgbOldText = SetTextColor(lpdis->hDC, rgbCleanText); } } rgbOldBack = SetBkColor(lpdis->hDC, rgbBackColor); hBrush = hBrushNormal; } FillRect(lpdis->hDC, (CONST RECT *)lprc, hBrush); DrawText(lpdis->hDC, tok.szText, STRINGSIZE(lstrlen(tok.szText)), lprc, DT_LEFT|DT_NOPREFIX); RLFREE( tok.szText); if (rgbOldText) { SetTextColor(lpdis->hDC, rgbOldText); } if (rgbOldBack) { SetBkColor(lpdis->hDC, rgbOldBack); } if (lpdis->itemState & ODS_FOCUS) { DrawFocusRect(lpdis->hDC, (CONST RECT *)lprc); } } } /********************************************************************** *FUNCTION: SaveTokList(HWND, FILE *fpTokFile) * * * *PURPOSE: Save current Token List * * * *COMMENTS: * * * *This saves the current contents of the Token List, and changes * *fTokChanges to indicate that the list has not been changed since the * *last save. * **********************************************************************/ static BOOL SaveTokList(HWND hWnd, FILE *fpTokFile) { HCURSOR hSaveCursor; BOOL bSuccess = TRUE; int IOStatus; UINT cTokens; UINT cCurrentTok = 0; CHAR *szTokBuf = NULL; LPTSTR lpstrToken = NULL; HGLOBAL hMem = NULL; LPTOKDATA lpTokData; // Set the cursor to an hourglass during the file transfer hSaveCursor = SetCursor(hHourGlass); // Find number of tokens in the list cTokens = (UINT)SendMessage( hListWnd, LB_GETCOUNT, (WPARAM)0, (LPARAM)0); if ( cTokens != LB_ERR ) { for (cCurrentTok = 0; bSuccess && (cCurrentTok < cTokens); cCurrentTok++) { int nLen1 = 0; int nLen2 = 0; // Get each token from list hMem = (HGLOBAL)SendMessage( hListWnd, LB_GETITEMDATA, (WPARAM)cCurrentTok, (LPARAM)0); if ( ! (lpTokData = (LPTOKDATA)GlobalLock(hMem)) ) { continue; } if ( (lpstrToken = (LPTSTR)GlobalLock( lpTokData->hToken)) ) { szTokBuf = (CHAR *)FALLOC( (nLen2 = MEMSIZE( (nLen1 = lstrlen(lpstrToken)+1)))); #ifdef UNICODE _WCSTOMBS( szTokBuf, lpstrToken, nLen2, nLen1); #else lstrcpy(szTokBuf, lpstrToken); #endif GlobalUnlock( lpTokData->hToken ); GlobalUnlock( hMem); IOStatus = fprintf(fpTokFile, "%s\n", szTokBuf); if ( IOStatus != (int) strlen(szTokBuf) + 1 ) { TCHAR szTmpBuf[256]; LoadString( hInst, IDS_FILESAVEERR, szTmpBuf, TCHARSIN( sizeof(szTmpBuf))); MessageBox( hWnd, szTmpBuf, tszAppName, MB_OK | MB_ICONHAND); bSuccess = FALSE; } RLFREE( szTokBuf); } } } // restore cursor SetCursor(hSaveCursor); return (bSuccess); } /** * Function: CleanDeltaList * frees the pTokenDeltaInfo list */ static void CleanDeltaList(void) { TOKENDELTAINFO FAR *pTokNode; while (pTokNode = pTokenDeltaInfo) { pTokenDeltaInfo = pTokNode->pNextTokenDelta; RLFREE( pTokNode->DeltaToken.szText); RLFREE( pTokNode); } } /* * About -- message processor for about box * */ //#ifdef RLWIN32 // //BOOL CALLBACK About( // //HWND hDlg, //UINT message, //WPARAM wParam, //LPARAM lParam) // //#else // INT_PTR CALLBACK About( HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam) // //#endif { switch ( message ) { case WM_INITDIALOG: { WORD wRC = SUCCESS; CHAR szModName[ MAXFILENAME]; GetModuleFileNameA( hInst, szModName, sizeof( szModName)); if ( (wRC = GetCopyright( szModName, szDHW, DHWSIZE)) == SUCCESS ) { SetDlgItemTextA( hDlg, IDC_COPYRIGHT, szDHW); } else { ShowErr( wRC, NULL, NULL); } } break; case WM_COMMAND: if ((wParam == IDOK) || (wParam == IDCANCEL)) { EndDialog(hDlg, TRUE); } break; default: return ( FALSE); } return ( TRUE); } //................................................................... int RLMessageBoxA( LPCSTR pszMsgText) { return ( MessageBoxA( NULL, pszMsgText, szAppName, MB_ICONHAND|MB_OK)); } //................................................................... void Usage() { return; } //................................................................... void DoExit( int nErrCode) { ExitProcess( (UINT)nErrCode); } //................................................................... static void SetNames( HWND hDlg, int iLastBox, LPSTR szNewFile) { static CHAR szDrive[ _MAX_DRIVE] = ""; static CHAR szDir[ _MAX_DIR] = ""; static CHAR szName[ _MAX_FNAME] = ""; static CHAR szExt[ _MAX_EXT] = ""; static CHAR szOldFileName[ MAXFILENAME]; if ( iLastBox == IDD_MPJ ) { lstrcpyA( gProj.szMpj, szNewFile); if ( ! fEditing && GetMasterProjectData( gProj.szMpj, NULL, NULL, FALSE) == SUCCESS ) { // Suggest a name for the target file GetDlgItemTextA( hDlg, IDD_BUILTRES, szOldFileName, MAXFILENAME); if ( szOldFileName[0] == '\0' || szOldFileName[0] == '.' ) { _splitpath( gProj.szPRJ, szDrive, szDir, szName, szExt); sprintf( gProj.szBld, "%s%s", szDrive, szDir); _splitpath( gMstr.szSrc, szDrive, szDir, szName, szExt); sprintf( &gProj.szBld[ lstrlenA( gProj.szBld)], "%s%s", szName, szExt); SetDlgItemTextA( hDlg, IDD_BUILTRES, gProj.szBld); } } else { return; } } if ( iLastBox == IDD_BUILTRES ) { lstrcpyA( gProj.szBld, szNewFile); } if ( ! fEditing && (iLastBox == IDD_MPJ || iLastBox == IDD_BUILTRES) ) { // Suggest a name for the project token file GetDlgItemTextA( hDlg, IDD_TOK, szOldFileName, MAXFILENAME); if ( szOldFileName[0] == '\0' || szOldFileName[0] == '.' ) { _splitpath( gProj.szPRJ, szDrive, szDir, szName, szExt); sprintf( gProj.szTok, "%s%s%s.%s", szDrive, szDir, szName, "TOK"); SetDlgItemTextA( hDlg, IDD_TOK, gProj.szTok); } // Suggest a name for the glossary file GetDlgItemTextA( hDlg, IDD_GLOSS, szOldFileName, MAXFILENAME); if ( szOldFileName[0] == '\0' || szOldFileName[0] == '.' ) { _splitpath( gProj.szPRJ, szDrive, szDir, szName, szExt); sprintf( gProj.szGlo, "%s%s%s.%s", szDrive, szDir, szName, "TXT"); SetDlgItemTextA( hDlg, IDD_GLOSS, gProj.szGlo); } } if ( iLastBox == IDD_TOK ) { lstrcpyA( gProj.szTok, szNewFile); } if ( iLastBox == IDD_GLOSS ) { lstrcpyA( gProj.szGlo, szNewFile); } }