3.호스트의 명령
가.명령
지금까지 작성했던 명령들은 컨트롤 수준의 편집 명령들이었는데 좀 더 거시적인 차원에서 보면 호스트 수준의 명령도 존재한다. 편집 명령은 문서의 내부 데이터를 다루지만 호스트의 명령은 문서 자체나 문서창을 관리하며 또한 컨트롤 자체의 설정을 조사하기도 한다. 호스트의 명령은 사실 반복의 의미는 거의 없으며 단축키 정의를 위해 존재한다. 물론 원한다면 매크로에 포함시킬 수는 있다. 호스트 수준의 명령 목록은 다음과 같다.
|
동사 |
목적어 |
설명 |
|
call |
매크로명 |
매크로 호출 |
|
clip |
상용구 명 |
상용구 삽입 |
|
navi |
next prev |
창 변경 |
|
set |
showenter showtab showspace showlinenum showmargin showcurline hideseltype |
set a b 형식 메뉴에 있는 건 제외 |
|
toggle |
showenter showtab showspace showlinenum showmargin |
|
보다시피 다른 매크로를 호출한다거나 설정을 변경하는 좀 더 큰 기능들이다. Macro.h에 이 매크로에 대한 열거형과 관련 함수의 원형을 선언한다. Macro.h는 실습을 시작할 때 미리 만들어 두었다.
enum {DGC_CALL, DGC_CLIP, DGC_NAVI, DGC_SET, DGC_TOGGLE};
#define DGVERBNUM 5
int ExecMacro(const TCHAR *szMacro);
int DoCommand(const TCHAR *szCom);
Macro.cpp 구현 파일에는 명령과 목적어에 대한 정보를 작성한다. 사용하는 구조체는 ApiEdit와 동일하며 명령과 목적어 포맷도 동일하다.
SMacVerb arHostVerb[]={
{"call","매크로 호출",0x00},
{"clip","상용구 삽입",0x00},
{"navi","윈도우 순환",0x02},
{"set","설정 변경",0x02},
{"toggle","설정 토글",0x02},
{"","",0x00},
};
SMacObject arHostObject[]={
{"next","다음 윈도우"}, // navi:0
{"prev","이전 윈도우"},
{NULL,NULL},
{"showenter","개행 코드 보기"}, // set:3
{"showtab","탭 코드 보기"},
{"showspace","공백 보기"},
{"showlinenum","줄번호 보기"},
{"showmargin","마진 보기"},
{"showcurline","현재행 강조"},
{"hideseltype","선택영역 숨기기"},
{NULL,NULL},
{"showenter","개행 코드 보기"}, // toggle:11
{"showtab","탭 코드 보기"},
{"showspace","공백 보기"},
{"showlinenum","줄번호 보기"},
{"showmargin","마진 보기"},
{NULL,NULL}
};
int arObjOfVerbHost[]={-1,-1,0,3,11};
이 명령들은 호스트가 제공하는 것이므로 ApiEdit에서는 직접적으로 사용할 수 없으며 호스트에 따라 나름대로의 명령을 정의할 수 있다.
나.매크로 클래스
호스트 입장에서 매크로는 실행 대상이면서 동시에 편집 대상이다. 언제든지 명령어를 첨삭할 수 있고 파일이나 레지스트리로 저장 또는 복구할 수 있다. 매크로를 관리하기 위해 여러 가지 정보와 함수들이 필요하므로 매크로를 위한 클래스를 작성한다. Macro.h에 다음 클래스를 선언한다.
struct SMacro
{
TCHAR Name[65];
TCHAR *Content;
};
class CMacro
{
public:
CMacro();
~CMacro();
SMacro *arMacro;
int Size;
int Num;
int Find(const TCHAR *Name);
void Set(int idx,const TCHAR *szCon);
void Add(const TCHAR *Name,const TCHAR *szCon);
void Delete(int idx);
void LoadFromReg(TCHAR *Key);
void SaveToReg(TCHAR *Key);
void LoadFromFile(TCHAR *Path);
void SaveToFile(TCHAR *Path);
};
SMacro 구조체는 하나의 매크로에 대한 이름과 내용을 가진다. 이름은 최대 64자까지 가능한데 널 종료 문자까지 고려하여 65의 크기를 가진다. 매크로의 내용은 길이가 가변적이므로 Content 멤버는 포인터로만 선언하고 포함되는 명령의 길이에 따라 동적으로 할당할 것이다. CMacro 클래스는 매크로의 집합을 다루는 클래스이다. arMacro 배열을 멤버로 가지며 매크로 개수가 가변적이므로 이 배열도 역시 동적으로 할당된다. 멤버 함수들은 Macro.cpp에 작성한다.
// 생성자. 완전히 빈 상태로 객체 생성
CMacro::CMacro()
{
Size=0;
Num=0;
arMacro=NULL;
}
CMacro::~CMacro()
{
int i;
for (i=0;i<Num;i++) {
free(arMacro[i].Content);
}
if (arMacro) {
free(arMacro);
}
}
// 이름으로부터 매크로 번호 찾음. 없으면 -1
int CMacro::Find(const TCHAR *Name)
{
int i;
for (i=0;i<Num;i++) {
if (strcmpi(Name,arMacro[i].Name)==0) {
return i;
}
}
return -1;
}
// 매크로 내용 대입. 대입전에 크기 점검
void CMacro::Set(int idx,const TCHAR *szCon)
{
unsigned size;
// 매크로 버퍼의 크기 점검
size=lstrlen(szCon)+1;
if (arMacro[idx].Content==NULL || _msize(arMacro[idx].Content) < size) {
arMacro[idx].Content=(TCHAR *)realloc(arMacro[idx].Content,size);
}
lstrcpy(arMacro[idx].Content,szCon);
}
void CMacro::Add(const TCHAR *Name,const TCHAR *szCon)
{
// 같을 때 재할당. 한번에 1이상 커지면 안됨. 새로 할당된 매크로는 크기 0으로 주어 다음에 바로 재할당되도록 함
if (Size == Num) {
Size++;
arMacro=(SMacro *)realloc(arMacro,sizeof(SMacro)*Size);
arMacro[Num].Content=NULL;
}
lstrcpy(arMacro[Num].Name,Name);
Set(Num,szCon);
Num++;
}
void CMacro::Delete(int idx)
{
int i;
free(arMacro[idx].Content);
for (i=idx;i<Num-1;i++) {
arMacro[i]=arMacro[i+1];
}
// 마지막 요소는 비워서 다음에 재할당되도록 한다.
arMacro[Num-1].Content=NULL;
Num--;
}
void CMacro::LoadFromReg(TCHAR *Key)
{
int i,count;
TCHAR *szMacro;
TCHAR szKey[MAX_PATH];
TCHAR szSub[12];
TCHAR szName[32];
lstrcpy(szKey,Key);
lstrcat(szKey,"Macro");
count=SHRegReadInt(SHCU,szKey,"nMacro",0);
szMacro=(TCHAR *)malloc(16384);
for (i=0;i<count;i++) {
wsprintf(szSub,"Macro%d",i);
SHRegReadString(SHCU,szKey,szSub,"",szMacro,16384);
wsprintf(szSub,"Name%d",i);
SHRegReadString(SHCU,szKey,szSub,"",szName,32);
Add(szName,szMacro);
}
free(szMacro);
}
void CMacro::SaveToReg(TCHAR *Key)
{
int i;
TCHAR szKey[MAX_PATH];
TCHAR szSub[12];
lstrcpy(szKey,Key);
lstrcat(szKey,"Macro");
SHRegWriteInt(SHCU,szKey,"nMacro",Num);
for (i=0;i<Num;i++) {
wsprintf(szSub,"Macro%d",i);
SHRegWriteString(SHCU,szKey,szSub,arMacro[i].Content);
wsprintf(szSub,"Name%d",i);
SHRegWriteString(SHCU,szKey,szSub,arMacro[i].Name);
}
}
void CMacro::LoadFromFile(TCHAR *Path)
{
}
void CMacro::SaveToFile(TCHAR *Path)
{
}
초기화, 해제, 추가, 삭제 등의 멤버 함수들과 레지스트리로의 입출력 함수들이 작성되어 있다. 파일 입출력 함수는 스팩에만 기획되어 있고 아직 구현하지는 않았는데 매크로의 문법이 확정적이지 않기 때문에 잠시 보류해 두었다. 매크로 기능이 좀 더 정교하게 다듬어지면 전체 매트로를 파일로 저장하여 사용자끼로 교환할 수도 있을 것이다. 파일 입출력 기능이 아직 작성되지 않았으므로 매크로는 레지스트리에만 지역적으로 존재할 수 있다.
SMacro 객체 하나면 매크로의 집합을 모두 관리할 수 있으므로 당근은 매크로 객체를 전역으로 단 하나만 선언한다. 매크로의 관리의 주체는 컨트롤이 아니라 호스트이므로 이 객체는 Dangeun.cpp에 선언한다.
CMacro DgMacro;
외부에서 이 객체를 언제든지 액세스할 수 있어야 하므로 global.h에도 extern 선언한다.
extern CMacro DgMacro;
이 객체는 전적으로 매크로 대화상자에서 관리될 것다. 당근은 OnCreate, OnDestroy에서 이 객체가 레지스트리에 자신을 저장할 수 있게만 하면 된다.
int OnCreate(HWND hWnd,WPARAM wParam,LPARAM lParam)
{
....
if (SHRegReadInt(SHCU,KEY"Setting","StartAction",1000) == 1000) {
Option.GetStyleColor();
FindFlag=AE_FIND_WRAP | AE_FIND_RECURSIVE;
arFind[3].num=2;
arFind[3].Set(0,"*.*");
arFind[3].Set(1,"*.cpp;*.hpp;*.c;*.h;*.inl");
} else {
Option.Load(KEY);
DgMacro.LoadFromReg(KEY);
....
void OnDestroy(HWND hWnd,WPARAM wParam,LPARAM lParam)
{
....
Option.Save(KEY);
DgMacro.SaveToReg(KEY);
....
클래스 자체에 레지스트리 입출력문이 완비되어 있으므로 레지스트리 루트키와 함께 멤버 함수만 호출하면 된다.
다.명령 실행
호스트의 명령을 실행하는 함수를 Macro.cpp에 작성한다. 방식은 ApiEdit와 거의 유사한데 호출 관계가 다소 복잡하다.
// 명령 실행.
// 0: 정상 실행
// -1:동사 없음
// -2:지원되지 않는 목적어
// -3:닫는 따옴표 없음
int DoCommand(const TCHAR *szCom)
{
int comlen;
const TCHAR *pc, *ps, *p;
TCHAR *Com, *pCom ;
int Verb, Object;
HWND hActive;
SInfo *pSi;
int Result=0;
TCHAR *str;
int count,Value;
int i;
// 선행 공백은 무시한다.
ps=szCom;
SkipSpace(ps);
// 주석이면 명령 전체를 무시한다.
if (*ps=='/' && *(ps+1)=='/') {
return 0;
}
// 명령어의 길이를 구한다. 널, 개행, 세미콜론이 문장의 끝이다.
for (pc=ps;;pc++) {
if (*pc==NULL || *pc=='\r' || *pc==';') {
break;
}
if (SkipString(pc)==FALSE) {
return -3;
}
}
comlen=pc-ps;
// szCom의 모든 문자는 소문자로, 단 따옴표 안은 제외. 닫는 따옴표가 있는지는 이미 체크했음
Com=(TCHAR *)malloc(comlen+1);
lstrcpyn(Com,ps,comlen+1);
for (pCom=Com;*pCom;pCom++) {
SkipString(const_cast<const TCHAR *&>(pCom));
if (IsCharUpper(*pCom)) {
*pCom+=0x20;
}
}
hActive=(HWND)SendMessage(g_hMDIClient,WM_MDIGETACTIVE,0,(LPARAM)NULL);
if (hActive) {
pSi=(SInfo *)GetWindowLong(hActive,0);
} else {
return 0;
}
// 동사를 먼저 찾는다. 없으면 에러로 처리한다.
p=Com;
Verb=GetComVerb(p,arHostVerb);
if (Verb==-1) {
Result=-1;
goto End;
}
switch (Verb) {
case DGC_CALL:
GetComString(p,str);
count=GetComNumber(p,1);
if (str) {
for (i=0;i<count;i++) {
Result=ExecMacro(str);
if (Result != 0) {
break;
}
}
free(str);
} else {
Result=-3;
goto End;
}
break;
case DGC_CLIP:
break;
case DGC_NAVI:
// 매크로 실행중에는 사용할 수 없다.
if (pSi->Ae.GetActiveView()->AeMc.runlevel==0) {
Object=GetComObject(Verb,p,arHostObject,arObjOfVerbHost);
switch (Object) {
case 0:
SendMessage(g_hMDIClient,WM_MDINEXT,NULL,(LPARAM)TRUE);
break;
case 1:
SendMessage(g_hMDIClient,WM_MDINEXT,NULL,(LPARAM)FALSE);
break;
}
}
break;
case DGC_SET:
Object=GetComObject(Verb,p,arHostObject,arObjOfVerbHost);
Value=GetComNumber(p,0);
switch (Object) {
case 0:
pSi->Ae.SetShowState(SHOWENTER,Value!=0);
break;
case 1:
pSi->Ae.SetShowState(SHOWTAB,Value!=0);
break;
case 2:
pSi->Ae.SetShowState(SHOWSPACE,Value!=0);
break;
case 3:
pSi->Ae.SetShowState(SHOWLINENUM,Value!=0);
break;
case 4:
pSi->Ae.SetShowState(SHOWMARGIN,Value!=0);
break;
case 5:
pSi->Ae.SetShowCurLine(Value);
break;
case 6:
pSi->Ae.SetHideSelType(Value);
break;
}
break;
case DGC_TOGGLE:
Object=GetComObject(Verb,p,arHostObject,arObjOfVerbHost);
switch (Object) {
case 0:
pSi->Ae.SetShowState(SHOWENTER,!pSi->Ae.GetShowState(SHOWENTER));
break;
case 1:
pSi->Ae.SetShowState(SHOWTAB,!pSi->Ae.GetShowState(SHOWTAB));
break;
case 2:
pSi->Ae.SetShowState(SHOWSPACE,!pSi->Ae.GetShowState(SHOWSPACE));
break;
case 3:
pSi->Ae.SetShowState(SHOWLINENUM,!pSi->Ae.GetShowState(SHOWLINENUM));
break;
case 4:
pSi->Ae.SetShowState(SHOWMARGIN,!pSi->Ae.GetShowState(SHOWMARGIN));
break;
}
break;
}
End:
free(Com);
return Result;
}
// 매크로 실행.
int ExecMacro(const TCHAR *szMacro)
{
int idx;
HWND hActive;
SInfo *pSi;
idx=DgMacro.Find(szMacro);
if (idx==-1) {
return -1;
}
hActive=(HWND)SendMessage(g_hMDIClient,WM_MDIGETACTIVE,0,(LPARAM)NULL);
if (hActive==NULL) {
return -1;
}
pSi=(SInfo *)GetWindowLong(hActive,0);
pSi->Ae.ExecMacro(DgMacro.arMacro[idx].Content);
return 0;
}
ExecMacro는 DgMacro 객체에서 이름으로 매크로를 찾고 활성 창의 할성 뷰로 이 매크로를 전달한다. 뷰의 ExecMacro 함수는 뷰의 DoCommand 함수를 호출하여 편집 명령을 처리하되 뷰가 이해하지 못하는 동사는 호스트의 DoCommand 함수로 넘긴다. 즉 ApiEdit의 명령은 ApiEdit가 처리하고 당근의 명령은 당근이 처리하되 우선권은 ApiEdit가 가진다. 만약 호스트가 이해하지 못하는 동사가 있다면 이때는 에러로 처리한다.
활성창을 변경하는 navi 명령은 매크로 실행중에는 무시된다. 이 명령은 매크로를 위해 만든 것이 아니라 단축키를 위해 만든 것이다. 상용구 삽입 명령은 아직 상용구 기능을 구현하지 않았기 때문에 실행하지 않는다. 차후 상용구 기능을 완성하면 이 명령 실행 코드도 작성할 것이다.
라.매크로의 중첩
당근은 매크로가 매크로를 호출할 수 있다. 즉 중첩 가능하다. 매크로 중첩은 호스트의 call 명령에 의해 실행되는데 이 명령이 실행되는 과정이 굉장히 복잡하다. 다음 두 가지 사실을 먼저 정리하도록 하자.
1.매크로 실행의 주체는 컨트롤이다. 매크로에 포함된 명령들이 대부분 편집 관련 명령이므로 컨트롤이 직접 실행하는 것이 효율적이다. 물론 호스트가 매크로의 명령을 하나씩 추출해서 컨트롤의 DoCommand를 호출할 수도 있지만 이 경우 편집동작들이 그룹을 구성할 수 없다. 매크로에 속한 모든 명령들은 하나의 편집 그룹을 구성해야 한다.
2.매크로 관리의 주체는 호스트이다. 컨트롤은 레지스트리나 파일에 대한 제어권이 없으며 또한 매크로를 관리하는 대화상자를 가지지 못한다. 따라서 컨트롤은 DgMacro 객체 따위는 아예 존재 자체를 모른다. 그래서 ApiEdit::ExecMacro는 매크로의 이름이 아닌 매크로 내용을 인수로 전달받는다.
이렇게 역할 분담이 되어 있기 때문에 call 명령의 처리가 아주 어려워진다. call 명령 다음에는 매크로 이름이 오는데 컨트롤은 매크로의 이름으로부터 내용을 얻을 수 없기 때문이다. 그래서 call 명령이 컨트롤의 명령이 될 수 없는 것이다. 즉 매크로의 중첩은 ApiEdit의 기능이 아니고 당근의 기능이다.
대신 ApiEdit는 자신이 이해하지 못하는 명령에 대해 호스트에게 UserBase+2 메시지를 보내 일단 처리할 기회를 제공한다. 비단 call 명령 뿐만 아니라 set, toggle, navi 등의 명령에 대해서도 마찬가지이다. ApiEdit의 DoCommand가 자신이 정의하지 않는 동사에 대해 호스트에게 처리를 위임함으로써 호스트는 나름대로의 명령 체계를 구성할 수 있는 자유를 제공받sms다.
그렇다면 왜 메시지를 보내는가? 함수를 호출하면 더 직관적이고 빠를텐데 말이다. 이는 컨트롤의 독립성을 확보하기 위해서이다. 이 메시지를 처리하지 않는 호스트와도 사용될 수 있어야 한다. 즉, 호스트의 명령이 전혀 없어도 컨트롤은 자신의 메시지만 처리할 수 있다. ApiEdit::ExecMacro가 호스트에 UserBase+2를 부모 윈도우에게 보내므로 부모는 이 메시지를 받았을 때 lParam으로 전달된 명령을 실행해야 한다. 다음 코드를 작성한다.
LRESULT CALLBACK DGChildProc(HWND hWnd,UINT iMessage,WPARAM wParam,LPARAM lParam)
{
....
pSi=(SInfo *)GetWindowLongPtr(hWnd,0);
if (pSi && iMessage > WM_USER) {
if (iMessage == pSi->Ae.GetUserBase()+1) {
SetSettingView((CApiEditText *)lParam);
return 0;
}
if (iMessage == pSi->Ae.GetUserBase()+2) {
return DoCommand((TCHAR *)lParam);
}
}
DoCommand 함수는 DGC_CALL 명령에 대해 str로 추출된 매크로를 count 회수만큼 실행한다. 이때 ExecMacro 함수를 호출하는데 이 함수는 매크로의 내용을 인수로 전달받지 않고 매크로의 이름을 전달받는다는 점이 ApiEdit의 경우와 다르다. 호스트는 DgMacro를 관리하고 있으므로 이름으로 매크로를 실행할 수 있고 따라서 call 명령에 대한 처리가 가능하다. 매크로 관련 함수들의 호출 관계가 복잡한데 그림으로 그려 보면 다음과 같다.
호출된 함수가 호출한 함수를 다시 호출하는 셈이므로 일종의 재귀 호출인 셈이다. 좀 더 구체적으로 move right;call "MyMacro";move left 매크로의 실행을 추적해 보자. MyMacro에는 insert "1" 명령 하나만 들어 있다고 하자. 이때 이 매크로가 처리되는 과정은 다음과 같다.
1.실행의 주체가 컨트롤이므로 매크로는 최초 CApiEdit::ExecMacro로 전달된다. 이 함수에서 편집 그룹을 시작하고 URnest, runlevel을 1로 만든다. 이후 명령 기록은 하지 않으며 모든 편집 명령은 그룹으로 묶인다.
2.매크로의 첫번째 명령인 move right가 실행된다. 컨트롤의 DoCommand 함수가 호출될 것이다.
3.두번째 명령은 call인데 이 명령은 컨트롤이 이해하지 못하기 때문에 UserBase+2 메시지를 통해 간접적으로 당근의 DoCommand 함수를 호출한다.
4.DoCommand 함수는 call 명령에 대해 ExecMacro 함수를 호출하며 이 함수는 DgMacro에서 매크로 내용을 읽어 다시 CApiEdit::ExecMacro를 호출한다.
5.중첩된 MyMacro가 다시 실행된다. runlevel은 2가 되고 URnest도 2가 될 것이다.
6.매크로 내의 insert "1" 명령이 실행된다. 이 명령은 CApiEdit::DoCommand가 처리한다. 명령을 처리한 후 MyMacro는 종료되는데 이때 runlevel과 URnest는 다시 1이된다. 아직 매크로 실행중이며 편집 그룹도 계속 유지된다. CApiEdit::ExecMacro가 리턴되어 3번 호출 전으로 돌아간다.
7.마지막 명령인 move left가 CApiEdit::DoCommand에 의해 실행되고 전체 ExecMacro 실행이 종료된다. runlevel과 URnest는 모두 0이 되어 편집 그룹도 해제되고 명령 기록도 재개된다.
이런 식이라면 3중 4중의 매크로 중첩도 무리없이 처리해낸다. 다른 방식도 가능한데 당근의 ExecMacro 함수가 매크로 실행의 주체가 될 수도 있다. 직접 컨트롤의 StartUndoGroup, EndUndoGroup을 호출하고 runlevel을 관리하면서 명령의 동사를 보고 누구것인지 판별해서 적절한 DoCommand를 호출하면 된다. call 명령에 대해서는 자기 자신을 다시 재귀 호출하기만 하면 된다. 이렇게 해도 별 문제는 없지만 외부에서 활성 컨트롤의 활성 뷰를 건드려야 한다는 점이 마음에 안든다. 또한 매크로 실행 기능이 호스트 제작자에게 전가된다는 점이 큰 부담이다.