able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/sdktools/restools/rltools/rlquiked/rlquiked.c

3029 lines
93 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
#include <windows.h>
#ifdef RLWIN16
//#include <toolhelp.h>
#endif
#ifdef RLWIN32
#include <windowsx.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 "RLQuikEd.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 "rlmsgtbl.h"
#ifdef WIN32
HINSTANCE hInst; /* Instance of the main window */
#else
HWND hInst; /* Instance of the main window */
#endif
HWND hMainWnd = NULL; // handle to main window
HWND hListWnd = NULL; // handle to tok list window
HWND hStatusWnd = NULL; // handle to status windows
int nUpdateMode = 0; // needed in rlcommon.lib
BOOL fCodePageGiven = FALSE; //... Set to TRUE if -p arg given
CHAR szAppName[50] = "";
CHAR szFileTitle[14] = ""; // holds base name of latest opened file
CHAR szCustFilterSpec[MAXCUSTFILTER]=""; // custom filter buffer
extern UCHAR szDHW[]; //... used in debug strings
#ifndef RLWIN32
static BOOL PASCAL _loadds WatchTask( WORD wID,DWORD dwData);
static FARPROC lpfnWatchTask = NULL;
#endif
static int ExecResEditor( HWND , CHAR *, CHAR *, CHAR *);
static void DrawLBItem( LPDRAWITEMSTRUCT lpdis);
static void CleanDeltaList( void);
static void MakeStatusLine( TOKEN *pTok);
static TOKENDELTAINFO FAR *
InsertQuikTokList( FILE * fpTokFile);
// File IO vars
static CHAR szFilterSpec [180] = "";
static CHAR szResFilterSpec [60] = "";
static CHAR szExeFilterSpec [60] = "";
static CHAR szDllFilterSpec [60] = "";
static CHAR szCplFilterSpec [60] = "";
static CHAR szGlossFilterSpec [60] = "";
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 szEditor[MAXFILENAME] = "";
static BOOL gbNewProject = FALSE; // indicates whether 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 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
static TCHAR *szClassName = TEXT("RLQuikEdClass");
static TCHAR *szStatusClass = TEXT("RLQuikEdStatus");
static TOKENDELTAINFO FAR *
pTokenDeltaInfo; // linked list of token deta info
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};
static TRANSLIST *pTransList =(TRANSLIST *) NULL; // circular doubly linked list of translations
// Window vars
static BOOL fWatchEditor;
static CHAR szTempRes[MAXFILENAME] = ""; // the temporary file created by the resource editor
static CHAR szTRes[MAXFILENAME] = "";
// 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 */
static TCHAR szSearchType[80] = TEXT("");
static TCHAR szSearchText[512] = TEXT("");
static WORD wSearchStatus = 0;
static WORD wSearchStatusMask = 0;
static BOOL fSearchDirection;
static BOOL fSearchStarted = FALSE;
// 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 FARPROC lpTokEditDlg;
#endif
static HWND hTokEditDlgWnd = NULL;
extern MSTRDATA gMstr; //... Data from Master Project file (MPJ)
extern PROJDATA gProj; //... Data from Project file (PRJ)
extern BOOL gfReplace; //... FALSE if appending new language to existing resources
extern BOOL fInQuikEd; //... Are we in the rlquiked?
extern BOOL fInThirdPartyEditer;//.. Are we in a 3rd-party resource editor?
extern BOOL bRLGui;
// Global Variables:
static CHAR * gszHelpFile = "RLTools.hlp";
/**
*
*
* 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_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");
LoadStrIntoAnsiBuf(hInstance, IDS_CPLSPEC, sz, sizeof(sz));
szFilterSpecFromSz1Sz2(szCplFilterSpec, sz, "*.CPL");
CatSzFilterSpecs(szFilterSpec, szExeFilterSpec, szDllFilterSpec);
CatSzFilterSpecs(sztFilterSpec, szFilterSpec, szCplFilterSpec);
CatSzFilterSpecs(szFilterSpec, sztFilterSpec, szResFilterSpec);
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(NULL, IDI_APPLICATION);
wc.hCursor = LoadCursor(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("RLQuikEdIcon"));
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
wc.lpszMenuName = TEXT("RLQuikEd");
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;
hAccTable = LoadAccelerators(hInst, TEXT("RLQuikEd"));
hMainWnd = CreateWindow(szClassName,
tszAppName,
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
(HWND) NULL,
(HMENU) NULL,
hInstance,
(LPVOID) NULL);
if (!hMainWnd)
{
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),
(HWND) hMainWnd,
(HMENU)IDC_LIST, // Child control i.d.
hInstance,
(LPVOID)NULL);
if ( ! hListWnd )
{
// clean up after error.
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,
(LPVOID)NULL);
if ( ! hStatusWnd )
{
// clean up after error.
DeleteObject((HGDIOBJ)hListWnd);
DeleteObject((HGDIOBJ)hMainWnd);
return( FALSE);
}
hHourGlass = LoadCursor(NULL, IDC_WAIT);
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:
*
*
**/
#ifdef RLWIN32
INT WINAPI WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpszCmdLine,
int nCmdShow)
#else
int PASCAL WinMain(HANDLE hInstance,
HANDLE hPrevInstance,
LPSTR lpszCmdLine,
int nCmdShow)
#endif
{
MSG msg;
HWND FirstWnd, FirstChildWnd;
bRLGui = TRUE;
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);
}
fInQuikEd = TRUE;
hInst = hInstance;
gProj.wLanguageID = LANGIDFROMLCID( GetThreadLocale());
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, tszAppName, 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, tszAppName, 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( &msg);
DispatchMessage ( &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)
{
FILE *f = NULL;
WORD rc = 0;
// if its 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 bChanged;
hOldCursor = SetCursor( hHourGlass);
// szTempRes returned from resource editor, contains only dialogs
// need to merge it back into the main token file
MyGetTempFileName( 0, "TOK", 0, szDlgToks);
rc = (WORD)GenerateTokFile( szDlgToks,
szTempRes,
&bChanged,
0);
InsDlgToks( gProj.szTok,
szDlgToks,
ID_RT_DIALOG);
remove( szDlgToks);
if ( rc )
{
QuitT( IDS_TOKGENERR, (LPTSTR)rc, NULL);
return FALSE;
}
// gProj.szTok, now contains the latest tokens
SetCursor( hOldCursor);
//Rlqked10 doesn't save when changed tokens by DialogEditor.
fTokChanges = TRUE;
}
}
fInThirdPartyEditer = FALSE;
remove( szTempRes);
// 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 thrid party edit command.
// is it a list dox command ??
DoListBoxCommand (hWnd, wMsg, wParam, lParam);
switch (wMsg)
{
case WM_COMMAND:
if (DoMenuCommand(hWnd, wMsg, wParam, lParam))
{
return TRUE;
}
else
{
return FALSE;
}
break;
case WM_CLOSE:
{
char sz[128] = "";
int rc ;
LoadStrIntoAnsiBuf( hInst, IDS_SAVECHANGES, sz, sizeof( sz));
if ( fPrjChanges || fTokChanges )
{
rc = MessageBoxA( hWnd,
sz,
szAppName,
MB_ICONQUESTION | MB_YESNOCANCEL);
}
else
{
rc = IDNO;
}
if ( rc == IDYES )
{
if ( ! SendMessage( hWnd, WM_SAVEPROJECT, (WPARAM)0, (LPARAM)0))
{
return FALSE;
}
}
if (rc == IDCANCEL)
{
return(FALSE);
}
if (gProj.szTok[0])
{
remove(gProj.szTok);
gProj.szTok[0] = 0;
}
if (hMainWnd)
{
DestroyWindow(hMainWnd);
}
if (hListWnd)
{
DestroyWindow(hListWnd);
}
if (hStatusWnd)
{
DestroyWindow(hStatusWnd);
}
_fcloseall();
FreeLangList();
#ifdef _DEBUG
{
FILE *pLeakList = fopen( "C:\\LEAKLIST.TXT", "wt");
FreeMemList( pLeakList);
fclose( pLeakList);
}
#endif // _DEBUG
return FALSE;
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, 0L);
// remove translation list
if (pTransList)
{
pTransList->pPrev->pNext = NULL; // so we can find the end of the list
}
while (pTransList)
{
TRANSLIST *pTemp;
pTemp = pTransList;
pTransList = pTemp->pNext;
RLFREE( pTemp->sz);
RLFREE( pTemp);
}
DragAcceptFiles(hMainWnd, FALSE);
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_SETFOCUS:
SetFocus (hListWnd);
break;
case WM_DRAWITEM:
DrawLBItem((LPDRAWITEMSTRUCT)lParam);
break;
case WM_DELETEITEM:
{
GlobalFree( (HGLOBAL)((LPDELETEITEMSTRUCT)lParam)->itemData);
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_LOADPROJECT:
{
HCURSOR hOldCursor = NULL;
BOOL bChanged = FALSE;
BOOL fRC = TRUE;
hOldCursor = SetCursor( hHourGlass);
if ( gProj.szTok[0] )
{
remove( gProj.szTok);
}
#ifdef RLRES32
//... Get project lanuages
fRC = DialogBox( hInst,
MAKEINTRESOURCE( IDD_LANGUAGES),
hMainWnd,
GetLangIDsProc) ? TRUE : FALSE;
#endif
if ( fRC )
{
strcpy( gProj.szBld, gMstr.szSrc);
rc = (WORD)GenerateTokFile( gProj.szTok,
gMstr.szSrc,
&fTokChanges,
0);
SetCursor( hOldCursor);
if (rc)
{
QuitT( IDS_TOKGENERR, (LPTSTR)rc, NULL);
}
if ( ( ! fTokChanges) && (gProj.wLanguageID != gMstr.wLanguageID) )
{
fTokChanges = TRUE;
}
fPrjChanges = FALSE;
fPRJOutOfDate = FALSE;
SendMessage( hWnd, WM_LOADTOKENS, (WPARAM)0, (LPARAM)0);
}
else
{
SetWindowText( hMainWnd, tszAppName);
SetCursor( hOldCursor);
}
break;
}
case WM_LOADTOKENS:
{
HMENU hMenu;
// Remove the current token list
SendMessage( hListWnd, LB_RESETCONTENT, (WPARAM)0, (LPARAM)0);
CleanDeltaList();
// Hide token list, while we add new tokens
ShowWindow(hListWnd, SW_HIDE);
if (f = FOPEN(gProj.szTok, "rt"))
{
int i;
HCURSOR hOldCursor;
hOldCursor = SetCursor(hHourGlass);
// Insert tokens from token file into the list box
pTokenDeltaInfo = InsertQuikTokList(f);
FCLOSE( f);
// Make list box visible
ShowWindow( hListWnd, SW_SHOW);
if ( SendMessage( hListWnd,
LB_GETCOUNT,
(WPARAM)0,
(LPARAM)0) > 0 )
{
hMenu = GetMenu(hWnd);
EnableMenuItem(hMenu, IDM_P_SAVE, MF_ENABLED|MF_BYCOMMAND);
EnableMenuItem(hMenu, IDM_P_SAVEAS, MF_ENABLED|MF_BYCOMMAND);
EnableMenuItem(hMenu, IDM_P_CLOSE, 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_COPY, MF_ENABLED|MF_BYCOMMAND);
EnableMenuItem(hMenu, IDM_E_PASTE, MF_ENABLED|MF_BYCOMMAND);
for (i = IDM_FIRST_EDIT; i <= IDM_LAST_EDIT;i++)
{
EnableMenuItem(hMenu,i,MF_ENABLED|MF_BYCOMMAND);
}
fTokFile = TRUE;
fTokChanges = (gProj.wLanguageID != gMstr.wLanguageID);
SetCursor(hOldCursor);
}
else
{
SetCursor(hOldCursor);
fTokChanges = FALSE;
MessageBox( hListWnd,
TEXT("No tokens matching given criteria found"),
tszAppName,
MB_ICONINFORMATION|MB_OK);
}
}
}
break;
case WM_SAVEPROJECT:
{
_fcloseall();
if ( SendMessage( hWnd, WM_SAVETOKENS, (WPARAM)0, (LPARAM)0) )
{
if (fPrjChanges)
{
HCURSOR hOldCursor = NULL;
CHAR sz[100] = "";
WORD rc;
if ( gProj.szBld[0] == '\0' )
{
if(gProj.fSourceEXE)
{
rc = (WORD)GetFileNameFromBrowse( hWnd,
szFileName,
MAXFILENAME,
szSaveDlgTitle,
szFilterSpec,
"EXE");
}
else
{
rc = (WORD)GetFileNameFromBrowse( hWnd,
szFileName,
MAXFILENAME,
szSaveDlgTitle,
szResFilterSpec,
"RES");
}
if (rc)
{
strcpy( gProj.szBld, szFileName);
}
else
{
return( FALSE); // user cancelled
}
}
hOldCursor = SetCursor(hHourGlass);
rc = (WORD)GenerateImageFile(gProj.szBld,
gMstr.szSrc,
gProj.szTok,
gMstr.szRdfs,
0);
SetCursor(hOldCursor);
switch(rc)
{
case 1:
gProj.fTargetEXE = IsExe( gProj.szBld);
gProj.fSourceEXE = IsExe( gMstr.szSrc);
fPrjChanges = FALSE;
sprintf( sz, "%s - %s", szAppName, gProj.szBld);
SetWindowTextA(hWnd,sz);
break;
case (WORD)-1:
lstrcpyA( gProj.szBld, gMstr.szSrc);
LoadStrIntoAnsiBuf(hInst, IDS_RLQ_CANTSAVEASRES, sz, sizeof(sz));
MessageBoxA( NULL, sz, gProj.szBld, MB_ICONHAND|MB_OK);
break;
case (WORD)-2:
lstrcpyA( gProj.szBld, gMstr.szSrc);
LoadStrIntoAnsiBuf(hInst, IDS_RLQ_CANTSAVEASEXE, sz, sizeof(sz));
MessageBoxA( NULL, sz, gProj.szBld,MB_ICONHAND|MB_OK);
break;
}
return(TRUE);
}
// no project changes to save
}
return TRUE;
}
break;
case WM_SAVETOKENS:
if ( fTokChanges )
{
if (f = FOPEN(gProj.szTok, "wt"))
{
SaveTokList(hWnd, f);
FCLOSE(f);
fTokChanges = FALSE;
fPrjChanges = TRUE;
}
else
{
LoadStrIntoAnsiBuf( hInst, IDS_FILESAVEERR, szDHW, DHWSIZE);
MessageBoxA( hWnd,
szDHW,
gProj.szTok,
MB_ICONHAND | MB_OK);
return FALSE;
}
}
return TRUE; // everything saved ok
case WM_DROPFILES:
{
CHAR sz[MAXFILENAME] = "";
#ifndef CAIRO
DragQueryFileA((HDROP) wParam, 0, sz, MAXFILENAME);
#else
DragQueryFile((HDROP) wParam, 0, sz, MAXFILENAME);
#endif
LoadNewFile(sz);
DragFinish((HDROP) wParam);
return(TRUE);
}
default:
break;
}
return (DefWindowProc(hWnd, wMsg, wParam, lParam));
}
/**
* 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
LPTSTR lpstrBuffer;
CHAR szTmpBuf[32] = "";
TCHAR szName[32] = TEXT(""); // 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;
// this is the WM_COMMAND
switch (wMsg)
{
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_TOKPREVTRANS);
cTextLen = GetWindowTextLength( hDlgItem);
szKey = (TCHAR *)FALLOC( MEMSIZE( cTextLen + 1));
szKey[0] = TEXT('\0');
GetDlgItemText( hTokEditDlgWnd,
IDD_TOKPREVTRANS,
szKey,
cTextLen+1);
hDlgItem = GetDlgItem( hTokEditDlgWnd, IDD_TOKCURTRANS);
cTextLen = GetWindowTextLength( hDlgItem);
szText = (TCHAR *)FALLOC( MEMSIZE( cTextLen + 1));
szText[0] = TEXT('\0');
GetDlgItemText( hTokEditDlgWnd,
IDD_TOKCURTRANS,
szText,
cTextLen + 1);
TransString( szKey, szText, &pTransList, lFilePointer);
RLFREE( szKey);
RLFREE( szText);
return TRUE;
}
case WM_TOKEDIT:
{
TCHAR *szBuffer = NULL;
int cTextLen = 0;
// 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
HGLOBAL hMem = (HGLOBAL)SendMessage( hListWnd,
LB_GETITEMDATA,
(WPARAM)wIndex,
(LPARAM)0);
lpstrBuffer = (LPTSTR)GlobalLock( hMem);
if ( ! lpstrBuffer )
{
QuitA( IDS_ENGERR_11, NULL, NULL);
}
cTextLen = lstrlen( lpstrBuffer);
szBuffer = (TCHAR *)FALLOC( MEMSIZE( cTextLen + 1));
lstrcpy( szBuffer, lpstrBuffer);
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 = (LPTSTR)FALLOC( MEMSIZE( cTextLen + 1));
lstrcpy( tok.szText, (LPTSTR)lParam);
RLFREE( (void *)lParam);
// Mark token as clean
#ifdef RLWIN32
tok.wReserved = (WORD) ST_TRANSLATED;
#else
tok.wReserved = ST_TRANSLATED;
#endif
szBuffer = (TCHAR *)FALLOC( MEMSIZE( TokenToTextSize( &tok) + 1));
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_ZEROINIT, MEMSIZE( lstrlen( szBuffer) + 1));
lpstrBuffer = (LPTSTR)GlobalLock( hMem);
lstrcpy( lpstrBuffer, szBuffer);
GlobalUnlock( hMem);
RLFREE( szBuffer);
SendMessage( hListWnd,
LB_INSERTSTRING,
(WPARAM)wIndex,
(LPARAM)hMem);
// Now put focus back on the current string
SendMessage( hListWnd, LB_SETCURSEL, (LPARAM)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
LPARAM 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 = (LPARAM) MAKELONG( 0, LBN_DBLCLK);
SendMessage( hMainWnd, WM_COMMAND, (WPARAM)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;
HGLOBAL hMem = NULL;
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("RLQuikEd"),
hWnd,
TokEditDlgProc);
#else
lpTokEditDlg =
(FARPROC) MakeProcInstance(TokEditDlgProc,
hInst);
hTokEditDlgWnd = CreateDialog(hInst,
TEXT("RLQuikEd"),
hWnd,
lpTokEditDlg);
#endif
}
// Get token info from listbox, and place in token struct
hMem = (HGLOBAL)SendMessage( hListWnd,
LB_GETITEMDATA,
(WPARAM)wIndex,
(LPARAM)0);
lpstrBuffer = (LPTSTR)GlobalLock( hMem);
szBuffer = (LPTSTR)FALLOC( MEMSIZE( lstrlen( lpstrBuffer) +1));
lstrcpy(szBuffer, lpstrBuffer);
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 do the ID string
#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);
RLFREE( tok.szText);
SendMessage( hMainWnd,
WM_TRANSLATE,
(WPARAM)0,
(LPARAM)0);
SetActiveWindow(hTokEditDlgWnd);
wIndex = (UINT)SendMessage( hListWnd,
LB_GETCURSEL,
(WPARAM)0,
(LPARAM)0);
return TRUE;
}
default:
// let these messages fall through,
break;
}
}
default:
return FALSE;
}
}
break; // WM_COMMAND Case
}
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;
CHAR sz[256] = "";
BOOL fRC = TRUE;
sz[0] = 0;
// Commands entered from the application menu, or child windows.
switch (GET_WM_COMMAND_ID(wParam, lParam))
{
case IDM_P_OPEN:
if ( GetFileNameFromBrowse( hWnd,
sz,
MAXFILENAME,
szOpenDlgTitle,
szFilterSpec,
".EXE") )
{
LoadNewFile( sz);
strcpy( gProj.szBld, gMstr.szSrc);
}
break;
case IDM_P_SAVE:
SendMessage( hWnd, WM_SAVEPROJECT, (WPARAM)0, (LPARAM)0);
break;
case IDM_P_SAVEAS:
{
CHAR szOldName[MAXFILENAME] = "";
strcpy( szOldName, gProj.szBld);
gProj.szBld [0] = 0; // force user to enter a name
fPrjChanges = TRUE; // force project to be saved
if ( ! SendMessage( hWnd, WM_SAVEPROJECT, (WPARAM)0, (LPARAM)0) )
{
// restore the name
strcpy( gProj.szBld, szOldName);
}
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
SetWindowText(hMainWnd, tszAppName);
// Remove the current token list
SendMessage( hListWnd, LB_RESETCONTENT, (WPARAM)0, (LPARAM)0);
CleanDeltaList();
// Hide token list since it\'s empty
ShowWindow(hListWnd, SW_HIDE);
// Force Repaint of status Window
InvalidateRect(hStatusWnd, NULL, TRUE);
EnableMenuItem(hMenu, IDM_P_CLOSE, MF_GRAYED|MF_BYCOMMAND);
EnableMenuItem(hMenu, IDM_P_SAVE, MF_GRAYED|MF_BYCOMMAND);
EnableMenuItem(hMenu, IDM_P_SAVEAS, 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_COPY, MF_GRAYED|MF_BYCOMMAND);
EnableMenuItem(hMenu, IDM_E_PASTE, 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_EXIT:
// send wm_close message to main window
if (hMainWnd)
{
PostMessage(hMainWnd, WM_CLOSE, (WPARAM)0, (LPARAM)0); //bugbug??
}
return FALSE;
break;
case IDM_E_COPY:
{
HGLOBAL hStringMem = NULL;
LPTSTR lpstrBuffer = NULL;
LPTSTR lpString = NULL;
TCHAR *szString = NULL;
int nIndex = 0;
int nLength = 0;
int nActual = 0;
TOKEN tok;
// 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);
lpstrBuffer = (LPTSTR)GlobalLock( hMem);
szString = (LPTSTR)FALLOC( MEMSIZE( lstrlen( lpstrBuffer )+ 1));
lstrcpy( szString, lpstrBuffer);
GlobalUnlock( hMem);
ParseBufToTok( szString, &tok);
RLFREE( szString);
nLength = lstrlen( tok.szText) + 1;
// Allocate memory for the string
hStringMem = GlobalAlloc( GHND, (DWORD)MEMSIZE( nLength));
if ( hStringMem != NULL )
{
if ( (lpString = GlobalLock( hStringMem)) != NULL )
{
#ifdef UNICODE
UINT uTextType = CF_UNICODETEXT;
#else
UINT uTextType = CF_TEXT;
#endif
// Get the selected text
lstrcpy( lpString, tok.szText);
// Unlock the block
GlobalUnlock( hStringMem);
// Open the Clipboard and clear its contents
OpenClipboard( hWnd);
EmptyClipboard();
// Give the Clipboard the text data
SetClipboardData( uTextType, hStringMem);
CloseClipboard();
hStringMem = NULL;
}
else
{
LoadStringA( hInst, IDS_ERR_NO_MEMORY, szDHW, DHWSIZE);
MessageBoxA( hWnd,
szDHW,
szAppName,
MB_ICONHAND | MB_OK);
}
}
else
{
LoadStringA( hInst, IDS_ERR_NO_MEMORY, szDHW, DHWSIZE);
MessageBoxA( hWnd,
szDHW,
szAppName,
MB_ICONHAND | MB_OK);
}
RLFREE( tok.szText);
}
break;
}
case IDM_G_GLOSS:
if ( GetFileNameFromBrowse( hWnd,
gProj.szGlo,
MAXFILENAME,
szOpenDlgTitle,
szGlossFilterSpec,
NULL) )
{
OFSTRUCT Of = { 0, 0, 0, 0, 0, ""};
// file exists?
if ( OpenFile( gProj.szGlo, &Of, OF_EXIST) != HFILE_ERROR )
{ // Yes
HCURSOR hOldCursor = SetCursor( hHourGlass);
MakeGlossIndex( lFilePointer);
SetCursor( hOldCursor);
}
else
{
gProj.szGlo[0] = 0;
}
}
break;
case IDM_E_PASTE:
if ( fTokFile && OpenClipboard( hWnd) )
{
UINT puFormat[] = { CF_TEXT, CF_OEMTEXT, CF_UNICODETEXT };
int nType = GetPriorityClipboardFormat( puFormat, 3);
// Check for current position and change that token's text
if ( nType != 0 && nType != -1 )
{
HGLOBAL hClipMem = NULL;
HGLOBAL hMem = NULL;
LPTSTR lpstrBuffer = NULL;
LPTSTR lpClipMem = NULL;
TCHAR *szString = NULL;
TOKEN tok;
#ifdef UNICODE
UINT uWantType = CF_UNICODETEXT;
#else
UINT uWantType = CF_TEXT;
#endif
int nLength = 0;
WPARAM wIndex = (WPARAM)SendMessage( hListWnd,
LB_GETCURSEL,
(WPARAM)0,
(LPARAM)0);
if ( wIndex == LB_ERR )
{
#if defined(UNICODE)
break;
#else // not UNICODE
wIndex = (WPARAM)-1;
#endif // UNICODE
}
hClipMem = GetClipboardData( uWantType);
lpClipMem = (LPTSTR)GlobalLock( hClipMem);
hMem = (HGLOBAL)SendMessage( hListWnd,
LB_GETITEMDATA,
wIndex,
(LPARAM)0);
lpstrBuffer = (LPTSTR)GlobalLock( hMem);
szString = (LPTSTR)FALLOC( MEMSIZE( lstrlen( lpstrBuffer) + 1));
lstrcpy( szString, lpstrBuffer);
GlobalUnlock( hMem);
// copy the string to the token
ParseBufToTok( szString, &tok);
RLFREE( szString);
RLFREE( tok.szText);
tok.szText = (TCHAR *)FALLOC( MEMSIZE( lstrlen( lpClipMem) + 1));
lstrcpy( tok.szText, lpClipMem);
GlobalUnlock( hClipMem);
szString = (TCHAR *)FALLOC( MEMSIZE( TokenToTextSize( &tok)+ 1));
ParseTokToBuf( szString, &tok);
RLFREE( tok.szText);
// Paste the text
SendMessage( hListWnd,
WM_SETREDRAW,
(WPARAM)FALSE,
(LPARAM)0);
SendMessage( hListWnd,
LB_DELETESTRING,
wIndex,
(LPARAM)0);
hMem = GlobalAlloc( GMEM_ZEROINIT,
MEMSIZE( lstrlen( szString) + 1));
lpstrBuffer = (LPTSTR)GlobalLock( hMem);
lstrcpy( lpstrBuffer, szString);
GlobalUnlock( hMem);
RLFREE( szString);
SendMessage( hListWnd,
LB_INSERTSTRING,
wIndex,
(LPARAM)hMem);
SendMessage( hListWnd,
LB_SETCURSEL,
wIndex,
(LPARAM)0);
SendMessage( hListWnd,
WM_SETREDRAW,
(WPARAM)TRUE,
(LPARAM)0);
InvalidateRect( hListWnd, NULL, TRUE);
fTokChanges = TRUE; // Set Dirty Flag
// Close the Clipboard
CloseClipboard();
SetFocus( hListWnd);
}
}
CloseClipboard();
break;
case IDM_E_FINDDOWN:
if ( fSearchStarted )
{
if ( ! DoTokenSearch( szSearchType,
szSearchText,
wSearchStatus,
wSearchStatusMask,
0,
TRUE) )
{
TCHAR sz1[80] = TEXT("");
TCHAR sz2[80] = TEXT("");
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;
} //... ELSE fall thru
case IDM_E_FINDUP:
if ( fSearchStarted )
{
if ( ! DoTokenSearch( szSearchType,
szSearchText,
wSearchStatus,
wSearchStatusMask,
1,
TRUE) )
{
TCHAR sz1[80] = TEXT("");
TCHAR sz2[80] = TEXT("");
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;
} //... ELSE fall thru
case IDM_E_FIND:
{
#ifndef RLWIN32
WNDPROC lpfnTOKFINDMsgProc;
lpfnTOKFINDMsgProc = MakeProcInstance((WNDPROC)TOKFINDMsgProc, hInst);
if (!DialogBox(hInst, TEXT("TOKFIND"), hWnd, lpfnTOKFINDMsgProc))
#else
if (!DialogBox(hInst, TEXT("TOKFIND"), hWnd, TOKFINDMsgProc))
#endif
{
#ifndef DBCS
// 'Token Not Found' is strange because user selected cancel
TCHAR sz1[80] = TEXT("");
TCHAR sz2[80] = TEXT("");
LoadString( hInst,
IDS_TOKEN_NOT_FOUND,
sz2,
TCHARSIN( sizeof( sz2)));
LoadString( hInst,
IDS_FIND_TOKEN,
sz1,
TCHARSIN( sizeof( sz1)));
MessageBox( hWnd,
sz2,
sz1,
MB_ICONINFORMATION | MB_OK);
#endif //DBCS
}
#ifndef RLWIN32
FreeProcInstance( lpfnTOKFINDMsgProc);
#endif
return TRUE;
}
case IDM_H_CONTENTS:
{
OFSTRUCT Of = { 0, 0, 0, 0, 0, ""};
if ( OpenFile( gszHelpFile, &Of, OF_EXIST) == HFILE_ERROR )
{
LoadStringA( hInst, IDS_ERR_NO_HELP , szDHW, DHWSIZE);
MessageBoxA( hWnd, szDHW, gszHelpFile, MB_OK);
}
else
{
WinHelpA( hWnd, gszHelpFile, HELP_KEY, (LPARAM)(LPSTR)"RLQuikEd");
}
break;
}
case IDM_H_ABOUT:
{
#ifndef RLWIN32
WNDPROC lpProcAbout;
lpProcAbout = MakeProcInstance(About, hInst);
DialogBox(hInst, TEXT("ABOUT"), hWnd, lpProcAbout);
FreeProcInstance(lpProcAbout);
#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
if ( LoadStrIntoAnsiBuf(hInst, (UINT)wParam, szEditor, sizeof(szEditor)) )
{
if ( SendMessage( hWnd, WM_SAVETOKENS, (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
strcpy(szExecCmd, szEditor);
lstrcat(szExecCmd, " ");
lstrcat(szExecCmd, szArgs);
lstrcat(szExecCmd, " ");
lstrcat(szExecCmd, szFile);
lpfnWatchTask = MakeProcInstance(WatchTask, hInst);
NotifyRegister(NULL, 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
TCHAR sz[80] = TEXT("");
NotifyUnRegister(NULL);
FreeProcInstance(lpfnWatchTask);
remove(szFile);
fInThirdPartyEditer = FALSE;
SendMessage(hWnd, WM_LOADTOKENS, 0, 0);
LoadString(hInst, IDS_GENERALFAILURE, sz, CHARSIZE( sz));
}
return RetCode;
}
#endif
#ifdef RLWIN32
static int ExecResEditor(HWND hWnd, CHAR *szEditor, CHAR *szFile, CHAR *szArgs)
{
TCHAR wszExecCmd[256] = TEXT("");
CHAR szExecCmd[256] = "";
DWORD dwRetCode;
DWORD dwExitCode;
BOOL fSuccess;
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( 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;
}
if (fExit)
{
// successful execution
ShowWindow(hWnd,SW_HIDE);
PostMessage(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);
}
// close the editor object handles
CloseHandle(ProcessInfo.hThread) ;
CloseHandle(ProcessInfo.hProcess) ;
}
else
{
dwRetCode = GetLastError(); // not used - debugging only (so far)
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 RLQuikEd 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 RLQuikEds main window.
*
* History:
* 2/92, implemented SteveBl
*/
#ifdef RLWIN16
static 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:
*
*
**/
#ifdef RLWIN32
INT_PTR CALLBACK TokEditDlgProc(HWND hDlg, UINT wMsg, WPARAM wParam, LPARAM lParam)
#else
static BOOL APIENTRY TokEditDlgProc(HWND hDlg, UINT wMsg, WPARAM wParam, LPARAM lParam)
#endif
{
HWND hCtl;
HWND hParentWnd;
// TCHAR *szTokTextBuf;
UINT static wcTokens = 0;
UINT wNotifyCode;
UINT wIndex;
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
// disallow auto translate if we don\'t have a glossary file
if (*gProj.szGlo == '\0')
{
hCtl = GetDlgItem(hDlg, IDD_TRANSLATE);
if (hCtl)
{
EnableWindow(hCtl, FALSE);
}
hCtl = GetDlgItem(hDlg, IDD_ADD);
if (hCtl)
{
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)
{
hCtl = GetDlgItem(hDlg, IDOK);
if (hCtl)
{
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 = 0;
cTotalTextLen = 80;
hDlgItem = GetDlgItem(hDlg, IDD_TOKPREVTRANS);
cCurTextLen = GetWindowTextLength( hDlgItem);
cTotalTextLen += cCurTextLen;
szTranslated = (TCHAR *)FALLOC( MEMSIZE( cCurTextLen + 1));
GetDlgItemText( hDlg,
IDD_TOKPREVTRANS,
(LPTSTR)szUntranslated,
cCurTextLen + 1);
hDlgItem = GetDlgItem( hDlg, IDD_TOKCURTRANS);
cCurTextLen = GetWindowTextLength( hDlgItem);
cTotalTextLen += cCurTextLen;
szTranslated = (TCHAR *)FALLOC( MEMSIZE( cCurTextLen + 1));
GetDlgItemText( hDlg,
IDD_TOKCURTRANS,
(LPTSTR)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( szTranslated);
RLFREE( szUntranslated);
break;
}
case IDD_TRANSLATE:
// if \(!pTransList\)
// SendMessage\(hMainWnd, WM_TRANSLATE, \(WPARAM\) 0,\(LPARAM\) 0\);
// Get next thing in the translation list
if ( pTransList )
{
pTransList = pTransList->pNext;
SetDlgItemText( hDlg, IDD_TOKCURTRANS, (LPTSTR)pTransList->sz);
}
break;
case IDOK:
{
int cTokenTextLen;
HWND hDlgItem;
TCHAR *szTokenTextBuf;
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);
szTokenTextBuf = (TCHAR *)FALLOC( MEMSIZE( cTokenTextLen + 1));
GetDlgItemText(hDlg,
IDD_TOKCURTRANS,
szTokenTextBuf,
cTokenTextLen+1);
hParentWnd = GetParent(hDlg);
SendMessage( hParentWnd,
WM_TOKEDIT,
(WPARAM)0,
(LPARAM)szTokenTextBuf);
// Exit, or goto to next changed token if in update mode
// fall through to IDCANCEL
}
case IDCANCEL:
// remove edit dialog box
if (hDlg)
{
DestroyWindow(hDlg);
}
hTokEditDlgWnd = 0;
#ifndef RLWIN32
FreeProcInstance(lpTokEditDlg);
#endif
break;
} // GET_WM_COMMAND_ID
return TRUE;
default:
hCtl = GetDlgItem(hDlg, IDOK);
if (hCtl)
{
EnableWindow(hCtl, TRUE);
}
return FALSE;
} // Main Switch
}
/**
*
* Function: TOKFINDMsgProc
*
* Arguments:
*
* Returns:
* NA.
*
* Errors Codes:
*
* History:
*
**/
#ifdef RLWIN32
INT_PTR CALLBACK TOKFINDMsgProc(HWND hWndDlg, UINT wMsg, WPARAM wParam, LPARAM lParam)
#else
static BOOL APIENTRY TOKFINDMsgProc(HWND hWndDlg, UINT wMsg, UINT wParam, LONG 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_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)));
rc = (DWORD)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" */
fSearchStarted = TRUE;
GetDlgItemText(hWndDlg, IDD_TYPELST, szSearchType, 40);
GetDlgItemText(hWndDlg, IDD_FINDTOK, szSearchText, 256);
wSearchStatus = ST_TRANSLATED;
wSearchStatusMask = ST_TRANSLATED ;
fSearchDirection = IsDlgButtonChecked(hWndDlg, IDD_FINDUP);
if( DoTokenSearch (szSearchType,
szSearchText,
wSearchStatus,
wSearchStatusMask,
fSearchDirection,
0) )
{
EndDialog( hWndDlg, TRUE );
}
else
{
TCHAR sz1[80], sz2[80];
LoadString(hInst, IDS_FIND_TOKEN, sz1, sizeof(sz1));
LoadString(hInst, IDS_TOKEN_NOT_FOUND, sz2, sizeof(sz2));
MessageBox(hWndDlg, sz2, sz1, MB_ICONINFORMATION | MB_OK);
EndDialog( hWndDlg, FALSE );
}
return TRUE;
case IDCANCEL:
/* and dismiss the dialog window returning FALSE */
EndDialog(hWndDlg, FALSE);
return TRUE;
}
break; /* End of WM_COMMAND */
default:
return FALSE;
}
return FALSE;
}
/**
* Function:
*
* Arguments:
*
* Returns:
*
* Errors Codes:
*
* History:
**/
static void DrawLBItem(LPDRAWITEMSTRUCT lpdis)
{
LPRECT lprc = (LPRECT) &(lpdis->rcItem);
DWORD rgbOldText = 0;
DWORD rgbOldBack = 0;
LPTSTR lpstrToken;
HBRUSH hBrush;
static DWORD rgbHighlightText;
static DWORD rgbHighlightBack;
static HBRUSH hBrushHilite = NULL;
static HBRUSH hBrushNormal = NULL;
static DWORD rgbBackColor;
static DWORD rgbCleanText;
TCHAR *szToken;
TOKEN tok;
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);
lpstrToken = (LPTSTR)GlobalLock( hMem);
szToken = (TCHAR *)FALLOC( MEMSIZE( lstrlen( lpstrToken) + 1));
lstrcpy( szToken,lpstrToken);
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);
}
MakeStatusLine(&tok);
rgbOldText = SetTextColor(lpdis->hDC, rgbHighlightText);
rgbOldBack = SetBkColor(lpdis->hDC, rgbHighlightBack);
hBrush = hBrushHilite;
}
else
{
if (!hBrushNormal)
{
rgbBackColor = RGB(192,192,192);
rgbCleanText = RGB(0,0,0);
hBrushNormal = CreateSolidBrush(rgbBackColor);
}
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 *
**********************************************************************/
static BOOL SaveTokList(HWND hWnd, FILE *fpTokFile)
{
HCURSOR hSaveCursor = NULL;
BOOL bSuccess = TRUE;
int cTokenTextLen = 0;
int IOStatus = 0;
UINT cTokens = 0;
UINT cCurrentTok = 0;
CHAR *szTokBuf = NULL;
TCHAR *szTmpBuf = NULL;
LPTSTR lpstrToken = NULL;
// 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++)
{
// Get each token from list
HGLOBAL hMem = (HGLOBAL)SendMessage( hListWnd,
LB_GETITEMDATA,
(WPARAM)cCurrentTok,
(LPARAM)0);
if ( hMem )
{
if ( (lpstrToken = (LPTSTR)GlobalLock( hMem)) != NULL )
{
#ifdef UNICODE
cTokenTextLen = MEMSIZE( lstrlen(lpstrToken) + 1 );
szTmpBuf = (TCHAR *)FALLOC( cTokenTextLen );
szTokBuf = FALLOC( cTokenTextLen );
lstrcpy( szTmpBuf, lpstrToken);
_WCSTOMBS( szTokBuf, szTmpBuf, cTokenTextLen, lstrlen(szTmpBuf)+1);
cTokenTextLen = lstrlenA( szTokBuf );
RLFREE( szTmpBuf);
#else //UNICODE
cTokenTextLen = lstrlen( lpstrToken);
szTokBuf = FALLOC( cTokenTextLen + 1);
lstrcpy( szTokBuf, lpstrToken);
#endif
GlobalUnlock( hMem);
IOStatus = fprintf( fpTokFile, "%s\n", szTokBuf);
RLFREE( szTokBuf);
if ( IOStatus != (int)cTokenTextLen + 1 )
{
TCHAR szTmpBuf[256];
LoadString( hInst,
IDS_FILESAVEERR,
szTmpBuf,
TCHARSIN( sizeof( szTmpBuf)));
MessageBox( hWnd,
szTmpBuf,
NULL,
MB_OK | MB_ICONHAND);
bSuccess = FALSE;
}
}
}
}
}
// 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
INT_PTR CALLBACK About(
HWND hDlg,
unsigned message,
WPARAM wParam,
LPARAM lParam)
#else
static BOOL APIENTRY About(
HWND hDlg,
unsigned message,
UINT wParam,
LONG 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:
switch ( GET_WM_COMMAND_ID(wParam, lParam) )
{
case IDOK:
case IDCANCEL:
EndDialog(hDlg, TRUE);
break;
}
break;
default:
return( FALSE);
}
return( TRUE);
}
#ifdef RLWIN32
/*
* GetLangIDsProc -- message processor for getting language IDs
*
*/
INT_PTR CALLBACK GetLangIDsProc(
HWND hDlg,
unsigned message,
WPARAM wParam,
LPARAM lParam)
{
switch( message )
{
case WM_INITDIALOG:
{
LPTSTR pszName = NULL;
int nSel = 0;
FillListAndSetLang( hDlg,
IDD_MSTR_LANG_NAME,
&gMstr.wLanguageID,
NULL);
FillListAndSetLang( hDlg,
IDD_PROJ_LANG_NAME,
&gProj.wLanguageID,
NULL);
CheckRadioButton( hDlg, IDC_REPLACE, IDC_APPEND, IDC_REPLACE);
}
break;
case WM_COMMAND:
switch( GET_WM_COMMAND_ID( wParam, lParam) )
{
case IDC_REPLACE:
case IDC_APPEND:
CheckRadioButton( hDlg,
IDC_REPLACE,
IDC_APPEND,
GET_WM_COMMAND_ID( wParam, lParam));
break;
case IDD_MSTR_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 = -1;
if ( (nSel = SendDlgItemMessage( hDlg,
IDD_MSTR_LANG_NAME,
CB_GETCURSEL,
(WPARAM)0,
(LPARAM)0)) != CB_ERR
&& SendDlgItemMessage( hDlg,
IDD_MSTR_LANG_NAME,
CB_GETLBTEXT,
(WPARAM)nSel,
(LPARAM)(LPTSTR)szDHW) != CB_ERR )
{
WORD wPri = 0;
WORD wSub = 0;
if ( GetLangIDs( (LPTSTR)szDHW, &wPri, &wSub) )
{
gMstr.wLanguageID = MAKELANGID( wPri, wSub);
}
}
}
else
{
return( FALSE);
}
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);
}
}
}
else
{
return( FALSE);
}
break;
case IDOK:
{
gfReplace = IsDlgButtonChecked( hDlg, IDC_REPLACE);
EndDialog( hDlg, TRUE);
break;
}
case IDCANCEL:
EndDialog( hDlg, FALSE);
break;
default:
return( FALSE);
}
break;
default:
return( FALSE);
}
return( TRUE);
}
#endif //RLWIN32
/*
* Function: Make Status Line
* Builds status line string from a token
*
* Inputs:
* pszStatusLine, buffer to hold string
* pTok, pointer to token structure
*
* History:
* 3/92, implemented SteveBl
*/
static void MakeStatusLine( TOKEN *pTok)
{
TCHAR szName[32] = TEXT("");
TCHAR szResIDStr[20] = TEXT("");
static BOOL fFirstCall = TRUE;
if ( pTok->szName[0] )
{
lstrcpy( szName, pTok->szName);
}
else
#ifdef UNICODE
{
char szTmpBuf[32] = "";
_itoa(pTok->wName, szTmpBuf, 10);
_MBSTOWCS( szName,
szTmpBuf,
WCHARSIN( sizeof( szName)),
ACHARSIN( strlen( szTmpBuf) + 1));
}
#else
{
_itoa(pTok->wName, szName, 10);
}
#endif
if ( pTok->wType <= 16 || pTok->wType == ID_RT_DLGINIT )
{
LoadString( hInst,
IDS_RESOURCENAMES+pTok->wType,
szResIDStr,
TCHARSIN( sizeof( szResIDStr)));
}
else
{
#ifdef UNICODE
char szTmpBuf[40] = "";
_WCSTOMBS( szTmpBuf,
szResIDStr,
ACHARSIN( sizeof( szTmpBuf)),
(UINT)-1);
_itoa( pTok->wType, szTmpBuf, 10);
#else
_itoa( pTok->wType, szResIDStr, 10);
#endif
}
if ( fFirstCall )
{
SendMessage( hStatusWnd,
WM_FMTSTATLINE,
(WPARAM)0,
(LPARAM)TEXT("15s10s5i5i"));
fFirstCall = FALSE;
}
SendMessage( hStatusWnd, WM_UPDSTATLINE, (WPARAM)0, (LPARAM)szName);
SendMessage( hStatusWnd, WM_UPDSTATLINE, (WPARAM)1, (LPARAM)szResIDStr);
SendMessage( hStatusWnd, WM_UPDSTATLINE, (WPARAM)2, (LPARAM)pTok->wID);
SendMessage( hStatusWnd,
WM_UPDSTATLINE,
(WPARAM)3,
(LPARAM)lstrlen(pTok->szText));
}
/**************************************************************************
*Procedure: InsertQuikTokList *
* *
*Inputs: *
* file pointer to the token file *
* *
*Returns: *
* pointer to token delta list \(always NULL\) *
* *
*History: *
* 3/92 - original implementation - SteveBl *
* 2/93 - Rewrote to use get token, since tokens can be arb length *
* MHotchin. *
* *
*Comments: *
* Since RLQuikEd\'s token files are always temporary files generated *
* from res files we know that all tokens are new and unique. There is *
* never any tracking data so we never have to build a token delta info *
* list. For this reason, InsertQuikTokList allways returns NULL. *
* Also, every token must be marked as ST_TRANSLATED *
* *
**************************************************************************/
static TOKENDELTAINFO FAR *InsertQuikTokList( FILE * fpTokFile)
{
static TOKEN tInputToken;
int rcFileCode = 0;
UINT uTokCharsW = 0;
LPTSTR pszTokBuf = NULL;
rewind(fpTokFile);
while ( (rcFileCode = GetToken( fpTokFile, &tInputToken)) >= 0 )
{
if ( rcFileCode == 0 )
{
HGLOBAL hMem = NULL;
uTokCharsW = TokenToTextSize( &tInputToken) + 1;
hMem = GlobalAlloc( GMEM_ZEROINIT, MEMSIZE( uTokCharsW));
pszTokBuf = (LPTSTR)GlobalLock( hMem);
ParseTokToBuf( pszTokBuf, &tInputToken);
GlobalUnlock( hMem);
if ( SendMessage( hListWnd,
LB_ADDSTRING,
(WPARAM)0,
(LPARAM)hMem) < 0)
{
QuitT( IDS_ENGERR_11, NULL, NULL);
}
}
}
return NULL;
}
/****************************************************************************
*Procedure: LoadNewFile *
* *
*Inputs: *
* Pointer to path string *
* *
*Returns: *
* boolean success or failure *
* *
*History: *
* 6/92 - created from IDM_P_OPEN case in DoMenuCommand - t-gregti *
* *
*Comments: *
* This is nice to have so code isn't repeated in the file-browse and *
* drag-drop cases. *
*****************************************************************************/
static BOOL LoadNewFile( CHAR *szPath)
{ // Save old project
OFSTRUCT Of = { 0, 0, 0, 0, 0, ""};
if ( ! SendMessage( hMainWnd, WM_SAVEPROJECT, (LPARAM)0, (LPARAM)0) )
{
return( FALSE);
}
if ( gProj.szTok[0] ) // get rid of the old temp file
{
remove( gProj.szTok);
gProj.szTok[0] = 0;
}
strcpy( szFileName, szPath);
if ( OpenFile( szFileName, &Of, OF_EXIST) != HFILE_ERROR )
{
if ( IsExe( szFileName) )
{
gProj.fSourceEXE = TRUE;
gProj.fTargetEXE = TRUE;
}
else
{
gProj.fSourceEXE = FALSE;
gProj.fTargetEXE = FALSE;
}
strcpy( gMstr.szSrc, szFileName);
gMstr.szRdfs[0] = 0;
gProj.szTok[0] = 0;
MyGetTempFileName( 0,"TOK", 0, gProj.szTok);
sprintf( szDHW, "%s - %s", szAppName, szFileName);
SetWindowTextA( hMainWnd, szDHW);
SendMessage( hMainWnd, WM_LOADPROJECT, (LPARAM)0, (LPARAM)0);
}
return(TRUE);
}
//...................................................................
int RLMessageBoxA(
LPCSTR pszMsgText)
{
return( MessageBoxA( hMainWnd, pszMsgText, szAppName, MB_ICONSTOP|MB_OK));
}
//...................................................................
void Usage()
{
return;
}
void DoExit( int nErrCode)
{
ExitProcess( (UINT)nErrCode);
}
Reference in a new issue Copy permalink