windows-nt/Source/XPSP1/NT/base/pnp/setupapi/resource.c

635 lines
14 KiB
C
Raw Normal View History

2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1993-1998 Microsoft Corporation
Module Name:
resource.c
Abstract:
Routines that manipulate resources (strings, messages, etc).
Author:
Ted Miller (tedm) 6-Feb-1995
Revision History:
--*/
#include "precomp.h"
#pragma hdrstop
VOID
SetDlgText(
IN HWND hwndDlg,
IN INT iControl,
IN UINT nStartString,
IN UINT nEndString
)
/*++
Routine Description:
This routine concatenates a number of string resources and does a
SetWindowText() for a dialog text control.
Arguments:
hwndDlg - Handle to dialog window
iControl - Dialog control ID to receive text
nStartString - ID of first string resource to concatenate
nEndString - ID of last string resource to concatenate
Return Value:
None.
Remarks:
String IDs must be consecutive.
--*/
{
TCHAR StringBuffer[SDT_MAX_TEXT];
UINT i;
INT Len = 0;
for(i = nStartString;
((i <= nEndString) && (Len < (SDT_MAX_TEXT - 1)));
i++)
{
Len += LoadString(MyDllModuleHandle,
i,
StringBuffer + Len,
SDT_MAX_TEXT - Len
);
}
if(!Len) {
StringBuffer[0] = TEXT('\0');
}
SetDlgItemText(hwndDlg, iControl, StringBuffer);
}
PTSTR
MyLoadString(
IN UINT StringId
)
/*++
Routine Description:
Retreive a string from the string resources of this module.
Arguments:
StringId - supplies string table identifier for the string.
Return Value:
Pointer to buffer containing string. If the string was not found
or some error occurred retreiving it, this buffer will be empty.
Caller can free the buffer with MyFree().
If NULL is returned, out of memory.
--*/
{
PTSTR Buffer, p;
int Length, RequiredLength;
//
// Start out with a reasonably-sized buffer so that we'll rarely need to
// grow the buffer and retry (Length is in terms of characters, not bytes).
//
Length = LINE_LEN;
while(TRUE) {
Buffer = MyMalloc(Length * sizeof(TCHAR));
if(!Buffer) {
return NULL;
}
RequiredLength = LoadString(MyDllModuleHandle,
StringId,
Buffer,
Length
);
if(!RequiredLength) {
*Buffer = TEXT('\0');
Length = 1;
break;
}
//
// Because of the way LoadString works, there's no way to
// tell for sure whether your buffer was big enough in the case where
// the length returned just fits in the buffer you supplied (the API
// silently truncates in this case). Thus, if RequiredLength is exactly
// the size of our supplied buffer (minus terminating null, which
// LoadString doesn't count), we increase the buffer size by LINE_LEN
// characters and try again, to make sure we get the whole string.
//
if(RequiredLength < (Length - 1)) {
//
// Looks like we got the whole string. Set the length to be the
// required length + 1 character, to accommodate the terminating
// null character.
//
Length = RequiredLength + 1;
break;
} else {
MyFree(Buffer);
Length += LINE_LEN;
}
}
//
// Resize the buffer to its correct size. If this fails (which it shouldn't)
// it's no big deal, it just means we're using a larger buffer for this string
// than we need to.
//
if(p = MyRealloc(Buffer, Length * sizeof(TCHAR))) {
Buffer = p;
}
return Buffer;
}
PTSTR
FormatStringMessageV(
IN UINT FormatStringId,
IN va_list *ArgumentList
)
/*++
Routine Description:
Retreive a string from the string resources of this module and
format it using FormatMessage.
Arguments:
StringId - supplies string table identifier for the string.
ArgumentList - supplies list of strings to be substituted in the
format string.
Return Value:
Pointer to buffer containing formatted message. If the string was not found
or some error occurred retreiving it, this buffer will be empty.
Caller can free the buffer with MyFree().
If NULL is returned, out of memory.
--*/
{
PTSTR FormatString;
va_list arglist;
PTSTR Message;
PTSTR Return;
DWORD d;
//
// First, load the format string.
//
FormatString = MyLoadString(FormatStringId);
if(!FormatString) {
return(NULL);
}
//
// Now format the message using the arguements the caller passed.
//
d = FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING,
FormatString,
0,
0,
(PTSTR)&Message,
0,
ArgumentList
);
MyFree(FormatString);
if(!d) {
return(NULL);
}
//
// Make duplicate using our memory system so user can free with MyFree().
//
Return = DuplicateString(Message);
LocalFree((HLOCAL)Message);
return(Return);
}
PTSTR
FormatStringMessage(
IN UINT FormatStringId,
...
)
/*++
Routine Description:
Retreive a string from the string resources of this module and
format it using FormatMessage.
Arguments:
StringId - supplies string table identifier for the string.
Return Value:
Pointer to buffer containing formatted message. If the string was not found
or some error occurred retreiving it, this buffer will be empty.
Caller can free the buffer with MyFree().
If NULL is returned, out of memory.
--*/
{
va_list arglist;
PTSTR p;
va_start(arglist,FormatStringId);
p = FormatStringMessageV(FormatStringId,&arglist);
va_end(arglist);
return(p);
}
PTSTR
FormatStringMessageFromStringV(
IN PTSTR FormatString,
IN va_list *ArgumentList
)
/*++
Routine Description:
Format the input string using FormatMessage.
Arguments:
FormatString - supplies the format string.
ArgumentList - supplies list of strings to be substituted in the
format string.
Return Value:
Pointer to buffer containing formatted message. If some error occurred
formatting the string, this buffer will be empty.
Caller can free the buffer with MyFree().
If NULL is returned, out of memory.
--*/
{
va_list arglist;
PTSTR Message;
PTSTR Return;
DWORD d;
//
// Format the message using the arguements the caller passed.
//
d = FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING,
FormatString,
0,
0,
(PTSTR)&Message,
0,
ArgumentList
);
if(!d) {
return(NULL);
}
//
// Make duplicate using our memory system so user can free with MyFree().
//
Return = DuplicateString(Message);
LocalFree((HLOCAL)Message);
return(Return);
}
PTSTR
FormatStringMessageFromString(
IN PTSTR FormatString,
...
)
/*++
Routine Description:
Format the input string using FormatMessage.
Arguments:
FormatString - supplies the format string.
Return Value:
Pointer to buffer containing formatted message. If some error occurred
formatting the string, this buffer will be empty.
Caller can free the buffer with MyFree().
If NULL is returned, out of memory.
--*/
{
va_list arglist;
PTSTR p;
va_start(arglist,FormatString);
p = FormatStringMessageFromStringV(FormatString,&arglist);
va_end(arglist);
return(p);
}
INT
FormatMessageBox(
IN HANDLE hinst,
IN HWND hwndParent,
IN UINT TextMessageId,
IN PCTSTR Title,
IN UINT Style,
...
)
/*++
Routine Description:
This routine formats two message strings--one containing messagebox text,
and the other containing a messagebox caption. The message box is then
displayed.
The message ids can be either a message in this dll's message table
resources or a win32 error code, in which case a description of
that error is retreived from the system.
Arguments:
hinst - Supplies the handle of the module containing string resources to
be used.
hwndParent - Supplies the handle of window to be the parent of the message box.
TextMessageId - Supplies message-table identifier or win32 error code
for the messagebox text.
TitleMessageId - Supplies message-table identifier or win32 error code
for the messagebox caption.
Style - Supplies style flags for the message box.
... - Supplies arguments to be inserted in the message text.
Return Value:
The return value is zero if there is not enough memory to create the message box, or
if a failure occurred while creating the message box.
If the function succeeds, the return value is one of the following menu-item values
returned by the dialog box:
IDABORT Abort button was selected.
IDCANCEL Cancel button was selected.
IDIGNORE Ignore button was selected.
IDNO No button was selected.
IDOK OK button was selected.
IDRETRY Retry button was selected.
IDYES Yes button was selected.
If a message box has a Cancel button, the function returns the IDCANCEL value if
either the ESC key is pressed or the Cancel button is selected. If the message box
has no Cancel button, pressing ESC has no effect.
--*/
{
va_list arglist;
PTSTR Text = NULL;
INT ret;
//
// We should never be called if we're not interactive.
//
MYASSERT(!(GlobalSetupFlags & (PSPGF_NONINTERACTIVE|PSPGF_UNATTENDED_SETUP)));
if(GlobalSetupFlags & (PSPGF_NONINTERACTIVE|PSPGF_UNATTENDED_SETUP)) {
return 0;
}
try {
va_start(arglist, Style);
Text = RetreiveAndFormatMessageV(TextMessageId, &arglist);
va_end(arglist);
if(Text) {
//
// We always beep when we display the message
//
MessageBeep(Style & (MB_ICONHAND|MB_ICONEXCLAMATION|MB_ICONQUESTION|MB_ICONASTERISK));
ret = MessageBox(hwndParent, Text, Title, Style);
} else {
ret = 0;
}
} except(EXCEPTION_EXECUTE_HANDLER) {
ret = 0;
}
if(Text) {
MyFree(Text);
}
return ret;
}
PTSTR
RetreiveAndFormatMessageV(
IN UINT MessageId,
IN va_list *ArgumentList
)
/*++
Routine Description:
Format a message string using a message string and caller-supplied
arguments.
The message id can be either a message in this dll's message table
resources or a win32 error code, in which case a description of
that error is retreived from the system.
Arguments:
MessageId - supplies message-table identifier or win32 error code
for the message.
ArgumentList - supplies arguments to be inserted in the message text.
Return Value:
Pointer to buffer containing formatted message. If the message was not found
or some error occurred retreiving it, this buffer will be empty.
Caller can free the buffer with MyFree().
If NULL is returned, out of memory.
--*/
{
DWORD d;
PTSTR Buffer;
PTSTR Message;
TCHAR ModuleName[MAX_PATH];
TCHAR ErrorNumber[24];
PTCHAR p;
PTSTR Args[2];
d = FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER
| ((MessageId < MSG_FIRST) ? FORMAT_MESSAGE_FROM_SYSTEM : FORMAT_MESSAGE_FROM_HMODULE),
(PVOID)MyDllModuleHandle,
MessageId,
MAKELANGID(LANG_NEUTRAL,SUBLANG_NEUTRAL),
(PTSTR)&Buffer,
0,
ArgumentList
);
if(!d) {
if(GetLastError() == ERROR_NOT_ENOUGH_MEMORY) {
return(NULL);
}
wsprintf(ErrorNumber,TEXT("%x"),MessageId);
Args[0] = ErrorNumber;
Args[1] = ModuleName;
if(GetModuleFileName(MyDllModuleHandle,ModuleName,MAX_PATH)) {
if(p = _tcsrchr(ModuleName,TEXT('\\'))) {
Args[1] = p+1;
}
} else {
ModuleName[0] = 0;
}
d = FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ARGUMENT_ARRAY,
NULL,
ERROR_MR_MID_NOT_FOUND,
MAKELANGID(LANG_NEUTRAL,SUBLANG_NEUTRAL),
(PTSTR)&Buffer,
0,
(va_list *)Args
);
if(!d) {
//
// Give up.
//
return(NULL);
}
}
//
// Make duplicate using our memory system so user can free with MyFree().
//
Message = DuplicateString(Buffer);
LocalFree((HLOCAL)Buffer);
return(Message);
}
PTSTR
RetreiveAndFormatMessage(
IN UINT MessageId,
...
)
/*++
Routine Description:
Format a message string using a message string and caller-supplied
arguments.
The message id can be either a message in this dll's message table
resources or a win32 error code, in which case a description of
that error is retreived from the system.
Arguments:
MessageId - supplies message-table identifier or win32 error code
for the message.
... - supplies arguments to be inserted in the message text.
Return Value:
Pointer to buffer containing formatted message. If the message was not found
or some error occurred retreiving it, this buffer will be empty.
Caller can free the buffer with MyFree().
If NULL is returned, out of memory.
--*/
{
va_list arglist;
PTSTR p;
va_start(arglist,MessageId);
p = RetreiveAndFormatMessageV(MessageId,&arglist);
va_end(arglist);
return(p);
}