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

2875 lines
87 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
// 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
#include <windows.h>
#ifdef RLWIN32
#include <windowsx.h>
#endif
#include <commdlg.h>
#include <shellapi.h>
#include <stdio.h>
#include <stdlib.h>
#include "windefs.h"
#include "toklist.h"
#include "RLADMIN.H"
#include "RESTOK.H"
#include "update.h"
#include "custres.h"
#include "exe2res.h"
#include "commbase.h"
#include "wincomon.h"
#include "projdata.h"
#include "showerrs.h"
#include "resread.h"
#include "langlist.h"
#include "resource.h"
// Global Variables:
extern BOOL gbMaster;
extern MSTRDATA gMstr;
extern PROJDATA gProj;
extern UCHAR szDHW[];
extern BOOL bRLGui;
#ifdef WIN32
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
CHAR szFileTitle[14] = ""; // holds base name of latest opened file
CHAR szCustFilterSpec[MAXCUSTFILTER]=""; // custom filter buffer
HWND hMainWnd = NULL; // handle to main window
HWND hListWnd = NULL; // handle to tok list window
HWND hStatusWnd = NULL; // handle to status windows
static int iLastBox = IDD_SOURCERES;
static CHAR * gszHelpFile = "rltools.hlp";
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;
static BOOL fLanguageGiven = FALSE;
static BOOL fLangSelected = FALSE;
static void DrawLBItem( LPDRAWITEMSTRUCT lpdis);
static void MakeStatusLine( TOKEN *pTok);
static BOOL SaveMtkList( HWND hWnd, FILE *fpTokFile);
static TOKENDELTAINFO FAR *InsertMtkList( FILE * fpTokFile);
static void CleanDeltaList( void);
static long lFilePointer[30];
// File IO vars
static OPENFILENAMEA ofn;
static CHAR szFilterSpec [60] = "";
static CHAR szExeFilterSpec [60] = "";
static CHAR szDllFilterSpec [60] = "";
static CHAR szResFilterSpec [60] = "";
static CHAR szExeResFilterSpec [180] = "";
static CHAR szMtkFilterSpec [60] = "";
static CHAR szMPJFilterSpec [60] = "";
static CHAR szRdfFilterSpec [60] = "";
static CHAR szFileName[MAXFILENAME] = "";// holds full name of latest opened file
static TCHAR tszAppName[100] = TEXT("");
static CHAR szAppName[100] = "";
static TCHAR szClassName[]=TEXT("RLAdminClass");
static TCHAR szStatusClass[]=TEXT("RLAdminStatus");
static BOOL fMtkChanges = FALSE; // set to true when toke file is out of date
static BOOL fMtkFile = FALSE;
static BOOL fMpjChanges = 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 CHAR szNewFileName[MAXFILENAME] = "";
static CHAR szPrompt[80] = "";
static CHAR *szFSpec = NULL;
static CHAR *szExt = NULL;
static TOKENDELTAINFO FAR *pTokenDeltaInfo; // linked list of token deta info
// Window vars
static HCURSOR hHourGlass = NULL; // handle to hourglass cursor
static HCURSOR hSaveCursor = NULL; // current cursor handle
static HACCEL hAccTable = NULL;
static RECT Rect = {0,0,0,0}; // dimension of the client window
static UINT cyChildHeight = 0; // height of status windows
// NOTIMPLEMENTED is a macro that displays a "Not implemented" dialog
#define NOTIMPLEMENTED {\
LoadString(hInst,IDS_NOT_IMPLEMENTED,szDHW, DHWSIZE);\
MessageBox(hMainWnd,szDHW,tszAppName,MB_ICONEXCLAMATION | MB_OK);}
// Edit Tok Dialog
static FARPROC lpTokEditDlg = NULL;
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[180] = "";
gbMaster=TRUE;
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_MTKSPEC,sz,sizeof(sz));
szFilterSpecFromSz1Sz2(szMtkFilterSpec,sz,"*.MTK");
LoadStrIntoAnsiBuf(hInstance,IDS_RDFSPEC,sz,sizeof(sz));
szFilterSpecFromSz1Sz2(szRdfFilterSpec,sz,"*.RDF");
LoadStrIntoAnsiBuf(hInstance,IDS_MPJSPEC,sz,sizeof(sz));
szFilterSpecFromSz1Sz2(szMPJFilterSpec,sz,"*.MPJ");
szFilterSpecFromSz1Sz2(szFilterSpec,sz,"*.MPJ");
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("RLAdminIcon"));
wc.hCursor = LoadCursor((HINSTANCE) NULL, IDC_ARROW);
wc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
wc.lpszMenuName = TEXT("RLAdmin");
wc.lpszClassName = szClassName;
return( RegisterClass( (CONST WNDCLASS *)&wc) ? TRUE : FALSE);
}
/**
*
*
* 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("RLAdmin"));
hMainWnd = CreateWindow( szClassName,
tszAppName,
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
(HWND) NULL,
(HMENU) NULL,
(HINSTANCE)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),
hMainWnd,
(HMENU)IDC_LIST, // Child control i.d.
hInstance,
NULL);
if ( ! hListWnd )
{
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,
hInst,
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 = MAXFILENAME;
ofn.lpstrInitialDir = NULL;
ofn.lpstrFileTitle = szFileTitle;
ofn.nMaxFileTitle = MAXFILENAME;
ofn.lpstrTitle = NULL;
ofn.lpstrDefExt = "MPJ";
ofn.Flags = 0;
GetLangList();
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;
static TCHAR szString[256] = TEXT("");
hInst = hInstance;
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);
}
GetModuleFileNameA( hInst, szDHW, DHWSIZE);
GetInternalName( szDHW, szAppName, ACHARSIN( 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, (HWND)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)
{
DoListBoxCommand (hWnd, wMsg, wParam, lParam);
switch (wMsg)
{
case WM_DROPFILES:
{
#ifndef CAIRO
DragQueryFileA((HDROP)wParam, 0, szDHW, MAXFILENAME);
#else
DragQueryFile((HDROP)wParam, 0, szDHW, MAXFILENAME);
#endif
MessageBoxA( hWnd, szDHW, szAppName, MB_OK);
if ( SendMessage( hWnd, WM_SAVEPROJECT, (WPARAM)0, (LPARAM)0) )
{
if ( GetMasterProjectData( gProj.szMpj,
NULL,
NULL,
FALSE) == SUCCESS )
{
sprintf( szDHW, "%s - %s", szAppName, gProj.szMpj);
SetWindowTextA( hMainWnd, szDHW);
SendMessage( hMainWnd, WM_LOADTOKENS, (WPARAM)0, (LPARAM)0);
}
}
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, 0L);
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)) &&
fMtkFile)
#else // not UNICODE
if ((IsClipboardFormatAvailable(CF_TEXT) ||
IsClipboardFormatAvailable(CF_OEMTEXT)) &&
fMtkFile)
#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:
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_LOADTOKENS:
{
HMENU hMenu = NULL;
FILE *f = NULL;
OFSTRUCT Of = { 0, 0, 0, 0, 0, ""};
// 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 ( OpenFile( gMstr.szMtk, &Of, OF_EXIST) == HFILE_ERROR )
{
// file doesn't exist, create it
BOOL bUpdate;
HCURSOR hOldCursor;
hOldCursor = SetCursor(hHourGlass);
LoadCustResDescriptions(gMstr.szRdfs);
GenerateTokFile(gMstr.szMtk,
gMstr.szSrc,
&bUpdate, 0);
SetCursor(hOldCursor);
ClearResourceDescriptions();
SzDateFromFileName( gMstr.szSrcDate, gMstr.szSrc);
SzDateFromFileName( gMstr.szMpjLastRealUpdate, gMstr.szMtk);
fMpjChanges = TRUE;
fMPJOutOfDate = FALSE;
}
SzDateFromFileName( szDHW, gMstr.szSrc);
if ( lstrcmpA( szDHW, gMstr.szSrcDate) )
{
HCURSOR hOldCursor;
BOOL bUpdate;
// MPJ is not up to date
fMPJOutOfDate = TRUE;
hOldCursor = SetCursor( hHourGlass);
LoadCustResDescriptions( gMstr.szRdfs);
GenerateTokFile( gMstr.szMtk,
gMstr.szSrc,
&bUpdate, 0);
if ( bUpdate )
{
SzDateFromFileName( gMstr.szMpjLastRealUpdate,
gMstr.szMtk);
}
ClearResourceDescriptions();
SzDateFromFileName(gMstr.szSrcDate,
gMstr.szSrc);
fMpjChanges = TRUE;
fMPJOutOfDate = FALSE;
SetCursor(hOldCursor);
}
else
{
fMPJOutOfDate = FALSE;
}
if ( f = fopen(gMstr.szMtk,"rt") )
{
HCURSOR hOldCursor;
hOldCursor = SetCursor(hHourGlass);
// Insert tokens from token file into the list box
pTokenDeltaInfo = InsertMtkList(f);
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_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_COPY, MF_ENABLED|MF_BYCOMMAND);
EnableMenuItem(hMenu, IDM_E_COPYTOKEN, MF_ENABLED|MF_BYCOMMAND);
EnableMenuItem(hMenu, IDM_E_PASTE, MF_ENABLED|MF_BYCOMMAND);
fMtkFile = TRUE;
fMtkChanges = FALSE;
SetCursor(hOldCursor);
}
break;
}
case WM_SAVEPROJECT:
{
fMtkFile = FALSE;
if ( fMtkChanges )
{
FILE *f = NULL;
if ( (f = fopen( gMstr.szMtk, "wt")) )
{
SaveMtkList( hWnd,f);
FCLOSE(f);
SzDateFromFileName( gMstr.szMpjLastRealUpdate,
gMstr.szMtk);
fMtkChanges = FALSE;
fMpjChanges = TRUE;
}
else
{
LoadStrIntoAnsiBuf(hInst, IDS_FILESAVEERR, szDHW, DHWSIZE);
MessageBoxA( hWnd,
szDHW,
gMstr.szMtk,
MB_ICONHAND | MB_OK);
return FALSE;
}
}
if ( fMpjChanges )
{
if ( PutMasterProjectData( gProj.szMpj) != SUCCESS )
{
LoadStrIntoAnsiBuf(hInst, IDS_FILESAVEERR, szDHW, DHWSIZE);
MessageBoxA(hWnd, szDHW,gProj.szMpj, MB_ICONHAND | MB_OK);
return FALSE;
}
fMpjChanges = FALSE;
}
return TRUE; // everything saved ok
}
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; // struct for token read from token list
TCHAR szName[32] = TEXT(""); // buffer to hold token name
CHAR szTmpBuf[64] = "";
TCHAR szID[14] = TEXT(""); // buffer to hold token id
TCHAR sz[512] = TEXT(""); // buffer to hold messages
static UINT wIndex= 0;
LONG lListParam = 0L;
HWND hCtl = NULL;
LPTSTR lpstrToken = NULL;
HGLOBAL hMem = NULL;
// this is the WM_COMMAND
switch (wMsg)
{
case WM_TOKEDIT:
{
WORD wReservedOld;
TCHAR *szBuffer;
// 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);
lpstrToken = (LPTSTR)GlobalLock( hMem);
szBuffer = (TCHAR *)FALLOC( MEMSIZE( lstrlen( lpstrToken) + 1));
lstrcpy( szBuffer, lpstrToken);
GlobalUnlock( hMem);
ParseBufToTok(szBuffer, &tok);
RLFREE( szBuffer);
wReservedOld = tok.wReserved;
switch (LOWORD(wParam))
{
case 0:
tok.wReserved = 0;
break;
case 1:
tok.wReserved = ST_CHANGED|ST_NEW;
break;
case 2:
tok.wReserved = ST_NEW;
break;
case 3:
tok.wReserved = ST_READONLY;
break;
}
if (wReservedOld != tok.wReserved)
{
fMtkChanges = TRUE;
}
szBuffer = (TCHAR *)FALLOC( MEMSIZE( TokenToTextSize( &tok)));
ParseTokToBuf( szBuffer, &tok);
RLFREE( tok.szText);
SendMessage( hListWnd, WM_SETREDRAW, (WPARAM)FALSE, (LPARAM)0);
// Now remove old token
SendMessage( hListWnd, LB_DELETESTRING, (WPARAM)wIndex, (LPARAM)0);
// Replacing with the new token
hMem = GlobalAlloc( GMEM_ZEROINIT, MEMSIZE( lstrlen( szBuffer) + 1));
lpstrToken = (LPTSTR)GlobalLock( hMem);
lstrcpy( lpstrToken, szBuffer);
GlobalUnlock( hMem);
SendMessage( hListWnd,
LB_INSERTSTRING,
(WPARAM)wIndex,
(LPARAM)hMem);
RLFREE( szBuffer);
// 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
UINT wListParam = 0;
// 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,
(WPARAM)IDC_LIST,
(LPARAM)lListParam);
#else
SendMessage( hMainWnd,
WM_COMMAND,
MAKEWPARAM( IDC_LIST, LBN_DBLCLK),
(LPARAM)0);
#endif
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:
{
TCHAR szResIDStr[20] = TEXT("");
LPTSTR lpstrToken;
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("RLAdmin"),
hWnd,
TokEditDlgProc);
#else
lpTokEditDlg = (FARPROC) MakeProcInstance(TokEditDlgProc,
hInst);
hTokEditDlgWnd = CreateDialog(hInst,
TEXT("RLAdmin"),
hWnd,
lpTokEditDlg);
#endif
}
// Get token info from listbox, and place in token struct
hMem = (HGLOBAL)SendMessage( hListWnd,
LB_GETITEMDATA,
(WPARAM)wIndex,
(LPARAM)0);
lpstrToken = (LPTSTR)GlobalLock( hMem);
szBuffer = (LPTSTR)FALLOC( MEMSIZE( lstrlen( lpstrToken) + 1));
lstrcpy( szBuffer, lpstrToken);
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_TOKCURTEXT,
(LPTSTR) tok.szText);
SetDlgItemText(hTokEditDlgWnd,
IDD_TOKPREVTEXT,
(LPTSTR) FindDeltaToken(tok,
pTokenDeltaInfo,
ST_CHANGED));
hCtl = GetDlgItem(hTokEditDlgWnd,IDD_STATUS);
{
int i;
if (tok.wReserved & ST_READONLY)
{
i = 3;
}
else if (tok.wReserved == ST_NEW)
{
i = 2;
}
else if (tok.wReserved & ST_CHANGED)
{
i = 1;
}
else
{
i = 0;
}
SendMessage( hCtl, CB_SETCURSEL, (WPARAM)i, (LPARAM)0);
}
SetActiveWindow(hTokEditDlgWnd);
wIndex = (UINT)SendMessage( hListWnd,
LB_GETCURSEL,
(WPARAM)0,
(LPARAM)0);
RLFREE( tok.szText);
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;
CHAR sz[256]="";
TCHAR tsz[256] = TEXT("");
#ifndef RLWIN32
FARPROC lpNewDlg,lpViewDlg;
#endif
// Commands entered from the application menu, or child windows.
switch (GET_WM_COMMAND_ID(wParam, lParam))
{
case IDM_P_NEW:
if ( SendMessage( hWnd, WM_SAVEPROJECT, (WPARAM)0, (LPARAM)0) )
{
CHAR szOldFile[MAXFILENAME] = "";
strcpy( szOldFile, szFileName);
if ( ! GetFileNameFromBrowse( hWnd,
szFileName,
MAXFILENAME,
szSaveDlgTitle,
szFilterSpec,
"MPJ"))
{
break;
}
strcpy( gProj.szMpj, szFileName);
#ifdef RLWIN32
if (DialogBox(hInst, TEXT("PROJECT"), hWnd, NewDlgProc))
#else
lpNewDlg = MakeProcInstance( NewDlgProc, hInst);
if (DialogBox(hInst, TEXT("PROJECT"), hWnd, lpNewDlg))
#endif
{
sprintf( szDHW, "%s - %s", szAppName, gProj.szMpj);
SetWindowTextA( hWnd,szDHW);
gMstr.szSrcDate[0] = 0;
gMstr.szMpjLastRealUpdate[0] = 0;
SendMessage( hWnd, WM_LOADTOKENS, (WPARAM)0, (LPARAM)0);
}
else
{
strcpy( gProj.szMpj, szOldFile);
}
#ifndef RLWIN32
FreeProcInstance(lpTokEditDlg);
#endif
}
break;
case IDM_P_OPEN:
if ( SendMessage( hWnd, WM_SAVEPROJECT, (WPARAM)0, (LPARAM)0) )
{
if ( GetFileNameFromBrowse( hWnd,
gProj.szMpj,
MAXFILENAME,
szOpenDlgTitle,
szFilterSpec,
"MPJ"))
{
if ( GetMasterProjectData( gProj.szMpj, NULL, NULL, FALSE) == SUCCESS )
{
sprintf( szDHW, "%s - %s", szAppName, gProj.szMpj);
SetWindowTextA( hMainWnd, szDHW);
SendMessage( hMainWnd,
WM_LOADTOKENS,
(WPARAM)0,
(LPARAM)0);
}
}
}
break;
case IDM_P_VIEW:
#ifdef RLWIN32
DialogBox(hInst, TEXT("VIEWPROJECT"), hWnd, ViewDlgProc);
#else
lpViewDlg = MakeProcInstance(ViewDlgProc, hInst);
DialogBox(hInst, TEXT("VIEWPROJECT"), hWnd, lpViewDlg);
#endif
break;
case IDM_P_CLOSE:
{
HMENU hMenu;
hMenu = GetMenu(hWnd);
if ( SendMessage( hWnd, WM_SAVEPROJECT, (WPARAM)0, (LPARAM)0) )
{
// Remove file name from window title
SetWindowTextA(hMainWnd, szAppName);
// Hide token list since it's 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_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_COPY,MF_GRAYED|MF_BYCOMMAND);
EnableMenuItem(hMenu,IDM_E_COPYTOKEN,MF_GRAYED|MF_BYCOMMAND);
EnableMenuItem(hMenu,IDM_E_PASTE,MF_GRAYED|MF_BYCOMMAND);
}
break;
}
case IDM_P_EXIT:
// send wm_close message to main window
PostMessage(hMainWnd, WM_CLOSE, (WPARAM)0, (LPARAM)0);
break;
case IDM_E_COPYTOKEN:
{
HGLOBAL hStringMem = NULL;
LPTSTR lpString = NULL;
int nIndex = 0;
int nLength = 0;
LPTSTR lpstrToken = NULL;
// 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);
lpstrToken = (LPTSTR)GlobalLock( hMem);
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( 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
{
LoadString( hInst,
IDS_ERR_NO_MEMORY,
tsz,
TCHARSIN( sizeof( tsz)));
MessageBox( hWnd,
tsz,
tszAppName,
MB_ICONHAND | MB_OK);
}
}
else
{
LoadString( hInst,
IDS_ERR_NO_MEMORY,
tsz,
TCHARSIN( sizeof(tsz)));
MessageBox( hWnd,
tsz,
tszAppName,
MB_ICONHAND | MB_OK);
}
}
break;
}
case IDM_E_COPY:
{
HGLOBAL hStringMem = NULL;
HGLOBAL hMem = NULL;
LPTSTR lpString = NULL;
TCHAR *pszString = NULL;
int nIndex = 0;
int nLength = 0;
int nActual = 0;
TOKEN tok;
LPTSTR lpstrToken = NULL;
// Is anything selected in the listbox
if ( (nIndex = (int)SendMessage( hListWnd,
LB_GETCURSEL,
(WPARAM)0,
(LPARAM)0)) != LB_ERR )
{
hMem = (HGLOBAL)SendMessage( hListWnd,
LB_GETITEMDATA,
(WPARAM)nIndex,
(LPARAM)0);
lpstrToken = (LPTSTR)
pszString = (TCHAR *)FALLOC( MEMSIZE( lstrlen( lpstrToken) + 1 ));
lstrcpy( pszString, lpstrToken);
GlobalUnlock( hMem);
ParseBufToTok( pszString, &tok);
RLFREE( pszString);
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
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
#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,
tsz,
TCHARSIN( sizeof(tsz)));
MessageBox( hWnd,
tsz,
tszAppName,
MB_ICONHAND | MB_OK);
}
}
else
{
LoadString( hInst,
IDS_ERR_NO_MEMORY,
tsz,
TCHARSIN( sizeof( tsz)));
MessageBox( hWnd,
tsz,
tszAppName,
MB_ICONHAND | MB_OK);
}
RLFREE( tok.szText);
}
break;
}
case IDM_E_PASTE:
{
HGLOBAL hClipMem = NULL;
HGLOBAL hMem = NULL;
LPTSTR lpClipMem = NULL;
TCHAR *pszPasteString = NULL;
int nIndex = 0;
TOKEN tok;
LPTSTR lpstrToken = NULL;
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 it.
break;
#else // not UNICODE
nIndex = -1;
#endif // UNICODE
}
#if defined(UNICODE) //enabled Paste command
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);
lpstrToken = (LPTSTR)GlobalLock( hMem);
pszPasteString = (LPTSTR)FALLOC( MEMSIZE( lstrlen( lpstrToken) + 1));
lstrcpy( pszPasteString, lpstrToken);
GlobalUnlock( hMem);
// copy the string to the token
ParseBufToTok( pszPasteString, &tok);
RLFREE( pszPasteString);
RLFREE( tok.szText);
tok.szText = (TCHAR *)FALLOC( MEMSIZE( lstrlen( lpClipMem) + 1));
lstrcpy( tok.szText, lpClipMem);
GlobalUnlock(hClipMem);
pszPasteString = (LPTSTR)FALLOC( MEMSIZE( TokenToTextSize( &tok) + 1));
ParseTokToBuf( pszPasteString, &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_ZEROINIT, MEMSIZE( lstrlen( pszPasteString)+1));
lpstrToken = (LPTSTR)GlobalLock( hMem);
lstrcpy( lpstrToken, pszPasteString);
GlobalUnlock( hMem);
SendMessage( hListWnd,
LB_INSERTSTRING,
(WPARAM)nIndex,
(LPARAM)hMem);
SendMessage( hListWnd,
LB_SETCURSEL,
(WPARAM)nIndex,
(LPARAM)0);
SendMessage( hListWnd,
WM_SETREDRAW,
(WPARAM)TRUE,
(LPARAM)0);
InvalidateRect(hListWnd,NULL,TRUE);
fMtkChanges = TRUE; // Set Dirty Flag
RLFREE( pszPasteString);
// 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], 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;
} //... ELSE fall thru
case IDM_E_FINDUP:
if (fSearchStarted)
{
if ( ! DoTokenSearch( 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;
} //... ELSE fall thru
case IDM_E_FIND:
{
#ifndef RLWIN32
FARPROC lpfnTOKFINDMsgProc;
lpfnTOKFINDMsgProc = MakeProcInstance((FARPROC)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 #3042
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);
#endif //DBCS
}
#ifndef RLWIN32
FreeProcInstance( lpfnTOKFINDMsgProc);
#endif
return TRUE;
}
case IDM_E_REVIEW:
{
LRESULT lrSaveSelection = 0;
nUpdateMode = 1;
// set listbox selection to begining of the token list
lrSaveSelection = SendMessage( hListWnd,
LB_GETCURSEL,
(WPARAM)0,
(LPARAM)0);
SendMessage( hListWnd, LB_SETCURSEL, (WPARAM)0, (LPARAM)0);
if ( DoTokenSearch( NULL, NULL, ST_NEW, ST_NEW, FALSE, FALSE) )
{
#ifdef RLWIN32
SendMessage( hMainWnd,
WM_COMMAND,
MAKEWPARAM( IDC_LIST, LBN_DBLCLK),
(LPARAM)0);
#else
SendMessage( hMainWnd,
WM_COMMAND,
IDC_LIST,
MAKELONG( 0, LBN_DBLCLK));
#endif
}
}
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 ,
tsz,
TCHARSIN( sizeof( tsz)));
MessageBox( hWnd, tsz, NULL, MB_OK);
}
else
{
WinHelpA( hWnd, gszHelpFile, HELP_KEY,(DWORD_PTR)((LPSTR)"RLAdmin"));
}
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;
default:
break;
} // WM_COMMAND switch
return FALSE;
}
/**
*
*
* 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 TokEditDlgProc(
HWND hDlg,
UINT wMsg,
WPARAM wParam,
LPARAM lParam)
{
HWND hCtl;
HWND hParentWnd;
UINT static wcTokens = 0;
UINT wIndex;
static BOOL fChanged = FALSE;
switch(wMsg)
{
case WM_INITDIALOG:
cwCenter(hDlg, 0);
wcTokens = (UINT)SendMessage( hListWnd,
LB_GETCOUNT,
(WPARAM)0,
(LPARAM)0);
wcTokens--;
hCtl = GetDlgItem(hDlg,IDD_STATUS);
{
TCHAR sz[80];
LoadString( hInst, IDS_UNCHANGED, sz, TCHARSIN( sizeof( sz)));
SendMessage( hCtl, CB_ADDSTRING, (WPARAM)0, (LPARAM)sz);
LoadString( hInst, IDS_CHANGED, sz, TCHARSIN( sizeof( sz)));
SendMessage( hCtl, CB_ADDSTRING, (WPARAM)0, (LPARAM)sz);
LoadString( hInst, IDS_NEW, sz, TCHARSIN( sizeof( sz)));
SendMessage( hCtl, CB_ADDSTRING, (WPARAM)0, (LPARAM)sz);
LoadString( hInst, IDS_READONLY, sz, TCHARSIN( sizeof( sz)));
SendMessage( hCtl, CB_ADDSTRING, (WPARAM)0, (LPARAM)sz);
}
if( ! nUpdateMode )
{
if (hCtl = GetDlgItem(hDlg, IDD_SKIP))
{
EnableWindow(hCtl, FALSE);
}
}
else
{
if (hCtl = GetDlgItem(hDlg, IDD_SKIP))
{
EnableWindow(hCtl, TRUE);
}
}
fChanged = FALSE;
return TRUE;
case WM_COMMAND:
switch (GET_WM_COMMAND_ID(wParam, lParam))
{
case IDD_SKIP:
wIndex = (UINT)SendMessage( hListWnd,
LB_GETCURSEL,
(WPARAM)0,
(LPARAM)0);
if ( nUpdateMode && wIndex < wcTokens )
{
wIndex ++;
SendMessage( hListWnd,
LB_SETCURSEL,
(WPARAM)wIndex,
(LPARAM)0);
if ( DoTokenSearch( NULL, NULL, ST_NEW, ST_NEW, FALSE, FALSE) )
{
wIndex = (UINT)SendMessage( hListWnd,
LB_GETCURSEL,
(WPARAM)0,
(LPARAM)0);
SendMessage( hMainWnd,
WM_COMMAND,
MAKEWPARAM( IDC_LIST, LBN_DBLCLK),
(LPARAM)0);
return TRUE;
}
}
nUpdateMode = 0;
DestroyWindow(hDlg);
#ifndef RLWIN32
FreeProcInstance(lpTokEditDlg);
#endif
hTokEditDlgWnd = 0;
break;
case IDD_STATUS:
fChanged = TRUE;
break;
case IDOK:
wIndex = (UINT)SendMessage( hListWnd,
LB_GETCURSEL,
(WPARAM)0,
(LPARAM)0);
if (fChanged)
{
int i;
fChanged = FALSE;
hCtl = GetDlgItem(hDlg, IDD_STATUS);
i = (int)SendMessage( hCtl,
CB_GETCURSEL,
(WPARAM)0,
(LPARAM)0);
hParentWnd = GetParent(hDlg);
SendMessage( hParentWnd, WM_TOKEDIT, (WPARAM)i, (LPARAM)0);
}
// Exit, or goto to next changed token if in update mode
if ( nUpdateMode && wIndex < wcTokens )
{
wIndex++;
SendMessage( hListWnd,
LB_SETCURSEL,
(WPARAM)wIndex,
(LPARAM)0);
if ( DoTokenSearch( NULL, NULL, ST_NEW, ST_NEW, FALSE, FALSE) )
{
// go into edit mode
SendMessage( hMainWnd,
WM_COMMAND,
MAKEWPARAM( IDC_LIST, LBN_DBLCLK),
(LPARAM)0);
return TRUE;
}
}
// fall through to IDCANCEL
case IDCANCEL:
nUpdateMode = 0;
// remove edit dialog box
DestroyWindow(hDlg);
#ifndef RLWIN32
FreeProcInstance(lpTokEditDlg);
#endif
hTokEditDlgWnd = 0;
break;
} // WM_COMMAND
return TRUE;
default:
if (hCtl = GetDlgItem(hDlg, IDOK))
{
EnableWindow(hCtl, TRUE);
}
return FALSE;
} // Main Switch
}
/**
*
*
* Function: TOKFINDMsgProc
*
* Arguments:
*
* Returns:
* NA.
*
* Errors Codes:
*
* History:
*
*
**/
INT_PTR TOKFINDMsgProc(HWND hWndDlg, UINT wMsg, WPARAM wParam, LPARAM lParam)
{
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[40] = TEXT("");
UINT i;
switch(wMsg)
{
case WM_INITDIALOG:
CheckDlgButton(hWndDlg, IDD_READONLY, 2);
CheckDlgButton(hWndDlg, IDD_CHANGED, 2);
CheckDlgButton(hWndDlg, IDD_FINDDOWN, 1);
hCtl = GetDlgItem(hWndDlg, IDD_TYPELST);
for ( i = 0; i < sizeof( rgiTokenTypes) / 2; 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(wParam)
{
case IDOK: /* Button text: "Okay" */
fSearchStarted = TRUE;
GetDlgItemText( hWndDlg,
IDD_TYPELST,
szSearchType,
TCHARSIN( sizeof( szSearchType)));
GetDlgItemText( hWndDlg,
IDD_FINDTOK,
szSearchText,
TCHARSIN( sizeof( szSearchText)));
wSearchStatus = wSearchStatusMask = 0;
switch (IsDlgButtonChecked(hWndDlg, IDD_READONLY))
{
case 1:
wSearchStatus |= ST_READONLY;
case 0:
wSearchStatusMask |= ST_READONLY;
}
switch (IsDlgButtonChecked(hWndDlg, IDD_CHANGED))
{
case 1:
wSearchStatus |= ST_CHANGED;
case 0:
wSearchStatusMask |= ST_CHANGED;
}
fSearchDirection = IsDlgButtonChecked(hWndDlg, IDD_FINDUP);
if( DoTokenSearch(szSearchType,
szSearchText,
wSearchStatus,
wSearchStatusMask,
fSearchDirection,
FALSE) )
{
EndDialog( hWndDlg, TRUE );
}
else
{
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( hWndDlg, sz2, sz1, MB_ICONINFORMATION | MB_OK);
EndDialog( hWndDlg, FALSE );
}
case IDCANCEL:
EndDialog( hWndDlg, FALSE);
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:
**/
INT_PTR APIENTRY NewDlgProc(
HWND hDlg,
UINT wMsg,
WPARAM wParam,
LPARAM lParam)
{
CHAR pszDrive[ _MAX_DRIVE] = "";
CHAR pszDir[ _MAX_DIR] = "";
CHAR pszName[ _MAX_FNAME] = "";
CHAR pszExt[ _MAX_EXT] = "";
switch ( wMsg )
{
case WM_INITDIALOG:
{
LPTSTR pszLangName = NULL;
OFSTRUCT Of = { 0, 0, 0, 0, 0, ""};
int nSel = 0;
iLastBox = IDD_SOURCERES;
fLangSelected = FALSE;
_splitpath( gProj.szMpj, pszDrive, pszDir, pszName, pszExt);
sprintf( szDHW, "%s%s%s.%s", pszDrive, pszDir, pszName, "EXE");
SetDlgItemTextA( hDlg, IDD_SOURCERES, szDHW);
sprintf( szDHW, "%s%s%s.%s", pszDrive, pszDir, pszName, "MTK");
SetDlgItemTextA( hDlg, IDD_MTK, szDHW);
sprintf( szDHW, "%s%s%s.%s", pszDrive, pszDir, pszName, "RDF");
if ( OpenFile( szDHW, &Of, OF_EXIST) != HFILE_ERROR )
SetDlgItemTextA( hDlg, IDD_RDFS, szDHW);
else
SetDlgItemText( hDlg, IDD_RDFS, TEXT(""));
if ( gMstr.uCodePage == CP_ACP )
gMstr.uCodePage = GetACP();
else if ( gMstr.uCodePage == CP_OEMCP )
gMstr.uCodePage = GetOEMCP();
if ( ! IsValidCodePage( gMstr.uCodePage) )
{
static TCHAR szMsg[ 256];
CHAR *pszCP[1];
pszCP[0] = UlongToPtr(gMstr.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_TOK_CP, gMstr.uCodePage, FALSE);
return( TRUE);
}
SetDlgItemInt( hDlg, IDD_TOK_CP, gMstr.uCodePage, FALSE);
PostMessage( hDlg, WM_COMMAND, IDD_BROWSE, 0);
return TRUE;
}
case WM_COMMAND:
switch ( GET_WM_COMMAND_ID( wParam, lParam) )
{
case IDD_SOURCERES:
case IDD_MTK:
case IDD_RDFS:
iLastBox = GET_WM_COMMAND_ID(wParam, lParam);
break;
case IDD_BROWSE:
switch ( iLastBox )
{
case IDD_SOURCERES:
szFSpec = szExeResFilterSpec;
szExt = "EXE";
LoadStrIntoAnsiBuf( hInst,
IDS_RES_SRC,
szPrompt,
ACHARSIN( sizeof( szPrompt)));
fLangSelected = FALSE;
break;
case IDD_RDFS:
szFSpec = szRdfFilterSpec;
szExt = "RDF";
LoadStrIntoAnsiBuf( hInst,
IDS_RDF,
szPrompt,
ACHARSIN( sizeof( szPrompt)));
break;
case IDD_MTK:
szFSpec = szMtkFilterSpec;
szExt = "MTK";
LoadStrIntoAnsiBuf( hInst,
IDS_MTK,
szPrompt,
ACHARSIN( sizeof(szPrompt)));
break;
}
GetDlgItemTextA(hDlg, iLastBox, szNewFileName, MAXFILENAME);
if ( GetFileNameFromBrowse( hDlg,
szNewFileName,
MAXFILENAME,
szPrompt,
szFSpec,
szExt) )
{
SetDlgItemTextA( hDlg, iLastBox, szNewFileName);
if ( iLastBox == IDD_SOURCERES )
{ // fill in suggested name for the MTK box
CHAR pszDrive[_MAX_DRIVE] = "";
CHAR pszDir[ _MAX_DIR] = "";
CHAR pszName[ _MAX_FNAME] = "";
CHAR pszExt[ _MAX_EXT] = "";
lstrcpyA( gMstr.szSrc, szNewFileName);
FillListAndSetLang( hDlg,
IDD_MSTR_LANG_NAME,
&gMstr.wLanguageID,
&fLangSelected);
_splitpath( szNewFileName, pszDrive, pszDir, pszName, pszExt);
GetDlgItemTextA(hDlg, IDD_MTK, szNewFileName, MAXFILENAME);
if ( ! szNewFileName[0] )
{
sprintf( szNewFileName,
"%s%s%s.%s",
pszDrive,
pszDir,
pszName,
"MTK");
SetDlgItemTextA( hDlg, IDD_MTK, szNewFileName);
}
}
}
break;
case IDD_MSTR_LANG_NAME:
if ( GET_WM_COMMAND_CMD( wParam, lParam) == CBN_SELENDOK )
{
fLangSelected = TRUE;
}
break;
case IDOK:
if ( fLangSelected )
{
MSTRDATA stProject =
{ "", "", "", "", "",
MAKELANGID( LANG_ENGLISH, SUBLANG_ENGLISH_US),
CP_ACP
};
BOOL fTranslated = FALSE;
UINT uCP = GetDlgItemInt( hDlg,
IDD_TOK_CP,
&fTranslated,
FALSE);
//... Get the selected language name
//... then set the appropriate lang id vals
INT_PTR nSel = SendDlgItemMessage( hDlg,
IDD_MSTR_LANG_NAME,
CB_GETCURSEL,
(WPARAM)0,
(LPARAM)0);
if ( nSel != 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
{
fLangSelected = FALSE;
return( TRUE);
}
}
if ( uCP == CP_ACP )
uCP = GetACP();
else if ( uCP == CP_OEMCP )
uCP = GetOEMCP();
if ( IsValidCodePage( uCP) )
{
gMstr.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, gMstr.uCodePage, FALSE);
return( TRUE);
}
GetDlgItemTextA( hDlg,
IDD_SOURCERES,
stProject.szSrc,
MAXFILENAME);
GetDlgItemTextA( hDlg,
IDD_RDFS,
stProject.szRdfs,
MAXFILENAME);
GetDlgItemTextA( hDlg,
IDD_MTK,
stProject.szMtk,
MAXFILENAME);
if ( stProject.szSrc[0] && stProject.szMtk[0] )
{
_fullpath( gMstr.szSrc,
stProject.szSrc,
ACHARSIN( sizeof( gMstr.szSrc)));
_fullpath( gMstr.szMtk,
stProject.szMtk,
ACHARSIN( sizeof( gMstr.szMtk)));
if ( stProject.szRdfs[0] )
{
_fullpath( gMstr.szRdfs,
stProject.szRdfs,
ACHARSIN( sizeof( gMstr.szRdfs)));
}
else
{
gMstr.szRdfs[0] = '\0';
}
gProj.fSourceEXE = IsExe( gMstr.szSrc);
EndDialog( hDlg, TRUE);
return( TRUE);
}
else
{
break;
}
}
else
{
LoadString( hInst, IDS_SELECTLANG, (LPTSTR)szDHW, TCHARSIN( DHWSIZE));
MessageBox( hDlg, (LPTSTR)szDHW, tszAppName, MB_ICONHAND | MB_OK);
break;
}
case IDCANCEL:
EndDialog(hDlg, FALSE);
return( TRUE);
}
break;
}
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 ViewDlgProc(
HWND hDlg,
UINT wMsg,
WPARAM wParam,
LPARAM lParam)
{
static int iLastBox = IDD_SOURCERES;
switch(wMsg)
{
case WM_INITDIALOG:
{
WORD wPri = PRIMARYLANGID( gMstr.wLanguageID);
WORD wSub = SUBLANGID( gMstr.wLanguageID);
LPTSTR pszName = GetLangName( wPri, wSub);
SetDlgItemTextA( hDlg, IDD_VIEW_SOURCERES, gMstr.szSrc);
SetDlgItemTextA( hDlg, IDD_VIEW_MTK, gMstr.szMtk);
SetDlgItemTextA( hDlg, IDD_VIEW_RDFS, gMstr.szRdfs);
SetDlgItemText( hDlg, IDD_MSTR_LANG_NAME, pszName);
SetDlgItemInt( hDlg, IDD_TOK_CP, gMstr.uCodePage, FALSE);
return TRUE;
}
case WM_COMMAND:
switch ( wParam )
{
case IDOK:
EndDialog( hDlg, TRUE);
return TRUE;
}
}
return FALSE;
}
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 rgbChangedText;
static DWORD rgbBackColor;
static DWORD rgbUnchangedText;
static DWORD rgbReadOnlyText;
static DWORD rgbNewText;
TCHAR *szToken = NULL;
TOKEN tok;
LPTSTR lpstrToken = NULL;
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 = (LPTSTR)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)
{
rgbChangedText = RGB(255, 0, 0);
rgbBackColor = RGB(192, 192, 192);
rgbUnchangedText = RGB(0, 0, 0);
rgbReadOnlyText = RGB(127, 127, 127);
rgbNewText = RGB(0, 0, 255);
hBrushNormal = CreateSolidBrush(rgbBackColor);
}
if (tok.wReserved & ST_READONLY)
{
rgbOldText = SetTextColor(lpdis->hDC, rgbReadOnlyText);
}
else if (tok.wReserved & ST_CHANGED)
{
rgbOldText = SetTextColor(lpdis->hDC, rgbChangedText);
}
else if (tok.wReserved & ST_NEW)
{
rgbOldText = SetTextColor(lpdis->hDC, rgbNewText);
}
else
{
rgbOldText = SetTextColor(lpdis->hDC, rgbUnchangedText);
}
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: Make Status Line
* Builds status line string from a token
*
* Inputs:
* pszStatusLine, buffer to hold string
* pTok, pointer to token structure
*
* History:
* 2/92, implemented SteveBl
* 7/92, changed to talk to new StatusWndProc t-GregTi
*/
static void MakeStatusLine(TOKEN *pTok)
{
static BOOL fFirstCall = TRUE;
TCHAR szName[32] = TEXT("");
TCHAR szStatus[20] = TEXT("");
TCHAR szResIDStr[20] = TEXT("");
CHAR szTmpBuf[32] = "";
// now build status line
if (pTok->szName[0])
{
lstrcpy(szName, pTok->szName);
}
else
{
#ifdef UNICODE
_itoa(pTok->wName, szTmpBuf, 10);
_MBSTOWCS( szName,
szTmpBuf,
WCHARSIN( sizeof( szName)),
ACHARSIN( strlen( szTmpBuf) + 1));
#else
_itoa(pTok->wName, szName, 10);
#endif
}
if ( pTok->wReserved & ST_READONLY )
{
LoadString( hInst,
IDS_READONLY,
szStatus,
TCHARSIN( sizeof( szStatus)));
}
else if (pTok->wReserved == ST_NEW)
{
LoadString( hInst,
IDS_NEW,
szStatus,
TCHARSIN( sizeof( szStatus)));
}
else if (pTok->wReserved & ST_CHANGED)
{
LoadString( hInst,
IDS_CHANGED,
szStatus,
TCHARSIN( sizeof( szStatus)));
}
else
{
LoadString( hInst,
IDS_UNCHANGED,
szStatus,
TCHARSIN( sizeof( szStatus)));
}
if ( pTok->wType <= 16 || pTok->wType == ID_RT_DLGINIT )
{
LoadString( hInst,
IDS_RESOURCENAMES+pTok->wType,
szResIDStr,
TCHARSIN( sizeof( szResIDStr)));
}
else
{
#ifdef UNICODE
_itoa( pTok->wType, szTmpBuf, 10);
_MBSTOWCS( szResIDStr,
szTmpBuf,
WCHARSIN( sizeof( szResIDStr)),
ACHARSIN( strlen( szTmpBuf) + 1));
#else
_itoa(pTok->wType, szResIDStr, 10);
#endif
}
if (fFirstCall)
{
SendMessage( hStatusWnd,
WM_FMTSTATLINE,
(WPARAM)0,
(LPARAM)TEXT("10s10s5i8s4i"));
fFirstCall = FALSE;
}
SendMessage( hStatusWnd, WM_UPDSTATLINE, (WPARAM)0, (LPARAM)szResIDStr);
SendMessage( hStatusWnd, WM_UPDSTATLINE, (WPARAM)1, (LPARAM)szName);
SendMessage( hStatusWnd, WM_UPDSTATLINE, (WPARAM)2, (LPARAM)pTok->wID);
SendMessage( hStatusWnd, WM_UPDSTATLINE, (WPARAM)3, (LPARAM)szStatus);
SendMessage( hStatusWnd,
WM_UPDSTATLINE,
(WPARAM)4,
(LPARAM)lstrlen( pTok->szText));
}
/**********************************************************************
*FUNCTION: SaveMtkList(HWND) *
* *
*PURPOSE: Save current Token List *
* *
*COMMENTS: *
* *
*This saves the current contents of the Token List *
**********************************************************************/
static BOOL SaveMtkList(HWND hWnd, FILE *fpTokFile)
{
BOOL bSuccess = TRUE;
int IOStatus; // result of a file write
UINT cTokens;
UINT cCurrentTok = 0;
TCHAR *szTmpBuf;
CHAR *szTokBuf;
TCHAR str[255] = TEXT("");
TOKENDELTAINFO FAR *pTokNode;
LPTSTR lpstrToken;
// 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++)
{
#ifdef UNICODE
int nLenW = 0;
int nLenA = 0;
#endif
// Get each token from list
HGLOBAL hMem = (HGLOBAL)SendMessage( hListWnd,
LB_GETITEMDATA,
(WPARAM)cCurrentTok,
(LPARAM)0);
lpstrToken = (LPTSTR)GlobalLock( hMem);
#ifdef UNICODE
nLenW = lstrlen( lpstrToken) + 1;
szTmpBuf = (TCHAR *)FALLOC( (nLenA = MEMSIZE( nLenW)));
lstrcpy( szTmpBuf, lpstrToken);
GlobalUnlock( hMem);
szTokBuf = (CHAR *)FALLOC( nLenA);
_WCSTOMBS( szTokBuf, szTmpBuf, nLenA, nLenW);
RLFREE( szTmpBuf);
#else
szTokBuf = (CHAR *)FALLOC( strlen( lpstrToken) + 1);
lstrcpy( szTokBuf, lpstrToken);
#endif
IOStatus = fprintf(fpTokFile, "%s\n", szTokBuf);
if ( IOStatus != (int) strlen(szTokBuf) + 1 )
{
LoadString( hInst,
IDS_FILESAVEERR,
str,
TCHARSIN( sizeof( str)));
MessageBox( hWnd, str, NULL, MB_OK | MB_ICONHAND);
bSuccess = FALSE;
}
RLFREE( szTokBuf);
}
}
pTokNode = pTokenDeltaInfo;
while (pTokNode)
{
TOKEN *pTok;
int nLenW = 0;
int nLenA = 0;
pTok = &(pTokNode->DeltaToken);
#ifdef UNICODE
nLenW = TokenToTextSize( pTok);
szTmpBuf = (TCHAR *)FALLOC( (nLenA = MEMSIZE( nLenW)));
ParseTokToBuf( szTmpBuf, pTok);
szTokBuf = (CHAR *)FALLOC( nLenA);
_WCSTOMBS( szTokBuf, szTmpBuf, nLenA, nLenW);
RLFREE( szTmpBuf);
#else
szTokBuf = (CHAR *)FALLOC( TokenToTextSize( pTok));
ParseTokToBuf( szTokBuf, pTok);
#endif
IOStatus = fprintf(fpTokFile, "%s\n", szTokBuf);
if ( IOStatus != (int) strlen(szTokBuf) + 1 )
{
LoadString( hInst,
IDS_FILESAVEERR,
str,
TCHARSIN( sizeof(str)));
MessageBox( hWnd, str, NULL, MB_OK | MB_ICONHAND);
bSuccess = FALSE;
}
pTokNode = pTokNode->pNextTokenDelta;
}
// 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);
}
}
static TOKENDELTAINFO FAR *InsertMtkList(FILE * fpTokFile)
{
TOKENDELTAINFO FAR * ptTokenDeltaInfo, FAR * pTokenDeltaInfo = NULL;
int scTokStat;
TOKEN tToken;
UINT wcChars = 0;
LPTSTR lpstrToken;
rewind(fpTokFile);
while ( (scTokStat = GetToken( fpTokFile, &tToken)) >= 0 )
{
if ( scTokStat == 0 )
{
if ( tToken.wReserved != ST_CHANGED )
{
HGLOBAL hMem = GlobalAlloc( GMEM_ZEROINIT, MEMSIZE( TokenToTextSize( &tToken)));
lpstrToken = (LPTSTR)GlobalLock( hMem);
ParseTokToBuf( lpstrToken, &tToken);
GlobalUnlock( hMem);
// only add tokens that aren't changed && old
if ( SendMessage( hListWnd,
LB_ADDSTRING,
(WPARAM)0,
(LPARAM)hMem) < 0 )
{
QuitA( IDS_ENGERR_11, NULL, NULL);
}
}
else
{
// the current token is delta info so save in delta list.
if (!pTokenDeltaInfo)
{
ptTokenDeltaInfo = pTokenDeltaInfo =
UpdateTokenDeltaInfo(&tToken);
}
else
{
ptTokenDeltaInfo->pNextTokenDelta =
UpdateTokenDeltaInfo(&tToken);
ptTokenDeltaInfo = ptTokenDeltaInfo->pNextTokenDelta;
}
}
RLFREE( tToken.szText);
}
}
return(pTokenDeltaInfo);
}
/*
* About -- message processor for about box
*
*/
//#ifdef RLWIN32
INT_PTR CALLBACK About(
HWND hDlg,
UINT message,
WPARAM wParam,
LPARAM lParam)
{
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( hMainWnd, pszMsgText, szAppName, MB_ICONHAND|MB_OK));
}
//...................................................................
void Usage()
{
return;
}
//...................................................................
void DoExit( int nErrCode)
{
ExitProcess( (UINT)nErrCode);
}
Reference in a new issue Copy permalink