Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-11-01 20:32:36 +00:00
Code Issues Packages Projects Releases Wiki Activity
reactos/modules/rosapps/applications/sysutils/fontsub/fontsub.cpp

1604 lines
44 KiB
C++
Raw Blame History

// FontSub by Katayama Hirofumi MZ
//
// To the extent possible under law, the person who associated CC0 with
// FontSub has waived all copyright and related or neighboring rights
// to FontSub.
//
// You should have received a copy of the CC0 legalcode along with this
// work. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
#include <windows.h>
#include <windowsx.h>
#include <commctrl.h>
#include <tchar.h>
#include <vector> // for std::vector
#include <set> // for std::set
#include <string> // for std::basic_string
#include <algorithm> // for std::sort
#include <cstdio>
#include <cstring>
#include <cassert>
#include "resource.h"
#define NAME_COLUMN_WIDTH 250
#define SUB_COLUMN_WIDTH 250
#define MAX_STRING 120
#ifndef _countof
#define _countof(array) (sizeof(array) / sizeof(array[0]))
#endif
typedef std::wstring STRING;
struct ITEM
{
STRING m_Name, m_Substitute;
BYTE m_CharSet1, m_CharSet2;
ITEM(const STRING& Name, const STRING& Substitute,
BYTE CharSet1, BYTE CharSet2)
: m_Name(Name), m_Substitute(Substitute),
m_CharSet1(CharSet1), m_CharSet2(CharSet2) { }
};
/* global variables */
HINSTANCE g_hInstance = NULL;
HWND g_hMainWnd = NULL;
HICON g_hIcon = NULL;
HWND g_hListView = NULL;
BOOL g_bModified = FALSE;
BOOL g_bNeedsReboot = FALSE;
INT g_iItem = 0;
LPCWSTR g_pszClassName = L"ReactOS Font Substitutes Editor";
LPCWSTR g_pszFileHeader = L"Windows Registry Editor Version 5.00";
WCHAR g_szTitle[MAX_STRING];
WCHAR g_szNameHead[MAX_STRING];
WCHAR g_szSubstituteHead[MAX_STRING];
INT g_iSortColumn = 0;
BOOL g_bSortAscendant = TRUE;
LPCWSTR g_pszKey =
L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\FontSubstitutes";
typedef std::set<STRING> FONTNAMESET;
typedef std::vector<ITEM> ITEMVECTOR;
FONTNAMESET g_Names;
ITEMVECTOR g_Items;
STRING g_strFontName;
STRING g_strSubstitute;
BYTE g_CharSet1 = DEFAULT_CHARSET;
BYTE g_CharSet2 = DEFAULT_CHARSET;
typedef struct CHARSET_ENTRY
{
BYTE CharSet;
LPCWSTR DisplayName;
} CHARSET_ENTRY;
CHARSET_ENTRY g_CharSetList[] =
{
{ DEFAULT_CHARSET, L"DEFAULT_CHARSET (1)" },
{ ANSI_CHARSET, L"ANSI_CHARSET (0)" },
{ SYMBOL_CHARSET, L"SYMBOL_CHARSET (2)" },
{ SHIFTJIS_CHARSET, L"SHIFTJIS_CHARSET (128)" },
{ HANGUL_CHARSET, L"HANGUL_CHARSET (129)" },
{ GB2312_CHARSET, L"GB2312_CHARSET (134)" },
{ CHINESEBIG5_CHARSET, L"CHINESEBIG5_CHARSET (136)" },
{ OEM_CHARSET, L"OEM_CHARSET (255)" },
{ JOHAB_CHARSET, L"JOHAB_CHARSET (130)" },
{ HEBREW_CHARSET, L"HEBREW_CHARSET (177)" },
{ ARABIC_CHARSET, L"ARABIC_CHARSET (178)" },
{ GREEK_CHARSET, L"GREEK_CHARSET (161)" },
{ TURKISH_CHARSET, L"TURKISH_CHARSET (162)" },
{ VIETNAMESE_CHARSET, L"VIETNAMESE_CHARSET (163)" },
{ THAI_CHARSET, L"THAI_CHARSET (222)" },
{ EASTEUROPE_CHARSET, L"EASTEUROPE_CHARSET (238)" },
{ RUSSIAN_CHARSET, L"RUSSIAN_CHARSET (204)" },
{ MAC_CHARSET, L"MAC_CHARSET (77)" },
{ BALTIC_CHARSET, L"BALTIC_CHARSET (186)" }
};
const WCHAR g_LongestName[] = L"CHINESEBIG5_CHARSET (136)";
static void trim(STRING& str)
{
static const WCHAR Spaces[] = L" \t\r\n";
size_t i = str.find_first_not_of(Spaces);
size_t j = str.find_last_not_of(Spaces);
if (i == STRING::npos || j == STRING::npos)
{
str.clear();
}
else
{
str = str.substr(i, j - i + 1);
}
}
static int CALLBACK
EnumFontFamExProc(const ENUMLOGFONTW *pelf,
const NEWTEXTMETRICW *pntm,
int FontType,
LPARAM lParam)
{
switch (pelf->elfFullName[0])
{
case UNICODE_NULL: case L'@':
break;
default:
g_Names.insert((const WCHAR *)pelf->elfFullName);
}
switch (pelf->elfLogFont.lfFaceName[0])
{
case UNICODE_NULL: case L'@':
break;
default:
g_Names.insert(pelf->elfLogFont.lfFaceName);
}
return 1;
}
BOOL DoLoadNames(void)
{
g_Names.clear();
LOGFONTW lf;
ZeroMemory(&lf, sizeof(lf));
lf.lfCharSet = DEFAULT_CHARSET;
HDC hDC = CreateCompatibleDC(NULL);
EnumFontFamiliesExW(hDC, &lf, (FONTENUMPROCW)EnumFontFamExProc, 0, 0);
DeleteDC(hDC);
return !g_Names.empty();
}
inline bool ItemCompareByNameAscend(const ITEM& Item1, const ITEM& Item2)
{
return Item1.m_Name < Item2.m_Name;
}
inline bool ItemCompareByNameDescend(const ITEM& Item1, const ITEM& Item2)
{
return Item1.m_Name > Item2.m_Name;
}
inline bool ItemCompareBySubAscend(const ITEM& Item1, const ITEM& Item2)
{
return Item1.m_Substitute < Item2.m_Substitute;
}
inline bool ItemCompareBySubDescend(const ITEM& Item1, const ITEM& Item2)
{
return Item1.m_Substitute > Item2.m_Substitute;
}
void DoSort(INT iColumn, BOOL bAscendant = TRUE)
{
LV_COLUMN Column;
ZeroMemory(&Column, sizeof(Column));
Column.mask = LVCF_IMAGE | LVCF_SUBITEM;
Column.iImage = 2;
Column.iSubItem = 0;
ListView_SetColumn(g_hListView, 0, &Column);
Column.iSubItem = 1;
ListView_SetColumn(g_hListView, 1, &Column);
switch (iColumn)
{
case 0:
Column.iSubItem = 0;
if (bAscendant)
{
std::sort(g_Items.begin(), g_Items.end(),
ItemCompareByNameAscend);
Column.iImage = 0;
ListView_SetColumn(g_hListView, 0, &Column);
}
else
{
std::sort(g_Items.begin(), g_Items.end(),
ItemCompareByNameDescend);
Column.iImage = 1;
ListView_SetColumn(g_hListView, 0, &Column);
}
break;
case 1:
Column.iSubItem = 1;
if (bAscendant)
{
std::sort(g_Items.begin(), g_Items.end(),
ItemCompareBySubAscend);
Column.iImage = 0;
ListView_SetColumn(g_hListView, 1, &Column);
}
else
{
std::sort(g_Items.begin(), g_Items.end(),
ItemCompareBySubDescend);
Column.iImage = 1;
ListView_SetColumn(g_hListView, 1, &Column);
}
break;
}
g_iSortColumn = iColumn;
g_bSortAscendant = bAscendant;
InvalidateRect(g_hListView, NULL, TRUE);
}
void LV_AddItems(HWND hwnd)
{
ListView_DeleteAllItems(hwnd);
LV_ITEM Item;
ZeroMemory(&Item, sizeof(Item));
Item.mask = LVIF_PARAM;
const INT Count = INT(g_Items.size());
for (INT i = 0; i < Count; ++i)
{
Item.iItem = i;
Item.iSubItem = 0;
Item.lParam = i;
ListView_InsertItem(hwnd, &Item);
Item.iItem = i;
Item.iSubItem = 1;
Item.lParam = i;
ListView_InsertItem(hwnd, &Item);
}
}
BOOL DoLoadItems(void)
{
ITEMVECTOR Items;
HKEY hKey = NULL;
RegOpenKeyExW(HKEY_LOCAL_MACHINE, g_pszKey, 0, KEY_READ, &hKey);
if (hKey == NULL)
return FALSE;
WCHAR szName[MAX_STRING], szValue[MAX_STRING];
DWORD cbName, cbValue;
for (DWORD dwIndex = 0; ; ++dwIndex)
{
cbName = sizeof(szName);
cbValue = sizeof(szValue);
LONG Error = RegEnumValueW(hKey, dwIndex, szName, &cbName,
NULL, NULL, (LPBYTE)szValue, &cbValue);
if (Error != ERROR_SUCCESS)
break;
BYTE CharSet1 = DEFAULT_CHARSET, CharSet2 = DEFAULT_CHARSET;
LPWSTR pch;
pch = wcsrchr(szName, L',');
if (pch)
{
*pch = 0;
CharSet1 = (BYTE)_wtoi(pch + 1);
}
pch = wcsrchr(szValue, L',');
if (pch)
{
*pch = 0;
CharSet2 = (BYTE)_wtoi(pch + 1);
}
ITEM Item(szName, szValue, CharSet1, CharSet2);
trim(Item.m_Name);
trim(Item.m_Substitute);
Items.push_back(Item);
}
RegCloseKey(hKey);
g_Items = Items;
LV_AddItems(g_hListView);
DoSort(0, TRUE);
g_bModified = FALSE;
g_bNeedsReboot = FALSE;
return !g_Items.empty();
}
BOOL DoLoad(void)
{
return DoLoadNames() && DoLoadItems();
}
void LV_InvalidateRow(HWND hwnd, INT iRow = -1)
{
if (iRow == -1)
iRow = ListView_GetNextItem(hwnd, -1, LVNI_SELECTED);
if (iRow == -1)
return;
RECT Rect;
LPRECT GccIsWhining = &Rect;
ListView_GetItemRect(hwnd, iRow, GccIsWhining, LVIR_BOUNDS);
InvalidateRect(hwnd, &Rect, FALSE);
}
BOOL LV_Init(HWND hwnd)
{
ListView_SetExtendedListViewStyle(hwnd,
LVS_EX_FULLROWSELECT | LVS_EX_GRIDLINES);
HIMAGELIST hImageList;
hImageList = ImageList_Create(12, 12, ILC_COLOR8 | ILC_MASK, 2, 2);
HBITMAP hbm;
hbm = (HBITMAP)LoadImage(g_hInstance, MAKEINTRESOURCE(2), IMAGE_BITMAP,
12, 12, LR_CREATEDIBSECTION | LR_LOADMAP3DCOLORS);
assert(hbm);
ImageList_AddMasked(hImageList, hbm, RGB(192, 192, 192));
DeleteObject(hbm);
hbm = (HBITMAP)LoadImage(g_hInstance, MAKEINTRESOURCE(3), IMAGE_BITMAP,
12, 12, LR_CREATEDIBSECTION | LR_LOADMAP3DCOLORS);
assert(hbm);
ImageList_AddMasked(hImageList, hbm, RGB(192, 192, 192));
DeleteObject(hbm);
hbm = (HBITMAP)LoadImage(g_hInstance, MAKEINTRESOURCE(4), IMAGE_BITMAP,
12, 12, LR_CREATEDIBSECTION | LR_LOADMAP3DCOLORS);
assert(hbm);
ImageList_AddMasked(hImageList, hbm, RGB(192, 192, 192));
DeleteObject(hbm);
ListView_SetImageList(hwnd, hImageList, LVSIL_SMALL);
LV_COLUMNW Column;
ZeroMemory(&Column, sizeof(Column));
Column.mask = LVCF_FMT | LVCF_TEXT | LVCF_SUBITEM | LVCF_WIDTH | LVCF_IMAGE;
Column.fmt = LVCFMT_LEFT;
Column.cx = NAME_COLUMN_WIDTH;
Column.pszText = g_szNameHead;
Column.iSubItem = 0;
Column.iImage = 0;
ListView_InsertColumn(hwnd, 0, &Column);
Column.cx = SUB_COLUMN_WIDTH;
Column.pszText = g_szSubstituteHead;
Column.iSubItem = 1;
Column.iImage = 2;
ListView_InsertColumn(hwnd, 1, &Column);
UINT State = LVIS_SELECTED | LVIS_FOCUSED;
ListView_SetItemState(hwnd, 0, State, State);
return TRUE;
}
BOOL EditDlg_OnInitDialog(HWND hwnd, HWND hwndFocus, LPARAM lParam)
{
COMBOBOXEXITEMW Item;
ZeroMemory(&Item, sizeof(Item));
Item.mask = CBEIF_TEXT;
FONTNAMESET::iterator it, end = g_Names.end();
for (it = g_Names.begin(); it != end; ++it)
{
Item.pszText = const_cast<LPWSTR>(it->c_str());
Item.iItem = ComboBox_GetCount(GetDlgItem(hwnd, cmb2));
SendDlgItemMessageW(hwnd, cmb2, CBEM_INSERTITEM, 0, (LPARAM)&Item);
}
SetDlgItemTextW(hwnd, edt1, g_strFontName.c_str());
SetDlgItemTextW(hwnd, cmb2, g_strSubstitute.c_str());
const INT Count = _countof(g_CharSetList);
for (INT i = 0; i < Count; ++i)
{
Item.pszText = const_cast<LPWSTR>(g_CharSetList[i].DisplayName);
Item.iItem = ComboBox_GetCount(GetDlgItem(hwnd, cmb3));
SendDlgItemMessageW(hwnd, cmb3, CBEM_INSERTITEM, 0, (LPARAM)&Item);
Item.iItem = ComboBox_GetCount(GetDlgItem(hwnd, cmb4));
SendDlgItemMessageW(hwnd, cmb4, CBEM_INSERTITEM, 0, (LPARAM)&Item);
}
SendDlgItemMessageW(hwnd, cmb3, CB_SETCURSEL, 0, 0);
SendDlgItemMessageW(hwnd, cmb4, CB_SETCURSEL, 0, 0);
for (INT i = 0; i < Count; ++i)
{
if (g_CharSet1 == g_CharSetList[i].CharSet)
{
SendDlgItemMessageW(hwnd, cmb3, CB_SETCURSEL, i, 0);
}
if (g_CharSet2 == g_CharSetList[i].CharSet)
{
SendDlgItemMessageW(hwnd, cmb4, CB_SETCURSEL, i, 0);
}
}
SIZE siz;
HDC hDC = CreateCompatibleDC(NULL);
SelectObject(hDC, GetStockObject(DEFAULT_GUI_FONT));
GetTextExtentPoint32W(hDC, g_LongestName, lstrlenW(g_LongestName), &siz);
DeleteDC(hDC);
SendDlgItemMessageW(hwnd, cmb3, CB_SETHORIZONTALEXTENT, siz.cx + 16, 0);
SendDlgItemMessageW(hwnd, cmb4, CB_SETHORIZONTALEXTENT, siz.cx + 16, 0);
EnableWindow(GetDlgItem(hwnd, cmb3), FALSE);
return TRUE;
}
void LV_OnDelete(HWND hwnd, INT iRow = -1)
{
if (iRow == -1)
iRow = ListView_GetNextItem(hwnd, -1, LVNI_SELECTED);
if (iRow == -1)
return;
UINT State = LVIS_SELECTED | LVIS_FOCUSED;
ListView_SetItemState(g_hListView, iRow, State, State);
WCHAR sz[MAX_STRING];
LoadStringW(g_hInstance, IDS_QUERYDELETE, sz, _countof(sz));
if (IDYES != MessageBoxW(g_hMainWnd, sz, g_szTitle,
MB_ICONINFORMATION | MB_YESNO))
{
return;
}
ListView_DeleteItem(hwnd, iRow);
g_Items.erase(g_Items.begin() + iRow);
g_bModified = TRUE;
ListView_SetItemState(g_hListView, iRow, State, State);
InvalidateRect(hwnd, NULL, TRUE);
}
void EditDlg_OnCommand(HWND hwnd, int id, HWND hwndCtl, UINT codeNotify)
{
WCHAR szValue[MAX_STRING];
STRING str;
INT i;
switch (id)
{
case IDOK:
GetDlgItemTextW(hwnd, cmb2, szValue, _countof(szValue));
str = szValue;
trim(str);
if (str.empty())
{
WCHAR sz[MAX_STRING];
SendDlgItemMessageW(hwnd, cmb2, CB_SETEDITSEL, 0, MAKELPARAM(0, -1));
SetFocus(GetDlgItem(hwnd, cmb2));
LoadStringW(g_hInstance, IDS_ENTERNAME2, sz, _countof(sz));
MessageBoxW(hwnd, sz, NULL, MB_ICONERROR);
return;
}
g_Items[g_iItem].m_CharSet2 = DEFAULT_CHARSET;
i = SendDlgItemMessageW(hwnd, cmb4, CB_GETCURSEL, 0, 0);
if (i != CB_ERR)
{
g_Items[g_iItem].m_CharSet2 = g_CharSetList[i].CharSet;
}
g_Items[g_iItem].m_Substitute = str;
g_bModified = TRUE;
EndDialog(hwnd, IDOK);
break;
case IDCANCEL:
EndDialog(hwnd, IDCANCEL);
break;
case psh1:
LV_OnDelete(g_hListView, g_iItem);
EndDialog(hwnd, psh1);
break;
}
}
INT_PTR CALLBACK
EditDlg_DlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch (uMsg)
{
HANDLE_MSG(hwnd, WM_INITDIALOG, EditDlg_OnInitDialog);
HANDLE_MSG(hwnd, WM_COMMAND, EditDlg_OnCommand);
}
return 0;
}
void LV_OnDblClk(HWND hwnd)
{
g_iItem = ListView_GetNextItem(hwnd, -1, LVNI_SELECTED);
if (g_iItem == -1)
return;
g_strFontName = g_Items[g_iItem].m_Name;
g_strSubstitute = g_Items[g_iItem].m_Substitute;
g_CharSet1 = g_Items[g_iItem].m_CharSet1;
g_CharSet2 = g_Items[g_iItem].m_CharSet2;
DialogBox(g_hInstance, MAKEINTRESOURCE(IDD_EDIT), g_hMainWnd,
EditDlg_DlgProc);
InvalidateRect(g_hListView, NULL, TRUE);
}
BOOL MainWnd_OnCreate(HWND hwnd, LPCREATESTRUCT lpCreateStruct)
{
DWORD dwStyle = WS_CHILD | WS_VISIBLE | WS_VSCROLL |
LVS_SINGLESEL | LVS_REPORT | LVS_OWNERDRAWFIXED;
DWORD dwExStyle = WS_EX_CLIENTEDGE;
g_hListView = CreateWindowEx(dwExStyle, WC_LISTVIEW, NULL, dwStyle,
0, 0, 0, 0,
hwnd, (HMENU)1, g_hInstance, NULL);
if (g_hListView == NULL)
return FALSE;
if (!LV_Init(g_hListView))
return FALSE;
if (!DoLoad())
return FALSE;
UINT State = LVIS_SELECTED | LVIS_FOCUSED;
ListView_SetItemState(g_hListView, 0, State, State);
SetFocus(g_hListView);
return TRUE;
}
BOOL AddDlg_OnInitDialog(HWND hwnd, HWND hwndFocus, LPARAM lParam)
{
COMBOBOXEXITEMW Item;
ZeroMemory(&Item, sizeof(Item));
Item.iItem = -1;
Item.mask = CBEIF_TEXT;
FONTNAMESET::iterator it, end = g_Names.end();
for (it = g_Names.begin(); it != end; ++it)
{
Item.pszText = const_cast<LPWSTR>(it->c_str());
Item.iItem = ComboBox_GetCount(GetDlgItem(hwnd, cmb1));
SendDlgItemMessageW(hwnd, cmb1, CBEM_INSERTITEM, 0, (LPARAM)&Item);
Item.iItem = ComboBox_GetCount(GetDlgItem(hwnd, cmb2));
SendDlgItemMessageW(hwnd, cmb2, CBEM_INSERTITEM, 0, (LPARAM)&Item);
}
WCHAR szEnterName[MAX_STRING];
LoadStringW(g_hInstance, IDS_ENTERNAME, szEnterName, _countof(szEnterName));
SetDlgItemTextW(hwnd, cmb1, szEnterName);
SendDlgItemMessageW(hwnd, cmb1, CB_SETEDITSEL, 0, MAKELPARAM(0, -1));
const INT Count = _countof(g_CharSetList);
for (INT i = 0; i < Count; ++i)
{
Item.pszText = const_cast<LPWSTR>(g_CharSetList[i].DisplayName);
Item.iItem = ComboBox_GetCount(GetDlgItem(hwnd, cmb3));
SendDlgItemMessageW(hwnd, cmb3, CBEM_INSERTITEM, 0, (LPARAM)&Item);
Item.iItem = ComboBox_GetCount(GetDlgItem(hwnd, cmb4));
SendDlgItemMessageW(hwnd, cmb4, CBEM_INSERTITEM, 0, (LPARAM)&Item);
}
SendDlgItemMessageW(hwnd, cmb3, CB_SETCURSEL, 0, 0);
SendDlgItemMessageW(hwnd, cmb4, CB_SETCURSEL, 0, 0);
for (INT i = 0; i < Count; ++i)
{
if (g_CharSet1 == g_CharSetList[i].CharSet)
{
SendDlgItemMessageW(hwnd, cmb3, CB_SETCURSEL, i, 0);
}
if (g_CharSet2 == g_CharSetList[i].CharSet)
{
SendDlgItemMessageW(hwnd, cmb4, CB_SETCURSEL, i, 0);
}
}
SIZE siz;
HDC hDC = CreateCompatibleDC(NULL);
SelectObject(hDC, GetStockObject(DEFAULT_GUI_FONT));
GetTextExtentPoint32W(hDC, g_LongestName, lstrlenW(g_LongestName), &siz);
DeleteDC(hDC);
SendDlgItemMessageW(hwnd, cmb3, CB_SETHORIZONTALEXTENT, siz.cx + 16, 0);
SendDlgItemMessageW(hwnd, cmb4, CB_SETHORIZONTALEXTENT, siz.cx + 16, 0);
return TRUE;
}
void AddDlg_OnCommand(HWND hwnd, int id, HWND hwndCtl, UINT codeNotify)
{
WCHAR szKey[MAX_STRING], szValue[MAX_STRING], sz[MAX_STRING];
INT i, iCharSet1, iCharSet2;
BYTE CharSet1, CharSet2;
STRING key, value;
switch (id)
{
case IDOK:
GetDlgItemTextW(hwnd, cmb1, szKey, _countof(szKey));
key = szKey;
trim(key);
LoadStringW(g_hInstance, IDS_ENTERNAME, sz, _countof(sz));
if (key.empty() || key == sz)
{
SendDlgItemMessageW(hwnd, cmb1, CB_SETEDITSEL, 0, MAKELPARAM(0, -1));
SetFocus(GetDlgItem(hwnd, cmb1));
LoadStringW(g_hInstance, IDS_ENTERNAME2, sz, _countof(sz));
MessageBoxW(hwnd, sz, NULL, MB_ICONERROR);
return;
}
GetDlgItemTextW(hwnd, cmb2, szValue, _countof(szValue));
value = szValue;
trim(value);
if (value.empty())
{
SendDlgItemMessageW(hwnd, cmb2, CB_SETEDITSEL, 0, MAKELPARAM(0, -1));
SetFocus(GetDlgItem(hwnd, cmb2));
LoadStringW(g_hInstance, IDS_ENTERNAME2, sz, _countof(sz));
MessageBoxW(hwnd, sz, NULL, MB_ICONERROR);
return;
}
iCharSet1 = SendDlgItemMessageW(hwnd, cmb3, CB_GETCURSEL, 0, 0);
if (iCharSet1 == CB_ERR)
iCharSet1 = 0;
iCharSet2 = SendDlgItemMessageW(hwnd, cmb4, CB_GETCURSEL, 0, 0);
if (iCharSet2 == CB_ERR)
iCharSet2 = 0;
CharSet1 = g_CharSetList[iCharSet1].CharSet;
CharSet2 = g_CharSetList[iCharSet2].CharSet;
for (i = 0; i < (INT)g_Items.size(); ++i)
{
if (g_Items[i].m_Name == key &&
g_Items[i].m_CharSet1 == CharSet1)
{
WCHAR sz[MAX_STRING];
SendDlgItemMessageW(hwnd, cmb1, CB_SETEDITSEL, 0, MAKELPARAM(0, -1));
SetFocus(GetDlgItem(hwnd, cmb1));
LoadStringW(g_hInstance, IDS_ALREADYEXISTS, sz, _countof(sz));
MessageBoxW(hwnd, sz, NULL, MB_ICONERROR);
return;
}
}
{
ITEM Item(key, value, CharSet1, CharSet2);
g_Items.push_back(Item);
g_bModified = TRUE;
i = (INT)g_Items.size();
LV_ITEM LvItem;
ZeroMemory(&LvItem, sizeof(LvItem));
LvItem.mask = LVIF_PARAM;
LvItem.iItem = i;
LvItem.lParam = i;
LvItem.iSubItem = 0;
ListView_InsertItem(g_hListView, &LvItem);
LvItem.iSubItem = 1;
ListView_InsertItem(g_hListView, &LvItem);
}
g_bModified = TRUE;
EndDialog(hwnd, IDOK);
break;
case IDCANCEL:
EndDialog(hwnd, IDCANCEL);
break;
}
}
INT_PTR CALLBACK
AddDlg_DlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch (uMsg)
{
HANDLE_MSG(hwnd, WM_INITDIALOG, AddDlg_OnInitDialog);
HANDLE_MSG(hwnd, WM_COMMAND, AddDlg_OnCommand);
}
return 0;
}
void MainWnd_OnNew(HWND hwnd)
{
g_iItem = ListView_GetNextItem(hwnd, -1, LVNI_SELECTED);
if (g_iItem == -1)
return;
g_strFontName = g_Items[g_iItem].m_Name;
g_strSubstitute = g_Items[g_iItem].m_Substitute;
g_CharSet1 = g_Items[g_iItem].m_CharSet1;
g_CharSet2 = g_Items[g_iItem].m_CharSet2;
if (IDOK == DialogBox(g_hInstance, MAKEINTRESOURCE(IDD_ADD), g_hMainWnd,
AddDlg_DlgProc))
{
INT i = ListView_GetItemCount(g_hListView) - 1;
UINT State = LVIS_SELECTED | LVIS_FOCUSED;
ListView_SetItemState(g_hListView, i, State, State);
ListView_EnsureVisible(g_hListView, i, FALSE);
}
}
BOOL MainWnd_OnUpdateRegistry(HWND hwnd)
{
// open the key
HKEY hKey = NULL;
RegOpenKeyExW(HKEY_LOCAL_MACHINE, g_pszKey, 0, KEY_ALL_ACCESS, &hKey);
if (hKey == NULL)
return FALSE;
// clear all values
WCHAR szName[MAX_STRING], szValue[MAX_STRING];
DWORD cbName, cbValue;
for (;;)
{
cbName = sizeof(szName);
cbValue = sizeof(szValue);
LONG Error = RegEnumValueW(hKey, 0, szName, &cbName,
NULL, NULL, (LPBYTE)szValue, &cbValue);
if (Error != ERROR_SUCCESS)
break;
RegDeleteValueW(hKey, szName);
}
// set values
size_t Count = g_Items.size();
for (size_t i = 0; i < Count; ++i)
{
DWORD cbData = (g_Items[i].m_Substitute.size() + 1) * sizeof(WCHAR);
RegSetValueExW(hKey, g_Items[i].m_Name.c_str(), 0,
REG_SZ, (LPBYTE)g_Items[i].m_Substitute.c_str(), cbData);
}
// close now
RegCloseKey(hKey);
g_bModified = FALSE;
g_bNeedsReboot = TRUE;
return TRUE;
}
LPWSTR SkipSpace(LPCWSTR pch)
{
while (*pch && wcschr(L" \t\r\n", *pch) != NULL)
{
++pch;
}
return const_cast<LPWSTR>(pch);
}
LPWSTR SkipQuoted(LPWSTR pch)
{
++pch; // L'"'
while (*pch)
{
if (*pch == L'"')
{
++pch;
break;
}
if (*pch == L'\\')
{
++pch;
}
++pch;
}
return pch;
}
void UnescapeHex(const STRING& str, size_t& i, STRING& Ret, BOOL Unicode)
{
STRING Num;
// hexadecimal
if (iswxdigit(str[i]))
{
Num += str[i];
++i;
if (iswxdigit(str[i]))
{
Num += str[i];
++i;
if (Unicode)
{
if (iswxdigit(str[i]))
{
Num += str[i];
++i;
if (iswxdigit(str[i]))
{
Num += str[i];
++i;
}
}
}
}
}
if (!Num.empty())
{
Ret += (WCHAR)wcstoul(&Num[0], NULL, 16);
}
}
void UnescapeOther(const STRING& str, size_t& i, STRING& Ret)
{
STRING Num;
// check octal
if (L'0' <= str[i] && str[i] < L'8')
{
Num += str[i];
++i;
if (L'0' <= str[i] && str[i] < L'8')
{
Num += str[i];
++i;
if (L'0' <= str[i] && str[i] < L'8')
{
Num += str[i];
++i;
}
}
}
if (Num.empty())
{
Ret += str[i];
++i;
}
else
{
// octal
Ret += (WCHAR)wcstoul(&Num[0], NULL, 8);
}
}
// process escape sequence
void UnescapeChar(const STRING& str, size_t& i, STRING& Ret)
{
if (str[i] != L'\\')
{
Ret += str[i];
++i;
return;
}
++i;
switch (str[i])
{
case L'a': Ret += L'\a'; ++i; break;
case L'b': Ret += L'\b'; ++i; break;
case L'f': Ret += L'\f'; ++i; break;
case L'n': Ret += L'\n'; ++i; break;
case L'r': Ret += L'\r'; ++i; break;
case L't': Ret += L'\t'; ++i; break;
case L'v': Ret += L'\v'; ++i; break;
case L'x':
// hexidemical
++i;
UnescapeHex(str, i, Ret, FALSE);
break;
case L'u':
// Unicode hexidemical
++i;
UnescapeHex(str, i, Ret, TRUE);
break;
default:
// other case
UnescapeOther(str, i, Ret);
break;
}
}
STRING Unquote(const STRING& str)
{
if (str[0] != L'"')
return str;
STRING Ret;
size_t i = 1;
while (i < str.size())
{
if (str[i] == L'"' || str[i] == UNICODE_NULL)
break;
UnescapeChar(str, i, Ret);
}
return Ret;
}
BOOL DoParseFile(LPVOID pvContents, DWORD dwSize)
{
ITEMVECTOR Items;
LPWSTR pch, pchSep, pchStart = (LPWSTR)pvContents;
pchStart[dwSize / sizeof(WCHAR)] = UNICODE_NULL;
// check header
const DWORD cbHeader = lstrlenW(g_pszFileHeader) * sizeof(WCHAR);
if (memcmp(pchStart, g_pszFileHeader, cbHeader) != 0)
return FALSE;
pchStart += cbHeader / sizeof(WCHAR);
// find the key
WCHAR szKey[MAX_STRING];
wsprintfW(szKey, L"[HKEY_LOCAL_MACHINE\\%s]", g_pszKey);
pch = wcsstr(pchStart, szKey);
if (pch == NULL)
return FALSE;
pchStart = pch + lstrlenW(szKey);
for (;;)
{
pchStart = SkipSpace(pchStart);
if (*pchStart == UNICODE_NULL || *pchStart == L'[')
break;
pch = wcschr(pchStart, L'\n');
if (pch)
*pch = UNICODE_NULL;
pchSep = SkipQuoted(pchStart);
if (*pchSep == L'=')
{
*pchSep = UNICODE_NULL;
STRING key = pchStart;
trim(key);
key = Unquote(key);
STRING value = pchSep + 1;
trim(value);
value = Unquote(value);
BYTE CharSet1 = DEFAULT_CHARSET, CharSet2 = DEFAULT_CHARSET;
size_t pos;
pos = key.find(L',');
if (pos != STRING::npos)
{
CharSet1 = (BYTE)_wtoi(&key[pos + 1]);
key.resize(pos);
trim(key);
}
pos = value.find(L',');
if (pos != STRING::npos)
{
CharSet2 = (BYTE)_wtoi(&value[pos + 1]);
value.resize(pos);
trim(value);
}
ITEM Item(key, value, CharSet1, CharSet2);
Items.push_back(Item);
}
if (pch == NULL)
break;
pchStart = pch + 1;
}
g_Items = Items;
g_bModified = TRUE;
LV_AddItems(g_hListView);
return TRUE;
}
BOOL DoImport(HWND hwnd, LPCWSTR pszFile)
{
HANDLE hFile = CreateFileW(pszFile, GENERIC_READ,
FILE_SHARE_READ | FILE_SHARE_DELETE, NULL,
OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, NULL);
if (hFile == INVALID_HANDLE_VALUE)
return FALSE;
BOOL bSuccess = FALSE;
DWORD dwSize = GetFileSize(hFile, NULL);
if (dwSize != 0xFFFFFFFF)
{
std::vector<BYTE> Contents(dwSize + 2);
DWORD cbRead;
if (ReadFile(hFile, &Contents[0], dwSize, &cbRead, NULL) &&
cbRead == dwSize)
{
/* check BOM */
if (memcmp(&Contents[0], "\xFF\xFE", 2) == 0)
{
bSuccess = DoParseFile(&Contents[2], dwSize - 2);
}
else
{
bSuccess = DoParseFile(&Contents[0], dwSize);
}
}
}
CloseHandle(hFile);
return bSuccess;
}
STRING Escape(const STRING& str)
{
STRING Ret;
for (size_t i = 0; i < str.size(); ++i)
{
switch (str[i])
{
case L'"': case L'\\':
Ret += L'\\';
Ret += str[i];
break;
default:
Ret += str[i];
}
}
return Ret;
}
BOOL DoExport(HWND hwnd, LPCWSTR pszFile)
{
HANDLE hFile = CreateFileW(pszFile, GENERIC_WRITE, FILE_SHARE_READ,
NULL, CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_WRITE_THROUGH, NULL);
if (hFile == INVALID_HANDLE_VALUE)
return FALSE;
BOOL bSuccess;
DWORD dwSize, cbWritten;
WCHAR szCharSet1[MAX_STRING], szCharSet2[MAX_STRING];
WCHAR szLine[MAX_STRING * 2 + 4];
/* write header */
dwSize = lstrlenW(g_pszFileHeader) * sizeof(WCHAR);
bSuccess =
WriteFile(hFile, "\xFF\xFE", 2, &cbWritten, NULL) &&
WriteFile(hFile, g_pszFileHeader, dwSize, &cbWritten, NULL);
if (bSuccess)
{
wsprintfW(szLine, L"\r\n\r\n[HKEY_LOCAL_MACHINE\\%s]\r\n", g_pszKey);
dwSize = lstrlenW(szLine) * sizeof(WCHAR);
bSuccess = WriteFile(hFile, szLine, dwSize, &cbWritten, NULL);
}
if (bSuccess)
{
size_t i, Count = g_Items.size();
for (i = 0; i < Count; ++i)
{
if (g_Items[i].m_CharSet1 != DEFAULT_CHARSET)
wsprintfW(szCharSet1, L",%u", g_Items[i].m_CharSet1);
else
szCharSet1[0] = UNICODE_NULL;
if (g_Items[i].m_CharSet2 != DEFAULT_CHARSET)
wsprintfW(szCharSet2, L",%u", g_Items[i].m_CharSet2);
else
szCharSet2[0] = UNICODE_NULL;
STRING Name = Escape(g_Items[i].m_Name);
STRING Substitute = Escape(g_Items[i].m_Substitute);
wsprintfW(szLine, L"\"%s%s\"=\"%s%s\"\r\n",
Name.c_str(), szCharSet1,
Substitute.c_str(), szCharSet2);
dwSize = lstrlenW(szLine) * sizeof(WCHAR);
if (!WriteFile(hFile, szLine, dwSize, &cbWritten, NULL))
{
bSuccess = FALSE;
break;
}
}
WriteFile(hFile, L"\r\n", 2 * sizeof(WCHAR), &cbWritten, NULL);
}
CloseHandle(hFile);
if (!bSuccess)
{
DeleteFileW(pszFile);
}
return bSuccess;
}
void MakeFilter(LPWSTR pszFilter)
{
while (*pszFilter)
{
if (*pszFilter == L'|')
*pszFilter = 0;
++pszFilter;
}
}
void MainWnd_OnImport(HWND hwnd)
{
OPENFILENAMEW ofn = {0};
WCHAR szFile[MAX_PATH] = L"";
WCHAR szImportTitle[MAX_STRING];
WCHAR szCannotImport[MAX_STRING];
WCHAR szImportFilter[MAX_STRING];
LoadStringW(g_hInstance, IDS_IMPORT, szImportTitle, _countof(szImportTitle));
LoadStringW(g_hInstance, IDS_CANTIMPORT, szCannotImport, _countof(szCannotImport));
LoadStringW(g_hInstance, IDS_INPFILTER, szImportFilter, _countof(szImportFilter));
MakeFilter(szImportFilter);
ofn.lStructSize = OPENFILENAME_SIZE_VERSION_400;
ofn.hwndOwner = hwnd;
ofn.lpstrFilter = szImportFilter;
ofn.lpstrFile = szFile;
ofn.nMaxFile = _countof(szFile);
ofn.lpstrTitle = szImportTitle;
ofn.Flags = OFN_DONTADDTORECENT | OFN_ENABLESIZING |
OFN_EXPLORER | OFN_FILEMUSTEXIST |
OFN_HIDEREADONLY | OFN_LONGNAMES |
OFN_PATHMUSTEXIST;
ofn.lpstrDefExt = L"reg";
if (GetOpenFileNameW(&ofn))
{
if (!DoImport(hwnd, szFile))
{
MessageBoxW(hwnd, szCannotImport, g_szTitle, MB_ICONERROR);
}
}
}
void MainWnd_OnExport(HWND hwnd)
{
OPENFILENAMEW ofn = {0};
WCHAR szFile[MAX_PATH] = L"";
WCHAR szExportTitle[MAX_STRING];
WCHAR szCannotExport[MAX_STRING];
WCHAR szExportFilter[MAX_STRING];
LoadStringW(g_hInstance, IDS_EXPORT, szExportTitle, _countof(szExportTitle));
LoadStringW(g_hInstance, IDS_CANTEXPORT, szCannotExport, _countof(szCannotExport));
LoadStringW(g_hInstance, IDS_OUTFILTER, szExportFilter, _countof(szExportFilter));
MakeFilter(szExportFilter);
ofn.lStructSize = OPENFILENAME_SIZE_VERSION_400;
ofn.hwndOwner = hwnd;
ofn.lpstrFilter = szExportFilter;
ofn.lpstrFile = szFile;
ofn.nMaxFile = _countof(szFile);
ofn.lpstrTitle = szExportTitle;
ofn.Flags = OFN_DONTADDTORECENT | OFN_ENABLESIZING |
OFN_EXPLORER | OFN_HIDEREADONLY | OFN_LONGNAMES |
OFN_PATHMUSTEXIST | OFN_OVERWRITEPROMPT;
ofn.lpstrDefExt = L"reg";
if (GetSaveFileNameW(&ofn))
{
if (!DoExport(hwnd, szFile))
{
MessageBoxW(hwnd, szCannotExport, g_szTitle, MB_ICONERROR);
}
}
}
void MainWnd_OnReload(HWND hwnd)
{
DoLoad();
}
void MainWnd_OnEdit(HWND hwnd)
{
LV_OnDblClk(g_hListView);
}
void MainWnd_OnDelete(HWND hwnd)
{
LV_OnDelete(g_hListView);
}
void MainWnd_OnOpenRegKey(HWND hwnd)
{
static const WCHAR s_szRegeditKey[] =
L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Applets\\Regedit";
WCHAR sz[MAX_STRING];
// open regedit key
HKEY hKey = NULL;
LSTATUS Result = RegCreateKeyExW(HKEY_CURRENT_USER, s_szRegeditKey, 0,
NULL, 0, KEY_WRITE, NULL, &hKey, NULL);
if (Result != ERROR_SUCCESS)
{
LoadStringW(g_hInstance, IDS_CANTOPENKEY, sz, _countof(sz));
MessageBoxW(hwnd, sz, NULL, MB_ICONERROR);
return;
}
// set LastKey value
wsprintfW(sz, L"HKEY_LOCAL_MACHINE\\%s", g_pszKey);
DWORD dwSize = sizeof(sz);
Result = RegSetValueExW(hKey, L"LastKey", 0, REG_SZ,
(LPBYTE)sz, dwSize);
// close now
RegCloseKey(hKey);
if (Result != ERROR_SUCCESS)
{
LoadStringW(g_hInstance, IDS_CANTOPENKEY, sz, _countof(sz));
MessageBoxW(hwnd, sz, NULL, MB_ICONERROR);
return;
}
// open by regedit
ShellExecuteW(hwnd, NULL, L"regedit.exe", NULL, NULL, SW_SHOWNORMAL);
}
void MainWnd_OnAbout(HWND hwnd)
{
WCHAR szAbout[MAX_PATH];
LoadStringW(g_hInstance, IDS_ABOUT, szAbout, _countof(szAbout));
MSGBOXPARAMS Params;
ZeroMemory(&Params, sizeof(Params));
Params.cbSize = sizeof(Params);
Params.hwndOwner = hwnd;
Params.hInstance = g_hInstance;
Params.lpszText = szAbout;
Params.lpszCaption = g_szTitle;
Params.dwStyle = MB_OK | MB_USERICON;
Params.lpszIcon = MAKEINTRESOURCEW(1);
Params.dwLanguageId = LANG_USER_DEFAULT;
MessageBoxIndirectW(&Params);
}
void MainWnd_OnCommand(HWND hwnd, int id, HWND hwndCtl, UINT codeNotify)
{
switch (id)
{
case ID_NEW:
MainWnd_OnNew(hwnd);
break;
case ID_EDIT:
MainWnd_OnEdit(hwnd);
break;
case ID_EXIT:
PostMessage(hwnd, WM_CLOSE, 0, 0);
break;
case ID_RELOAD:
MainWnd_OnReload(hwnd);
break;
case ID_UPDATE_REGISTRY:
MainWnd_OnUpdateRegistry(hwnd);
break;
case ID_DELETE:
MainWnd_OnDelete(hwnd);
break;
case ID_IMPORT:
MainWnd_OnImport(hwnd);
break;
case ID_EXPORT:
MainWnd_OnExport(hwnd);
break;
case ID_OPEN_REGKEY:
MainWnd_OnOpenRegKey(hwnd);
break;
case ID_ABOUT:
MainWnd_OnAbout(hwnd);
break;
}
}
void MainWnd_OnDestroy(HWND hwnd)
{
PostQuitMessage(0);
}
void MainWnd_OnSize(HWND hwnd, UINT state, int cx, int cy)
{
MoveWindow(g_hListView, 0, 0, cx, cy, TRUE);
}
void MainWnd_OnDrawItem(HWND hwnd, const DRAWITEMSTRUCT *lpDrawItem)
{
if (lpDrawItem->CtlType != ODT_LISTVIEW)
return;
HDC hDC = lpDrawItem->hDC;
SetBkMode(hDC, TRANSPARENT);
INT iColumn = 0, x, cx;
RECT rcItem, rcSubItem, rcText;
STRING Str;
x = -GetScrollPos(g_hListView, SB_HORZ);
rcItem = lpDrawItem->rcItem;
if (lpDrawItem->itemState & ODS_SELECTED)
{
FillRect(hDC, &rcItem, (HBRUSH)(COLOR_HIGHLIGHT + 1));
SetTextColor(hDC, GetSysColor(COLOR_HIGHLIGHTTEXT));
}
else
{
FillRect(hDC, &rcItem, (HBRUSH)(COLOR_WINDOW + 1));
SetTextColor(hDC, GetSysColor(COLOR_WINDOWTEXT));
}
cx = ListView_GetColumnWidth(g_hListView, iColumn);
rcSubItem = rcItem;
rcSubItem.left = x;
rcSubItem.right = x + cx;
WCHAR sz[MAX_STRING];
rcText = rcSubItem;
InflateRect(&rcText, -1, -1);
Str = g_Items[lpDrawItem->itemID].m_Name;
BYTE CharSet1 = g_Items[lpDrawItem->itemID].m_CharSet1;
if (CharSet1 != DEFAULT_CHARSET)
wsprintfW(sz, L"%s,%u", Str.c_str(), CharSet1);
else
wsprintfW(sz, L"%s", Str.c_str());
DrawTextW(hDC, sz, lstrlenW(sz), &rcText,
DT_SINGLELINE | DT_LEFT | DT_VCENTER | DT_END_ELLIPSIS |
DT_NOPREFIX);
x += cx;
++iColumn;
cx = ListView_GetColumnWidth(g_hListView, iColumn);
rcSubItem = rcItem;
rcSubItem.left = x;
rcSubItem.right = x + cx;
rcText = rcSubItem;
InflateRect(&rcText, -1, -1);
Str = g_Items[lpDrawItem->itemID].m_Substitute;
BYTE CharSet2 = g_Items[lpDrawItem->itemID].m_CharSet2;
if (CharSet2 != DEFAULT_CHARSET)
wsprintfW(sz, L"%s,%u", Str.c_str(), CharSet2);
else
wsprintfW(sz, L"%s", Str.c_str());
DrawTextW(hDC, sz, lstrlenW(sz), &rcText,
DT_SINGLELINE | DT_LEFT | DT_VCENTER | DT_END_ELLIPSIS |
DT_NOPREFIX);
}
void MainWnd_OnMeasureItem(HWND hwnd, MEASUREITEMSTRUCT *lpMeasureItem)
{
if (lpMeasureItem->CtlType != ODT_LISTVIEW)
return;
TEXTMETRIC tm;
HDC hDC = GetDC(hwnd);
GetTextMetrics(hDC, &tm);
ReleaseDC(hwnd, hDC);
lpMeasureItem->itemHeight = tm.tmHeight * 4 / 3;
}
LRESULT MainWnd_OnNotify(HWND hwnd, int idFrom, NMHDR *pnmhdr)
{
NM_LISTVIEW *pNMLV = (NM_LISTVIEW *)pnmhdr;
LV_KEYDOWN *pLVKD = (LV_KEYDOWN *)pnmhdr;
switch (pnmhdr->code)
{
case LVN_COLUMNCLICK:
if (pNMLV->iSubItem == g_iSortColumn)
DoSort(pNMLV->iSubItem, !g_bSortAscendant);
else
DoSort(pNMLV->iSubItem, TRUE);
break;
case NM_DBLCLK:
LV_OnDblClk(g_hListView);
break;
case LVN_KEYDOWN:
if (pLVKD->wVKey == VK_RETURN) // [Enter] key
{
LV_OnDblClk(g_hListView);
}
if (pLVKD->wVKey == VK_DELETE) // [Del] key
{
LV_OnDelete(g_hListView);
}
break;
}
return 0;
}
LRESULT MainWnd_OnContextMenu(HWND hwnd, HWND hwndContext, UINT xPos, UINT yPos)
{
POINT pt = {(INT)xPos, (INT)yPos};
ScreenToClient(g_hListView, &pt);
SendMessageW(g_hListView, WM_LBUTTONDOWN, 0, MAKELPARAM(pt.x, pt.y));
HMENU hMenu = LoadMenu(g_hInstance, MAKEINTRESOURCE(2));
if (hMenu == NULL)
return 0;
HMENU hSubMenu = GetSubMenu(hMenu, 0);
if (hSubMenu == NULL)
return 0;
SetForegroundWindow(hwnd);
TrackPopupMenu(hSubMenu, TPM_LEFTALIGN | TPM_RIGHTBUTTON,
xPos, yPos, 0, g_hMainWnd, NULL);
PostMessage(g_hMainWnd, WM_NULL, 0, 0);
return 0;
}
void MainWnd_OnActivate(HWND hwnd, UINT state, HWND hwndActDeact, BOOL fMinimized)
{
if (state != WA_INACTIVE)
{
SetFocus(g_hListView);
}
}
BOOL EnableProcessPrivileges(LPCWSTR lpPrivilegeName, BOOL bEnable = TRUE)
{
HANDLE hToken;
LUID luid;
TOKEN_PRIVILEGES tokenPrivileges;
BOOL Ret;
Ret = ::OpenProcessToken(::GetCurrentProcess(),
TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
&hToken);
if (!Ret)
return Ret; // failure
Ret = ::LookupPrivilegeValueW(NULL, lpPrivilegeName, &luid);
if (Ret)
{
tokenPrivileges.PrivilegeCount = 1;
tokenPrivileges.Privileges[0].Luid = luid;
tokenPrivileges.Privileges[0].Attributes = bEnable ? SE_PRIVILEGE_ENABLED : 0;
Ret = ::AdjustTokenPrivileges(hToken, FALSE, &tokenPrivileges, 0, 0, 0);
}
::CloseHandle(hToken);
return Ret;
}
void MainWnd_OnClose(HWND hwnd)
{
if (!g_bNeedsReboot && !g_bModified)
{
DestroyWindow(hwnd);
return;
}
if (g_bModified)
{
WCHAR szUpdateNow[MAX_STRING];
LoadStringW(g_hInstance, IDS_QUERYUPDATE, szUpdateNow, _countof(szUpdateNow));
INT id = MessageBoxW(hwnd, szUpdateNow, g_szTitle,
MB_ICONINFORMATION | MB_YESNOCANCEL);
switch (id)
{
case IDYES:
MainWnd_OnUpdateRegistry(hwnd);
break;
case IDNO:
break;
case IDCANCEL:
return;
}
}
if (g_bNeedsReboot)
{
WCHAR szRebootNow[MAX_STRING];
LoadStringW(g_hInstance, IDS_REBOOTNOW, szRebootNow, _countof(szRebootNow));
INT id = MessageBoxW(hwnd, szRebootNow, g_szTitle,
MB_ICONINFORMATION | MB_YESNOCANCEL);
switch (id)
{
case IDYES:
EnableProcessPrivileges(SE_SHUTDOWN_NAME, TRUE);
::ExitWindowsEx(EWX_REBOOT | EWX_FORCE, 0);
break;
case IDNO:
break;
case IDCANCEL:
return;
}
}
::DestroyWindow(hwnd);
}
LRESULT CALLBACK
WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch (uMsg)
{
HANDLE_MSG(hwnd, WM_CREATE, MainWnd_OnCreate);
HANDLE_MSG(hwnd, WM_COMMAND, MainWnd_OnCommand);
HANDLE_MSG(hwnd, WM_DESTROY, MainWnd_OnDestroy);
HANDLE_MSG(hwnd, WM_SIZE, MainWnd_OnSize);
HANDLE_MSG(hwnd, WM_DRAWITEM, MainWnd_OnDrawItem);
HANDLE_MSG(hwnd, WM_MEASUREITEM, MainWnd_OnMeasureItem);
HANDLE_MSG(hwnd, WM_NOTIFY, MainWnd_OnNotify);
HANDLE_MSG(hwnd, WM_CONTEXTMENU, MainWnd_OnContextMenu);
HANDLE_MSG(hwnd, WM_ACTIVATE, MainWnd_OnActivate);
HANDLE_MSG(hwnd, WM_CLOSE, MainWnd_OnClose);
default:
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
}
INT WINAPI wWinMain(
HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPWSTR lpCmdLine,
INT nCmdShow)
{
g_hInstance = hInstance;
InitCommonControls();
HACCEL hAccel = LoadAcceleratorsW(hInstance, MAKEINTRESOURCEW(1));
LoadStringW(hInstance, IDS_TITLE, g_szTitle, _countof(g_szTitle));
LoadStringW(hInstance, IDS_FONTNAME, g_szNameHead, _countof(g_szNameHead));
LoadStringW(hInstance, IDS_SUBSTITUTE, g_szSubstituteHead, _countof(g_szSubstituteHead));
WNDCLASSW wc = {0};
wc.style = 0;
wc.lpfnWndProc = WindowProc;
wc.hInstance = hInstance;
g_hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(1));
wc.hIcon = g_hIcon;
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = (HBRUSH)(COLOR_3DFACE + 1);
wc.lpszMenuName = MAKEINTRESOURCEW(1);
wc.lpszClassName = g_pszClassName;
if (!RegisterClassW(&wc))
{
MessageBoxA(NULL, "ERROR: RegisterClass failed.", NULL, MB_ICONERROR);
return 1;
}
const DWORD dwStyle = WS_OVERLAPPEDWINDOW;
INT Width = NAME_COLUMN_WIDTH + SUB_COLUMN_WIDTH +
GetSystemMetrics(SM_CXVSCROLL) +
GetSystemMetrics(SM_CXSIZEFRAME);
INT Height = 320;
RECT Rect = { 0, 0, Width, Height };
AdjustWindowRect(&Rect, dwStyle, TRUE);
Width = Rect.right - Rect.left;
Height = Rect.bottom - Rect.top;
g_hMainWnd = CreateWindowW(g_pszClassName, g_szTitle, dwStyle,
CW_USEDEFAULT, CW_USEDEFAULT, Width, Height,
NULL, NULL, hInstance, NULL);
if (g_hMainWnd == NULL)
{
MessageBoxA(NULL, "ERROR: CreateWindow failed.", NULL, MB_ICONERROR);
return 2;
}
ShowWindow(g_hMainWnd, nCmdShow);
UpdateWindow(g_hMainWnd);
MSG msg;
while (GetMessage(&msg, NULL, 0, 0))
{
if (TranslateAccelerator(g_hMainWnd, hAccel, &msg))
continue;
TranslateMessage(&msg);
DispatchMessage(&msg);
}
return (INT)msg.wParam;
}
Reference in a new issue View git blame Copy permalink