1180 lines
36 KiB
C
1180 lines
36 KiB
C
/*++
|
|
|
|
Copyright (c) 1992 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
group32.c
|
|
|
|
Abstract:
|
|
|
|
This module contains routines for reading/writing 32-bit Windows/NT
|
|
groups that are stored in the registry.
|
|
|
|
Author:
|
|
|
|
Steve Wood (stevewo) 22-Feb-1993
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "advapi.h"
|
|
#include <stdio.h>
|
|
|
|
#include <winbasep.h>
|
|
#include "win31io.h"
|
|
|
|
#define BMR_ICON 1
|
|
#define BMR_DEVDEP 0
|
|
|
|
#define ROUND_UP( X, A ) (((ULONG_PTR)(X) + (A) - 1) & ~((A) - 1))
|
|
#define PAGE_SIZE 4096
|
|
#define PAGE_NUMBER( A ) ((DWORD)(A) / PAGE_SIZE)
|
|
|
|
typedef int (WINAPI *PGETSYSTEMMETRICS)(
|
|
int nIndex
|
|
);
|
|
PGETSYSTEMMETRICS lpGetSystemMetrics;
|
|
|
|
ULONG
|
|
QueryNumberOfPersonalGroupNames(
|
|
HANDLE CurrentUser,
|
|
PHANDLE GroupNamesKey,
|
|
PHANDLE SettingsKey
|
|
)
|
|
{
|
|
NTSTATUS Status;
|
|
UNICODE_STRING KeyName, ValueName;
|
|
OBJECT_ATTRIBUTES ObjectAttributes;
|
|
WCHAR ValueNameBuffer[ 16 ];
|
|
KEY_VALUE_PARTIAL_INFORMATION KeyValueInformation;
|
|
ULONG ResultLength, NumberOfPersonalGroups;
|
|
|
|
RtlInitUnicodeString( &KeyName, L"SoftWare\\Microsoft\\Windows NT\\CurrentVersion\\Program Manager\\UNICODE Groups" );
|
|
InitializeObjectAttributes( &ObjectAttributes,
|
|
&KeyName,
|
|
OBJ_CASE_INSENSITIVE,
|
|
CurrentUser,
|
|
NULL
|
|
);
|
|
Status = NtOpenKey( GroupNamesKey,
|
|
STANDARD_RIGHTS_WRITE |
|
|
KEY_QUERY_VALUE |
|
|
KEY_ENUMERATE_SUB_KEYS |
|
|
KEY_SET_VALUE |
|
|
KEY_CREATE_SUB_KEY,
|
|
&ObjectAttributes
|
|
);
|
|
if (!NT_SUCCESS( Status )) {
|
|
BaseSetLastNTError( Status );
|
|
return 0;
|
|
}
|
|
|
|
RtlInitUnicodeString( &KeyName, L"SoftWare\\Microsoft\\Windows NT\\CurrentVersion\\Program Manager\\Settings" );
|
|
InitializeObjectAttributes( &ObjectAttributes,
|
|
&KeyName,
|
|
OBJ_CASE_INSENSITIVE,
|
|
CurrentUser,
|
|
NULL
|
|
);
|
|
Status = NtOpenKey( SettingsKey,
|
|
STANDARD_RIGHTS_WRITE |
|
|
KEY_QUERY_VALUE |
|
|
KEY_ENUMERATE_SUB_KEYS |
|
|
KEY_SET_VALUE |
|
|
KEY_CREATE_SUB_KEY,
|
|
&ObjectAttributes
|
|
);
|
|
if (!NT_SUCCESS( Status )) {
|
|
BaseSetLastNTError( Status );
|
|
NtClose( *GroupNamesKey );
|
|
return 0;
|
|
}
|
|
|
|
for (NumberOfPersonalGroups=1; ; NumberOfPersonalGroups++) {
|
|
swprintf( ValueNameBuffer, L"Group%d", NumberOfPersonalGroups );
|
|
RtlInitUnicodeString( &ValueName, ValueNameBuffer );
|
|
Status = NtQueryValueKey( *GroupNamesKey,
|
|
&ValueName,
|
|
KeyValuePartialInformation,
|
|
(PVOID)&KeyValueInformation,
|
|
sizeof( KeyValueInformation ),
|
|
&ResultLength
|
|
);
|
|
if (Status == STATUS_BUFFER_OVERFLOW) {
|
|
Status = STATUS_SUCCESS;
|
|
}
|
|
|
|
if (!NT_SUCCESS( Status ) ||
|
|
KeyValueInformation.Type != REG_SZ
|
|
) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
return NumberOfPersonalGroups - 1;
|
|
}
|
|
|
|
BOOL
|
|
NewPersonalGroupName(
|
|
HANDLE GroupNamesKey,
|
|
PWSTR GroupName,
|
|
ULONG GroupNumber
|
|
)
|
|
{
|
|
NTSTATUS Status;
|
|
UNICODE_STRING ValueName;
|
|
WCHAR ValueNameBuffer[ 16 ];
|
|
|
|
if (GroupNumber >= CGROUPSMAX) {
|
|
SetLastError( ERROR_TOO_MANY_NAMES );
|
|
return FALSE;
|
|
}
|
|
|
|
swprintf( ValueNameBuffer, L"Group%d", GroupNumber );
|
|
RtlInitUnicodeString( &ValueName, ValueNameBuffer );
|
|
Status = NtSetValueKey( GroupNamesKey,
|
|
&ValueName,
|
|
0,
|
|
REG_SZ,
|
|
GroupName,
|
|
(wcslen( GroupName ) + 1) * sizeof( WCHAR )
|
|
);
|
|
|
|
if (!NT_SUCCESS( Status )) {
|
|
BaseSetLastNTError( Status );
|
|
return FALSE;
|
|
}
|
|
else {
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
BOOL
|
|
DoesExistGroup(
|
|
HANDLE GroupsKey,
|
|
PWSTR GroupName
|
|
)
|
|
{
|
|
NTSTATUS Status;
|
|
UNICODE_STRING KeyName, ValueName;
|
|
HANDLE Key;
|
|
OBJECT_ATTRIBUTES ObjectAttributes;
|
|
KEY_VALUE_FULL_INFORMATION KeyValueInformation;
|
|
ULONG ResultLength;
|
|
|
|
RtlInitUnicodeString( &KeyName, GroupName );
|
|
InitializeObjectAttributes( &ObjectAttributes,
|
|
&KeyName,
|
|
OBJ_CASE_INSENSITIVE,
|
|
GroupsKey,
|
|
NULL
|
|
);
|
|
Status = NtOpenKey( &Key,
|
|
GENERIC_READ,
|
|
&ObjectAttributes
|
|
);
|
|
if (!NT_SUCCESS( Status )) {
|
|
BaseSetLastNTError( Status );
|
|
return FALSE;
|
|
}
|
|
|
|
RtlInitUnicodeString( &ValueName, L"" );
|
|
Status = NtQueryValueKey( Key,
|
|
&ValueName,
|
|
KeyValueFullInformation,
|
|
&KeyValueInformation,
|
|
sizeof( KeyValueInformation ),
|
|
&ResultLength
|
|
);
|
|
NtClose( Key );
|
|
if (!NT_SUCCESS( Status ) && Status != STATUS_BUFFER_OVERFLOW) {
|
|
BaseSetLastNTError( Status );
|
|
return FALSE;
|
|
}
|
|
else
|
|
if (KeyValueInformation.Type != REG_BINARY ||
|
|
KeyValueInformation.DataLength > 0xFFFF
|
|
) {
|
|
return FALSE;
|
|
}
|
|
else {
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
PGROUP_DEF
|
|
LoadGroup(
|
|
HANDLE GroupsKey,
|
|
PWSTR GroupName
|
|
)
|
|
{
|
|
PGROUP_DEF Group;
|
|
NTSTATUS Status;
|
|
UNICODE_STRING KeyName, ValueName;
|
|
HANDLE Key;
|
|
OBJECT_ATTRIBUTES ObjectAttributes;
|
|
PVOID Base;
|
|
KEY_VALUE_FULL_INFORMATION KeyValueInformation;
|
|
ULONG ResultLength;
|
|
|
|
RtlInitUnicodeString( &KeyName, GroupName );
|
|
InitializeObjectAttributes( &ObjectAttributes,
|
|
&KeyName,
|
|
OBJ_CASE_INSENSITIVE,
|
|
GroupsKey,
|
|
NULL
|
|
);
|
|
Status = NtOpenKey( &Key,
|
|
GENERIC_READ,
|
|
&ObjectAttributes
|
|
);
|
|
if (!NT_SUCCESS( Status )) {
|
|
BaseSetLastNTError( Status );
|
|
return NULL;
|
|
}
|
|
|
|
RtlInitUnicodeString( &ValueName, L"" );
|
|
Status = NtQueryValueKey( Key,
|
|
&ValueName,
|
|
KeyValueFullInformation,
|
|
&KeyValueInformation,
|
|
sizeof( KeyValueInformation ),
|
|
&ResultLength
|
|
);
|
|
if (!NT_SUCCESS( Status )) {
|
|
if (Status == STATUS_BUFFER_OVERFLOW) {
|
|
Status = STATUS_SUCCESS;
|
|
}
|
|
else {
|
|
NtClose( Key );
|
|
BaseSetLastNTError( Status );
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
if (KeyValueInformation.Type != REG_BINARY ||
|
|
KeyValueInformation.DataLength > 0xFFFF
|
|
) {
|
|
NtClose( Key );
|
|
return NULL;
|
|
}
|
|
|
|
Base = VirtualAlloc( NULL, 0xFFFF, MEM_RESERVE, PAGE_READWRITE );
|
|
if (Base == NULL ||
|
|
!VirtualAlloc( Base, KeyValueInformation.DataLength, MEM_COMMIT, PAGE_READWRITE )
|
|
) {
|
|
if (Base != NULL) {
|
|
VirtualFree( Base, 0, MEM_RELEASE );
|
|
}
|
|
|
|
NtClose( Key );
|
|
return NULL;
|
|
}
|
|
|
|
Status = NtQueryValueKey( Key,
|
|
&ValueName,
|
|
KeyValueFullInformation,
|
|
&KeyValueInformation,
|
|
KeyValueInformation.DataLength,
|
|
&ResultLength
|
|
);
|
|
NtClose( Key );
|
|
if (!NT_SUCCESS( Status )) {
|
|
VirtualFree( Base, 0, MEM_RELEASE );
|
|
return NULL;
|
|
}
|
|
else {
|
|
Group = (PGROUP_DEF)((PCHAR)Base + KeyValueInformation.DataOffset);
|
|
|
|
//
|
|
// Set total size of group
|
|
//
|
|
Group->wReserved = (WORD)(ResultLength - KeyValueInformation.DataOffset);
|
|
RtlMoveMemory( Base, Group, Group->wReserved );
|
|
return (PGROUP_DEF)Base;
|
|
}
|
|
}
|
|
|
|
|
|
BOOL
|
|
SaveGroup(
|
|
HANDLE GroupsKey,
|
|
PWSTR GroupName,
|
|
PGROUP_DEF Group
|
|
)
|
|
{
|
|
NTSTATUS Status;
|
|
UNICODE_STRING KeyName, ValueName;
|
|
HANDLE Key;
|
|
OBJECT_ATTRIBUTES ObjectAttributes;
|
|
ULONG CreateDisposition;
|
|
LONG ValueLength;
|
|
|
|
|
|
RtlInitUnicodeString( &KeyName, GroupName );
|
|
InitializeObjectAttributes( &ObjectAttributes,
|
|
&KeyName,
|
|
OBJ_CASE_INSENSITIVE,
|
|
GroupsKey,
|
|
NULL
|
|
);
|
|
Status = NtCreateKey( &Key,
|
|
STANDARD_RIGHTS_WRITE |
|
|
KEY_QUERY_VALUE |
|
|
KEY_ENUMERATE_SUB_KEYS |
|
|
KEY_SET_VALUE |
|
|
KEY_CREATE_SUB_KEY,
|
|
&ObjectAttributes,
|
|
0,
|
|
NULL,
|
|
0,
|
|
&CreateDisposition
|
|
);
|
|
if (!NT_SUCCESS( Status )) {
|
|
BaseSetLastNTError( Status );
|
|
return FALSE;
|
|
}
|
|
|
|
ValueLength = (LONG)((ULONG)Group->wReserved);
|
|
Group->wReserved = 0;
|
|
Group->wCheckSum = (WORD)-ValueLength;
|
|
|
|
RtlInitUnicodeString( &ValueName, L"" );
|
|
Status = NtSetValueKey( Key,
|
|
&ValueName,
|
|
0,
|
|
REG_BINARY,
|
|
Group,
|
|
ValueLength
|
|
);
|
|
|
|
Group->wReserved = (WORD)ValueLength;
|
|
Group->wCheckSum = 0;
|
|
NtClose( Key );
|
|
if (!NT_SUCCESS( Status )) {
|
|
return FALSE;
|
|
}
|
|
else {
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
BOOL
|
|
DeleteGroup(
|
|
HANDLE GroupsKey,
|
|
PWSTR GroupName
|
|
)
|
|
{
|
|
NTSTATUS Status;
|
|
UNICODE_STRING KeyName;
|
|
HANDLE Key;
|
|
OBJECT_ATTRIBUTES ObjectAttributes;
|
|
|
|
|
|
RtlInitUnicodeString( &KeyName, GroupName );
|
|
InitializeObjectAttributes( &ObjectAttributes,
|
|
&KeyName,
|
|
OBJ_CASE_INSENSITIVE,
|
|
GroupsKey,
|
|
NULL
|
|
);
|
|
Status = NtOpenKey( &Key,
|
|
STANDARD_RIGHTS_WRITE |
|
|
DELETE |
|
|
KEY_QUERY_VALUE |
|
|
KEY_ENUMERATE_SUB_KEYS |
|
|
KEY_SET_VALUE |
|
|
KEY_CREATE_SUB_KEY,
|
|
&ObjectAttributes
|
|
);
|
|
if (!NT_SUCCESS( Status )) {
|
|
if (Status == STATUS_OBJECT_NAME_NOT_FOUND) {
|
|
return TRUE;
|
|
}
|
|
else {
|
|
BaseSetLastNTError( Status );
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
Status = NtDeleteKey( Key );
|
|
NtClose( Key );
|
|
if (!NT_SUCCESS( Status )) {
|
|
return FALSE;
|
|
}
|
|
else {
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
|
|
BOOL
|
|
UnloadGroup(
|
|
PGROUP_DEF Group
|
|
)
|
|
{
|
|
return VirtualFree( Group, 0, MEM_RELEASE );
|
|
}
|
|
|
|
|
|
BOOL
|
|
ExtendGroup(
|
|
PGROUP_DEF Group,
|
|
BOOL AppendToGroup,
|
|
DWORD cb
|
|
)
|
|
{
|
|
PBYTE Start, Commit, End;
|
|
|
|
if (((DWORD)Group->wReserved + cb) > 0xFFFF) {
|
|
return FALSE;
|
|
}
|
|
|
|
Start = (PBYTE)Group + Group->cbGroup;
|
|
End = Start + cb;
|
|
|
|
if (PAGE_NUMBER( Group->wReserved ) != PAGE_NUMBER( Group->wReserved + cb )) {
|
|
Commit = (PBYTE)ROUND_UP( (PBYTE)Group + Group->wReserved, PAGE_SIZE );
|
|
if (!VirtualAlloc( Commit, ROUND_UP( cb, PAGE_SIZE ), MEM_COMMIT, PAGE_READWRITE )) {
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
if (!AppendToGroup) {
|
|
memmove( End, Start, Group->wReserved - Group->cbGroup );
|
|
}
|
|
|
|
Group->wReserved += (WORD)cb;
|
|
return TRUE;
|
|
}
|
|
|
|
WORD
|
|
AddDataToGroup(
|
|
PGROUP_DEF Group,
|
|
PBYTE Data,
|
|
DWORD cb
|
|
)
|
|
{
|
|
WORD Offset;
|
|
|
|
if (cb == 0) {
|
|
cb = strlen( Data ) + 1;
|
|
}
|
|
cb = (DWORD)ROUND_UP( cb, sizeof( DWORD ) );
|
|
|
|
if (!ExtendGroup( Group, FALSE, cb )) {
|
|
return 0;
|
|
}
|
|
|
|
if (((DWORD)Group->cbGroup + cb) > 0xFFFF) {
|
|
return 0;
|
|
}
|
|
|
|
Offset = Group->cbGroup;
|
|
Group->cbGroup += (WORD)cb;
|
|
|
|
if (Data != NULL) {
|
|
memmove( (PBYTE)Group + Offset, Data, cb );
|
|
}
|
|
else {
|
|
memset( (PBYTE)Group + Offset, 0, cb );
|
|
}
|
|
|
|
return Offset;
|
|
}
|
|
|
|
BOOL
|
|
AddTagToGroup(
|
|
PGROUP_DEF Group,
|
|
WORD wID,
|
|
WORD wItem,
|
|
WORD cb,
|
|
PBYTE rgb
|
|
)
|
|
{
|
|
WORD Offset;
|
|
PTAG_DEF Tag;
|
|
|
|
cb = (WORD)(ROUND_UP( cb, sizeof( DWORD ) ));
|
|
|
|
Offset = Group->wReserved;
|
|
if (!ExtendGroup( Group, TRUE, FIELD_OFFSET( TAG_DEF, rgb[ 0 ] ) + cb )) {
|
|
return FALSE;
|
|
}
|
|
|
|
Tag = (PTAG_DEF)PTR( Group, Offset );
|
|
Tag->wID = wID;
|
|
Tag->dummy1 = 0;
|
|
Tag->wItem = (int)wItem;
|
|
Tag->dummy2 = 0;
|
|
if (cb != 0 || rgb != NULL) {
|
|
Tag->cb = (WORD)(cb + FIELD_OFFSET( TAG_DEF, rgb[ 0 ] ));
|
|
memmove( &Tag->rgb[ 0 ], rgb, cb );
|
|
}
|
|
else {
|
|
Tag->cb = 0;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
ULONG MonoChromePalette[] = {
|
|
0x00000000, 0x00ffffff
|
|
};
|
|
|
|
BITMAPINFOHEADER DefaultQuestionIconBIH = {
|
|
0x00000028,
|
|
0x00000020,
|
|
0x00000040,
|
|
0x0001,
|
|
0x0004,
|
|
0x00000000,
|
|
0x00000280,
|
|
0x00000000,
|
|
0x00000000,
|
|
0xFFFFFFFF,
|
|
0x00000000
|
|
};
|
|
|
|
ULONG DefaultQuestionIconBits[] = {
|
|
0x00000000, 0x00000000, 0x00000000, 0x00000000
|
|
, 0x00000000, 0x33000000, 0x00000030, 0x00000000
|
|
, 0x00000000, 0xbb080000, 0x00000083, 0x00000000
|
|
, 0x00000000, 0xff0b0000, 0x000000b3, 0x00000000
|
|
, 0x00000000, 0xff0b0000, 0x000000b3, 0x00000000
|
|
, 0x00000000, 0xbb000000, 0x00000080, 0x00000000
|
|
, 0x00000000, 0x00000000, 0x00000000, 0x00000000
|
|
, 0x00000000, 0x00000000, 0x00000000, 0x00000000
|
|
, 0x00000000, 0x00000000, 0x00000000, 0x00000000
|
|
, 0x00000000, 0x33000000, 0x00000030, 0x00000000
|
|
, 0x00000000, 0xbb080000, 0x00000083, 0x00000000
|
|
, 0x00000000, 0xbb0b0000, 0x000000b3, 0x00000000
|
|
, 0x00000000, 0xff0b0000, 0x000000b3, 0x00000000
|
|
, 0x00000000, 0xff0b0000, 0x000030b8, 0x00000000
|
|
, 0x00000000, 0xbf000000, 0x000083bb, 0x00000000
|
|
, 0x00000000, 0xbf000000, 0x0033b8fb, 0x00000000
|
|
, 0x00000000, 0x0b000000, 0x33b8bbbf, 0x00000000
|
|
, 0x00000000, 0x00000000, 0xb3bbfbbb, 0x00000030
|
|
, 0x00000000, 0x00000000, 0xbbbbbb00, 0x00000030
|
|
, 0x00000000, 0x00000000, 0xbbbb0000, 0x00000083
|
|
, 0x00000000, 0x00000000, 0xbb0b0000, 0x000000b3
|
|
, 0x00000000, 0x00003033, 0xbb0b0000, 0x000000b3
|
|
, 0x08000000, 0x000083bb, 0xbb0b0000, 0x000000b3
|
|
, 0x0b000000, 0x0000b3bb, 0xbb0b0000, 0x000000b3
|
|
, 0x0b000000, 0x0030b8ff, 0xbb3b0000, 0x000000b3
|
|
, 0x0b000000, 0x0083bbff, 0xbb8b0300, 0x000000b3
|
|
, 0x00000000, 0x33b8fbbf, 0xbbbb3833, 0x00000080
|
|
, 0x00000000, 0xbbbbffbb, 0xb8bbbbbb, 0x00000030
|
|
, 0x00000000, 0xbbffbf0b, 0x83bbbbbb, 0x00000000
|
|
, 0x00000000, 0xffbf0b00, 0x00b8bbff, 0x00000000
|
|
, 0x00000000, 0xbb0b0000, 0x0000b8bb, 0x00000000
|
|
, 0x00000000, 0x00000000, 0x00000000, 0x00000000
|
|
, 0xff7ffcff, 0xff3ff8ff, 0xff1ff0ff, 0xff1ff0ff
|
|
, 0xff1ff0ff, 0xff3ff8ff, 0xff7ffcff, 0xffffffff
|
|
, 0xff7ffcff, 0xff3ff8ff, 0xff1ff0ff, 0xff1ff0ff
|
|
, 0xff1ff0ff, 0xff0ff0ff, 0xff03f8ff, 0xff00f8ff
|
|
, 0x7f00fcff, 0x3f00feff, 0x3f00ffff, 0x1fc0ffff
|
|
, 0x1ff01fff, 0x1ff00ffe, 0x1ff007fc, 0x1ff007fc
|
|
, 0x1fe003fc, 0x1f0000fc, 0x3f0000fe, 0x3f0000fe
|
|
, 0x7f0000ff, 0xff0080ff, 0xff03e0ff, 0xff0ff8ff
|
|
};
|
|
|
|
|
|
BOOL
|
|
ConvertIconBits(
|
|
PCURSORSHAPE_16 pIconHeader
|
|
);
|
|
|
|
BOOL
|
|
ConvertIconBits(
|
|
PCURSORSHAPE_16 pIconHeader
|
|
)
|
|
{
|
|
PBYTE Src;
|
|
UINT cbScanLine;
|
|
UINT nScanLine;
|
|
UINT i, j, k;
|
|
PBYTE Plane0;
|
|
PBYTE Plane1;
|
|
PBYTE Plane2;
|
|
PBYTE Plane3;
|
|
PBYTE p;
|
|
BYTE Color0, Color1, Color2, Color3, FourColor, FourColorPlane[ 32 * 4 * 4 ];
|
|
|
|
Src = (PBYTE)(pIconHeader + 1) + (pIconHeader->cbWidth * pIconHeader->cy);
|
|
cbScanLine = (((pIconHeader->cx * pIconHeader->BitsPixel + 31) & ~31) / 8);
|
|
nScanLine = pIconHeader->cy;
|
|
|
|
if (pIconHeader->Planes != 4) {
|
|
return FALSE;
|
|
}
|
|
else
|
|
if (pIconHeader->BitsPixel != 1) {
|
|
return FALSE;
|
|
}
|
|
else
|
|
if (pIconHeader->cx != pIconHeader->cy) {
|
|
return FALSE;
|
|
}
|
|
else
|
|
if (nScanLine != 32) {
|
|
return FALSE;
|
|
}
|
|
else
|
|
if (cbScanLine != 4) {
|
|
return FALSE;
|
|
}
|
|
|
|
Plane0 = (PBYTE)Src;
|
|
Plane1 = Plane0 + cbScanLine;
|
|
Plane2 = Plane1 + cbScanLine;
|
|
Plane3 = Plane2 + cbScanLine;
|
|
p = &FourColorPlane[ 0 ];
|
|
j = nScanLine;
|
|
while (j--) {
|
|
k = cbScanLine;
|
|
while (k--) {
|
|
Color0 = *Plane0++;
|
|
Color1 = *Plane1++;
|
|
Color2 = *Plane2++;
|
|
Color3 = *Plane3++;
|
|
i = 4;
|
|
while (i--) {
|
|
FourColor = 0;
|
|
if (Color0 & 0x80) {
|
|
FourColor |= 0x10;
|
|
}
|
|
if (Color1 & 0x80) {
|
|
FourColor |= 0x20;
|
|
}
|
|
if (Color2 & 0x80) {
|
|
FourColor |= 0x40;
|
|
}
|
|
if (Color3 & 0x80) {
|
|
FourColor |= 0x80;
|
|
}
|
|
if (Color0 & 0x40) {
|
|
FourColor |= 0x01;
|
|
}
|
|
if (Color1 & 0x40) {
|
|
FourColor |= 0x02;
|
|
}
|
|
if (Color2 & 0x40) {
|
|
FourColor |= 0x04;
|
|
}
|
|
if (Color3 & 0x40) {
|
|
FourColor |= 0x08;
|
|
}
|
|
|
|
Color0 <<= 2;
|
|
Color1 <<= 2;
|
|
Color2 <<= 2;
|
|
Color3 <<= 2;
|
|
|
|
*p++ = FourColor;
|
|
}
|
|
}
|
|
|
|
Plane0 += 3 * cbScanLine;
|
|
Plane1 += 3 * cbScanLine;
|
|
Plane2 += 3 * cbScanLine;
|
|
Plane3 += 3 * cbScanLine;
|
|
}
|
|
|
|
memmove( Src, &FourColorPlane[ 0 ], sizeof( FourColorPlane ) );
|
|
pIconHeader->BitsPixel = 4;
|
|
pIconHeader->Planes = 1;
|
|
pIconHeader->cbWidth = cbScanLine * 4;
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
VOID
|
|
CopyIconBits(
|
|
PBYTE Dst,
|
|
PBYTE Src,
|
|
UINT cbScanLine,
|
|
UINT nScanLine
|
|
);
|
|
|
|
VOID
|
|
CopyIconBits(
|
|
PBYTE Dst,
|
|
PBYTE Src,
|
|
UINT cbScanLine,
|
|
UINT nScanLine
|
|
)
|
|
{
|
|
Src += (cbScanLine * nScanLine);
|
|
while (nScanLine--) {
|
|
Src -= cbScanLine;
|
|
memcpy( Dst, Src, cbScanLine );
|
|
Dst += cbScanLine;
|
|
}
|
|
}
|
|
|
|
typedef struct _WIN31_GROUP_ITEM_DESC {
|
|
LPSTR GroupName;
|
|
LPSTR ItemName;
|
|
} WIN31_GROUP_ITEM_DESC, *PWIN31_GROUP_ITEM_DESC;
|
|
|
|
WIN31_GROUP_ITEM_DESC GroupItemsToIgnore[] = {
|
|
{"Main", "File Manager"},
|
|
{NULL, "Control Panel"},
|
|
{NULL, "Print Manager"},
|
|
{NULL, "ClipBook Viewer"},
|
|
{NULL, "MS-DOS Prompt"},
|
|
{NULL, "Windows Setup"},
|
|
{NULL, "Read Me"},
|
|
{"Accessories", "Paintbrush"},
|
|
{NULL, "Write"},
|
|
{NULL, "Terminal"},
|
|
{NULL, "Notepad"},
|
|
{NULL, "Recorder"},
|
|
{NULL, "Clock"},
|
|
{NULL, "Object Packager"},
|
|
{NULL, "Media Player"},
|
|
{NULL, "Sound Recorder"},
|
|
{"Network", NULL},
|
|
{NULL, NULL}
|
|
};
|
|
|
|
PGROUP_DEF
|
|
CreateGroupFromGroup16(
|
|
LPSTR GroupName,
|
|
PGROUP_DEF16 Group16
|
|
)
|
|
{
|
|
PWIN31_GROUP_ITEM_DESC p1, ItemsToIgnore;
|
|
PGROUP_DEF Group;
|
|
PITEM_DEF Item;
|
|
PITEM_DEF16 Item16;
|
|
PTAG_DEF16 Tag16;
|
|
DWORD cb;
|
|
PBYTE p;
|
|
LPSTR s;
|
|
UINT i;
|
|
PCURSORSHAPE_16 pIconHeader;
|
|
PBITMAPINFOHEADER pbmi;
|
|
BOOL bUserDefaultIcon, bItemConvertedOkay;
|
|
int imagesize, colorsize, masksize, bmisize;
|
|
|
|
ItemsToIgnore = NULL;
|
|
p1 = GroupItemsToIgnore;
|
|
while (p1->GroupName || p1->ItemName) {
|
|
if (p1->GroupName &&
|
|
!_stricmp( p1->GroupName, GroupName )
|
|
) {
|
|
if (p1->ItemName == NULL) {
|
|
return (PGROUP_DEF)-1;
|
|
}
|
|
|
|
ItemsToIgnore = p1;
|
|
break;
|
|
}
|
|
|
|
p1 += 1;
|
|
}
|
|
|
|
Group = VirtualAlloc( NULL, 0xFFFF, MEM_RESERVE, PAGE_READWRITE );
|
|
if (Group == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
if (!VirtualAlloc( Group,
|
|
cb = FIELD_OFFSET( GROUP_DEF, rgiItems[ 0 ] ),
|
|
MEM_COMMIT,
|
|
PAGE_READWRITE
|
|
)
|
|
) {
|
|
VirtualFree( Group, 0, MEM_RELEASE );
|
|
return NULL;
|
|
}
|
|
cb = (DWORD)ROUND_UP( cb, sizeof( DWORD ) );
|
|
Group->wReserved = (WORD)cb;
|
|
Group->cbGroup = (WORD)cb;
|
|
Group->cItems = (Group16->cItems + NSLOTS - 1) & ~(NSLOTS-1);
|
|
AddDataToGroup( Group, NULL, (Group->cItems * sizeof( Group->rgiItems[ 0 ] )) );
|
|
Group->pName = AddDataToGroup( Group,
|
|
GroupName,
|
|
0
|
|
);
|
|
Group->dwMagic = GROUP_MAGIC;
|
|
Group->wCheckSum = 0; /* adjusted later... */
|
|
Group->nCmdShow = SW_SHOWMINIMIZED; // Group16->nCmdShow;
|
|
Group->wIconFormat = Group16->wIconFormat;
|
|
|
|
if (lpGetSystemMetrics == NULL) {
|
|
lpGetSystemMetrics = (PGETSYSTEMMETRICS)GetProcAddress( LoadLibrary( "user32.dll" ),
|
|
"GetSystemMetrics"
|
|
);
|
|
if (lpGetSystemMetrics == NULL) {
|
|
lpGetSystemMetrics = (PGETSYSTEMMETRICS)-1;
|
|
}
|
|
}
|
|
|
|
if (lpGetSystemMetrics != (PGETSYSTEMMETRICS)-1) {
|
|
Group->cxIcon = (WORD)(*lpGetSystemMetrics)(SM_CXICON);
|
|
Group->cyIcon = (WORD)(*lpGetSystemMetrics)(SM_CYICON);
|
|
}
|
|
|
|
Group->ptMin.x = (LONG)Group16->ptMin.x;
|
|
Group->ptMin.y = (LONG)Group16->ptMin.y;
|
|
|
|
Group->rcNormal.left = (int)Group16->rcNormal.Left;
|
|
Group->rcNormal.top = (int)Group16->rcNormal.Top;
|
|
Group->rcNormal.right = (int)Group16->rcNormal.Right;
|
|
Group->rcNormal.bottom = (int)Group16->rcNormal.Bottom;
|
|
|
|
|
|
for (i=0; i<Group16->cItems; i++) {
|
|
if (Group16->rgiItems[ i ] == 0) {
|
|
continue;
|
|
}
|
|
|
|
Item16 = ITEM16( Group16, i );
|
|
if (p1 = ItemsToIgnore) {
|
|
s = PTR( Group16, Item16->pName );
|
|
do {
|
|
if (!_stricmp( p1->ItemName, s )) {
|
|
s = NULL;
|
|
break;
|
|
}
|
|
p1 += 1;
|
|
}
|
|
while (p1->GroupName == NULL && p1->ItemName != NULL);
|
|
|
|
if (s == NULL) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
Group->rgiItems[ i ] = AddDataToGroup( Group, NULL, sizeof( ITEM_DEF ) );
|
|
if (Group->rgiItems[ i ] == 0) {
|
|
break;
|
|
}
|
|
|
|
Item = ITEM( Group, i );
|
|
Item->pt.x = (LONG)Item16->pt.x;
|
|
Item->pt.y = (LONG)Item16->pt.y;
|
|
Item->idIcon = Item16->iIcon;
|
|
Item->indexIcon = Item16->iIcon;
|
|
Item->wIconVer = 3;
|
|
|
|
bUserDefaultIcon = FALSE;
|
|
pIconHeader = (PCURSORSHAPE_16)PTR( Group16, Item16->pHeader );
|
|
if (pIconHeader->Planes != 1) {
|
|
if (!ConvertIconBits( pIconHeader )) {
|
|
KdPrint(("WIN31IO: Invalid 16-bit item icon at %08x\n", pIconHeader ));
|
|
bUserDefaultIcon = TRUE;
|
|
}
|
|
}
|
|
else
|
|
if (pIconHeader->BitsPixel != 1 &&
|
|
pIconHeader->BitsPixel != 4 &&
|
|
pIconHeader->BitsPixel != 8
|
|
) {
|
|
bUserDefaultIcon = TRUE;
|
|
}
|
|
|
|
if (!bUserDefaultIcon) {
|
|
bmisize = sizeof( BITMAPINFOHEADER );
|
|
imagesize = Item16->cbXORPlane;
|
|
masksize = Item16->cbANDPlane;
|
|
|
|
if (pIconHeader->BitsPixel == 1) {
|
|
colorsize = sizeof( MonoChromePalette );
|
|
}
|
|
else {
|
|
colorsize = 0;
|
|
}
|
|
|
|
Item->cbIconRes = (WORD)(bmisize +
|
|
colorsize +
|
|
imagesize +
|
|
masksize
|
|
);
|
|
|
|
Item->cbIconRes = (WORD)ROUND_UP( Item->cbIconRes, sizeof( DWORD ) );
|
|
Item->pIconRes = AddDataToGroup( Group, NULL, Item->cbIconRes );
|
|
if (Item->pIconRes != 0) {
|
|
p = PTR( Group, Item->pIconRes );
|
|
pbmi = (PBITMAPINFOHEADER)p;
|
|
|
|
pbmi->biSize = bmisize;
|
|
pbmi->biWidth = pIconHeader->cx;
|
|
pbmi->biHeight = pIconHeader->cy * 2;
|
|
pbmi->biPlanes = pIconHeader->Planes;
|
|
pbmi->biBitCount = pIconHeader->BitsPixel;
|
|
pbmi->biCompression = BI_RGB;
|
|
pbmi->biSizeImage = imagesize;
|
|
pbmi->biXPelsPerMeter = 0;
|
|
pbmi->biYPelsPerMeter = 0;
|
|
pbmi->biClrImportant = 0;
|
|
|
|
if (colorsize != 0) {
|
|
memcpy( p + bmisize, MonoChromePalette, colorsize );
|
|
pbmi->biClrUsed = 0;
|
|
}
|
|
else {
|
|
pbmi->biClrUsed = (DWORD)-1;
|
|
}
|
|
|
|
CopyIconBits( p + bmisize + colorsize,
|
|
(PBYTE)PTR( Group16, Item16->pXORPlane ),
|
|
(((pIconHeader->cx * pIconHeader->BitsPixel + 31) & ~31) / 8),
|
|
pIconHeader->cy
|
|
);
|
|
|
|
CopyIconBits( p + bmisize + colorsize + imagesize,
|
|
(PBYTE)PTR( Group16, Item16->pANDPlane ),
|
|
(((pIconHeader->cx + 31) & ~31) / 8),
|
|
pIconHeader->cy
|
|
);
|
|
}
|
|
}
|
|
else {
|
|
bmisize = sizeof( DefaultQuestionIconBIH );
|
|
imagesize = sizeof( DefaultQuestionIconBits );
|
|
Item->cbIconRes = bmisize + imagesize;
|
|
Item->cbIconRes = (WORD)ROUND_UP( Item->cbIconRes, sizeof( DWORD ) );
|
|
Item->pIconRes = AddDataToGroup( Group, NULL, Item->cbIconRes );
|
|
if (Item->pIconRes != 0) {
|
|
p = PTR( Group, Item->pIconRes );
|
|
memcpy( p, &DefaultQuestionIconBIH, bmisize );
|
|
memcpy( p + bmisize, &DefaultQuestionIconBits, imagesize );
|
|
}
|
|
}
|
|
|
|
bItemConvertedOkay = FALSE;
|
|
if (Item->pIconRes != 0) {
|
|
Item->pName = AddDataToGroup( Group,
|
|
PTR( Group16, Item16->pName ),
|
|
0
|
|
);
|
|
if (Item->pName != 0) {
|
|
Item->pCommand = AddDataToGroup( Group,
|
|
PTR( Group16, Item16->pCommand ),
|
|
0
|
|
);
|
|
if (Item->pCommand != 0) {
|
|
Item->pIconPath = AddDataToGroup( Group,
|
|
PTR( Group16, Item16->pIconPath ),
|
|
0
|
|
);
|
|
if (Item->pIconPath != 0) {
|
|
bItemConvertedOkay = TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!bItemConvertedOkay) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
Tag16 = (PTAG_DEF16)((PBYTE)Group16 + Group16->cbGroup);
|
|
if (bItemConvertedOkay &&
|
|
Tag16->wID == ID_MAGIC && Tag16->wItem == ID_LASTTAG &&
|
|
*(UNALIGNED DWORD *)&Tag16->rgb[ 0 ] == PMTAG_MAGIC
|
|
) {
|
|
while (Tag16->wID != ID_LASTTAG) {
|
|
if (!AddTagToGroup( Group,
|
|
Tag16->wID,
|
|
Tag16->wItem,
|
|
(WORD)(Tag16->cb - FIELD_OFFSET( TAG_DEF16, rgb[ 0 ] )),
|
|
&Tag16->rgb[ 0 ]
|
|
)
|
|
) {
|
|
bItemConvertedOkay = FALSE;
|
|
break;
|
|
}
|
|
|
|
Tag16 = (PTAG_DEF16)((PBYTE)Tag16 + Tag16->cb);
|
|
}
|
|
|
|
if (bItemConvertedOkay) {
|
|
if (!AddTagToGroup( Group,
|
|
ID_LASTTAG,
|
|
0xFFFF,
|
|
0,
|
|
NULL
|
|
)
|
|
) {
|
|
bItemConvertedOkay = FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!bItemConvertedOkay) {
|
|
UnloadGroup( Group );
|
|
SetLastError( ERROR_NOT_ENOUGH_MEMORY );
|
|
return NULL;
|
|
}
|
|
else {
|
|
return Group;
|
|
}
|
|
}
|
|
|
|
|
|
#if DBG
|
|
|
|
BOOL
|
|
DumpGroup(
|
|
PWSTR GroupName,
|
|
PGROUP_DEF Group
|
|
)
|
|
{
|
|
PBITMAPINFOHEADER Icon;
|
|
PICON_HEADER16 Icon16;
|
|
PITEM_DEF Item;
|
|
PTAG_DEF Tag;
|
|
PULONG p;
|
|
int cb;
|
|
UINT i;
|
|
|
|
DbgPrint( "%ws - Group at %08x\n", GroupName, Group );
|
|
DbgPrint( " dwMagic: %08x\n", Group->dwMagic );
|
|
DbgPrint( " wCheckSum: %04x\n", Group->wCheckSum );
|
|
DbgPrint( " cbGroup: %04x\n", Group->cbGroup );
|
|
DbgPrint( " nCmdShow: %04x\n", Group->nCmdShow );
|
|
DbgPrint( " rcNormal: [%08x,%08x,%08x,%08x]\n",
|
|
Group->rcNormal.left,
|
|
Group->rcNormal.top,
|
|
Group->rcNormal.right,
|
|
Group->rcNormal.bottom
|
|
);
|
|
DbgPrint( " ptMin: [%08x,%08x]\n", Group->ptMin.x, Group->ptMin.y );
|
|
DbgPrint( " pName: [%04x] %s\n", Group->pName, Group->pName ? (PSZ)PTR( Group, Group->pName ) : "(null)" );
|
|
DbgPrint( " cxIcon: %04x\n", Group->cxIcon );
|
|
DbgPrint( " cyIcon: %04x\n", Group->cyIcon );
|
|
DbgPrint( " wIconFormat: %04x\n", Group->wIconFormat );
|
|
DbgPrint( " wReserved: %04x\n", Group->wReserved );
|
|
DbgPrint( " cItems: %04x\n", Group->cItems );
|
|
|
|
for (i=0; i<Group->cItems; i++) {
|
|
DbgPrint( " Item[ %02x ] at %04x\n", i, Group->rgiItems[ i ] );
|
|
if (Group->rgiItems[ i ] != 0) {
|
|
Item = ITEM( Group, i );
|
|
DbgPrint( " pt: [%08x, %08x]\n",
|
|
Item->pt.x,
|
|
Item->pt.y
|
|
);
|
|
DbgPrint( " idIcon: %04x\n", Item->idIcon );
|
|
DbgPrint( " wIconVer: %04x\n", Item->wIconVer );
|
|
DbgPrint( " cbIconRes:%04x\n", Item->cbIconRes );
|
|
DbgPrint( " indexIcon:%04x\n", Item->indexIcon );
|
|
DbgPrint( " dummy2: %04x\n", Item->dummy2 );
|
|
DbgPrint( " pIconRes: %04x\n", Item->pIconRes );
|
|
if (Item->wIconVer == 2) {
|
|
Icon16 = (PICON_HEADER16)PTR( Group, Item->pIconRes );
|
|
DbgPrint( " xHot: %04x\n", Icon16->xHotSpot );
|
|
DbgPrint( " yHot: %04x\n", Icon16->yHotSpot );
|
|
DbgPrint( " cx: %04x\n", Icon16->cx );
|
|
DbgPrint( " cy: %04x\n", Icon16->cy );
|
|
DbgPrint( " cbWid:%04x\n", Icon16->cbWidth );
|
|
DbgPrint( " Plane:%04x\n", Icon16->Planes );
|
|
DbgPrint( " BPP: %04x\n", Icon16->BitsPixel );
|
|
p = (PULONG)(Icon16+1);
|
|
cb = Item->cbIconRes - sizeof( *Icon16 );
|
|
}
|
|
else {
|
|
Icon = (PBITMAPINFOHEADER)PTR( Group, Item->pIconRes );
|
|
DbgPrint( " biSize : %08x\n", Icon->biSize );
|
|
DbgPrint( " biWidth : %08x\n", Icon->biWidth );
|
|
DbgPrint( " biHeight : %08x\n", Icon->biHeight );
|
|
DbgPrint( " biPlanes : %04x\n", Icon->biPlanes );
|
|
DbgPrint( " biBitCount : %04x\n", Icon->biBitCount );
|
|
DbgPrint( " biCompression : %08x\n", Icon->biCompression );
|
|
DbgPrint( " biSizeImage : %08x\n", Icon->biSizeImage );
|
|
DbgPrint( " biXPelsPerMeter: %08x\n", Icon->biXPelsPerMeter );
|
|
DbgPrint( " biYPelsPerMeter: %08x\n", Icon->biYPelsPerMeter );
|
|
DbgPrint( " biClrUsed : %08x\n", Icon->biClrUsed );
|
|
DbgPrint( " biClrImportant : %08x\n", Icon->biClrImportant );
|
|
p = (PULONG)(Icon+1);
|
|
cb = Item->cbIconRes - sizeof( *Icon );
|
|
}
|
|
|
|
DbgPrint( " dummy3: %04x\n", Item->dummy3 );
|
|
DbgPrint( " pName: [%04x] %s\n", Item->pName, PTR( Group, Item->pName ) );
|
|
DbgPrint( " pCommand:[%04x] %s\n", Item->pCommand, PTR( Group, Item->pCommand ) );
|
|
DbgPrint( " pIconPth:[%04x] %s\n", Item->pIconPath, PTR( Group, Item->pIconPath ) );
|
|
DbgPrint( " IconData: %04x bytes\n", cb );
|
|
while (cb > 0) {
|
|
DbgPrint( " %08x", *p++ );
|
|
cb -= sizeof( *p );
|
|
if (cb >= sizeof( *p )) {
|
|
cb -= sizeof( *p );
|
|
DbgPrint( " %08x", *p++ );
|
|
if (cb >= sizeof( *p )) {
|
|
cb -= sizeof( *p );
|
|
DbgPrint( " %08x", *p++ );
|
|
if (cb >= sizeof( *p )) {
|
|
cb -= sizeof( *p );
|
|
DbgPrint( " %08x", *p++ );
|
|
}
|
|
}
|
|
}
|
|
|
|
DbgPrint( "\n" );
|
|
}
|
|
}
|
|
}
|
|
|
|
Tag = (PTAG_DEF)((PBYTE)Group + Group->cbGroup);
|
|
if (Tag->wID == ID_MAGIC && Tag->wItem == ID_LASTTAG &&
|
|
*(LPDWORD)&Tag->rgb == PMTAG_MAGIC
|
|
) {
|
|
while (Tag->wID != ID_LASTTAG) {
|
|
DbgPrint( " Tag at %04x\n", (PBYTE)Tag - (PBYTE)Group );
|
|
DbgPrint( " wID: %04x\n", Tag->wID );
|
|
DbgPrint( " dummy1: %04x\n", Tag->dummy1 );
|
|
DbgPrint( " wItem: %08x\n", Tag->wItem );
|
|
DbgPrint( " cb: %04x\n", Tag->cb );
|
|
DbgPrint( " dummy2: %04x\n", Tag->dummy2 );
|
|
switch( Tag->wID ) {
|
|
case ID_MAGIC:
|
|
DbgPrint( " rgb: ID_MAGIC( %.4s )\n", Tag->rgb );
|
|
break;
|
|
|
|
case ID_WRITERVERSION:
|
|
DbgPrint( " rgb: ID_WRITERVERSION( %s )\n", Tag->rgb );
|
|
break;
|
|
|
|
case ID_APPLICATIONDIR:
|
|
DbgPrint( " rgb: ID_APPLICATIONDIR( %s )\n", Tag->rgb );
|
|
break;
|
|
|
|
case ID_HOTKEY:
|
|
DbgPrint( " rgb: ID_HOTKEY( %04x )\n", *(LPWORD)Tag->rgb );
|
|
break;
|
|
|
|
case ID_MINIMIZE:
|
|
DbgPrint( " rgb: ID_MINIMIZE()\n" );
|
|
break;
|
|
|
|
case ID_LASTTAG:
|
|
DbgPrint( " rgb: ID_LASTTAG()\n" );
|
|
break;
|
|
|
|
default:
|
|
DbgPrint( " rgb: unknown data format for this ID\n" );
|
|
break;
|
|
}
|
|
|
|
|
|
Tag = (PTAG_DEF)((PBYTE)Tag + Tag->cb);
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
#endif // DBG
|