You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1030 lines
23 KiB
1030 lines
23 KiB
/*++
|
|
|
|
Copyright (c) 1990-1995 Microsoft Corporation
|
|
|
|
|
|
Module Name:
|
|
|
|
resource.c
|
|
|
|
|
|
Abstract:
|
|
|
|
This module contains functions to load resources
|
|
|
|
|
|
Author:
|
|
|
|
29-Aug-1995 Tue 12:29:27 created -by- Daniel Chou (danielc)
|
|
|
|
|
|
[Environment:]
|
|
|
|
NT Windows - Common Printer Driver UI DLL.
|
|
|
|
|
|
[Notes:]
|
|
|
|
|
|
Revision History:
|
|
|
|
|
|
--*/
|
|
|
|
|
|
#include "precomp.h"
|
|
#pragma hdrstop
|
|
|
|
|
|
#define DBG_CPSUIFILENAME DbgResource
|
|
|
|
|
|
|
|
#define DBG_GETSTR0 0x00000001
|
|
#define DBG_GETSTR1 0x00000002
|
|
#define DBG_GETICON 0x00000004
|
|
#define DBG_COMPOSESTR 0x00000008
|
|
#define DBG_ADD_SPACE 0x00000010
|
|
#define DBG_ADD_WCHAR 0x00000020
|
|
#define DBG_AMPERCENT 0x00000040
|
|
|
|
|
|
DEFINE_DBGVAR(0);
|
|
|
|
|
|
|
|
extern HINSTANCE hInstDLL;
|
|
|
|
|
|
//
|
|
// Remove Ampercent will remove a '&' sign, if two '&' signs (ie. '&&') then
|
|
// only one is removed, ALSO if a '(&X)' (ie. SPACE + & + Left Parenthesis +
|
|
// Single Character + Right Parenthesis) then it consider to be a Localization
|
|
// hot key indicator, then the whole ' (&X)' will be removed
|
|
//
|
|
|
|
|
|
#define REMOVE_AMPERCENT(CHTYPE) \
|
|
{ \
|
|
CHTYPE *pOrg; \
|
|
CHTYPE *pCopy; \
|
|
UINT cRemoved; \
|
|
CHTYPE ch; \
|
|
\
|
|
\
|
|
cRemoved = 0; \
|
|
pOrg = \
|
|
pCopy = pStr; \
|
|
\
|
|
CPSUIDBG(DBG_AMPERCENT, ("RemoveAmpercent (ORG)='%ws'", pOrg)); \
|
|
\
|
|
do { \
|
|
\
|
|
while ((ch = *pStr++) && (ch != (CHTYPE)'&')) { \
|
|
\
|
|
if (cRemoved) { \
|
|
\
|
|
*pCopy = ch; \
|
|
} \
|
|
\
|
|
++pCopy; \
|
|
} \
|
|
\
|
|
if (ch) { \
|
|
\
|
|
++cRemoved; \
|
|
\
|
|
if (*pStr == (CHTYPE)'&') { \
|
|
\
|
|
*pCopy++ = *pStr++; \
|
|
\
|
|
} else if ((*(pCopy - 1) == (CHTYPE)'(') && \
|
|
(*(pStr + 1) == (CHTYPE)')')) { \
|
|
\
|
|
cRemoved += 3; \
|
|
ch = (CHTYPE)')'; \
|
|
pCopy -= 1; \
|
|
pStr += 2; \
|
|
\
|
|
if ((*pStr == (CHTYPE)' ') && \
|
|
((pCopy == pOrg) || \
|
|
((pCopy > pOrg) && \
|
|
(*(pCopy - 1) == (CHTYPE)' ')))) { \
|
|
\
|
|
CPSUIDBG(DBG_AMPERCENT, ("Extra SPACE")); \
|
|
\
|
|
if (pCopy == pOrg) { \
|
|
\
|
|
++pStr; \
|
|
\
|
|
} else { \
|
|
\
|
|
--pCopy; \
|
|
} \
|
|
\
|
|
++cRemoved; \
|
|
} \
|
|
} \
|
|
} \
|
|
\
|
|
} while (ch); \
|
|
\
|
|
if (cRemoved) { \
|
|
\
|
|
*pCopy = (CHTYPE)'\0'; \
|
|
\
|
|
CPSUIDBG(DBG_AMPERCENT, (" RemoveAmpercent (%3ld)='%ws'", \
|
|
cRemoved, pOrg)); \
|
|
} \
|
|
\
|
|
return(cRemoved); \
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
UINT
|
|
RemoveAmpersandA(
|
|
LPSTR pStr
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function remove ampersand from a string, the string must be writable
|
|
|
|
|
|
Arguments:
|
|
|
|
pStr - string to be serarch and remove the ampersand if found
|
|
|
|
|
|
Return Value:
|
|
|
|
UINT, count of ampersands removed
|
|
|
|
|
|
Author:
|
|
|
|
19-Sep-1995 Tue 21:55:19 created -by- Daniel Chou (danielc)
|
|
|
|
|
|
Revision History:
|
|
|
|
|
|
--*/
|
|
|
|
{
|
|
REMOVE_AMPERCENT(CHAR);
|
|
}
|
|
|
|
|
|
|
|
|
|
UINT
|
|
RemoveAmpersandW(
|
|
LPWSTR pStr
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function remove ampersand from a string, the string must be writable
|
|
|
|
|
|
Arguments:
|
|
|
|
pwStr - string to be serarch and remove the ampersand if found
|
|
|
|
|
|
Return Value:
|
|
|
|
UINT, count of ampersands removed
|
|
|
|
|
|
Author:
|
|
|
|
19-Sep-1995 Tue 21:55:19 created -by- Daniel Chou (danielc)
|
|
|
|
|
|
Revision History:
|
|
|
|
|
|
--*/
|
|
|
|
{
|
|
REMOVE_AMPERCENT(WCHAR);
|
|
}
|
|
|
|
|
|
|
|
|
|
UINT
|
|
DupAmpersandW(
|
|
LPWSTR pwStr,
|
|
INT cChar,
|
|
INT cMaxChar
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function remove ampersand from a string, the string must be writable
|
|
|
|
|
|
Arguments:
|
|
|
|
pwStr - string to be serarch and remove the ampersand if found
|
|
|
|
|
|
Return Value:
|
|
|
|
UINT, count of ampersands removed
|
|
|
|
|
|
Author:
|
|
|
|
19-Sep-1995 Tue 21:55:19 created -by- Daniel Chou (danielc)
|
|
|
|
|
|
Revision History:
|
|
|
|
|
|
--*/
|
|
|
|
{
|
|
LPWSTR pw;
|
|
LPWSTR pwCopy;
|
|
INT i;
|
|
INT cAdd = 0;
|
|
|
|
|
|
if (((i = cChar) > 0) && ((cMaxChar -= cChar) > 0)) {
|
|
|
|
pw = pwStr;
|
|
|
|
while ((i--) && (cAdd < cMaxChar)) {
|
|
|
|
if (*pw++ == L'&') {
|
|
|
|
++cAdd;
|
|
}
|
|
}
|
|
|
|
if (cAdd) {
|
|
|
|
pw = pwStr + cChar;
|
|
pwCopy = pw + cAdd;
|
|
|
|
CPSUIASSERT(0, "DupAmpersandW(): pwStr[%u] is not NULL",
|
|
*pw == L'\0', IntToPtr(cChar));
|
|
|
|
while (pwCopy >= pwStr) {
|
|
|
|
if ((*pwCopy-- = *pw--) == L'&') {
|
|
|
|
*pwCopy-- = L'&';
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return((UINT)cAdd);
|
|
}
|
|
|
|
|
|
|
|
|
|
UINT
|
|
GetString(
|
|
PGSBUF pGSBuf,
|
|
LPTSTR pStr
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function load the string either from caller (ANSI or UNICODE) or
|
|
from common UI DLL, if the pStr is valid then it will just it, after
|
|
getting the correct string, it will convert it to UNICODE as needed
|
|
|
|
Arguments:
|
|
|
|
pGSBuf - Pointer to GSBUF structure and following structure must set
|
|
|
|
pTVWnd - Pointer to the TVWND which has all then information
|
|
needed.
|
|
|
|
pBuf - Pointer to the begining of the buffer (LPWSTR)
|
|
|
|
pEndBuf - Pointer to the end of the buffer
|
|
|
|
|
|
pStr - Pointer to the string to be converted
|
|
|
|
|
|
Return Value:
|
|
|
|
UINT - Count of character stored in the pBuf not include the NULL
|
|
terminator, if the pBuf only has one character left then it
|
|
always store a NULL and return 0
|
|
|
|
|
|
Author:
|
|
|
|
29-Aug-1995 Tue 12:30:49 created -by- Daniel Chou (danielc)
|
|
First version
|
|
|
|
31-Aug-1995 Thu 10:58:04 updated -by- Daniel Chou (danielc)
|
|
Re-write to do UNICODE conversion and ANSI call checking
|
|
|
|
05-Feb-1996 Mon 12:20:28 updated -by- Daniel Chou (danielc)
|
|
Fix the bug when UNICODE we do lstrcpy without checking the buffer
|
|
size.
|
|
|
|
Revision History:
|
|
|
|
|
|
--*/
|
|
|
|
{
|
|
LPWSTR pBuf;
|
|
WORD Flags;
|
|
GSBUF GSBuf = *pGSBuf;
|
|
UINT RemoveAmpersandOff = 0;
|
|
INT cChar;
|
|
INT Len = 0;
|
|
|
|
|
|
//
|
|
// Make pBuf pointed to the first available character
|
|
//
|
|
|
|
pBuf = pGSBuf->pBuf;
|
|
Flags = pGSBuf->Flags;
|
|
|
|
|
|
CPSUIASSERT(0, "GetString(pBuf=NULL)", pBuf, 0);
|
|
|
|
if (pGSBuf->pEndBuf) {
|
|
|
|
cChar = (INT)(pGSBuf->pEndBuf - pBuf);
|
|
|
|
} else {
|
|
|
|
cChar = MAX_RES_STR_CHARS;
|
|
}
|
|
|
|
//
|
|
// Check if we have room to convert the string, make sure we reduced the
|
|
// cChar by one for the NULL terminator
|
|
//
|
|
|
|
if ((pStr == NULL) || (cChar < 2)) {
|
|
|
|
if (pStr) {
|
|
|
|
CPSUIWARN(("GetString: pStr=%08lx, Buffer cChar=%ld too smaller",
|
|
pStr, cChar));
|
|
}
|
|
|
|
*pBuf = L'\0';
|
|
return(0);
|
|
}
|
|
|
|
if (pGSBuf->chPreAdd != L'\0') {
|
|
|
|
CPSUIDBG(DBG_GETSTR0, ("GetString(): Pre-Add Char = '%wc'",
|
|
pGSBuf->chPreAdd));
|
|
|
|
//
|
|
// If we pre-add character first then do it now
|
|
//
|
|
|
|
if ((*pBuf++ = pGSBuf->chPreAdd) == L'&') {
|
|
|
|
RemoveAmpersandOff = 1;
|
|
}
|
|
|
|
cChar--;
|
|
pGSBuf->chPreAdd = L'\0';
|
|
}
|
|
|
|
if (--cChar < 1) {
|
|
|
|
CPSUIDBG(DBG_GETSTR1, ("GetString()=Only has one character for SPACE"));
|
|
NULL;
|
|
|
|
} else if (!VALID_PTR(pStr)) {
|
|
|
|
HINSTANCE hInst;
|
|
WORD ResID;
|
|
|
|
|
|
//
|
|
// Apperantly this is the resource ID, the LoadString() will not
|
|
// write exceed the cChar included the NULL terminator according to
|
|
// the Win32 help file. At here we know we either have to convert
|
|
// the ASCII string to UNICODE or we load the UNICODE string to the
|
|
// buffer already
|
|
//
|
|
|
|
ResID = LOWORD(LODWORD(pStr));
|
|
|
|
CPSUIDBGBLK({
|
|
|
|
if ((ResID >= IDI_CPSUI_ICONID_FIRST) &&
|
|
(ResID <= IDI_CPSUI_ICONID_LAST)) {
|
|
|
|
CPSUIERR(("ResID=%ld is in icon ID range, change it", ResID));
|
|
|
|
ResID = ResID - IDI_CPSUI_ICONID_FIRST + IDS_CPSUI_STRID_FIRST;
|
|
}
|
|
})
|
|
|
|
if ((ResID >= IDS_CPSUI_STRID_FIRST) &&
|
|
(ResID <= IDS_CPSUI_STRID_LAST)) {
|
|
|
|
hInst = hInstDLL;
|
|
|
|
if (Flags & GBF_INT_NO_PREFIX) {
|
|
|
|
Flags &= ~GBF_PREFIX_OK;
|
|
}
|
|
|
|
} else {
|
|
|
|
hInst = (Flags & GBF_IDS_INT_CPSUI) ? hInstDLL : pGSBuf->hInst;
|
|
|
|
CPSUIASSERT(0, "GetString(hInst=NULL, %08lx)", pStr, 0);
|
|
}
|
|
|
|
//
|
|
// Now loaded from common UI DLL directly to the user buffer
|
|
//
|
|
|
|
if (Len = LoadString(hInst, ResID, pBuf, cChar)) {
|
|
|
|
pBuf += Len;
|
|
|
|
} else {
|
|
|
|
pBuf = pGSBuf->pBuf;
|
|
|
|
CPSUIERR(("LoadString(ID=%ld) FAILED", ResID));
|
|
}
|
|
|
|
} else if ((Flags & GBF_COPYWSTR) ||
|
|
(!(Flags & GBF_ANSI_CALL))) {
|
|
|
|
//
|
|
// We have UNICODE string but may need to put into the buffer
|
|
//
|
|
|
|
if (Len = lstrlen(pStr)) {
|
|
|
|
if (Len > cChar) {
|
|
|
|
Len = cChar;
|
|
}
|
|
|
|
CopyMemory(pBuf, pStr, sizeof(WCHAR) * Len);
|
|
|
|
pBuf += Len;
|
|
}
|
|
|
|
} else {
|
|
|
|
//
|
|
// We are loading the ANSI string
|
|
//
|
|
|
|
if (Len = lstrlenA((LPSTR)pStr)) {
|
|
|
|
if (Len = MultiByteToWideChar(CP_ACP,
|
|
0,
|
|
(LPCSTR)pStr,
|
|
Len,
|
|
pBuf,
|
|
cChar)) {
|
|
pBuf += Len;
|
|
|
|
} else {
|
|
|
|
//
|
|
// Conversion is not complete so make sure it NULL terminated
|
|
//
|
|
|
|
pBuf = pGSBuf->pBuf;
|
|
|
|
CPSUIWARN(("GetString: pstr='%hs', Buffer reach limit=%ld, Len=%ld",
|
|
pStr, cChar, Len));
|
|
}
|
|
|
|
CPSUIDBG(DBG_GETSTR0, ("Convert to UNICODE, Len=%d, cChar=%d",
|
|
Len, cChar));
|
|
}
|
|
}
|
|
|
|
//
|
|
// Save the new index back and return the len to the caller
|
|
//
|
|
|
|
*pBuf = L'\0';
|
|
Len = (INT)(pBuf - pGSBuf->pBuf);
|
|
|
|
if (!(Flags & GBF_PREFIX_OK)) {
|
|
|
|
Len -= RemoveAmpersandW(pGSBuf->pBuf + RemoveAmpersandOff);
|
|
}
|
|
|
|
if (Flags & GBF_DUP_PREFIX) {
|
|
|
|
Len += DupAmpersandW(pGSBuf->pBuf,
|
|
Len,
|
|
(INT)(UINT)(pGSBuf->pEndBuf - pGSBuf->pBuf));
|
|
}
|
|
|
|
CPSUIDBG(DBG_GETSTR1, ("GetString()=%ws (%d/%d)", pGSBuf->pBuf, Len, cChar));
|
|
|
|
CPSUIASSERT(0, "GetString() : Len != Real Len (%ld)",
|
|
Len == lstrlen(pGSBuf->pBuf), IntToPtr(lstrlen(pGSBuf->pBuf)));
|
|
|
|
pGSBuf->pBuf += Len;
|
|
|
|
return((UINT)Len);
|
|
}
|
|
|
|
|
|
|
|
|
|
UINT
|
|
GSBufAddNumber(
|
|
PGSBUF pGSBuf,
|
|
DWORD Number,
|
|
BOOL Sign
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Convert a number to a string with the limitation of GSBUF
|
|
|
|
|
|
Arguments:
|
|
|
|
pGSBuf - Pointer to GSBUF structure and following structure must set
|
|
|
|
pTVWnd - Pointer to the TVWND which has all then information
|
|
needed.
|
|
|
|
pBuf - Pointer to the begining of the buffer (LPWSTR)
|
|
|
|
pEndBuf - Pointer to the end of the buffer
|
|
|
|
|
|
Number - LONG number to be converted
|
|
|
|
Sign - if TRUE then Number is a sign long number else it is a unsigned
|
|
DWORD
|
|
|
|
Return Value:
|
|
|
|
UINT total bytes converted to the string
|
|
|
|
|
|
Author:
|
|
|
|
21-Feb-1996 Wed 12:17:00 created -by- Daniel Chou (danielc)
|
|
|
|
|
|
Revision History:
|
|
|
|
|
|
--*/
|
|
|
|
{
|
|
WCHAR wBuf[50];
|
|
UINT cChar;
|
|
UINT Len = 0;
|
|
|
|
if ((cChar = (INT)(pGSBuf->pEndBuf - pGSBuf->pBuf - 1)) > 0) {
|
|
|
|
StringCchPrintfW(wBuf, COUNT_ARRAY(wBuf), (Sign) ? L"%ld" : L"%lu", Number);
|
|
if((Len = lstrlenW(wBuf)) > 0) {
|
|
|
|
if (Len > cChar) {
|
|
|
|
Len = cChar;
|
|
}
|
|
|
|
CopyMemory(pGSBuf->pBuf, wBuf, sizeof(WCHAR) * Len);
|
|
|
|
pGSBuf->pBuf += Len;
|
|
*(pGSBuf->pBuf) = L'\0';
|
|
}
|
|
}
|
|
|
|
return Len;
|
|
}
|
|
|
|
|
|
|
|
UINT
|
|
GSBufAddWChar(
|
|
PGSBUF pGSBuf,
|
|
UINT IntCharStrID,
|
|
UINT Count
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Add a single character to the GSBuf
|
|
|
|
|
|
Arguments:
|
|
|
|
pGSBuf - Pointer to GSBUF structure and following structure must set
|
|
|
|
pTVWnd - Pointer to the TVWND which has all then information
|
|
needed.
|
|
|
|
pBuf - Pointer to the begining of the buffer (LPWSTR)
|
|
|
|
pEndBuf - Pointer to the end of the buffer
|
|
|
|
|
|
wch - a single character to be added
|
|
|
|
|
|
Return Value:
|
|
|
|
BOOLEAN, true if succeed else false
|
|
|
|
|
|
Author:
|
|
|
|
21-Feb-1996 Wed 12:00:24 created -by- Daniel Chou (danielc)
|
|
|
|
|
|
Revision History:
|
|
|
|
|
|
--*/
|
|
|
|
{
|
|
WCHAR wCh[2];
|
|
UINT cAvai;
|
|
|
|
|
|
if ((Count) &&
|
|
((cAvai = (UINT)(pGSBuf->pEndBuf - pGSBuf->pBuf)) > 1) &&
|
|
(LoadString(hInstDLL, IntCharStrID, wCh, COUNT_ARRAY(wCh)))) {
|
|
|
|
CPSUIDBG(DBG_ADD_WCHAR, ("GSBufAddWChar(%08lx, %u, %u)=%u of '%wc'",
|
|
pGSBuf, IntCharStrID, Count,
|
|
(Count > (cAvai - 1)) ? cAvai - 1 : Count, wCh[0]));
|
|
|
|
if (Count > (cAvai -= 1)) {
|
|
|
|
Count = cAvai;
|
|
}
|
|
|
|
cAvai = Count;
|
|
|
|
while (cAvai--) {
|
|
|
|
*(pGSBuf->pBuf)++ = wCh[0];
|
|
}
|
|
|
|
*(pGSBuf->pBuf) = L'\0';
|
|
|
|
return(Count);
|
|
|
|
} else {
|
|
|
|
CPSUIERR(("GSBufAddWChar(%08lx, %u, %u) FAILED",
|
|
pGSBuf, IntCharStrID, Count));
|
|
|
|
return(0);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
UINT
|
|
GSBufAddSpace(
|
|
PGSBUF pGSBuf,
|
|
UINT Count
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
|
|
|
|
|
|
Arguments:
|
|
|
|
|
|
|
|
|
|
Return Value:
|
|
|
|
|
|
|
|
|
|
Author:
|
|
|
|
20-Jul-1996 Sat 00:59:47 created -by- Daniel Chou (danielc)
|
|
|
|
|
|
Revision History:
|
|
|
|
|
|
--*/
|
|
|
|
{
|
|
static WCHAR wSpace[2] = { 0, 0 };
|
|
UINT cAvai;
|
|
|
|
|
|
if (wSpace[0] == L'\0') {
|
|
|
|
LoadString(hInstDLL,
|
|
IDS_INT_CPSUI_SPACE_CHAR,
|
|
wSpace,
|
|
COUNT_ARRAY(wSpace));
|
|
}
|
|
|
|
if ((wSpace[0] != L'\0') &&
|
|
(Count) &&
|
|
((cAvai = (UINT)(pGSBuf->pEndBuf - pGSBuf->pBuf)) > 1)) {
|
|
|
|
CPSUIDBG(DBG_ADD_SPACE, ("GSBufAddSpace(%08lx, %u)=%u of '%wc'",
|
|
pGSBuf, Count,
|
|
(Count > (cAvai - 1)) ? cAvai - 1 : Count, wSpace[0]));
|
|
|
|
if (Count > (cAvai -= 1)) {
|
|
|
|
Count = cAvai;
|
|
}
|
|
|
|
cAvai = Count;
|
|
|
|
while (cAvai--) {
|
|
|
|
*(pGSBuf->pBuf)++ = wSpace[0];
|
|
}
|
|
|
|
*(pGSBuf->pBuf) = L'\0';
|
|
|
|
return(Count);
|
|
|
|
} else {
|
|
|
|
CPSUIERR(("GSBufAddSpace(%08lx, %u) FAILED", pGSBuf, Count));
|
|
|
|
return(0);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
UINT
|
|
GetStringBuffer(
|
|
HINSTANCE hInst,
|
|
WORD GBFlags,
|
|
WCHAR chPreAdd,
|
|
LPTSTR pStr,
|
|
LPWSTR pBuf,
|
|
UINT cwBuf
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
|
|
|
|
|
|
Arguments:
|
|
|
|
|
|
|
|
|
|
Return Value:
|
|
|
|
|
|
|
|
|
|
Author:
|
|
|
|
07-Sep-1995 Thu 10:45:09 created -by- Daniel Chou (danielc)
|
|
|
|
|
|
Revision History:
|
|
|
|
|
|
--*/
|
|
|
|
{
|
|
GSBUF GSBuf;
|
|
|
|
GSBuf.hInst = hInst;
|
|
GSBuf.Flags = GBFlags;
|
|
GSBuf.pBuf = (LPWSTR)pBuf;
|
|
GSBuf.pEndBuf = (LPWSTR)pBuf + cwBuf;
|
|
GSBuf.chPreAdd = chPreAdd;
|
|
|
|
return(GetString(&GSBuf, pStr));
|
|
}
|
|
|
|
|
|
|
|
|
|
LONG
|
|
LoadCPSUIString(
|
|
LPTSTR pStr,
|
|
UINT cStr,
|
|
UINT StrResID,
|
|
BOOL AnsiCall
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
|
|
|
|
|
|
Arguments:
|
|
|
|
|
|
|
|
|
|
Return Value:
|
|
|
|
|
|
|
|
|
|
Author:
|
|
|
|
08-Feb-1996 Thu 13:36:12 created -by- Daniel Chou (danielc)
|
|
|
|
|
|
Revision History:
|
|
|
|
|
|
--*/
|
|
|
|
{
|
|
if ((pStr) && (cStr)) {
|
|
|
|
UINT Len = 0;
|
|
|
|
if ((StrResID >= IDS_CPSUI_STRID_FIRST) &&
|
|
(StrResID <= IDS_CPSUI_STRID_LAST)) {
|
|
|
|
if (AnsiCall) {
|
|
|
|
if (Len = LoadStringA(hInstDLL, StrResID, (LPSTR)pStr, cStr)) {
|
|
|
|
Len -= RemoveAmpersandA((LPSTR)pStr);
|
|
}
|
|
|
|
} else {
|
|
|
|
if (Len = LoadString(hInstDLL, StrResID, (LPWSTR)pStr, cStr)) {
|
|
|
|
Len -= RemoveAmpersandW((LPWSTR)pStr);
|
|
}
|
|
}
|
|
}
|
|
|
|
return((LONG)Len);
|
|
|
|
} else {
|
|
|
|
return(-1);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
UINT
|
|
ComposeStrData(
|
|
HINSTANCE hInst,
|
|
WORD GBFlags,
|
|
LPWSTR pBuf,
|
|
UINT cwBuf,
|
|
UINT IntFormatStrID,
|
|
LPTSTR pStr,
|
|
DWORD dw1,
|
|
DWORD dw2
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
|
|
|
|
|
|
Arguments:
|
|
|
|
|
|
|
|
|
|
Return Value:
|
|
|
|
|
|
|
|
|
|
Author:
|
|
|
|
19-Jul-1996 Fri 17:11:19 created -by- Daniel Chou (danielc)
|
|
|
|
|
|
Revision History:
|
|
|
|
|
|
--*/
|
|
|
|
{
|
|
TCHAR szFormat[MAX_RES_STR_CHARS * 3];
|
|
LPTSTR pData;
|
|
LPTSTR pFinal;
|
|
UINT Count;
|
|
UINT i;
|
|
UINT cb;
|
|
|
|
|
|
ZeroMemory(szFormat, sizeof(szFormat));
|
|
if ((IntFormatStrID) &&
|
|
(i = LoadString(hInstDLL,
|
|
IntFormatStrID,
|
|
(LPTSTR)szFormat,
|
|
MAX_RES_STR_CHARS))) {
|
|
|
|
cb = ARRAYSIZE(szFormat) - i - 1;
|
|
pData = szFormat + i + 1;
|
|
|
|
if (!pStr) {
|
|
|
|
//
|
|
// Skip the pStr if it passed as NULL
|
|
//
|
|
|
|
StringCchPrintf(pFinal = pData, cb, szFormat, dw1, dw2);
|
|
Count = lstrlen(pFinal);
|
|
|
|
} else {
|
|
|
|
i = GetStringBuffer(hInst,
|
|
(WORD)(GBFlags | GBF_INT_NO_PREFIX),
|
|
(WCHAR)0,
|
|
pStr,
|
|
pData,
|
|
MAX_RES_STR_CHARS);
|
|
|
|
cb = cb - i - 1;
|
|
pFinal = pData + i + 1;
|
|
|
|
StringCchPrintf(pFinal, cb, szFormat, pData, dw1, dw2);
|
|
Count = lstrlen(pFinal);
|
|
}
|
|
|
|
if (Count > (cwBuf - 1)) {
|
|
|
|
Count = cwBuf - 1;
|
|
szFormat[Count] = '\0';
|
|
}
|
|
|
|
CopyMemory(pBuf, pFinal, (Count + 1) * sizeof(TCHAR));
|
|
|
|
|
|
CPSUIDBG(DBG_COMPOSESTR, ("ComposeString('%ws', '%ws', %lu, %lu)='%ws' [%u]",
|
|
szFormat, pData, dw1, dw2, pBuf, Count));
|
|
|
|
} else {
|
|
|
|
Count = GetStringBuffer(hInst, GBFlags, (WCHAR)0, pStr, pBuf, cwBuf);
|
|
|
|
CPSUIDBG(DBG_COMPOSESTR, ("ComposeString(%08lx, %lu, %lu)=FAILED, '%ws' [%u]",
|
|
pStr, dw1, dw2, pBuf, Count));
|
|
}
|
|
|
|
return(Count);
|
|
}
|
|
|