티젯 추가
MoveCursor
SoEnty07 프로젝트는 티젯을 대량으로 늘린다. 개별 티젯 작성 방법도 하나의 실습 주제이지만 SoEnty의 구조와는
큰 상관이 없다. 상세한 설명보다는 작업 기록 정도만 남기고 핵심 부분에 대해서만 간략하게 설명하기로
한다.
MoveCursor는 일정 시간동안 커서가 움직이지 않으면 한칸 오른쪽으로
움직여 주는 티젯이다. 이런게 왜 필요한가 싶겠지만 보안이 엄격한 회사에서는 화면 보호기를 강제 설정하여
업무에 방해가 되기도 한다. 또 재택 근무시 잠시 자리를 비울 때 항상 온라인 상태를 유지해 주고 백그라운드
작업시 컴퓨터를 계속 풀스피드로 돌릴 수 있어 여러 가지 용도가 있다.
class CMoveCursor : public CTidget
{
public:
HBITMAP
bitOn, bitOff;
bool
bCursorMove; //
커서 강제 이동 여부
int
TimerInterval; //
타이머 주기
int
CursorInterval; //
커서 강제 이동 주기(초단위)
int
CursorKeepSec; //
커서가 움직이지 않고 제 자리에 있었던 시간
int
RejectCount; //
커서 이동 회수(스크린 세이버 방지 회수)
POINT
OldCursorPt; //
이전 커서 위치
LRESULT
OnCreate(WPARAM wParam, LPARAM lParam);
LRESULT
OnDestroy(WPARAM wParam, LPARAM lParam);
void
OnDraw(HDC hdc, int width, int height);
void
OnClick();
LRESULT
OnTimer(WPARAM wParam, LPARAM lParam);
LRESULT
OnContextMenu(WPARAM wParam, LPARAM lParam);
void
LoadSetting();
void
SaveSetting();
static
INT_PTR CALLBACK MoveCursorDlgProc(HWND hDlg,
UINT
iMessage, WPARAM wParam, LPARAM lParam);
};
옵션이 약간 많다. 두 개의 비트맵으로 상태를 보여 주며 타이머 돌리며
커서 이동시키고 팝업창 열어 옵션을 조정하는 일반적인 구성이다.
LRESULT CMoveCursor::OnCreate(WPARAM wParam,
LPARAM lParam) {
bitOn
= LoadBitmap(g_hInst, MAKEINTRESOURCE(IDB_MOVECURSORON));
bitOff
= LoadBitmap(g_hInst, MAKEINTRESOURCE(IDB_MOVECURSOROFF));
LoadSetting();
RejectCount
= 0;
if
(bCursorMove) {
SetTimer(win_hWnd,
1, TimerInterval, NULL);
}
return
0;
}
LRESULT CMoveCursor::OnDestroy(WPARAM wParam,
LPARAM lParam) {
setting.set(dget_id,
L"moveCursor", bCursorMove);
DeleteObject(bitOn);
DeleteObject(bitOff);
KillTimer(win_hWnd,
1);
return
0;
}
void CMoveCursor::OnDraw(HDC hdc, int width, int
height)
{
int
wh = trayWindow.tidgetSize;
if
(bCursorMove) {
StretchBitmap(hdc,
0, 0, wh, wh, bitOn);
}
else {
StretchBitmap(hdc,
0, 0, wh, wh, bitOff);
}
}
void CMoveCursor::OnClick()
{
bCursorMove
= !bCursorMove;
if
(bCursorMove) {
KillTimer(win_hWnd,
1);
}
else {
SetTimer(win_hWnd,
1, TimerInterval, NULL);
}
SaveSetting();
InvalidateRect(win_hWnd,
NULL, FALSE);
}
LRESULT CMoveCursor::OnTimer(WPARAM wParam, LPARAM
lParam)
{
POINT
pt;
GetCursorPos(&pt);
//
같은 자리에 있는 누적 시간 갱신
if
(pt.x == OldCursorPt.x && pt.y == OldCursorPt.y) {
CursorKeepSec
+= TimerInterval / 1000;
//
스크린 세이버가 뜰 시간이 되면 강제로 커서 한칸 오른쪽으로 옮김
if
(CursorKeepSec >= CursorInterval) {
CursorKeepSec
= 0;
mouse_event(MOUSEEVENTF_MOVE,
1, 0, 0, 0);
RejectCount++;
}
//
위치가 바뀌면 누적 시간 리셋
}
else {
CursorKeepSec
= 0;
OldCursorPt
= pt;
}
return
0;
}
LRESULT CMoveCursor::OnContextMenu(WPARAM wParam,
LPARAM lParam)
{
if
(!IsWindow(hOptionPopup)) {
hOptionPopup
= CreateDialogParam(g_hInst, MAKEINTRESOURCE(IDD_MOVECURSOR),
win_hWnd,
MoveCursorDlgProc, (LPARAM)this);
ShowWindow(hOptionPopup,
SW_SHOW);
}
return
0;
}
INT_PTR CALLBACK
CMoveCursor::MoveCursorDlgProc(HWND hDlg, UINT iMessage, WPARAM wParam, LPARAM
lParam)
{
static
CMoveCursor* pTidget;
TCHAR
str[128];
RECT
wrt;
switch
(iMessage) {
case
WM_INITDIALOG:
pTidget
= (CMoveCursor*)lParam;
GetWindowRect(trayWindow.win_hWnd,
&wrt);
MovePopupToSide(hDlg,
wrt.left, wrt.top);
//
범위를 반대로 줘야 위가 증가, 아래가 감소이다.
SendDlgItemMessage(hDlg,
IDC_SPINMOVECURSORCYCLE, UDM_SETRANGE, 0, MAKELPARAM(600, 60));
wsprintf(str,
L"이동 횟수 : %d번",
pTidget->RejectCount);
SetDlgItemText(hDlg,
IDC_STMOVECURSORCOUNT, str);
if
(pTidget->bCursorMove) {
CheckDlgButton(hDlg,
IDC_CHKMOVECURSOR, BST_CHECKED);
}
SetDlgItemInt(hDlg,
IDC_EDMOVECURSORCYCLE, pTidget->CursorInterval, FALSE);
return
TRUE;
case
WM_NCACTIVATE:
if
(wParam == FALSE && hOptionPopup != NULL) {
pTidget->CursorInterval
= GetDlgItemInt(hDlg, IDC_EDMOVECURSORCYCLE, NULL, FALSE);
pTidget->TimerInterval
= pTidget->CursorInterval * 100;
if
(IsDlgButtonChecked(hDlg, IDC_CHKMOVECURSOR) == BST_CHECKED) {
pTidget->bCursorMove
= true;
SetTimer(pTidget->win_hWnd,
1, pTidget->TimerInterval, NULL);
}
else {
pTidget->bCursorMove
= false;
KillTimer(pTidget->win_hWnd,
1);
}
pTidget->SaveSetting();
hOptionPopup
= NULL;
DestroyWindow(hDlg);
}
return
TRUE;
case
WM_COMMAND:
switch
(LOWORD(wParam)) {
case
IDCANCEL:
hOptionPopup
= NULL;
DestroyWindow(hDlg);
return
TRUE;
}
break;
}
return
FALSE;
}
void CMoveCursor::LoadSetting()
{
bCursorMove
= setting.get(dget_id, L"moveCursor", 0);
CursorInterval
= setting.get(dget_id, L"CursorInterval", 180);
//
타이머는 이동주기의 1/10으로 자동 설정한다. 180초면 18초에 한번씩 확인하면 충분하다.
//
최초 옵션으로 만들었는데 사용자가 이런 내부적인 값까지 선택할 필요는 없다.
TimerInterval
= CursorInterval * 100;
CursorKeepSec
= 0;
}
void CMoveCursor::SaveSetting()
{
setting.set(dget_id,
L"bCursorMove", bCursorMove);
setting.set(dget_id,
L"CursorInterval", CursorInterval);
}
보통 화면 보호기를 5분으로 설정하므로 디폴트 주기는 3분으로 설정했다. 이 티젯이 켜져 있으면 3분 내로 이동이 없을 때 커서를 한칸 오른쪽으로 옮겨 준다. 그렇다고
매 3분마다 옮기는 것은 아니고 3분 동안 커서가 제자리에
있을 때만 동작한다. 사용자가 커서를 까딱거리고 있다면 굳이 옮겨줄 필요 없다.
SizeMeter
이 위젯은 윈도우 크기를 측정하는 간단한 위젯이다. 4K 모니터를
쓰다가 QHD로 다운그레이드하면 얼마나 좁아지나 보고 싶을 때,
1024 * 768 크기의 이미지 크기가 내 모니터상에서 얼마만한 크기인지 확인해 보고 싶을 때 사용한다.
class CSizeMeter : public CTidget
{
public:
HBITMAP
icon;
LRESULT
OnCreate(WPARAM wParam, LPARAM lParam);
LRESULT
OnDestroy(WPARAM wParam, LPARAM lParam);
void
OnDraw(HDC hdc, int width, int height);
void
OnClick();
};
class CSizeMeterWin : public CWindow
{
public:
void
Create(HWND hParent);
LRESULT
OnSize(WPARAM wParam, LPARAM lParam);
void
OnDraw(HDC hdc, int width, int height);
LRESULT
OnKeyDown(WPARAM wParam, LPARAM lParam);
};
티젯과 티젯이 띄우는 윈도우로 구성된다.
LRESULT CSizeMeter::OnCreate(WPARAM wParam, LPARAM
lParam) {
icon
= LoadBitmap(g_hInst, MAKEINTRESOURCE(IDB_SIZEMETER));
return
0;
}
LRESULT CSizeMeter::OnDestroy(WPARAM wParam,
LPARAM lParam) {
DeleteObject(icon);
return
0;
}
void CSizeMeter::OnDraw(HDC hdc, int width, int
height) {
int
wh = trayWindow.tidgetSize;
StretchBitmap(hdc,
0, 0, wh, wh, icon);
}
void CSizeMeter::OnClick() {
CSizeMeterWin*
pWin = new CSizeMeterWin();
pWin->Create(NULL);
}
void CSizeMeterWin::Create(HWND hParent)
{
CreateWindow(L"CWindow",
L"SizeMeter", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
CW_USEDEFAULT,
CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
NULL,
(HMENU)NULL, g_hInst, this);
}
LRESULT CSizeMeterWin::OnSize(WPARAM wParam,
LPARAM lParam)
{
CWindow::OnSize(wParam,
lParam);
InvalidateRect(win_hWnd,
NULL, TRUE);
return
0;
}
void CSizeMeterWin::OnDraw(HDC hdc, int width, int
height)
{
TCHAR
str[111];
SetBkMode(hdc,
TRANSPARENT);
SetTextAlign(hdc,
TA_CENTER);
wsprintf(str,
TEXT("%d x %d"), width, height);
TextOutSz(hdc,
width / 2, height / 2, str);
lstrcpy(str,
TEXT("1 ~ 9 : 표준 크기"));
TextOutSz(hdc,
width / 2, height / 2 + 30, str);
}
LRESULT CSizeMeterWin::OnKeyDown(WPARAM wParam,
LPARAM lParam)
{
RECT
crt;
int
w, h;
w
= 0;
switch
(wParam) {
case
'1':
w
= 320; h = 240; break;
case
'2':
w
= 640; h = 480; break;
case
'3':
w
= 800; h = 600; break;
case
'4':
w
= 1024; h = 768; break;
case
'5':
w
= 1280; h = 1024; break;
case
'6':
w
= 1600; h = 1200; break;
case
'7':
w
= 1920; h = 1080; break;
case
'8':
w
= 2560; h = 1440; break;
case
'9':
w
= 3840; h = 2160; break;
}
if
(w != 0)
{
SetRect(&crt,
0, 0, w, h);
DWORD
Style = GetWindowLong(win_hWnd, GWL_STYLE);
DWORD
ExStyle = GetWindowLong(win_hWnd, GWL_EXSTYLE);
AdjustWindowRectEx(&crt,
Style, GetMenu(win_hWnd) != NULL, ExStyle);
SetWindowPos(win_hWnd,
NULL, 0, 0, crt.right - crt.left, crt.bottom - crt.top,
SWP_NOMOVE
| SWP_NOZORDER);
}
return
0;
}
화면에 현재 크기를 보여 주고 키 입력을 통해 1024 * 768 등의
해상도로 빠르게 크기를 조정한다. 크기는 윈도우 기준이 아니라 작업 영역 기준이다. 이 티젯은 전에 잠시 만들어 두었던 것을 가져와 포함시킨 것인데 개선의 여지가 많다. 모니터 해상도를 조사하여 실제 크기의 자를 보여주면 그것도 실용적일 것 같다.
지금은 양을 늘리는데 급급해 일단 포함만 시켜 두었다.
Tetris
잘 아는 테트리스 게임이다. 업무중에 심심할 때 하라고 넣어 봤다.
class CTetris : public CTidget
{
public:
HBITMAP
icon;
LRESULT
OnCreate(WPARAM wParam, LPARAM lParam);
LRESULT
OnDestroy(WPARAM wParam, LPARAM lParam);
void
OnDraw(HDC hdc, int width, int height);
void
OnClick();
};
class CTetrisWin : public CWindow
{
public:
enum
{ EMPTY, BRICK, WALL = 7/*sizeof(Shape) / sizeof(Shape[0]) + 1*/ };
int
ts;
int
bw;
int
bh;
int
board[1000][1000];
int
nx, ny;
int
brick, rot;
int
nbrick;
int
score;
int
bricknum;
int
Interval;
enum
Status { GAMEOVER, RUNNING, PAUSE };
Status
GameStatus;
HBRUSH
arBrush[8];
CTetrisWin()
: CWindow() {
ts
= 24;
bw
= 10;
bh
= 20;
score
= 0;
bricknum
= 0;
memset(board,
0, sizeof(board));
}
void
Create();
LRESULT
OnCreate(WPARAM wParam, LPARAM lParam);
LRESULT
OnDestroy(WPARAM wParam, LPARAM lParam);
LRESULT
OnTimer(WPARAM wParam, LPARAM lParam);
void
OnDraw(HDC hdc, int width, int height);
LRESULT
OnKeyDown(WPARAM wParam, LPARAM lParam);
void
MakeNewBrick();
int
GetAround(int x, int y, int b, int r);
BOOL
MoveDown();
void
TestFull();
void
PrintTile(HDC hdc, int x, int y, int c);
void
AdjustMainWindow();
};
게임 하나를 통째로 넣다 보니 아무래도 길이가 좀 길기는 하다.
LRESULT CTetris::OnCreate(WPARAM wParam, LPARAM
lParam)
{
icon
= LoadBitmap(g_hInst, MAKEINTRESOURCE(IDB_TETRIS));
return
0;
}
LRESULT CTetris::OnDestroy(WPARAM wParam, LPARAM
lParam)
{
DeleteObject(icon);
return
0;
}
void CTetris::OnDraw(HDC hdc, int width, int
height) {
int
wh = trayWindow.tidgetSize;
StretchBitmap(hdc,
0, 0, wh, wh, icon);
}
void CTetris::OnClick() {
//
게임 윈도우를 생성하여 띄운다.
CTetrisWin*
pWin = new CTetrisWin();
pWin->Create();
}
// 클래스안에 초기화된 배열 선언하는 방법을 모르겠음. C문법을 다 까쟈 묵음.
struct TetPoint {
int
x, y;
};
TetPoint Shape[][4][4] = {
{
{0,0,1,0,2,0,-1,0}, {0,0,0,1,0,-1,0,-2}, {0,0,1,0,2,0,-1,0},
{0,0,0,1,0,-1,0,-2} },
{
{0,0,1,0,0,1,1,1}, {0,0,1,0,0,1,1,1}, {0,0,1,0,0,1,1,1}, {0,0,1,0,0,1,1,1} },
{
{0,0,-1,0,0,-1,1,-1}, {0,0,0,1,-1,0,-1,-1}, {0,0,-1,0,0,-1,1,-1},
{0,0,0,1,-1,0,-1,-1} },
{
{0,0,-1,-1,0,-1,1,0}, {0,0,-1,0,-1,1,0,-1}, {0,0,-1,-1,0,-1,1,0},
{0,0,-1,0,-1,1,0,-1} },
{
{0,0,-1,0,1,0,-1,-1}, {0,0,0,-1,0,1,-1,1}, {0,0,-1,0,1,0,1,1},
{0,0,0,-1,0,1,1,-1} },
{
{0,0,1,0,-1,0,1,-1}, {0,0,0,1,0,-1,-1,-1}, {0,0,1,0,-1,0,-1,1},
{0,0,0,-1,0,1,1,1} },
};
void CTetrisWin::Create()
{
CreateWindow(TEXT("CWindow"),
L"Tetris", WS_OVERLAPPED | WS_SYSMENU | WS_BORDER | WS_CAPTION |
WS_VISIBLE,
10,
10, 100, 100,
NULL,
(HMENU)NULL, g_hInst, this);
}
LRESULT CTetrisWin::OnCreate(WPARAM wParam, LPARAM
lParam)
{
GameStatus
= GAMEOVER;
srand(GetTickCount());
AdjustMainWindow();
//
메인 윈도우의 옆에 연다.
RECT
wrt;
GetWindowRect(mainWindow.win_hWnd,
&wrt);
MovePopupToSide(win_hWnd,
wrt.left, wrt.top);
//
0번은 빈칸, 1~6은 벽돌. 7은 벽
COLORREF
arTileColor[] = { 0, 0xff0000, 0x00ff00, 0x0000ff, 0xffff00, 0xff00ff,
0x00ffff, 0x000000 };
for
(int i = 1; i <= 7; i++) {
arBrush[i]
= CreateSolidBrush(arTileColor[i]);
}
return
0;
}
LRESULT CTetrisWin::OnDestroy(WPARAM wParam,
LPARAM lParam)
{
for
(int i = 1; i <= 7; i++) {
DeleteObject(arBrush[i]);
}
return
0;
}
LRESULT CTetrisWin::OnTimer(WPARAM wParam, LPARAM
lParam)
{
if
(MoveDown() == TRUE) {
MakeNewBrick();
}
return
0;
}
void CTetrisWin::OnDraw(HDC hdc, int width, int
height)
{
int
x, y, i;
TCHAR
str[128];
FillRect(hdc,
0, 0, width, height, (HBRUSH)GetStockObject(LTGRAY_BRUSH));
//
테두리 그림
for
(x = 0; x < bw + 1; x++) {
PrintTile(hdc,
x, 0, WALL);
PrintTile(hdc,
x, bh + 1, WALL);
}
for
(y = 0; y < bh + 2; y++) {
PrintTile(hdc,
0, y, WALL);
PrintTile(hdc,
bw + 1, y, WALL);
}
//
게임판 그림
for
(x = 1; x < bw + 1; x++) {
for
(y = 1; y < bh + 1; y++) {
PrintTile(hdc,
x, y, board[x][y]);
}
}
//
이동중인 벽돌 그림
if
(GameStatus != GAMEOVER && brick != -1) {
for
(i = 0; i < 4; i++) {
PrintTile(hdc,
nx + Shape[brick][rot][i].x, ny + Shape[brick][rot][i].y, brick + 1);
}
}
//
다음 벽돌 그림
for
(x = bw + 3; x <= bw + 11; x++) {
for
(y = bh - 5; y <= bh + 1; y++) {
if
(x == bw + 3 || x == bw + 11 || y == bh - 5 || y == bh + 1) {
PrintTile(hdc,
x, y, WALL);
}
else {
PrintTile(hdc,
x, y, 0);
}
}
}
if
(GameStatus != GAMEOVER) {
for
(i = 0; i < 4; i++) {
PrintTile(hdc,
bw + 7 + Shape[nbrick][0][i].x, bh - 2 + Shape[nbrick][0][i].y, nbrick + 1);
}
}
//
정보 출력
HFONT
oldFont;
oldFont
= (HFONT)SelectObject(hdc, mainFont[1]);
SetBkMode(hdc,
TRANSPARENT);
lstrcpy(str,
TEXT("1~9:게임판 크기"));
TextOutSz(hdc,
(bw + 4) * ts, 30, str);
lstrcpy(str,
TEXT("Enter:시작/중지"));
TextOutSz(hdc,
(bw + 4) * ts, 60, str);
wsprintf(str,
TEXT("점수 : %d "), score);
TextOutSz(hdc,
(bw + 4) * ts, 90, str);
wsprintf(str,
TEXT("벽돌 : %d 개 "), bricknum);
TextOutSz(hdc,
(bw + 4) * ts, 120, str);
SelectObject(hdc,
oldFont);
}
LRESULT CTetrisWin::OnKeyDown(WPARAM wParam,
LPARAM lParam)
{
int
x, y;
int
trot;
//
게임 시작 여부에 상관없이 동작하는 키
if
(wParam == VK_RETURN) {
if
(GameStatus == GAMEOVER) {
for
(x = 0; x < bw + 2; x++) {
for
(y = 0; y < bh + 2; y++) {
board[x][y]
= (y == 0 || y == bh + 1 || x == 0 || x == bw + 1) ? WALL : EMPTY;
}
}
score
= 0;
bricknum
= 0;
GameStatus
= RUNNING;
nbrick
= random(sizeof(Shape) / sizeof(Shape[0]));
MakeNewBrick();
Interval
= 1000;
SetTimer(win_hWnd,
1, Interval, NULL);
}
else if (GameStatus == RUNNING) {
GameStatus
= PAUSE;
KillTimer(win_hWnd,
1);
}
else if (GameStatus == PAUSE) {
GameStatus
= RUNNING;
SetTimer(win_hWnd,
1, Interval, NULL);
}
}
//
게임판 크기는 시작 전에만 바꿀 수 있다.
if
(GameStatus == GAMEOVER && wParam >= '1' && wParam <=
'9') {
switch
(wParam) {
case
'1':
bw
= 8; bh = 16; ts = 32;
break;
case
'2': // 디폴트
bw
= 10; bh = 20; ts = 24;
break;
case
'3':
bw
= 12; bh = 24; ts = 40;
break;
case
'4':
bw
= 15; bh = 30; ts = 28;
break;
case
'5': // FHD 최대 크기
bw
= 200; bh = 100; ts = 8;
break;
case
'6':
bw
= 20; bh = 40; ts = 32;
break;
case
'7':
bw
= 50; bh = 100; ts = 16;
break;
case
'8':
bw
= 200; bh = 100; ts = 16;
break;
case
'9': // 4k 최대 크기
bw
= 400; bh = 200; ts = 8;
break;
}
//
이전판에 하던건 다 지우고 조정한다.
memset(board,
0, sizeof(board));
AdjustMainWindow();
return
0;
}
//
이하의 키는 게임 중에는 쓸 수 없다.
if
(GameStatus != RUNNING || brick == -1) {
return
0;
}
switch
(wParam) {
case
VK_LEFT:
if
(GetAround(nx - 1, ny, brick, rot) == EMPTY) {
nx--;
InvalidateRect(win_hWnd,
NULL, FALSE);
}
break;
case
VK_RIGHT:
if
(GetAround(nx + 1, ny, brick, rot) == EMPTY) {
nx++;
InvalidateRect(win_hWnd,
NULL, FALSE);
}
break;
case
VK_UP:
trot
= (rot == 3 ? 0 : rot + 1);
if
(GetAround(nx, ny, brick, trot) == EMPTY) {
rot
= trot;
InvalidateRect(win_hWnd,
NULL, FALSE);
}
break;
case
VK_DOWN:
if
(MoveDown() == TRUE) {
MakeNewBrick();
}
break;
case
VK_SPACE:
while
(MoveDown() == FALSE) { ; }
MakeNewBrick();
break;
}
return
0;
}
void CTetrisWin::MakeNewBrick()
{
bricknum++;
brick
= nbrick;
nbrick
= random(sizeof(Shape) / sizeof(Shape[0]));
nx
= bw / 2;
ny
= 3;
rot
= 0;
InvalidateRect(win_hWnd,
NULL, FALSE);
if
(GetAround(nx, ny, brick, rot) != EMPTY) {
KillTimer(win_hWnd,
1);
GameStatus
= GAMEOVER;
MessageBox(win_hWnd,
L"GAME OVER", L"알림", MB_OK);
}
}
int CTetrisWin::GetAround(int x, int y, int b, int
r)
{
int
i, k = EMPTY;
for
(i = 0; i < 4; i++) {
k
= max(k, board[x + Shape[b][r][i].x][y + Shape[b][r][i].y]);
}
return
k;
}
BOOL CTetrisWin::MoveDown()
{
if
(GetAround(nx, ny + 1, brick, rot) != EMPTY) {
TestFull();
return
TRUE;
}
ny++;
//
즉시 그려서 벽돌이 내려가는 모양을 보여 준다.
InvalidateRect(win_hWnd,
NULL, FALSE);
//
폭이 너무 넓으면 애니메이션하지 않는다.
if
(bw < 100) {
UpdateWindow(win_hWnd);
}
return
FALSE;
}
void CTetrisWin::TestFull()
{
int
i, x, y, ty;
int
count = 0;
static
int arScoreInc[] = { 0,1,3,8,20 };
for
(i = 0; i < 4; i++) {
board[nx
+ Shape[brick][rot][i].x][ny + Shape[brick][rot][i].y] = brick + 1;
}
//
이동중인 벽돌이 잠시 없는 상태.
brick
= -1;
for
(y = 1; y < bh + 1; y++) {
for
(x = 1; x < bw + 1; x++) {
if
(board[x][y] == EMPTY) break;
}
if
(x == bw + 1) {
count++;
for
(ty = y; ty > 1; ty--) {
for
(x = 1; x < bw + 1; x++) {
board[x][ty]
= board[x][ty - 1];
}
}
InvalidateRect(win_hWnd,
NULL, FALSE);
UpdateWindow(win_hWnd);
Sleep(150);
}
}
score
+= arScoreInc[count];
if
(bricknum % 10 == 0 && Interval > 200) {
Interval
-= 50;
SetTimer(win_hWnd,
1, Interval, NULL);
}
}
void CTetrisWin::PrintTile(HDC hdc, int x, int y,
int c)
{
HPEN
oldPen;
HBRUSH
oldBrush;
RECT
brt;
if
(c == EMPTY) {
if
(ts > 20) {
Rectangle(hdc,
x * ts + ts / 2 - 1, y * ts + ts / 2 - 1, x * ts + ts / 2 + 1, y * ts + ts / 2
+ 1);
}
else {
SetPixel(hdc,
x * ts + ts / 2, y * ts + ts / 2, RGB(128, 128, 128));
}
}
else {
SetRect(&brt,
x * ts, y * ts, x * ts + ts, y * ts + ts);
oldBrush
= (HBRUSH)SelectObject(hdc, arBrush[c]);
oldPen
= (HPEN)SelectObject(hdc, GetStockObject(NULL_PEN));
Rectangle(hdc,
brt.left, brt.top, brt.right, brt.bottom);
SelectObject(hdc,
oldBrush);
SelectObject(hdc,
oldPen);
//
입체감을 줄려고 했는데 예쁘지 않고 좀 느림.
/*white
= CreatePen(PS_SOLID, 1, RGB(200, 200, 200));
gray
= CreatePen(PS_SOLID, 1, RGB(32, 32, 32));
oldPen
= (HPEN)SelectObject(hdc, white);
MoveToEx(hdc,
brt.left, brt.top, NULL); LineTo(hdc, brt.left, brt.bottom);
MoveToEx(hdc,
brt.left, brt.top, NULL); LineTo(hdc, brt.right, brt.top);
SelectObject(hdc,
gray);
MoveToEx(hdc,
brt.left, brt.bottom, NULL); LineTo(hdc, brt.right, brt.bottom);
MoveToEx(hdc,
brt.right, brt.top, NULL); LineTo(hdc, brt.right, brt.bottom);
SelectObject(hdc,
oldPen);
DeleteObject(white);
DeleteObject(gray);
*/
}
}
void CTetrisWin::AdjustMainWindow()
{
RECT
crt;
SetRect(&crt,
0, 0, (bw + 12) * ts, (bh + 2) * ts);
AdjustWindowRect(&crt,
WS_OVERLAPPED | WS_SYSMENU | WS_BORDER | WS_CAPTION, FALSE);
SetWindowPos(win_hWnd,
NULL, 0, 0, crt.right - crt.left, crt.bottom - crt.top,
SWP_NOMOVE
| SWP_NOZORDER);
}
그래도 이만하면 소스 길이가 짧은 편이다. 이 게임도 더 개선할 여지가
많다.
OneImage
OneImage는 딱 하나의 이미지를 미리 등록해 놓고 클릭시 신속하게
열어서 보여주는 티젯이다. 개발을 하다 보면 설계도나 색상표, 기획안
등을 자주 참고해야 하는데 매번 파일을 열어 뒤적거리기 귀찮다. 이럴 때 미리 이미지로 만들어 두면
신속하게 열어 확인할 수 있다.
이미지 출력은 Win32 API만으로는 안되며 GDI+를 사용해야 한다. 다행히 윈도우10은 GDI+를 기본 내장하고 있어 별다른 추가 라이브러리가 없어도
이 기능을 바로 사용할 수 있다. 대신 몇가지 준비를 해 두어야 한다.
먼저 다음 유틸리티 함수를 작성한다.
// 지정한 영역의 중앙에 종횡비 맞추어 이미지 출력
void DrawImageCenter(HDC hdc, Image* pImage, int
width, int height, bool erase, HBRUSH backBrush)
{
Graphics
G(hdc);
int
iw, ih;
int
l, t, r, b, tsize;
iw
= pImage->GetWidth();
ih
= pImage->GetHeight();
if
(iw < width && ih < height) {
l
= width / 2 - iw / 2;
t
= height / 2 - ih / 2;
r
= l + iw;
b
= t + ih;
}
else {
//
이미지의 종횡비가 더 크면 : 화면이 세로로 길쭉할 때
if
((double)iw / ih > (double)width / height) {
l
= 0;
r
= width;
//
화면 폭의 비율만큼 그림의 폭도 줄인다.
tsize
= int(ih * width / (double)iw);
t
= height / 2 - tsize / 2;
b
= t + tsize;
}
else {
t
= 0;
b
= height;
tsize
= int(iw * height / (double)ih);
l
= width / 2 - tsize / 2;
r
= l + tsize;
}
}
G.DrawImage(pImage,
l, t, r - l, b - t);
//
이미지 바깥을 배경색으로
채운다.
if
(erase) {
FillRect(hdc,
0, 0, width, t, backBrush);
FillRect(hdc,
0, 0, l, height, backBrush);
FillRect(hdc,
0, b, width, height, backBrush);
FillRect(hdc,
r, t, width, height, backBrush);
}
}
// 회전된 이미지를 위쪽 방향으로 돌린다.
2, 4, 5, 6번 상태도 있어 좀 더 면밀한 연구가 필요하다.
void FixImageOrientation(Image* pImage)
{
UINT
size, count;
//
1번이 정방향이며 이 경우는 exif에 방향 정보가 기록되지 않는다.
unsigned
short orientation = 1;
PropertyItem*
arPro;
pImage->GetPropertySize(&size,
&count);
arPro
= (PropertyItem*)malloc(size);
pImage->GetAllPropertyItems(size,
count, arPro);
for
(int i = 0; i < (int)count; i++) {
if
(arPro[i].id == PropertyTagOrientation) {
orientation
= *(unsigned short*)arPro[i].value;
}
}
switch
(orientation) {
case
6:
pImage->RotateFlip(Rotate90FlipNone);
break;
case
3:
pImage->RotateFlip(Rotate180FlipNone);
break;
case
8:
pImage->RotateFlip(Rotate270FlipNone);
break;
}
}
// 현재 모니터를 가득 채운다.
void makeFullScreen(HWND hWnd)
{
SetWindowLongPtr(hWnd,
GWL_STYLE, WS_POPUP | WS_VISIBLE);
int
nowMonitor = GetMonitorOfWindow(hWnd);
RECT
rt = arMonitor[nowMonitor].rcMonitor;
SetWindowPos(hWnd,
HWND_NOTOPMOST, rt.left, rt.top,
rt.right
- rt.left, rt.bottom - rt.top, SWP_FRAMECHANGED);
}
사진은 항상 일정 영역의 중앙에 종횡바를 맞추어 출력해야 한다. 윈도우의
면적을 최대한 활용하되 찌그러지지는 말아야 한다. DrawImageCenter 함수는 주어진 영역의
종횡비를 계산하여 정확하게 출력해 준다. 계산식이 보기보다 약간 복잡하다.
디지털 카메라로 찍은 이미지는 방향이 기록되어 있는데 이 방향을 읽어 이미지를 회전해서 보여 줘야 한다. 그렇지 않으면 사람이 선 모습은 항상 누워 있는 모양으로 출력된다. FixImageOrientation
함수는 사진의 EXIF 정보를 참조하여 이미지를 회전시킨다.
makeFullScreen 함수는 창을 최대 위치로 확대한다. 화면 전체에 이미지를 가득 채워 보고 싶을 때 이 함수를 호출하면 된다. GDI+는 초기화해야만 사용할 수 있다. 직접 초기화하기는 번거로우므로 다음 도우미 클래스를 Util.h에
선언한다.
class CGdiPlusStarter
{
private:
ULONG_PTR
m_gpToken;
public:
bool
m_bSuccess;
CGdiPlusStarter()
{
GdiplusStartupInput
gpsi;
m_bSuccess
= (GdiplusStartup(&m_gpToken, &gpsi, NULL) == Ok);
}
~CGdiPlusStarter()
{
GdiplusShutdown(m_gpToken);
}
};
생성자에서 초기화하고 파괴자에서 셧다운한다. 이런 타입의 전역 변수
하나만 만들어 두면 초기화가 정리가 자동으로 수행된다. SoEnty.cpp에 이 타입의 변수를 전역으로
선언해 둔다.
CGdiPlusStarter g_gps;
이제 이미지 티젯을 만들어 보자. 티젯과 함께 이미지 뷰어창도 같이
만들어야 한다. 게다가 이 창은 이미지 슬라이더 위젯과 공유하는 기능이 있어 전방 선언이 필요하다.
class CImageViewer;
class COneImage : public CTidget
{
public:
TCHAR
imagePath[MAX_PATH];
Image*
nowImage;
HBITMAP
icon;
CImageViewer*
pViewer;
LRESULT
OnCreate(WPARAM wParam, LPARAM lParam);
LRESULT
OnDestroy(WPARAM wParam, LPARAM lParam);
void
OnDraw(HDC hdc, int width, int height);
void
OnClick();
LRESULT
OnContextMenu(WPARAM wParam, LPARAM lParam);
LRESULT
OnUser1(WPARAM wParam, LPARAM lParam);
};
class CImageSlide;
class CImageViewer : public CWindow
{
public:
int
parentType; //
누가 부모인지. 0 = 슬라이더, 1 = oneImage
CDget*
pParent; //
부모 객체. 아래 변수로 미리 캐스팅해 둔다.
CImageSlide*
pSlide;
COneImage*
pOneImage;
int
nowIdx; //
슬라이더의 현재 인덱스
TCHAR
imagePath[MAX_PATH]; //
OneImage의 이미지 경로
Image*
nowImage; //
런타임에 생성하는 이미지 객체
bool
fullScreen;
WINDOWPLACEMENT
prevWndPlace;
void
Create(int parentType, CDget* parent);
LRESULT
OnCreate(WPARAM wParam, LPARAM lParam);
LRESULT
OnDestroy(WPARAM wParam, LPARAM lParam);
LRESULT
OnPaint(WPARAM wParam, LPARAM lParam);
LRESULT
OnSize(WPARAM wParam, LPARAM lParam);
LRESULT
OnKeyDown(WPARAM wParam, LPARAM lParam);
LRESULT
OnLButtonDblClk(WPARAM wParam, LPARAM lParam);
LRESULT
OnUser1(WPARAM wParam, LPARAM lParam);
void
toggleFullScreen();
};
티젯의 구현 코드부터 작성해 보자.
LRESULT COneImage::OnCreate(WPARAM wParam, LPARAM
lParam)
{
nowImage
= NULL;
pViewer
= NULL;
setting.get(dget_id,
L"imagePath", L"", imagePath, MAX_PATH);
if
(lstrlen(imagePath) != 0) {
nowImage
= Image::FromFile(imagePath);
FixImageOrientation(nowImage);
}
icon
= LoadBitmap(g_hInst, MAKEINTRESOURCE(IDB_ONEIMAGE));
return
0;
}
LRESULT COneImage::OnDestroy(WPARAM wParam, LPARAM
lParam)
{
DeleteObject(icon);
if
(nowImage != NULL) {
delete
nowImage;
}
if
(pViewer != NULL) {
DestroyWindow(pViewer->win_hWnd);
}
return
0;
}
void COneImage::OnDraw(HDC hdc, int width, int
height)
{
int
wh = trayWindow.tidgetSize;
if
(nowImage == NULL) {
StretchBitmap(hdc,
0, 0, wh, wh, icon);
}
else {
DrawImageCenter(hdc,
nowImage, wh, wh, true, win_backBrush);
}
}
void COneImage::OnClick()
{
if
(nowImage != NULL) {
//
뷰어를 연다.
if
(pViewer == NULL) {
pViewer
= new CImageViewer();
lstrcpy(pViewer->imagePath,
imagePath);
pViewer->Create(1,
this);
}
}
}
// todo : 옵션 대화상자를 만들고 간단한 설명과 파일 열기 버튼을 배치한다.
// 이걸 하기 전에 포커스를 잃어도 옵션창이 닫히지 않도록 정책부터 결정해야
한다.
LRESULT COneImage::OnContextMenu(WPARAM wParam,
LPARAM lParam)
{
OPENFILENAME
OFN;
lstrcpy(imagePath,
L"");
memset(&OFN,
0, sizeof(OPENFILENAME));
OFN.lStructSize
= sizeof(OPENFILENAME);
OFN.hwndOwner
= win_hWnd;
OFN.lpstrFilter
= TEXT("이미지 파일(jpg, png)\0*.jpg;*.png\0");
OFN.lpstrFile
= imagePath;
OFN.nMaxFile
= MAX_PATH;
if
(GetOpenFileName(&OFN) == 0) return 0;
//
이미지가 결정되는 즉시 기록한다.
setting.set(dget_id,
L"imagePath", imagePath);
nowImage
= Image::FromFile(imagePath);
FixImageOrientation(nowImage);
InvalidateRect(win_hWnd,
NULL, TRUE);
return
0;
}
// 뷰어가 종료 신호를 보내면 기록해 둔다. 그래야
새로 열 수 있다.
LRESULT COneImage::OnUser1(WPARAM wParam, LPARAM
lParam)
{
pViewer
= NULL;
return
0;
}
생성할 때 등록해 놓은 이미지의 경로를 읽고 GDI+ 이미지로 미리
변환하여 방향까지 맞춰 둔다. OnDraw에서는 티젯 영역에 등록 이미지를 작게나마 출력한다. 클릭하면 이미지 뷰어창을 열고 경로를 알려 준다.
옵션창은 별도로 없고 마우스 오른쪽을 클릭하면 이미지 읽기창을 연다. 이미지를
선택하면 즉시 변경한다. 뷰어가 종료할 때 WM_USER+1 메시지를
보내며 이때 뷰어를 무효화한다. 한번에 두 개의 창을 열 수는 없도록 해 놓았는데 굳이 막을 필요까지는
없는 것 같다. 다음은 이미지 뷰어의 구현 코드이다.
// 이미지 뷰어 관련 todo - 기본
기능 구현해 놨고 다음은 차후에 천천히 할 것
// 타이틀바 제거하고 두꺼운 액자 두른 후 액자 드래그해서 크기 조정. 바닥 드래그해서 이동
// 마우스가 상단으로 올라가면 파일명과 닫기,
최대화 버튼 보여줄 것. 또는 상단 액자 두껍게 해서 항상 표시도 가능
// 확대, 축소, 패닝, 회전, 반사, 밝기 조정 기능 구현. 슬라이더의 경우 PgUp, PgDn으로 네비게이션 이동
void CImageViewer::Create(int parentType, CDget*
parent)
{
//
타입에 따라 부모를 캐스팅해 둔다. 위젯과 미니 위젯이 형제 관계여서 C 스타일로 다형성을 구현한다.
//
CWindow의 멤버를 참조할 때는 pParent를 바로 읽으면 된다.
pParent
= parent;
this->parentType
= parentType;
switch
(parentType) {
case
0:
pSlide
= (CImageSlide*)pParent;
break;
case
1:
pOneImage
= (COneImage*)pParent;
break;
}
CreateWindow(TEXT("CWindow"),
L"이미지 보기", WS_POPUPWINDOW | WS_THICKFRAME |
WS_CAPTION,
0,
0, 0, 0,
NULL,
(HMENU)NULL, g_hInst, this);
//
최후 실행 위치를 읽어온다. 일단 노말 좌표로 초기 좌표를 잡는다.
prevWndPlace.length
= sizeof(WINDOWPLACEMENT);
prevWndPlace.flags
= 0;
prevWndPlace.rcNormalPosition.left
= setting.get(pParent->dget_id, L"left", 10);
prevWndPlace.rcNormalPosition.top
= setting.get(pParent->dget_id, L"top", 10);
prevWndPlace.rcNormalPosition.right
= setting.get(pParent->dget_id, L"right", 650);
prevWndPlace.rcNormalPosition.bottom
= setting.get(pParent->dget_id, L"bottom", 490);
prevWndPlace.showCmd
= setting.get(pParent->dget_id, L"showCmd", SW_SHOWNORMAL);
SetWindowPlacement(win_hWnd,
&prevWndPlace);
//
전체 화면으로 전환한다.
fullScreen
= setting.get(pParent->dget_id, L"fullScreen", false);
if
(fullScreen) {
prevWndPlace.length
= sizeof(WINDOWPLACEMENT);
GetWindowPlacement(win_hWnd,
&prevWndPlace);
makeFullScreen(win_hWnd);
}
}
LRESULT CImageViewer::OnLButtonDblClk(WPARAM
wParam, LPARAM lParam)
{
//
일단 더블클릭으로 최대화한다. 차후 다른 방법으로 대체할 것.
toggleFullScreen();
return
0;
}
LRESULT CImageViewer::OnUser1(WPARAM wParam,
LPARAM lParam)
{
//
wParam으로 전달한 새 이미지를 표시한다.
if
(nowImage != NULL) {
delete
nowImage;
}
nowIdx
= (int)wParam;
// nowImage =
Image::FromFile(pSlide->arImage[nowIdx].c_str());
// SetWindowText(win_hWnd,
pSlide->arImage[nowIdx].c_str());
InvalidateRect(win_hWnd,
NULL, TRUE);
return
0;
}
LRESULT CImageViewer::OnCreate(WPARAM wParam,
LPARAM lParam)
{
//
슬라이더는 idx를 주고, OneImage는
경로를 직접 준다.
LPCTSTR
Path;
// if (parentType == 0) {
// Path =
pSlide->arImage[nowIdx].c_str();
// } else {
Path
= imagePath;
// }
nowImage
= Image::FromFile(Path);
FixImageOrientation(nowImage);
SetWindowText(win_hWnd,
Path);
return
0;
}
LRESULT CImageViewer::OnDestroy(WPARAM wParam,
LPARAM lParam)
{
if
(nowImage != NULL) {
delete
nowImage;
}
//
최후 실행 위치를 조사한다. 단, 전체 화면
모드이면 전체 화면 전의 노말 좌표를 기록한다.
if
(fullScreen == false) {
prevWndPlace.length
= sizeof(WINDOWPLACEMENT);
GetWindowPlacement(win_hWnd,
&prevWndPlace);
}
setting.set(pParent->dget_id,
L"left", prevWndPlace.rcNormalPosition.left);
setting.set(pParent->dget_id,
L"top", prevWndPlace.rcNormalPosition.top);
setting.set(pParent->dget_id,
L"right", prevWndPlace.rcNormalPosition.right);
setting.set(pParent->dget_id,
L"bottom", prevWndPlace.rcNormalPosition.bottom);
setting.set(pParent->dget_id,
L"showCmd", prevWndPlace.showCmd);
setting.set(pParent->dget_id,
L"fullScreen", fullScreen);
//
부모에게 자신이 종료했음을 알린다. 그래야 클릭시 새로운 뷰어를 만들 수 있다.
SendMessage(pParent->win_hWnd,
WM_USER + 1, 0, 0);
//
자기 자신을 삭제한다. 객체맵에서도 삭제된다. ->
이러면 닫힐 때 NCDESTROY를 처리하지 못해 다운됨.
-> 부모가 관리해 줘야 할 듯 하다.
//
delete this;
return
0;
}
LRESULT CImageViewer::OnPaint(WPARAM wParam,
LPARAM lParam)
{
HDC
hdc;
PAINTSTRUCT
ps;
hdc
= BeginPaint(win_hWnd, &ps);
RECT
crt;
GetClientRect(win_hWnd,
&crt);
//
부모의 배경 브러시 사용
DrawImageCenter(hdc,
nowImage, crt.right, crt.bottom, true, pParent->win_backBrush);
EndPaint(win_hWnd,
&ps);
return
0;
}
LRESULT CImageViewer::OnSize(WPARAM wParam, LPARAM
lParam)
{
InvalidateRect(win_hWnd,
NULL, TRUE);
return
0;
}
LRESULT CImageViewer::OnKeyDown(WPARAM wParam,
LPARAM lParam)
{
if
(wParam == VK_ESCAPE) {
DestroyWindow(win_hWnd);
}
if
(wParam == VK_RETURN) {
toggleFullScreen();
}
return
0;
}
void CImageViewer::toggleFullScreen()
{
fullScreen
= !fullScreen;
if
(fullScreen) {
//
전체 화면으로 전환하기 전의 노말 좌표를 미리 조사해 둔다.
prevWndPlace.length
= sizeof(WINDOWPLACEMENT);
GetWindowPlacement(win_hWnd,
&prevWndPlace);
makeFullScreen(win_hWnd);
}
else {
SetWindowLongPtr(win_hWnd,
GWL_STYLE, WS_POPUPWINDOW | WS_CAPTION | WS_THICKFRAME | WS_VISIBLE);
SetWindowPos(win_hWnd,
HWND_NOTOPMOST, 0, 0, 0, 0,
SWP_NOMOVE
| SWP_NOSIZE | SWP_FRAMECHANGED);
//
노말 좌표로 다시 복귀한다.
prevWndPlace.length
= sizeof(WINDOWPLACEMENT);
SetWindowPlacement(win_hWnd,
&prevWndPlace);
}
}
이미지 슬라이더와 관련된 기능은 아직 이미지 슬라이더가 없어 일단 주석 처리해 두었다. 경로나 첨자로 받은 정보로 이미지 객체를 생성해 두고 OnPaint에서
직접 그린다. 종료시는 마지막 위치와 상태를 저장해 두어 늘 보던 위치에 열어 준다.
Esc를 누르면 창을 닫는데 이 부분은 마우스 UI도 필요하다. 차후 위쪽에 오버랩되는 반투명한 창을 만들어 이미지
정보나 닫기 버튼, 확대/축소 등의 기능을 제공하면 적당할
것 같다.
EnumFont
폰트 열거 기능은 Win32 개발자에게 꼭 필요한 기능이다. 고급 언어는 객체가 다 해 주지만 API는 폰트의 모든 정보를 다
밝혀야 한다. 어떤 폰트가 있는지 고르기도 쉽지 않고 폰트의 속성을 일일이 조사할 수도 없어 열거해
봐야만 코드를 작성할 수 있다. 기존에 이미 만들어 두었던 유틸리티를 티젯으로 포함시켰다. 먼저 다음 함수를 Util에 선언한다.
void CopyClipboardText(LPCTSTR content)
{
HGLOBAL
hmem;
TCHAR*
ptr;
hmem
= GlobalAlloc(GHND, (lstrlen(content) + 1) * sizeof(TCHAR));
ptr
= (TCHAR*)GlobalLock(hmem);
memcpy(ptr,
content, (lstrlen(content) + 1) * sizeof(TCHAR));
GlobalUnlock(hmem);
if
(OpenClipboard(mainWindow.win_hWnd)) {
EmptyClipboard();
SetClipboardData(CF_UNICODETEXT,
hmem);
CloseClipboard();
}
else {
GlobalFree(hmem);
}
}
문자열을 인수로 받아 클립보드로 복사하는 함수이다. 앞서 색상표와
TextClip에서 이미 사용한 적이 있는데 앞으로도 종종 사용할 것 같아 아예 함수로 따로 만들었다. 이미 만들어 둔 것도 이 함수를 호출하도록 바꾸는게 좋지만 강좌 원고를 다시 쓰기 번거로워 다음 강좌를 쓸
때 바꾸기로 한다. 다음 두 클래스를 선언한다.
class CEnumFont :
public CTidget
{
public:
HBITMAP icon;
LRESULT OnCreate(WPARAM
wParam, LPARAM lParam);
LRESULT OnDestroy(WPARAM
wParam, LPARAM lParam);
void OnDraw(HDC hdc, int
width, int height);
void OnClick();
};
class
CEnumFontWin : public CWindow
{
public:
HWND hList, hChkAt, hChkSort,
hStNum, hBtnApi, hEdApi, hBtnMfc, hEdMfc;
enum { EF_LIST, EF_AT,
EF_SORT, EF_NUM, EF_API, EF_EDAPI, EF_MFC, EF_EDMFC };
static const int MAXFONT =
1000;
LOGFONT
arFont[CEnumFontWin::MAXFONT];
int
arFontType[CEnumFontWin::MAXFONT];
int numFont; // 발견된 폰트수
int nowFont; // 현재 폰트
bool includeAt; // @ 폰트 포함 여부
LRESULT OnMessage(UINT
iMessage, WPARAM wParam, LPARAM lParam);
LRESULT OnCreate(WPARAM
wParam, LPARAM lParam);
LRESULT OnDestroy(WPARAM
wParam, LPARAM lParam);
void OnDraw(HDC hdc, int
width, int height);
LRESULT OnCommand(WPARAM
wParam, LPARAM lParam);
void EnumFont();
static int CALLBACK
EnumFamCallBack(ENUMLOGFONT FAR* lpelf,
NEWTEXTMETRIC
FAR* lpntm, int FontType, LPARAM lParam);
static int compareFace(const
void* a, const void* b);
void GetCharSetStr(int
CharSet, TCHAR* str);
void GetPitchFamStr(int
Pitch, TCHAR* str);
void SetCreateFontCommand();
};
티젯은 아이콘 클릭만 받아 창을 띄워 주기만 한다. 열거창은 옵션도
좀 있고 폰트 정보를 조사 및 조립하는 함수도 여러 개 작성되어 있다.
LRESULT
CEnumFont::OnCreate(WPARAM wParam, LPARAM lParam)
{
icon = LoadBitmap(g_hInst,
MAKEINTRESOURCE(IDB_ENUMFONT));
return 0;
}
LRESULT
CEnumFont::OnDestroy(WPARAM wParam, LPARAM lParam)
{
DeleteObject(icon);
return 0;
}
void
CEnumFont::OnDraw(HDC hdc, int width, int height) {
int wh =
trayWindow.tidgetSize;
StretchBitmap(hdc, 0, 0, wh,
wh, icon);
}
void
CEnumFont::OnClick() {
CEnumFontWin* pWin = new
CEnumFontWin();
CreateWindow(TEXT("CWindow"),
L"폰트 열거",
WS_OVERLAPPED
| WS_SYSMENU | WS_BORDER | WS_CAPTION | WS_VISIBLE | WS_CLIPCHILDREN,
100,
100, 900, 800,
NULL,
(HMENU)NULL, g_hInst, pWin);
}
LRESULT
CEnumFontWin::OnMessage(UINT iMessage, WPARAM wParam, LPARAM lParam)
{
HFONT hFont, oldFont;
LPMEASUREITEMSTRUCT lpmis;
LPDRAWITEMSTRUCT lpdis;
HBRUSH bkBrush;
LOGFONT tmpFont;
switch (iMessage)
{
case WM_MEASUREITEM:
lpmis
= (LPMEASUREITEMSTRUCT)lParam;
lpmis->itemHeight
= 30;
return
0;
case WM_DRAWITEM:
lpdis
= (LPDRAWITEMSTRUCT)lParam;
// 선택된
항목은 파란 배경에 흰색으로 출력한다.
if
(lpdis->itemState & ODS_SELECTED) {
bkBrush
= GetSysColorBrush(COLOR_HIGHLIGHT);
SetBkColor(lpdis->hDC,
GetSysColor(COLOR_HIGHLIGHT));
SetTextColor(lpdis->hDC,
GetSysColor(COLOR_WINDOW));
}
else {
bkBrush
= GetSysColorBrush(COLOR_WINDOW);
SetBkColor(lpdis->hDC,
GetSysColor(COLOR_WINDOW));
SetTextColor(lpdis->hDC,
GetSysColor(COLOR_WINDOWTEXT));
}
FillRect(lpdis->hDC,
&lpdis->rcItem, bkBrush);
// 25
픽셀 높이로 글꼴 이름을 출력한다.
tmpFont
= arFont[lpdis->itemID];
tmpFont.lfHeight
= 25;
tmpFont.lfWidth
= 0;
hFont
= CreateFontIndirect(&tmpFont);
oldFont
= (HFONT)SelectObject(lpdis->hDC, hFont);
TextOutSz(lpdis->hDC,
lpdis->rcItem.left + 5, lpdis->rcItem.top + 2,
arFont[lpdis->itemID].lfFaceName);
SelectObject(lpdis->hDC,
oldFont);
DeleteObject(hFont);
return
0;
}
return
CWindow::OnMessage(iMessage, wParam, lParam);
}
LRESULT
CEnumFontWin::OnCreate(WPARAM wParam, LPARAM lParam)
{
int left, top;
left =
setting.get(L"EnumFont", L"left", 100);
top =
setting.get(L"EnumFont", L"top", 100);
SetWindowPos(win_hWnd, NULL,
left, top, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
EnsureVisible(win_hWnd);
SetBackColor(GetSysColor(COLOR_BTNFACE));
hList =
CreateWindowEx(WS_EX_CLIENTEDGE, TEXT("listbox"), NULL,
WS_CHILD
| WS_VISIBLE | WS_VSCROLL | LBS_NOTIFY | LBS_OWNERDRAWFIXED,
10,
10, 280, 550, win_hWnd, (HMENU)EF_LIST, g_hInst, NULL);
hChkAt =
CreateWindow(TEXT("button"), TEXT("@ 폰트 포함"), WS_CHILD | WS_VISIBLE |
BS_AUTOCHECKBOX,
10, 570, 120, 25, win_hWnd, (HMENU)EF_AT, g_hInst, NULL);
hChkSort =
CreateWindow(TEXT("button"), TEXT("폰트명 정렬"), WS_CHILD | WS_VISIBLE |
BS_AUTOCHECKBOX,
10, 600, 120, 25, win_hWnd, (HMENU)EF_SORT, g_hInst, NULL);
hStNum =
CreateWindow(TEXT("static"), TEXT("발견된 폰트"), WS_CHILD | WS_VISIBLE,
10,
630, 120, 25, win_hWnd, (HMENU)EF_NUM, g_hInst, NULL);
hBtnApi =
CreateWindow(TEXT("button"), TEXT("API 코드 복사"), WS_CHILD | WS_VISIBLE |
BS_PUSHBUTTON,
300, 450, 120, 30, win_hWnd, (HMENU)EF_API, g_hInst, NULL);
hEdApi =
CreateWindowEx(WS_EX_CLIENTEDGE, TEXT("edit"), NULL,
WS_CHILD
| WS_VISIBLE | WS_BORDER | ES_AUTOHSCROLL
| ES_MULTILINE,
300,
490, 580, 60, win_hWnd, (HMENU)EF_EDAPI, g_hInst, NULL);
SendMessage(hEdApi,
WM_SETFONT, (WPARAM)mainFont[1], MAKELPARAM(FALSE, 0));
hBtnMfc =
CreateWindow(TEXT("button"), TEXT("MFC 코드 복사"), WS_CHILD | WS_VISIBLE |
BS_PUSHBUTTON,
300, 560, 120, 30, win_hWnd, (HMENU)EF_MFC, g_hInst, NULL);
hEdMfc =
CreateWindowEx(WS_EX_CLIENTEDGE, TEXT("edit"), NULL,
WS_CHILD
| WS_VISIBLE | WS_BORDER | ES_AUTOHSCROLL | ES_MULTILINE,
300, 590,
580, 60, win_hWnd, (HMENU)EF_EDMFC, g_hInst, NULL);
SendMessage(hEdMfc,
WM_SETFONT, (WPARAM)mainFont[1], MAKELPARAM(FALSE, 0));
SendMessage(hChkSort,
BM_SETCHECK, BST_CHECKED, 0);
EnumFont();
return 0;
}
LRESULT
CEnumFontWin::OnDestroy(WPARAM wParam, LPARAM lParam)
{
RECT wrt;
GetWindowRect(win_hWnd,
&wrt);
setting.set(L"EnumFont",
L"left", wrt.left);
setting.set(L"EnumFont",
L"top", wrt.top);
return 0;
}
void
CEnumFontWin::OnDraw(HDC hdc, int width, int height)
{
int TabPos[] = { 250 };
TCHAR str[256], str2[128];
HFONT hFont, oldFont;
SetBkMode(hdc, TRANSPARENT);
wsprintf(str,
L"Height\t: %d", arFont[nowFont].lfHeight);
TabbedTextOut(hdc, 300, 20,
str, lstrlen(str), 1, TabPos, 0);
wsprintf(str, L"Width\t:
%d", arFont[nowFont].lfWidth);
TabbedTextOut(hdc, 300, 40,
str, lstrlen(str), 1, TabPos, 0);
wsprintf(str,
L"Escapement\t: %d", arFont[nowFont].lfEscapement);
TabbedTextOut(hdc, 300, 60,
str, lstrlen(str), 1, TabPos, 0);
wsprintf(str,
L"Orientation\t: %d", arFont[nowFont].lfOrientation);
TabbedTextOut(hdc, 300, 80,
str, lstrlen(str), 1, TabPos, 0);
wsprintf(str,
L"Weight\t: %d", arFont[nowFont].lfWeight);
TabbedTextOut(hdc, 300, 100,
str, lstrlen(str), 1, TabPos, 0);
wsprintf(str,
L"Italic\t: %s", arFont[nowFont].lfItalic ? L"TRUE" :
L"FALSE");
TabbedTextOut(hdc, 300, 120,
str, lstrlen(str), 1, TabPos, 0);
wsprintf(str,
L"Underline\t: %s", arFont[nowFont].lfUnderline ? L"TRUE" :
L"FALSE");
TabbedTextOut(hdc, 300, 140,
str, lstrlen(str), 1, TabPos, 0);
wsprintf(str,
L"StrikeOut\t: %s", arFont[nowFont].lfStrikeOut ? L"TRUE" :
L"FALSE");
TabbedTextOut(hdc, 300, 160,
str, lstrlen(str), 1, TabPos, 0);
GetCharSetStr(arFont[nowFont].lfCharSet,
str2);
wsprintf(str,
L"CharSet\t: %s", str2);
TabbedTextOut(hdc, 300, 180,
str, lstrlen(str), 1, TabPos, 0);
wsprintf(str,
L"OutPrecision\t: %d", arFont[nowFont].lfOutPrecision);
TabbedTextOut(hdc, 300, 200,
str, lstrlen(str), 1, TabPos, 0);
wsprintf(str,
L"ClipPrecision\t: %d", arFont[nowFont].lfClipPrecision);
TabbedTextOut(hdc, 300, 220,
str, lstrlen(str), 1, TabPos, 0);
wsprintf(str,
L"Quality\t: %d", arFont[nowFont].lfQuality);
TabbedTextOut(hdc, 300, 240,
str, lstrlen(str), 1, TabPos, 0);
GetPitchFamStr(arFont[nowFont].lfPitchAndFamily,
str2);
wsprintf(str,
L"PitchAndFamily\t: %s", str2);
TabbedTextOut(hdc, 300, 260,
str, lstrlen(str), 1, TabPos, 0);
wsprintf(str, L"FaceName\t:
%s", arFont[nowFont].lfFaceName);
TabbedTextOut(hdc, 300, 280,
str, lstrlen(str), 1, TabPos, 0);
// 폰트의 타입을 출력한다. 이 값은 LOGFONT 구조체에는 없다.
switch (arFontType[nowFont])
{
case 1:
wsprintf(str,
L"FontType\t: RASTER_FONTTYPE");
break;
case 2:
wsprintf(str, L"FontType\t:
DEVICE_FONTTYPE");
break;
case 4:
wsprintf(str,
L"FontType\t: TRUETYPE_FONTTYPE");
break;
default:
wsprintf(str,
L"FontType\t: UnKnown(%d)", arFontType[nowFont]);
}
TabbedTextOut(hdc, 300, 300,
str, lstrlen(str), 1, TabPos, 0);
// 폰트 샘플을 출력한다.
lstrcpy(str, L"English 한글 1234!@#$");
hFont =
CreateFontIndirect(&arFont[nowFont]);
oldFont =
(HFONT)SelectObject(hdc, hFont);
TextOutSz(hdc, 300, 340,
str);
SelectObject(hdc, oldFont);
DeleteObject(hFont);
}
LRESULT
CEnumFontWin::OnCommand(WPARAM wParam, LPARAM lParam)
{
TCHAR content[1024];
switch (LOWORD(wParam)) {
case EF_AT:
case EF_SORT:
EnumFont();
break;
case EF_LIST:
switch
(HIWORD(wParam)) {
case
LBN_SELCHANGE:
nowFont =
SendMessage(hList, LB_GETCURSEL, 0, 0);
SetCreateFontCommand();
InvalidateRect(win_hWnd,
NULL, TRUE);
break;
}
break;
case EF_API:
GetWindowText(hEdApi,
content, 1024);
CopyClipboardText(content);
break;
case EF_MFC:
GetWindowText(hEdMfc,
content, 1024);
CopyClipboardText(content);
break;
}
return 0;
}
void
CEnumFontWin::EnumFont()
{
HDC hdc;
int i;
numFont = 0;
nowFont = -1;
includeAt =
(SendMessage(hChkAt, BM_GETCHECK, 0, 0) == BST_CHECKED);
hdc =
GetDC(mainWindow.win_hWnd);
EnumFontFamilies(hdc, NULL,
(FONTENUMPROC)EnumFamCallBack, (LPARAM)this);
ReleaseDC(mainWindow.win_hWnd,
hdc);
if (SendMessage(hChkSort,
BM_GETCHECK, 0, 0) == BST_CHECKED) {
qsort(&arFont[0],
numFont, sizeof(LOGFONT), CEnumFontWin::compareFace);
}
// 발견된 모든 폰트의 타입 페이스를 리스트
박스에 출력한다.
SendMessage(hList,
LB_RESETCONTENT, 0, 0);
for (i = 0; i < numFont;
i++) {
SendMessage(hList,
LB_ADDSTRING, 0, (LPARAM)arFont[i].lfFaceName);
}
TCHAR szNum[111];
wsprintf(szNum, L"발견된
폰트 : %d", numFont);
SetWindowText(hStNum, szNum);
nowFont = 0;
SendMessage(hList,
LB_SETCURSEL, nowFont, 0);
SendMessage(win_hWnd,
WM_COMMAND, MAKEWPARAM(EF_LIST, LBN_SELCHANGE), (LPARAM)hList);
InvalidateRect(win_hWnd,
NULL, TRUE);
}
int CALLBACK
CEnumFontWin::EnumFamCallBack(ENUMLOGFONT FAR* lpelf,
NEWTEXTMETRIC FAR* lpntm, int
FontType, LPARAM lParam)
{
CEnumFontWin* pWin =
(CEnumFontWin*)lParam;
if (pWin->includeAt ==
false && _tcsrchr(lpelf->elfLogFont.lfFaceName, '@') != nullptr) {
return
TRUE;
}
if (pWin->numFont <
CEnumFontWin::MAXFONT) {
pWin->arFont[pWin->numFont]
= lpelf->elfLogFont;
pWin->arFontType[pWin->numFont]
= FontType;
pWin->numFont++;
return
TRUE;
} else {
return
FALSE;
}
}
int
CEnumFontWin::compareFace(const void* a, const void* b)
{
LOGFONT* aFont = (LOGFONT*)a;
LOGFONT* bFont = (LOGFONT*)b;
return
lstrcmp(aFont->lfFaceName, bFont->lfFaceName);
}
void
CEnumFontWin::GetCharSetStr(int CharSet, TCHAR* str)
{
switch (CharSet) {
case 0:lstrcpy(str,
L"ANSI_CHARSET"); break;
case 1:lstrcpy(str,
L"DEFAULT_CHARSET"); break;
case 2:lstrcpy(str,
L"SYMBOL_CHARSET"); break;
case 128:lstrcpy(str,
L"SHIFTJIS_CHARSET"); break;
case 129:lstrcpy(str,
L"HANGUL_CHARSET"); break;
case 136:lstrcpy(str,
L"CHINESEBIG5_CHARSET"); break;
case 255:lstrcpy(str,
L"OEM_CHARSET"); break;
case 130:lstrcpy(str,
L"JOHAB_CHARSET"); break;
case 177:lstrcpy(str,
L"HEBREW_CHARSET"); break;
case 178:lstrcpy(str,
L"ARABIC_CHARSET"); break;
case 161:lstrcpy(str,
L"GREEK_CHARSET"); break;
case 162:lstrcpy(str,
L"TURKISH_CHARSET"); break;
case 163:lstrcpy(str,
L"VIETNAMESE_CHARSET"); break;
case 222:lstrcpy(str,
L"THAI_CHARSET"); break;
case 238:lstrcpy(str,
L"EASTEUROPE_CHARSET"); break;
case 204:lstrcpy(str,
L"RUSSIAN_CHARSET"); break;
case 77:lstrcpy(str,
L"MAC_CHARSET"); break;
case 186:lstrcpy(str,
L"BALTIC_CHARSET"); break;
default:lstrcpy(str,
L"Etc"); break;
}
}
void
CEnumFontWin::GetPitchFamStr(int Pitch, TCHAR* str)
{
switch (Pitch & 0x0f) {
case 0:lstrcpy(str,
L"DEFAULT_PITCH");
break;
case 1:lstrcpy(str,
L"FIXED_PITCH");
break;
case 2:lstrcpy(str,
L"VARIABLE_PITCH");
break;
default:lstrcpy(str,
L"Etc");
}
switch (Pitch & 0xf0) {
case 0x00:lstrcat(str,
L" | FF_DONTCARE");
break;
case 0x10:lstrcat(str,
L" | FF_ROMAN");
break;
case 0x20:lstrcat(str,
L" | FF_SWISS");
break;
case 0x30:lstrcat(str,
L" | FF_MODERN");
break;
case 0x40:lstrcat(str,
L" | FF_SCRIPT");
break;
case 0x50:lstrcat(str,
L" | FF_DECORATIVE");
break;
}
}
void
CEnumFontWin::SetCreateFontCommand()
{
TCHAR Argu[128];
TCHAR Api[1024];
TCHAR Mfc[1024];
TCHAR CharSetStr[32];
TCHAR PitchFamStr[32];
GetCharSetStr(arFont[nowFont].lfCharSet,
CharSetStr);
GetPitchFamStr(arFont[nowFont].lfPitchAndFamily,
PitchFamStr);
wsprintf(Argu,
L"(%d,0,0,0,0,0,0,0,%s,3,2,1,\r\n\t%s,TEXT(\"%s\"));",
arFont[nowFont].lfHeight,
CharSetStr, PitchFamStr, arFont[nowFont].lfFaceName);
wsprintf(Api, L"hFont =
CreateFont(%d,0,0,0,0,0,0,0,%s,3,2,1,"
"\r\n\t%s,TEXT(\"%s\"));",
arFont[nowFont].lfHeight,
CharSetStr, PitchFamStr, arFont[nowFont].lfFaceName);
wsprintf(Api,
L"hFont=CreateFont%s", Argu);
SetWindowText(hEdApi, Api);
wsprintf(Mfc,
L"Font.CreateFont%s\r\n", Argu);
SetWindowText(hEdMfc, Mfc);
}
리스트 박스에 오너드로우로 폰트 모양을 직접 그려 선택하기 쉽도록 했다. 가로
뱡향의 @ 폰트는 실제로는 거의 쓰지 않는다. 비슷한 폰트가
두 벌씩 있어 목록이 혼잡해 보여 디폴트로 제외했다. 물론 꼭 원하는 포함해서 다시 열거할 수 있다. 폰트 이름으로 정렬하는 것이 찾기 쉽되 시스템에 등록한 순서대로 보고 싶다면 정렬하지 말아야 한다.
폰트를 선택하면 정보를 조립하여 보여 주되 숫자로 된 속성값을 문자열 형태로 바꿔서 보여 주다 보니 코드가 길다. 단순한 맵핑문이다. API와 MFC의
폰트 생성 명령을 보여 주고 클립보드로 복사해 준다. 만들고 싶은 폰트를 선택해서 코드 붙여 넣으면
바로 생성할 수 있다.
이 정도면 폰트를 골라 쓰는데 별 불편함은 없을 것 같다. 필요할
때 잠깐 열어서 폰트 선택하고 코드만 쏙 빼내오는 식으로 활용하면 된다.
Spy
스파이는 시스템 개발자에게 꼭 필요한 유틸리티이다. 비주얼 스튜디오에도
포함되어 있지만 메뉴에 등록되어 있지 않고 직접 탐색기를 뒤져야 실행할 수 있어 접근성이 떨어진다. 또
기능이 워낙 많아 사용 방법도 그리 간단하지 않다. 스파이의 기능중 꼭 필요한 기능만 추려 티젯으로
정의했다.
class CSpy :
public CTidget
{
public:
HBITMAP icon;
LRESULT OnCreate(WPARAM
wParam, LPARAM lParam);
LRESULT OnDestroy(WPARAM
wParam, LPARAM lParam);
void OnDraw(HDC hdc, int
width, int height);
void OnClick();
};
class CSpyWin :
public CWindow
{
public:
int TimerInterval;
HWND hWndOld;
HWND hEditInfo, hChkPause,
hEditHier;
enum { SPY_INFO, SPY_PAUSE,
SPY_HIER };
LRESULT OnMessage(UINT
iMessage, WPARAM wParam, LPARAM lParam);
LRESULT OnCreate(WPARAM
wParam, LPARAM lParam);
LRESULT OnDestroy(WPARAM
wParam, LPARAM lParam);
LRESULT OnTimer(WPARAM
wParam, LPARAM lParam);
void GetStyleString(DWORD
dwStyle, TCHAR* sStyle);
void GetExStyleString(DWORD
dwExStyle, TCHAR* sExStyle);
static BOOL CALLBACK
EnumChildProc(_In_ HWND hwnd, _In_ LPARAM lParam);
};
티젯은 창을 불러 주기만 하고 정보는 별도의 창을 열어 보여 준다. 윈도우
정보의 양이 많고 가변적이어서 예상외로 넓직한 창이 필요하다. 대상 윈도우를 선택하는 동작은 필요 없고
타이머를 돌리며 커서 바로 아래의 윈도우에 대한 정보를 출력한다.
LRESULT
CSpy::OnCreate(WPARAM wParam, LPARAM lParam)
{
icon = LoadBitmap(g_hInst,
MAKEINTRESOURCE(IDB_SPY));
return 0;
}
LRESULT
CSpy::OnDestroy(WPARAM wParam, LPARAM lParam)
{
DeleteObject(icon);
return 0;
}
void
CSpy::OnDraw(HDC hdc, int width, int height) {
int wh =
trayWindow.tidgetSize;
StretchBitmap(hdc, 0, 0, wh,
wh, icon);
}
void
CSpy::OnClick() {
CSpyWin* pWin = new
CSpyWin();
CreateWindow(TEXT("CWindow"),
L"Spy",
WS_OVERLAPPED
| WS_SYSMENU | WS_BORDER | WS_CAPTION | WS_VISIBLE | WS_CLIPCHILDREN,
100,
100, 635, 650,
NULL,
(HMENU)NULL, g_hInst, pWin);
}
LRESULT
CSpyWin::OnMessage(UINT iMessage, WPARAM wParam, LPARAM lParam)
{
switch (iMessage)
{
case 0:
return
0;
}
return
CWindow::OnMessage(iMessage, wParam, lParam);
}
LRESULT
CSpyWin::OnCreate(WPARAM wParam, LPARAM lParam)
{
int left, top;
left =
setting.get(L"Spy", L"left", 100);
top =
setting.get(L"Spy", L"top", 100);
SetWindowPos(win_hWnd, NULL,
left, top, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
EnsureVisible(win_hWnd);
SetBackColor(GetSysColor(COLOR_BTNFACE));
CreateWindow(TEXT("static"),
TEXT("윈도우 정보"), WS_CHILD | WS_VISIBLE,
10, 10, 300, 25, win_hWnd, (HMENU)-1, g_hInst,
NULL);
hChkPause =
CreateWindow(TEXT("button"), TEXT("일시 정지"),
WS_CHILD | WS_VISIBLE |
BS_AUTOCHECKBOX,
510, 10, 100, 25, win_hWnd, (HMENU)SPY_PAUSE, g_hInst, NULL);
hEditInfo =
CreateWindowEx(WS_EX_CLIENTEDGE, TEXT("edit"), NULL,
WS_CHILD
| WS_VISIBLE | WS_BORDER | ES_MULTILINE | WS_VSCROLL,
10,
40, 600, 250, win_hWnd, (HMENU)SPY_INFO, g_hInst, NULL);
SendMessage(hEditInfo,
WM_SETFONT, (WPARAM)mainFont[1], MAKELPARAM(FALSE, 0));
CreateWindow(TEXT("static"),
TEXT("윈도우 계층"), WS_CHILD | WS_VISIBLE,
10,
310, 300, 25, win_hWnd, (HMENU)-1, g_hInst, NULL);
hEditHier =
CreateWindowEx(WS_EX_CLIENTEDGE, TEXT("edit"), NULL,
WS_CHILD
| WS_VISIBLE | WS_BORDER | ES_MULTILINE | WS_VSCROLL,
10,
340, 600, 250, win_hWnd, (HMENU)SPY_HIER, g_hInst, NULL);
SendMessage(hEditHier,
WM_SETFONT, (WPARAM)mainFont[1], MAKELPARAM(FALSE, 0));
// 1초에 한번 조사하되 차후 사용자가
선택할 수 있도록 옵션화
TimerInterval = 1000;
SetTimer(win_hWnd, 1,
TimerInterval, NULL);
SendMessage(win_hWnd, WM_TIMER,
1, 0);
return 0;
}
LRESULT
CSpyWin::OnDestroy(WPARAM wParam, LPARAM lParam)
{
RECT wrt;
GetWindowRect(win_hWnd,
&wrt);
setting.set(L"Spy",
L"left", wrt.left);
setting.set(L"Spy",
L"top", wrt.top);
KillTimer(win_hWnd, 1);
return 0;
}
LRESULT
CSpyWin::OnTimer(WPARAM wParam, LPARAM lParam)
{
POINT pt;
RECT wrt, crt;
HWND hWndPoint;
HWND hWndParent;
DWORD dwStyle, dwExStyle;
TCHAR sCaption[256],
sClass[256];
TCHAR sStyle[256],
sExStyle[256];
TCHAR sLine[256];
TCHAR sText[1024];
GetCursorPos(&pt);
GetWindowRect(win_hWnd,
&wrt);
hWndPoint =
WindowFromPoint(pt);
bool pause =
(SendMessage(hChkPause, BM_GETCHECK, 0, 0) == BST_CHECKED);
// 이 윈도우 안이거나 이전 윈도우와 같거나
일시 정지 상태이면면 정보를 갱신하지 않는다.
if (PtInRect(&wrt, pt) ||
hWndPoint == hWndOld || pause) {
return
0;
}
hWndOld = hWndPoint;
if (hWndPoint == NULL) {
lstrcpy(sText,
TEXT("윈도우가 없음. 데스크탑을 가리키는 경우임"));
} else {
GetWindowText(hWndPoint,
sCaption, 256);
GetClassName(hWndPoint,
sClass, 256);
hWndParent
= GetParent(hWndPoint);
GetWindowRect(hWndPoint,
&crt);
dwStyle
= GetWindowLong(hWndPoint, GWL_STYLE);
GetStyleString(dwStyle,
sStyle);
dwExStyle
= GetWindowLong(hWndPoint, GWL_EXSTYLE);
GetExStyleString(dwExStyle,
sExStyle);
wsprintf(sText,
TEXT("핸들 : %d(0x%x)\r\n")
TEXT("클래스 : %s\r\n")
TEXT("캡션 : %s\r\n")
TEXT("부모 : %d(0x%x)\r\n")
TEXT("영역 : (%d,%d) - (%d,%d), %d*%d\r\n")
TEXT("스타일 : 0X%X\r\n
%s\r\n")
TEXT("확장
스타일 : 0X%X\r\n %s\r\n"),
(int)hWndPoint,
(int)hWndPoint, sClass, sCaption, (int)hWndParent, (int)hWndParent,
crt.left,
crt.top, crt.right, crt.bottom,
crt.right
- crt.left, crt.bottom - crt.top,
dwStyle,
sStyle, dwExStyle, sExStyle);
}
SetWindowText(hEditInfo,
sText);
// todo : 윈도우 계층을 그래픽으로
보여 주고 계층 내의 다른 윈도우 정보 조사 기능 작성
wstring ancestor =
L"";
HWND hwnd = hWndPoint;
for (;;) {
hwnd
= GetParent(hwnd);
if
(hwnd == NULL) {
HWND
hdesk = GetDesktopWindow();
lstrcpy(sCaption,
L"Desktop");
GetWindowRect(hdesk,
&crt);
}
else {
GetWindowText(hwnd,
sCaption, 256);
GetWindowRect(hwnd,
&crt);
}
wsprintf(sLine,
L"%d(%s) (%d,%d) - (%d,%d), %d*%d\r\n",
(int)hwnd,
sCaption,
crt.left,
crt.top, crt.right, crt.bottom,
crt.right
- crt.left, crt.bottom - crt.top
);
ancestor
= sLine + ancestor;
if
(hwnd == NULL) break;
}
wstring childs =
L"";
EnumChildWindows(hWndPoint,
EnumChildProc, (LPARAM)&childs);
ancestor = L"조상 계층\r\n" + ancestor + L"\r\n자식 목록\r\n"
+ childs;
SetWindowText(hEditHier,
ancestor.c_str());
return 0;
}
#define TEST(n)
(dwStyle & (1 << n))
void
CSpyWin::GetStyleString(DWORD dwStyle, TCHAR* sStyle)
{
if (TEST(31)) lstrcpy(sStyle,
TEXT("POPUP"));
else if (TEST(30))
lstrcpy(sStyle, TEXT("CHILD"));
else lstrcpy(sStyle,
TEXT("OVERLAPPED"));
if (TEST(29)) lstrcat(sStyle,
TEXT(" | MINIMIZE"));
if (TEST(28)) lstrcat(sStyle,
TEXT(" | VISIBLE"));
if (TEST(27)) lstrcat(sStyle,
TEXT(" | DISABLED"));
if (TEST(26)) lstrcat(sStyle,
TEXT(" | CLIPSIBLINGS"));
if (TEST(25)) lstrcat(sStyle,
TEXT(" | CLIPCHILDREN"));
if (TEST(24)) lstrcat(sStyle,
TEXT(" | MAXIMIZE"));
if (TEST(23)) lstrcat(sStyle,
TEXT(" | BORDER"));
if (TEST(22)) lstrcat(sStyle,
TEXT(" | DLGFRAME"));
// lstrcat(sStyle,
L"\r\n ");
if (TEST(21)) lstrcat(sStyle,
TEXT(" | VSCROLL"));
if (TEST(20)) lstrcat(sStyle,
TEXT(" | HSCROLL"));
if (TEST(19)) lstrcat(sStyle,
TEXT(" | SYSMENU"));
if (TEST(18)) lstrcat(sStyle,
TEXT(" | THICKFRAME"));
if (TEST(17)) lstrcat(sStyle,
TEXT(" | MINIMIZEBOX"));
if (TEST(16)) lstrcat(sStyle,
TEXT(" | MAXIMIZEBOX"));
}
void
CSpyWin::GetExStyleString(DWORD dwExStyle, TCHAR* sExStyle)
{
if (dwExStyle &
0x00001000L) lstrcpy(sExStyle, TEXT("RIGHT"));
else lstrcpy(sExStyle,
TEXT("LEFT"));
if (dwExStyle & 0x00000010L)
lstrcat(sExStyle, TEXT(" | ACCEPTFILES"));
if (dwExStyle &
0x00040000L) lstrcat(sExStyle, TEXT(" | APPWINDOW"));
if (dwExStyle &
0x00000200L) lstrcat(sExStyle, TEXT(" | CLIENTEDGE"));
if (dwExStyle &
0x02000000L) lstrcat(sExStyle, TEXT(" | COMPOSITED"));
if (dwExStyle &
0x00000400L) lstrcat(sExStyle, TEXT(" | CONTEXTHELP"));
if (dwExStyle &
0x00010000L) lstrcat(sExStyle, TEXT(" | CONTROLPARENT"));
if (dwExStyle &
0x00000001L) lstrcat(sExStyle, TEXT(" | DLGMODALFRAME"));
if (dwExStyle &
0x00080000L) lstrcat(sExStyle, TEXT(" | LAYERED"));
if (dwExStyle &
0x00400000L) lstrcat(sExStyle, TEXT(" | LAYOUTRTL"));
if (dwExStyle &
0x00004000L) lstrcat(sExStyle, TEXT(" | LEFTSCROLLBAR"));
if (dwExStyle &
0x00000040L) lstrcat(sExStyle, TEXT(" | MDICHILD"));
if (dwExStyle &
0x08000000L) lstrcat(sExStyle, TEXT(" | NOACTIVATE"));
if (dwExStyle &
0x00100000L) lstrcat(sExStyle, TEXT(" | NOINHERITLAYOUT"));
if (dwExStyle &
0x00000004L) lstrcat(sExStyle, TEXT(" | NOPARENTNOTIFY"));
if (dwExStyle &
0x00200000L) lstrcat(sExStyle, TEXT(" | NOREDIRECTIONBITMAP"));
if (dwExStyle &
0x00002000L) lstrcat(sExStyle, TEXT(" | RTLREADING"));
if (dwExStyle &
0x00020000L) lstrcat(sExStyle, TEXT(" | STATICEDGE"));
if (dwExStyle &
0x00000080L) lstrcat(sExStyle, TEXT(" | TOOLWINDOW"));
if (dwExStyle &
0x00000008L) lstrcat(sExStyle, TEXT(" | TOPMOST"));
if (dwExStyle &
0x00000020L) lstrcat(sExStyle, TEXT(" | TRANSPARENT"));
if (dwExStyle &
0x00000100L) lstrcat(sExStyle, TEXT(" | WINDOWEDGE"));
}
BOOL CALLBACK
CSpyWin::EnumChildProc(_In_ HWND hwnd, _In_ LPARAM lParam)
{
TCHAR sCaption[256];
TCHAR sLine[256];
RECT crt;
wstring* pChilds =
(wstring*)lParam;
GetWindowText(hwnd, sCaption,
256);
GetWindowRect(hwnd,
&crt);
wsprintf(sLine, L"%d(%s)
(%d,%d) - (%d,%d), %d*%d\r\n",
(int)hwnd,
sCaption,
crt.left,
crt.top, crt.right, crt.bottom,
crt.right
- crt.left, crt.bottom - crt.top
);
(*pChilds) += sLine;
return TRUE;
}
핵심 함수는 WindowFromPoint이며 이 함수가 리턴하는 윈도우에
대한 모든 정보를 조사하여 문자열로 조립한다. 속성 플래그를 숫자가 아닌 명칭으로 변환하기 위한 코드가
길다. 윈도우 자체의 속성과 윈도우 계층 정보를 조사하여 두 윈도우에 나누어 보여 준다.
원래 계획은 윈도우 계층을 그래픽 형태로 표시하고 계층 사이를 클릭하여 이동하려고 했으나 시간이 너무 오래 걸릴
것 같아 일단 문자열 형태로 출력했다. 다음에 시간이 나면 이 부분은 좀 더 개선해 볼 생각이다.
티젯 등록
클래스 하나가 곧 티젯 하나이다. 일부 유틸리티 함수가 추가되기는
하지만 웬만하면 클래스 하나에 캡슐화되어 다른 부분에 영향을 미치지 않는다. 그래서 새로운 티젯을 추가하거나
기존 티젯을 개선하는 것이 어렵지 않다.
이 장에서 추가한 티젯을 등록해야 객체를 만들 수 있다. CreateObject에서 클래스명과 객체 생성문을 연결해 둔다.
CTidget* CTidget::CreateObject(wstring cls)
{
....
if
(cls == L"MoveCursor") return new CMoveCursor();
if
(cls == L"SizeMeter") return new CSizeMeter();
if
(cls == L"Tetris") return new CTetris();
if
(cls == L"OneImage") return new COneImage();
if (cls ==
L"EnumFont") return new CEnumFont();
if
(cls == L"Spy") return new CSpy();
return
nullptr;
}
티젯 초기화 배열에도 새로 만든 티젯의 정보를 기록해 둔다.
STidgetInfo arTidgetInfo[] = {
....
{L"커서
이동", L"주기적으로 커서를 이동하여 화면 보호기 동작을 방지합니다.",
L"MoveCursor",
false},
{L"윈도우
크기 측정", L"표준 모니터 크기의 면적을 실제 윈도우로 확인합니다.",
L"SizeMeter",
false},
{L"테트리스", L"심심풀이 테트리스 게임입니다. 다양한 크기를
지원합니다.",
L"Tetris",
false},
{L"참조
이미지", L"단 하나의 이미지를 원하는 곳에 원하는 크기로 신속하게 열어 확인한다.",
L"OneImage",
true},
{L"폰트
열거", L"설치되어 있는 폰트의 목록을 보고 특성을 조사합니다. 폰트 생성 코드를 작성하여 복사합니다. ",
L"EnumFont",
true},
{L"스파이", L"커서 위치의 윈도우 속성을 조사합니다.",
L"Spy",
true},
{L"",
L"", L"", false},
};
OneImage는 멀티를 지원한다.
두 개 이상의 이미지를 등록해 놓고 각각 열어 볼 수 있다. 딱 하나의 이미지만 보여 주지만
여러 개의 티젯에 각각의 이미지를 등록할 수 있어 실용적이다. 그렇다면 SizeMeter나 Tetris는 어떨까? 이것도 크기별로 두 개를 열어 비교해 볼 수 있으니 멀티가 되어야 하지 않을까 싶겠지만 얘들은 원래 멀티가
되며 창을 얼마든지 띄울 수 있다.
티젯의 멀티 속성은 티젯 자체를 여러 개 배치할 수 있는가를 의미하는 것이지 티젯이 여는 창이 여러 개인가를
의미하는 것은 아니다. LCDTest 티젯도 멀티는 안되지만 여러 개의 창을 열어 놓고 각 모니터에
띄워 놓을 수 있다. 멀티인가 아닌가는 INI 파일에 설정을
따로 저장하는가 아닌가에 의해 결정된다.
메인의 OnCreate에서 첫 시작시 이 티젯을 생성한다. 만들어 놨으니 어쨌든 처음부터 보여야 사용자가 쓸 수 있다.
if
(widget_num == 0) {
....
pTidget
= CTidget::CreateDefaultObject(L"MoveCursor");
arTidget.push_back(pTidget);
pTidget
= CTidget::CreateDefaultObject(L"SizeMeter");
arTidget.push_back(pTidget);
pTidget
= CTidget::CreateDefaultObject(L"Tetris");
arTidget.push_back(pTidget);
pTidget
= CTidget::CreateDefaultObject(L"OneImage");
arTidget.push_back(pTidget);
pTidget
= CTidget::CreateDefaultObject(L"EnumFont"); arTidget.push_back(pTidget);
pTidget
= CTidget::CreateDefaultObject(L"Spy"); arTidget.push_back(pTidget);
설정 저장 기능이 동작하고 있어 여기에 티젯을 등록한다고 해서 바로 보이는 것은 아니다. 티젯 선택창을 열어 추가하거나
아니면 아예 INI 파일을 지워 버려야 초기 목록을 준비한다.