|
|
// 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 <windows.h>
#include <windowsx.h>
#ifdef RLWIN16
//#include <toolhelp.h>
#endif
#include <shellapi.h>
#include <commdlg.h>
// CRT includes
#include <stdio.h>
#include <stdlib.h>
// 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); }}
|
