당근 1.2

2.ApiEdit 분할

가. 도우미 수정

앞 절에서 객체 분할을 직접 해 보면서 분할 방법과 관련 이론에 대해 알아 보았으므로 이제 ApiEdit도 똑같은 방법으로 객체를 분할하자. 실습 절차나 방법은 거의 동일하지만 SplitView 예제와는 달리 객체가 훨씬 크기 때문에 작업해야 할 양이 더 많다. 일단 객체 분할만 하여 완전히 동일하게 동작하는 프로젝트를 만들고 난 후 창 분할을 할 것이다. 지금까지 그래왔던 것처럼 새 프로젝트는 항상 이전 프로젝트의 연속이다. 앞장에서 작성한 Dangeun13 프로젝트를 복사하여 Dangeun14 프로젝트를 만든다.

SplitView 예제를 완벽하게 이해하고 있다면 이 장의 실습은 아주 쉬울 것이나 그렇지 않다면 도대체 코드가 어떻게 바뀌는지 무척 어려워 보일 것이다. SplitView 예제는 비록 짧지만 이 장과 다음 장의 이론적인 근거가 되는 중요한 예제이므로 아직 잘 모르겠다면 다시 한번 더 복습하고 오기 바란다. 큰 프로젝트를 다룰 때는 짧은 예제를 통해 항상 이론을 먼저 확립한 후 실제 적용하는 것이 좋다.

앞에서 SplitView 예제를 만들 때와 동일한 방법으로 CApiEdit 클래스를 프레임과 뷰로 분할한다. 이미 했던 실습을 반복하는 것이므로 자세한 이론적 설명은 생략하고 실습 과정에 대해 요약적으로 정리하였다. 객체 분할에 대한 이론은 SplitView 예제와 거의 동일하지만 ApiEdit에는 그 외에도 복잡한 문제들이 몇가지 더 있는데 주로 멤버들을 어떻게 나누어 가질 것인가의 문제이다.

대부분의 코드는 1.0에 있던 코드를 그대로 가져 오거나 약간씩만 변경될 것이다. 이 실습에서 "원래 ApiEdit"라고 칭하는 것은 1.0의 ApiEdit 모듈을 의미하는 것인데 구체적으로 Dangeun13의 ApiEdit.cpp라고 생각하면 된다. 다음 순서대로 실습을 진행하는데 과정이 상당히 길어 시간이 오래 걸린다. 이 문서대로 여러 번 테스트를 했으므로 과정을 그대로 따라하면 객체 분할이 정확하게 완료된다.

ApiEdit.h에 모든 윈도우 클래스의 루트인CWindow 클래스를 선언한다. 앞에서 만들었던 클래스와 완전히 동일하다. 윈도우 핸들인 hWnd와 파괴자, 그리고 메시지를 처리하는 OnMessage 순수 가상 함수만 멤버로 포함되어 있다.

class CWindow

{

public:

HWND hWnd;

~CWindow();

virtual LRESULT OnMessage(UINT iMessage,WPARAM wParam,LPARAM lParam)=0;

};

파괴자도 동일하게 작성한다. 물론 이 코드는 ApiEdit.cpp에 작성하는데 _RegisterHelper 전역 도우미 객체 선언문 다음에 작성한다. 루트 클래스인 CWindow의 파괴자에서 객체를 제거하므로 CApiEdit를 비롯한 파생 클래스들은 객체 맵에서 자신을 제거하는 코드는 작성하지 않아도 된다.

CWindow::~CWindow()

{

if (_RegisterHelper.arObj)

_RegisterHelper.RemoveObject(hWnd);

}

그리고 ApiEdit.cpp에 작성되어 있는 도우미 객체를 수정한다. 역시 앞에서 만든 예제와 완전히 동일한 방법으로 수정한다. CApiEdit *를 CWindow *로 모두 변경하고 RemoveObject의 DestroyWindow 호출을 삭제한다. 이제 도우미는 CWindow로부터 파생된 모든 객체들을 관리할 수 있다.

ApiEditProc의 pAE를 CWindow *타입으로 바꾸어 CWindow 파생 클래스의 윈도우로 전달되는 모든 메시지를 처리할 수 있게 한다.

LRESULT CALLBACK ApiEditProc(HWND hWnd,UINT iMessage,WPARAM wParam,LPARAM lParam)

{

CWindow *pAE;

pAE=_RegisterHelper.FindObject(hWnd);

if (pAE == NULL) {

pAE=(CWindow *)((LPCREATESTRUCT)lParam)->lpCreateParams;

_RegisterHelper.AddObject(hWnd,pAE);

}

return pAE->OnMessage(iMessage, wParam, lParam);

}

도우미의 생성자에서 ApiEditText 윈도우 클래스를 추가 등록한다. 이 윈도우는 ApiEdit의 기본 뷰로 사용된다.

CRegisterHelper::CRegisterHelper()

{

....

RegisterClass(&WndClass);

WndClass.lpszClassName="ApiEditText";

RegisterClass(&WndClass);

....

윈도우 클래스의 이름만 바뀌었을 뿐 모든 속성은 ApiEdit 프레임과 동일하다. 배경 브러시도 없고 커서도 동일하며 심지어 윈도우 프로시저도 공유한다. 이름만 다른 똑같은 윈도우 클래스를 하나 더 만들었을 뿐인데 현재 단계에서는 뷰와 프레임이 같은 윈도우 클래스로부터 생성되어도 별 문제가 없다. 왜냐하면 도우미가 윈도우 클래스가 아닌 객체의 타입으로 메시지 처리 함수를 선택하기 때문이다.

ApiEdit.h에 지원하는 뷰의 타입에 대한 열거형과 프레임이 모든 뷰를 한꺼번에 관리할 수 있는 매크로 함수를 선언한다.

enum {TEXT_VIEW, HEXA_VIEW};

#define ForAllView(fn) for (int aet=0;aet<4 && arView[aet];aet++) {\

arView[aet]->fn;\

}

뷰의 타입은 텍스트 뷰, 헥사 뷰 일단 두가지이지만 얼마든지 더 늘어날 수 있으며 차후에 더 많은 뷰를 추가할 것이다. 헥사 뷰는 한참 후에나 만들어 보겠지만 일단 그런 뷰를 만들 계획이라는 것은 알아두자. 뷰의 타입을 다양하게 바꿔가며 쓰기 위해 ApiEdit를 분할하고 있는 중이다. ForAllView 매크로는 존재하는 모든 뷰를 순회하면서 fn 함수를 호출하는 매크로이다. 호스트에서 설정 상태를 변경하면 프레임은 생성되어 있는 모든 뷰에 대해 설정 변경 함수를 호출해야 하는데 그때마다 루프를 구성하기는 번거로우므로 미리 매크로 함수를 작성해 두었다. 예를 들어 모든 뷰의 줄간을 조정하고 싶다면 다음과 같이 호출한다.

ForAllView(SetLineRatio(aRatio))

매크로내에 세미콜론이 포함되어 있으므로 세미콜론은 뒤에 붙이지 말아야 한다. 물론 붙여도 무시되므로 별 상관은 없다. ApiEdit는 최대 4개까지 뷰를 분할할 수 있고 존재하는 뷰의 번호는 0부터 연속적이기 때문에 이런 자동화된 매크로 구성이 가능하다.

다. 프레임 작성

CWindow를 정의하고 객체 맵이 클래스 계층을 지원하기 위한 준비를 마쳤다. 다음은 프레임 클래스를 작성한다. 원래 CApiEdit 클래스의 멤버 중 문서나 전역 설정과 상관있는 멤버들이 프레임에 소속될 것이다. 뷰 관리를 위해 새로 추가되는 멤버 변수와 함수들도 물론 있다. 다음 순서에 따라 실습을 진행한다.

멤버 목록에 변화가 많으므로 ApiEdit.h에 선언되어 있는 CApiEdit 클래스 선언문을 완전히 삭제하고 다음과 같이 다시 작성한다. 클래스 선언문 이전에 있는 tagLine 구조체나 UndoRecord 구조체, 기타 열거형 선언 등은 그대로 두면 된다. 직접 입력하기 싫으면 CD-ROM의 소스에서 복사해 오되 그렇더라도 실습은 진행해 보기 바란다.

class CApiEditText;

class CApiEdit : public CWindow

{

friend class CApiEditText;

friend class CParse;

friend class CParseCpp;

friend class CParseNull;

friend class CParseHtml;

friend class CParseSql;

private:

TCHAR *buf;

static HFONT hLineNumFont;

static HCURSOR hCSel,hCCopy,hCMove,hCMargin,hCNoDrop;

BOOL bReadOnly;

int buflen;

int doclen;

BOOL bWantTab;

BOOL bModified;

int UndoSize;

int UndoMin;

int saveur;

int URtick;

int URnest;

int LastEditOff;

DWORD dwFormat;

BOOL bUseLineEnd;

BOOL bAllowDrag;

BOOL bSpaceForTab;

BOOL bAutoIndent;

BOOL bBlockIndentWithTab;

BOOL bHomeToFirstChar;

int HideSelType;

int nShowCurLine;

BOOL bHideCurLine;

int CaretWidth;

BOOL bCalcTabWithAvg;

COLORREF MarColor1, MarColor2;

COLORREF NumColor;

COLORREF MarkColor;

COLORREF CodeColor;

COLORREF CurColor;

COLORREF cFore,cBack;

COLORREF cSelFore,cSelBack;

public:

CApiEdit();

UndoRecord *pUR;

int URSize;

int nowur;

CApiEditText *arView[4];

int ActiveView;

BOOL Create(int x,int y,int w,int h,DWORD style,UINT id,HWND hParent);

LRESULT OnMessage(UINT iMessage,WPARAM wParam,LPARAM lParam);

BOOL OnCreate(HWND hWnd, LPCREATESTRUCT lpCreateStruct);

void OnPaint(HWND hWnd);

void OnSetFocus(HWND hWnd, HWND hwndOldFocus);

void OnDestroy(HWND hWnd);

void OnLButtonDown(HWND hWnd, BOOL fDoubleClick, int x, int y, UINT keyFlags);

void OnMouseMove(HWND hWnd, int x, int y, UINT keyFlags);

void OnLButtonUp(HWND hWnd, int x, int y, UINT keyFlags);

void OnSize(HWND hWnd, UINT state, int cx, int cy);

void OnCommand(HWND hWnd, int id, HWND hwndCtl, UINT codeNotify);

BOOL OnSetCursor(HWND hWnd, HWND hwndCursor, UINT codeHitTest, UINT msg);

BOOL IsDBCS(int nPos);

int GetPrevOff(int nPos);

int GetNextOff(int nPos);

void Insert(int nPos, TCHAR *str, BOOL bRec=TRUE);

void Delete(int nPos, int nCount, BOOL bRec=TRUE);

void SetWrap(int aWrap);

void Invalidate(int Pos1, int Pos2=-1);

int FindParaStart(int nPos);

int IncludeEnter(int nPos);

void ClearBookmark();

void ToggleBookmark(int Para, int Mark);

void GotoBookmark(int Mark);

void GotoLine(int Line, int Col=0, int Type=0);

static void LoadAeResource();

static void UnLoadAeResource();

BOOL GetModified() { return bModified; }

void SetModified(BOOL aModi);

void InitDoc();

void SetText(TCHAR *TextBuf, int dwSize);

void GetText(TCHAR *TextBuf, int BufSize, int s=-1, int e=-1);

int GetTextLength();

BOOL GetReadOnly() { return bReadOnly; }

void SetReadOnly(BOOL aReadOnly);

void GetSelect(int &s, int &e);

void SetSelect(int s, int e, BOOL bFind);

BOOL GetShowState(int nIndex);

void SetShowState(int nIndex, BOOL aValue);

int GetLineRatio();

void SetLineRatio(int aLineHeight);

int GetWrap();

int GetShowCurLine() { return nShowCurLine; }

void SetShowCurLine(int aShowCurLine);

int GetTabWidth();

void SetTabWidth(int aTabWidth);

int GetHideSelType() { return HideSelType; }

void SetHideSelType(int aHideSelType);

void GetFont(LOGFONT *alogfont);

void SetFont(LOGFONT *alogfont);

COLORREF GetForeColor() { return cFore; }

void SetForeColor(COLORREF acol);

COLORREF GetBackColor() { return cBack; }

void SetBackColor(COLORREF acol);

COLORREF GetSelForeColor() { return cSelFore; }

void SetSelForeColor(COLORREF acol);

COLORREF GetSelBackColor() { return cSelBack; }

void SetSelBackColor(COLORREF acol);

BOOL GetNoFirstSpace();

void SetNoFirstSpace(BOOL aNoFirstSpace);

BOOL GetWantTab() { return bWantTab; }

void SetWantTab(BOOL aWantTab) { bWantTab=aWantTab; }

int GetShowTabType();

void SetShowTabType(int aShowTabType);

int GetShowEnterType();

void SetShowEnterType(int aShowEnterType);

int GetShowSpaceType();

void SetShowSpaceType(int aShowSpaceType);

COLORREF GetMarColor1() { return MarColor1; }

void SetMarColor1(COLORREF acol);

COLORREF GetMarColor2() { return MarColor2; }

void SetMarColor2(COLORREF acol);

COLORREF GetMarkColor() { return MarkColor; }

void SetMarkColor(COLORREF acol);

COLORREF GetCodeColor() { return CodeColor; }

void SetCodeColor(COLORREF acol);

COLORREF GetCurColor() { return CurColor; }

void SetCurColor(COLORREF acol);

COLORREF GetNumColor() { return NumColor; }

void SetNumColor(COLORREF acol);

BOOL GetUseLineEnd() { return bUseLineEnd; }

void SetUseLineEnd(BOOL aUseLineEnd) { bUseLineEnd=aUseLineEnd; }

BOOL GetAllowDrag() { return bUseLineEnd; }

void SetAllowDrag(BOOL aAllowDrag) { bAllowDrag=aAllowDrag; }

int GetCaretWidth() { return CaretWidth; }

void SetCaretWidth(int aCaretWidth);

BOOL GetHideCurLine() { return bHideCurLine; }

void SetHideCurLine(BOOL aHideCurLine);

BOOL GetCalcTabWithAvg() { return bCalcTabWithAvg; }

void SetCalcTabWithAvg(int aCalcTabWithAvg);

int GetRightWrap();

void SetRightWrap(int aRightWrap);

int GetColMark();

void SetColMark(int aColMark);

void URInsert(int nPos, TCHAR *str);

void URDelete(int nPos, TCHAR *str);

void URMove(int nPos, int Dest, TCHAR *str);

void Undo();

void Redo();

BOOL CanUndo();

BOOL CanRedo();

void ClearRedo();

void NextRecord();

void AllocURData(int idx,int need,int extra);

int GetUndoSize() { return UndoSize; }

void SetUndoSize(int aSize);

int GetUndoMin() { return UndoMin; }

void SetUndoMin(int aMin);

void SaveModified();

void ArrangeModified();

void StartUndoGroup();

void EndUndoGroup();

CParse* GetParser();

void SetParser(int ParseType);

BOOL FindText(int nPos, TCHAR *what, DWORD dwFlag);

int ReplaceText(int nPos, TCHAR *what, DWORD dwFlag, TCHAR *to);

int GetOffset();

void GetSelRect(RECT &srt);

BOOL bFindSelect;

int GetInfoFromOff(int Type, int nPos=-1);

void GotoLastEditOff();

void SendNotify(int code);

int GetDocInfo(int type);

BOOL GetInsMode();

int GetOffFromPara(int pr, int pc);

BOOL GetSpaceForTab() { return bSpaceForTab; }

void SetSpaceForTab(BOOL aSpaceForTab) { bSpaceForTab=aSpaceForTab; }

BOOL GetAutoIndent() { return bAutoIndent; }

void SetAutoIndent(BOOL aAutoIndent) { bAutoIndent=aAutoIndent; }

BOOL GetBlockIndentWithTab() { return bBlockIndentWithTab; }

void SetBlockIndentWithTab(BOOL aBlockIndentWithTab)

{ bBlockIndentWithTab=aBlockIndentWithTab; }

BOOL GetHomeToFirstChar() { return bHomeToFirstChar; }

void SetHomeToFirstChar(BOOL aHomeToFirstChar) { bHomeToFirstChar=aHomeToFirstChar; }

DWORD GetFormat() { return dwFormat; }

void SetFormat(DWORD aFormat);

DWORD AnalyzeFormat(TCHAR *Text, int dwSize);

int ConvertFormat(DWORD from, DWORD to, TCHAR *src, TCHAR *&dest);

void BeginPrint(Ae_PrintInfo *pi);

BOOL PrintPage(Ae_PrintInfo *pi,int nPage);

void EndPrint(Ae_PrintInfo *pi);

CApiEditText *GetActiveView();

CApiEditText *CreateView(int Type);

void DeleteView(int nView);

};

그 많던 멤버 변수들이 대부분 삭제되었으며 문서와 직접 관련이 있는 변수들과 기타 몇 종류의 변수들만 남았다. 어떤 변수들이 살아 남았는지 목록을 살펴 보자. 우선 buf, doclen과 같이 문서의 데이터를 기억하는 멤버가 프레임에 속하며 취소 레코드를 관리하는 변수 전체도 프레임 소속이다. 모든 뷰들이 공유하는 커서, 폰트 등의 정적 멤버도 프레임이 가지며 뷰는 프레임으로부터 이 값들을 참조하기만 한다.

그 외 단순히 값만 기억하고 변경시 추가 작업이 필요없는 설정 변수들이 프레임에 소속된다. 줄간(LineRatio)이나 자동 개행 방식(nWrap) 등의 설정 변수들은 변경될 때 재정렬이나 화면 갱신, 캐럿 처리 등의 추가 동작이 필요하므로 뷰가 값을 직접 가져야 하지만 bAllowDrag나 bSpaceForTab은 마우스 드래그가 시작될 때나 탭 키가 입력될 때만 적용되므로 이 값이 바뀐다고 해서 뷰의 상태가 변하지는 않는다. 그래서 이 설정값은 프레임에 두고 뷰는 이 값들이 필요할 때 참조하기만 한다.

현재행 보기 옵션이나 색상 옵션들은 뷰가 사용하기는 하지만 뷰별로 각각 다른 옵션을 적용할 경우가 별로 없기 때문에 프레임이 멤버를 가지고 이 값이 변경될 때 뷰를 다시 그리도록 했다. 프레임이 가지는 변수는 모든 뷰에 공통적으로 적용되는 것들이고 뷰가 가지는 변수는 개별 뷰에서 각각 달라질 수 있는 것들이다.

추가된 멤버도 있는데 프레임 아래에 뷰가 생성되므로 연결된 뷰의 목록을 관리하기 위해 arView 배열을 멤버로 선언하였다. 뷰는 CApiEditText 타입을 가지므로 arView 배열의 타입은 CApiEditText *이며 이 배열의 크기가 4이므로 최대 4개까지의 뷰로 분할할 수 있다. ActiveView는 포커스를 가지고 있는 활성뷰의 번호이며 한번에 하나의 뷰만 활성화될 수 있다. 프레임이 뷰의 포인터를 멤버로 가지므로 CApiEditText 클래스를 전방 선언하였으며 뷰가 프레임의 모든 멤버를 자유롭게 액세스하기 위해 프렌드로 지정하였다.

호스트에서 옵션을 변경할 때 분할된 모든 뷰에 새 옵션을 적용해야 한다. 그러기 위해서는 외부에서 arView 배열을 참조할 수 있어야 하므로 arView와 관련 변수는 public 영역에 선언했다. 또한 이 차후 작성할 편집 정보 저장 기능을 구현하기 위해 분할 상태에 대한 정보를 호스트가 직접 다룰 필요가 있다. 취소 레코드인 pUR, URSize, nowur 등의 멤버도 마찬가지 이유로 public 영역으로 위치를 옮겼다.

멤버 변수들은 대폭 정리되었지만 멤버 함수들은 일부 몇가지를 제외하고 대부분 프레임에 남아 있다. 프레임이 사용자로부터 직접 입력을 받지는 않으므로 OnChar같은 메시지 처리 함수는 프레임에 남아 있을 필요가 없으며 글꼴을 다루지 않기 때문에 GetCharWidth같은 함수도 필요가 없다. InitDoc, Undo 같이 buf를 조작하는 함수들이 주로 프레임에 남아 있다.

프레임은 일부 몇가지를 제외하고 설정 변수들을 멤버로 가지지 않지만 대부분의 설정값 액세스 함수는 프레임에 그대로 남아 있어야 한다. 예를 들어 자동 개행 상태를 기억하는 nWrap 변수는 문서를 보여줄 방법을 지정하므로 프레임에 있을 필요가 없고 뷰에만 있으면 된다. 하지만 SetWrap/GetWrap 함수는 뷰의 멤버이면서 동시에 프레임의 멤버에도 속해야 한다.

왜냐하면 호스트의 입장에서는 프레임이 ApiEdit 컨트롤이기 때문에 자동 개행 상태를 바꿀 때 프레임의 SetWrap 함수를 호출하기 때문이다. 프레임의 SetWrap 함수는 모든 뷰의 SetWrap 함수를 다시 호출하는 중계역할을 할 뿐이며 자동 개행 상태가 바뀔 때의 추가 작업은 각 뷰의 SetWrap 함수가 할 것이다. 호스트에서 자동 개행 상태를 변경하면 다음 순서대로 함수가 호출된다.

프레임은 호스트의 자식이면서 동시에 뷰의 부모이다. 그래서 두 객체의 중간에서 통신을 담당해야 한다. 호스트가 보기에 ApiEdit는 하나의 컨트롤일 뿐이지 이 컨트롤이 뷰를 몇 개나 가지고 있는지, 어떤 뷰의 설정 상태를 바꿀 것인지에 대해서는 알 수도 없고 알 필요도 없다. 창분할 기능은 호스트와는 전혀 상관이 없는 컨트롤의 고유 기능이며 컨트롤이 스스로 제공하는 기능이기 때문이다. 사실 호스트는 뷰의 존재 자체를 모르며 그래서 arView 배열이 private 액세스 속성을 가지는 것이다.

추가된 멤버 함수로는 뷰를 생성, 파괴하는 CreateView, DeleteView와 활성 뷰를 구하는 GetActiveView가 있다. 이 함수의 코드는 SplitView예제의 경우와 거의 유사하며 잠시 후에 본체를 작성할 것이다.

ApiEdit.cpp는 이제 프레임의 모듈이 되므로 프레임에 관련된 함수만 정의해야 한다. 도우미에 대한 코드는 이 모듈에 계속 유지할 것이며 CApiEdit 프레임의 모든 멤버는 완전히 다시 작성한다. 일부 몇가지 함수를 제외하고는 함수의 의미가 바뀌므로 생성자 이후의 모든 멤버 함수들은 일단 삭제하자. 도우미 관련 코드는 앞에서 수정한대로 그대로 유지한다.

힘들게 작성한 대량의 코드를 삭제했는데 필요한 함수들은 다시 원래 ApiEdit.cpp에서 복사해 올 것이므로 걱정하지 않아도 된다. 당근 1.0으로 원래 ApiEdit.cpp를 열어 놓고 다음 작업을 진행하자. 먼저 생성자는 다음과 같이 작성한다.

CApiEdit::CApiEdit()

{

int i;

buf=NULL;

pUR=NULL;

bWantTab=TRUE;

UndoSize=100*1024;

UndoMin=100;

bUseLineEnd=TRUE;

bAllowDrag=TRUE;

bSpaceForTab=FALSE;

bAutoIndent=TRUE;

bBlockIndentWithTab=TRUE;

bHomeToFirstChar=TRUE;

bCalcTabWithAvg=TRUE;

nShowCurLine=0;

HideSelType=1;

MarColor1=RGB(192,192,192);

MarColor2=RGB(160,160,160);

NumColor=RGB(0,0,0);

MarkColor=RGB(255,255,0);

CodeColor=RGB(128,128,128);

CurColor=RGB(255,255,0);

cBack=GetSysColor(COLOR_WINDOW);

cFore=GetSysColor(COLOR_WINDOWTEXT);

cSelFore=GetSysColor(COLOR_HIGHLIGHTTEXT);

cSelBack=GetSysColor(COLOR_HIGHLIGHT);

CaretWidth=2;

bHideCurLine=TRUE;

ActiveView=0;

for (i=0;i<4;i++) {

arView[i]=NULL;

}

BOOL CApiEdit::Create(int x,int y,int w,int h,DWORD style,UINT id,HWND hParent)

{

CreateWindow("ApiEdit",NULL, style | WS_CLIPCHILDREN,

x,y,w,h,hParent,(HMENU)id,GetModuleHandle(NULL),this);

return TRUE;

}

문서와 관련된 멤버와 전역 설정 변수들을 초기화하며 뷰 배열을 모두 NULL로 만들어 최초 뷰 없이 프레임만 만든다. ActiveView는 0으로 초기화하여 첫 번째 뷰를 활성화시킨다. 원래 생성자에 있던 pLine, hBit, Parser에 대한 초기화 코드는 뷰와 관련된 것이므로 프레임의 생성자에서는 삭제된다. 파괴자는 CWindow로부터 상속받으므로 재정의할 필요가 없다.

Create 함수는 별로 변한 것이 없되 윈도우 스타일에 WS_CLIPCHILDREN 스타일이 추가되었다. 프레임의 작업 영역에는 뷰가 배치되므로 뷰가 차지하고 있는 영역은 그리기 영역에서 제외해야 한다. 그렇지 않으면 다시 그리기를 할 때마다 프레임과 뷰가 동시에 그려지므로 화면이 깜박거릴 것이다.

프레임도 윈도우이므로 메시지를 처리하는데 원래 CApiEdit가 메시지를 처리하는 방식과는 완전히 다르다. 프레임의 임무는 오로지 문서와 뷰를 관리하는 것뿐이므로 사용자로부터 명령을 받아들이지 않는다. 따라서 처리해야 할 메시지의 종류도 많지 않다. OnMessage 함수와 메시지 처리 함수를 다음과 같이 작성한다.

LRESULT CApiEdit::OnMessage(UINT iMessage,WPARAM wParam,LPARAM lParam)

{

switch(iMessage) {

HANDLE_MSG(hWnd, WM_CREATE, OnCreate);

HANDLE_MSG(hWnd, WM_DESTROY, OnDestroy);

HANDLE_MSG(hWnd, WM_PAINT, OnPaint);

HANDLE_MSG(hWnd, WM_SETFOCUS, OnSetFocus);

HANDLE_MSG(hWnd, WM_LBUTTONDOWN, OnLButtonDown);

HANDLE_MSG(hWnd, WM_LBUTTONDBLCLK, OnLButtonDown);

HANDLE_MSG(hWnd, WM_MOUSEMOVE, OnMouseMove);

HANDLE_MSG(hWnd, WM_LBUTTONUP, OnLButtonUp);

HANDLE_MSG(hWnd, WM_SIZE, OnSize);

HANDLE_MSG(hWnd, WM_COMMAND, OnCommand);

HANDLE_MSG(hWnd, WM_SETCURSOR, OnSetCursor);

}

return(DefWindowProc(hWnd,iMessage,wParam,lParam));

}

///////////////////////////////////////////////////////////////////////////////////

// 메시지 핸들러

BOOL CApiEdit::OnCreate(HWND hWnd, LPCREATESTRUCT lpCreateStruct)

{

InitDoc();

arView[0]=CreateView(TEXT_VIEW);

return TRUE;

}

void CApiEdit::OnDestroy(HWND hWnd)

{

int i;

for (i=0;i<4 && arView[i];i++) {

DeleteView(i);

}

free(buf);

if (pUR) {

for (i=0;;i++) {

if (pUR[i].action == UR_NONE)

break;

if (pUR[i].data)

free(pUR[i].data);

}

free(pUR);

}

void CApiEdit::OnSize(HWND hWnd, UINT state, int cx, int cy)

{

RECT crt;

if (state == SIZE_MINIMIZED) {

return;

}

GetClientRect(hWnd,&crt);

MoveWindow(arView[0]->hWnd,0,0,crt.right,crt.bottom,TRUE);

}

void CApiEdit::OnPaint(HWND hWnd)

{

HDC hdc;

PAINTSTRUCT ps;

hdc=BeginPaint(hWnd,&ps);

EndPaint(hWnd,&ps);

}

void CApiEdit::OnSetFocus(HWND hWnd, HWND hwndOldFocus)

{

if (ActiveView != -1)

SetFocus(GetActiveView()->hWnd);

}

void CApiEdit::OnLButtonDown(HWND hWnd, BOOL fDoubleClick, int x, int y, UINT keyFlags)

{

}

void CApiEdit::OnMouseMove(HWND hWnd, int x, int y, UINT keyFlags)

{

}

void CApiEdit::OnLButtonUp(HWND hWnd, int x, int y, UINT keyFlags)

{

}

void CApiEdit::OnCommand(HWND hWnd, int id, HWND hwndCtl, UINT codeNotify)

{

GetActiveView()->OnCommand(hWnd,id,hwndCtl,codeNotify);

}

BOOL CApiEdit::OnSetCursor(HWND hWnd, HWND hwndCursor, UINT codeHitTest, UINT msg)

{

return FORWARD_WM_SETCURSOR(hWnd,hwndCursor,codeHitTest,msg,DefWindowProc);

}

OnCreate에서는 InitDoc 함수를 호출하여 문서를 초기화하고 CreateView 함수를 호출하여 기본 뷰 하나를 만든다. OnSize에서는 기본 뷰를 프레임의 작업 영역에 가득 채우며 그래서 ApiEdit 컨트롤을 생성하면 기본 뷰 하나만 생성되어 사용자에게 보일 것이다. 여기까지의 초기화 결과를 보면 원래의 ApiEdit와 완전히 동일하다.

OnDestroy에서는 생성되어 있는 모든 뷰를 삭제하고 취소 레코드에 할당된 메모리를 해제한다. OnSetFocus에서는 활성 뷰로 포커스를 넘기되 단 활성뷰가 있을 때만 포커스를 넘긴다. 이 조건이 왜 필요한지는 잠시 후 알아볼 것이다. OnCommand는 호스트로부터 명령을 전달받아 그대로 활성뷰에게 넘기는 역할만 한다. OnPaint와 나머지 마우스 메시지 처리 함수들은 현재 아무 것도 하지 않고 있는데 창이 분할되면 분할창을 관리하는 코드가 작성될 것이다. OnSetCursor 함수도 디폴트 처리하며 실질적인 코드는 아직 없는 셈이다.

추가된 세 개의 멤버 함수를 다음과 같이 작성한다. 모두 뷰를 생성, 파괴하고 관리하는 함수들이다.

///////////////////////////////////////////////////////////////////////////////////

// 일반 함수들

CApiEditText *CApiEdit::GetActiveView()

{

return arView[ActiveView];

}

CApiEditText *CApiEdit::CreateView(int Type)

{

CApiEditText *pView;

switch (Type) {

case TEXT_VIEW:

pView=new CApiEditText;

break;

}

pView->pFrame=this;

pView->Create(0,0,0,0,WS_CHILD | WS_VISIBLE,0,hWnd);

return pView;

}

void CApiEdit::DeleteView(int nView)

{

if (ActiveView==nView) {

ActiveView=-1;

}

DestroyWindow(arView[nView]->hWnd);

delete arView[nView];

arView[nView]=NULL;

}

GetActiveView는 활성 뷰를 조사하는데 ActiveView에 활성 뷰의 첨자가 저장되어 있으므로 arView 배열에서 이 첨자의 뷰를 읽어 그 포인터를 리턴한다. 모든 편집 동작은 활성뷰에서 일어나므로 호스트나 프레임은 사용자로부터 전달되는 모든 편집 명령을 활성 뷰로 전달해야 한다. 따라서 편집 함수 호출은 모두 GetActiveView()->함수; 형태가 될 것이다.

CreateView 함수의 코드는 SplitView 함수와 거의 동일하므로 따로 분석할 필요가 없을 것이다. new 연산자로 요청된 뷰 객체를 생성하고 Create 함수를 호출하여 뷰 윈도우를 만들어 그 포인터만 리턴한다. 현재는 텍스트 뷰만 생성하지만 뷰 타입이 늘어나면 switch문의 case가 더 늘어나게 된다.

DeleteView 함수는 인수로 전달된 nView를 삭제하는데 앞에서 살펴봤다시피 파괴자에서 가상 함수를 제대로 찾지 못하기 때문에 DestroyWindow 함수로 윈도우를 먼저 파괴한 후 delete연산자로 객체를 파괴해야 한다. 객체를 파괴한 후 arView의 해당 뷰를 NULL로 만들어 이 뷰가 확실히 삭제되었음을 표시해 둔다. 여기까지는 SplitView 예제와 동일하되 다만 뷰를 삭제하기 전에 삭제되는 뷰가 활성뷰이면 ActiveView를 -1로 변경하여 임시적으로 활성뷰가 없는 상태로 만든다는 점이 조금 다르다.

이 처리가 필요한 이유는 파괴되기 직전의 뷰에게는 포커스를 주지 않기 위해서이다. 포커스를 가지고 있는 자식 윈도우가 파괴되면 부모 윈도우가 포커스를 받는데 프레임의 OnSetFocus는 활성 뷰에게 다시 포커스를 넘기도록 되어 있다. 그래서 이대로 아무 조치를 취하지 않고 DestroyWindow를 호출해 버리면 프레임은 죽어가는 자식에게 포커스를 넘기려고 할 것이며 자식은 죽어가는 마당에 포커스를 다시 받아 캐럿의 위치를 옮기려고 할 것이다. 하지만 뷰는 이미 자신이 동작하기 위한 데이터(정렬 정보)를 정리해 버렸기 때문에 캐럿의 위치를 찾다가 다운되고 만다.

활성뷰를 제거하기 전에 ActiveView에 -1을 대입하는 코드는 "이 녀석은 지금 열심히 죽고 있는 중임"이라는 표식을 남기는 것이고 프레임의 OnSetFocus는 뷰에게 포커스를 넘기기 전에 활성뷰가 제대로 살아 있는지를 먼저 확인한다. CApiEdit::OnSetFocus함수는 if (ActiveView != -1)이라는 조건을 점검함으로써 "음. 활성뷰가 꽥꼬닥 일보직전이군" 판단을 하고 포커스를 넘기지 않는다. DeleteView에서 뷰를 파괴하기 전에 ActiveView에 -1을 대입하는 코드는 어디까지나 임시적인 처리일 뿐이다. 따라서 DeleteView를 호출하는 모든 함수는 뷰를 삭제한 후 활성뷰를 정확하게 다시 찾아야 할 필요가 있다. ActiveView가 -1인 상태로 GetActiveView가 호출되도록 내버려 두어서는 안된다.

다음은 프레임의 멤버 함수를 수정한다. 원래 ApiEdit.cpp에서 코드를 복사해 온 후 약간만 손보면 된다. 객체가 분할됨으로써 조금씩 동작이 수정되어야 하는 함수들이며 다음 여섯 개가 있다. 먼저 문서를 관리하는 가장 핵심 함수인 Insert, Delete를 수정한다.

void CApiEdit::Insert(int nPos, TCHAR *str, BOOL bRec/*=TRUE*/)

{

int len;

int movelen;

int needlen;

if (bReadOnly)

return;

if (bRec) {

URInsert(nPos,str);

}

needlen=doclen+lstrlen(str)+1;

if (needlen > buflen) {

buflen = needlen+1024;

buf=(TCHAR *)realloc(buf,buflen);

if (buf == NULL) {

}

len=lstrlen(str);

if (len==0) return;

movelen=doclen-nPos+1;

memmove(buf+nPos+len,buf+nPos,movelen);

memcpy(buf+nPos,str,len);

SetModified(TRUE);

LastEditOff=nPos+len;

doclen+=len;

SendNotify(AEN_CHANGE);

}

void CApiEdit::Delete(int nPos, int nCount, BOOL bRec/*=TRUE*/)

{

int movelen;

TCHAR *p=buf+nPos;

TCHAR *t;

if (bReadOnly)

return;

if (nCount == 0) return;

if (doclen < nPos+nCount) return;

if (bRec) {

t=(TCHAR *)malloc(nCount+1);

lstrcpyn(t,p,nCount+1);

URDelete(nPos,t);

free(t);

}

movelen=doclen-nPos-nCount+1;

memmove(buf+nPos, buf+nPos+nCount, movelen);

SetModified(TRUE);

doclen-=nCount;

LastEditOff=nPos;

SendNotify(AEN_CHANGE);

}

읽기 전용 플래그 점검, 취소 레코드 관리, buf 관리 등 문서와 직접적인 상관이 있는 코드만 남았으며 삽입, 삭제에 따른 북마크 관리나 재정렬, 스크롤 정보 관리 등의 부가 작업은 뷰가 해야 한다. 뷰에도 동일한 이름의 함수가 있으며 뷰의 Insert, Delete에서 삽입, 삭제에 따른 부가 작업을 할 것이다. 이런 작업은 뷰마다 정책이 다를 수 있기 때문에 프레임이 직접 할 수 없는데 예를 들어 텍스트 뷰는 문서 내용이 바뀔 때마다 정렬을 다시 해야 하지만 헥사 뷰는 한 행의 바이트 수가 고정적이기 때문에 정렬할 필요가 없다.

사용자로부터 직접 키보드 입력을 받아들이는 주체는 뷰이다. 따라서 문자 입력이나 클립보드 조작이 있을 때 뷰의 Insert, Delete가 먼저 호출되며 이 함수에서 프레임의 Insert, Delete를 호출한 후 필요한 부가 작업을 한다. 취소 레코드를 관리하는 두 개의 함수와 문서 초기화 관련 함수도 다음과 같이 수정한다.

void CApiEdit::Undo()

{

int from, to, len, dest;

int tick;

CApiEditText *pView;

pView=GetActiveView();

if (pUR[nowur].action == UR_NONE || pUR[nowur].status==UR_CANCELED) {

nowur--;

}

pView->ClearSelection();

tick=pUR[nowur].tick;

for (;;) {

switch (pUR[nowur].action) {

case UR_INSERT:

pView->Delete(pUR[nowur].pos,lstrlen(pUR[nowur].data),FALSE);

pView->SetOffset(pUR[nowur].pos);

break;

case UR_DELETE:

pView->Insert(pUR[nowur].pos,pUR[nowur].data,FALSE);

pView->SetOffset(pUR[nowur].pos+lstrlen(pUR[nowur].data));

break;

case UR_MOVE:

from=pUR[nowur].pos;

to=pUR[nowur].dest[0];

len=pUR[nowur].dest[1];

if (from > to) {

dest=from+len;

pView->CopyString(FALSE,to,dest,len,FALSE);

} else {

pView->CopyString(FALSE,to-len,from,len,FALSE);

}

pView->SetOffset(from+len);

break;

}

pUR[nowur].status=UR_CANCELED;

if (tick==0 || nowur==0)

break;

if (tick!=pUR[nowur-1].tick)

break;

nowur--;

}

Invalidate(-1);

ArrangeModified();

}

void CApiEdit::Redo()

{

int from, to, len;

int tick;

CApiEditText *pView;

pView=GetActiveView();

pView->ClearSelection();

tick=pUR[nowur].tick;

for (;;) {

switch (pUR[nowur].action) {

case UR_INSERT:

pView->Insert(pUR[nowur].pos,pUR[nowur].data,FALSE);

pView->SetOffset(pUR[nowur].pos+lstrlen(pUR[nowur].data));

break;

case UR_DELETE:

pView->Delete(pUR[nowur].pos,lstrlen(pUR[nowur].data),FALSE);

pView->SetOffset(pUR[nowur].pos);

break;

case UR_MOVE:

from=pUR[nowur].pos;

to=pUR[nowur].dest[0];

len=pUR[nowur].dest[1];

pView->CopyString(FALSE,from,to,len,FALSE);

pView->SetOffset(to+len);

break;

}

pUR[nowur].status=UR_MAKING;

NextRecord();

if (tick==0)

break;

if (tick!=pUR[nowur].tick)

break;

}

Invalidate(-1);

ArrangeModified();

}

void CApiEdit::SetText(TCHAR *TextBuf, int dwSize)

{

TCHAR *dest;

InitDoc();

dwFormat=AnalyzeFormat(TextBuf, dwSize);

if (dwFormat != AE_FORMAT_WIN && dwFormat != AE_FORMAT_BINARY) {

ConvertFormat(dwFormat,AE_FORMAT_WIN,TextBuf,dest);

GetActiveView()->Insert(0,dest,FALSE);

free(dest);

} else {

GetActiveView()->Insert(0,TextBuf,FALSE);

}

void CApiEdit::InitDoc()

{

int i;

if (pUR) {

for (i=0;;i++) {

if (pUR[i].action == UR_NONE)

break;

if (pUR[i].data)

free(pUR[i].data);

}

free(pUR);

}

URSize=100;

pUR=(UndoRecord *)malloc(sizeof(UndoRecord)*URSize);

memset(pUR,0,sizeof(UndoRecord)*URSize);

nowur=0;

if (buf) {

free(buf);

}

buflen=1024;

buf=(TCHAR *)malloc(buflen);

memset(buf,0,buflen);

doclen=0;

bReadOnly=FALSE;

LastEditOff=0;

bModified=FALSE;

SaveModified();

URtick=0;

URnest=0;

dwFormat=AE_FORMAT_WIN;

ForAllView(InitView())

}

취소 레코드를 프레임이 가지고 있으므로 Undo, Redo 처리도 프레임이 하되 취소, 재실행 후 활성뷰에도 문서 변경 사실을 반영해야 한다. 그래서 Insert, Delete 함수는 프레임의 함수를 부르지 않고 뷰의 함수를 부른다. 뷰의 Insert, Delete는 프레임의 Insert, Delete를 호출할 뿐만 아니라 형제 뷰의 갱신까지도 같이 처리한다. 문서를 변경할 때는 항상 뷰의 Insert, Delete를 통해야 하며 SetText 함수도 문서를 읽은 후 뷰의 Insert 함수를 호출하도록 했다.

문서를 초기화하는 InitDoc 함수에는 off, pLine 등 뷰에 속하는 멤버들에 대한 초기화 코드가 삭제되었으며 버퍼, 취소 레코드 등 프레임의 멤버만 초기화한다. 뷰에 속한 멤버는 뷰가 스스로 초기화하므로 InitDoc은 오로지 문서와 관련된 멤버만 초기화하였다. 대신 프레임이 초기화될 때 각 뷰의 InitView를 호출함으로써 프레임에 연결된 모든 뷰도 초기화할 수 있도록 해야 한다. 문서가 초기화되면 이 문서를 보여주는 뷰들도 당연히 초기화해야 한다.

다음 멤버 함수는 원래 ApiEdit.cpp에 있던 함수의 코드와 완전히 동일하므로 그대로 다시 복사해 오면 된다. 이 함수들은 소스 파일에 연속적으로 붙어 있기 때문에 복사하기도 쉬울 것이다.

IsDBCS, GetPrevOff, GetNextOff(3개)

FindParaStart, IncludeEnter

LoadAeResource, UnLoadAeResource, SetModified

GetText,GetTextLength,SetReadOnly

CanUndo~ URMove(7개)

SetUndoSize~EndUndoGroup(6개)

SendNotify

SetFormat, AnalyzeFormat, ConvertFormat

IsDBCS 함수는 inline 속성을 해제한다. 커서와 폰트를 생성하는 정적 함수들의 내용은 뷰와는 아무런 상관이 없으므로 기존 코드를 그대로 쓸 수 있다. 취소 레코드를 관리하는 함수들도 Undo, Redo만 제외하고 대부분 그대로 쓸 수 있으며 포맷 관련 함수의 코드도 동일하다. 보다시피 이 함수들은 보기 모드와는 아무런 상관이 없는 것들이다.

그외의 멤버 함수들은 원래 ApiEdit.cpp에 있던 코드와는 완전히 다르므로 다시 작성해야 한다. 주로 설정값들을 다루는 함수들이며 호스트와 뷰 사이를 중계하는 역할만 하므로 코드의 길이가 아주 짧고 형식이 거의 유사하다.

int CApiEdit::GetWrap()

{

return GetActiveView()->GetWrap();

}

void CApiEdit::SetWrap(int aWrap)

{

ForAllView(SetWrap(aWrap))

}

void CApiEdit::Invalidate(int Pos1, int Pos2/*=-1*/)

{

ForAllView(Invalidate(Pos1,Pos2))

}

void CApiEdit::ClearBookmark()

{

ForAllView(ClearBookmark())

}

void CApiEdit::ToggleBookmark(int Para, int Mark)

{

GetActiveView()->ToggleBookmark(Para,Mark);

}

void CApiEdit::GotoBookmark(int Mark)

{

GetActiveView()->GotoBookmark(Mark);

}

void CApiEdit::GotoLine(int Line, int Col/*=0*/, int Type/*=0*/)

{

GetActiveView()->GotoLine(Line,Col,Type);

}

void CApiEdit::GetSelect(int &s, int &e)

{

GetActiveView()->GetSelect(s,e);

}

void CApiEdit::SetSelect(int s, int e, BOOL bFind)

{

GetActiveView()->SetSelect(s,e,bFind);

}

BOOL CApiEdit::GetShowState(int nIndex)

{

return GetActiveView()->GetShowState(nIndex);

}

void CApiEdit::SetShowState(int nIndex, BOOL aValue)

{

ForAllView(SetShowState(nIndex,aValue))

}

int CApiEdit::GetLineRatio()

{

return GetActiveView()->GetLineRatio();

}

void CApiEdit::SetLineRatio(int aLineHeight)

{

ForAllView(SetLineRatio(aLineHeight))

}

void CApiEdit::SetShowCurLine(int aShowCurLine)

{

nShowCurLine=aShowCurLine;

ForAllView(Invalidate(-1))

}

int CApiEdit::GetTabWidth()

{

return GetActiveView()->GetTabWidth();

}

void CApiEdit::SetTabWidth(int aTabWidth)

{

ForAllView(SetTabWidth(aTabWidth))

}

void CApiEdit::SetHideSelType(int aHideSelType)

{

HideSelType=aHideSelType;

ForAllView(Invalidate(-1))

}

void CApiEdit::GetFont(LOGFONT *alogfont)

{

GetActiveView()->GetFont(alogfont);

}

void CApiEdit::SetFont(LOGFONT *alogfont)

{

ForAllView(SetFont(alogfont))

}

void CApiEdit::SetForeColor(COLORREF acol)

{

if (acol==-1) {

cFore=GetSysColor(COLOR_WINDOWTEXT);

} else {

cFore=acol;

}

ForAllView(Invalidate(-1))

}

void CApiEdit::SetBackColor(COLORREF acol)

{

if (acol==-1) {

cBack=GetSysColor(COLOR_WINDOW);

} else {

cBack=acol;

}

ForAllView(Invalidate(-1))

}

void CApiEdit::SetSelForeColor(COLORREF acol)

{

if (acol==-1) {

cSelFore=GetSysColor(COLOR_HIGHLIGHTTEXT);

} else {

cSelFore=acol;

}

ForAllView(Invalidate(-1))

}

void CApiEdit::SetSelBackColor(COLORREF acol)

{

if (acol==-1) {

cSelBack=GetSysColor(COLOR_HIGHLIGHT);

} else {

cSelBack=acol;

}

ForAllView(Invalidate(-1))

}

BOOL CApiEdit::GetNoFirstSpace()

{

return GetActiveView()->GetNoFirstSpace();

}

void CApiEdit::SetNoFirstSpace(BOOL aNoFirstSpace)

{

ForAllView(SetNoFirstSpace(aNoFirstSpace))

}

int CApiEdit::GetShowTabType()

{

return GetActiveView()->GetShowTabType();

}

void CApiEdit::SetShowTabType(int aShowTabType)

{

ForAllView(SetShowTabType(aShowTabType))

}

int CApiEdit::GetShowEnterType()

{

return GetActiveView()->GetShowEnterType();

}

void CApiEdit::SetShowEnterType(int aShowEnterType)

{

ForAllView(SetShowEnterType(aShowEnterType))

}

int CApiEdit::GetShowSpaceType()

{

return GetActiveView()->GetShowSpaceType();

}

void CApiEdit::SetShowSpaceType(int aShowSpaceType)

{

ForAllView(SetShowSpaceType(aShowSpaceType))

}

void CApiEdit::SetMarColor1(COLORREF acol)

{

MarColor1=acol;

ForAllView(Invalidate(-1))

}

void CApiEdit::SetMarColor2(COLORREF acol)

{

MarColor2=acol;

ForAllView(Invalidate(-1))

}

void CApiEdit::SetMarkColor(COLORREF acol)

{

MarkColor=acol;

ForAllView(Invalidate(-1))

}

void CApiEdit::SetCodeColor(COLORREF acol)

{

CodeColor=acol;

ForAllView(Invalidate(-1))

}

void CApiEdit::SetCurColor(COLORREF acol)

{

CurColor=acol;

ForAllView(Invalidate(-1))

}

void CApiEdit::SetNumColor(COLORREF acol)

{

NumColor=acol;

ForAllView(Invalidate(-1))

}

void CApiEdit::SetCaretWidth(int aCaretWidth)

{

CaretWidth=aCaretWidth;

ForAllView(SetCaret())

}

void CApiEdit::SetHideCurLine(BOOL aHideCurLine)

{

bHideCurLine=aHideCurLine;

ForAllView(Invalidate(-1))

}

void CApiEdit::SetCalcTabWithAvg(int aCalcTabWithAvg)

{

bCalcTabWithAvg=aCalcTabWithAvg;

ForAllView(SetTabWidth(arView[aet]->GetTabWidth()))

}

int CApiEdit::GetRightWrap()

{

return GetActiveView()->GetRightWrap();

}

void CApiEdit::SetRightWrap(int aRightWrap)

{

ForAllView(SetRightWrap(aRightWrap))

}

int CApiEdit::GetColMark()

{

return GetActiveView()->GetColMark();

}

void CApiEdit::SetColMark(int aColMark)

{

ForAllView(SetColMark(aColMark))

}

CParse* CApiEdit::GetParser()

{

return GetActiveView()->GetParser();

}

void CApiEdit::SetParser(int ParseType)

{

ForAllView(SetParser(ParseType))

}

BOOL CApiEdit::FindText(int nPos, TCHAR *what, DWORD dwFlag)

{

return GetActiveView()->FindText(nPos,what,dwFlag);

}

int CApiEdit::ReplaceText(int nPos, TCHAR *what, DWORD dwFlag, TCHAR *to)

{

return GetActiveView()->ReplaceText(nPos,what,dwFlag,to);

}

int CApiEdit::GetOffset()

{

return GetActiveView()->GetOffset();

}

void CApiEdit::GetSelRect(RECT &srt)

{

GetActiveView()->GetSelRect(srt);

}

int CApiEdit::GetInfoFromOff(int Type, int nPos/*=-1*/)

{

return GetActiveView()->GetInfoFromOff(Type,nPos);

}

void CApiEdit::GotoLastEditOff()

{

GetActiveView()->GotoLastEditOff();

}

int CApiEdit::GetDocInfo(int type)

{

return GetActiveView()->GetDocInfo(type);

}

BOOL CApiEdit::GetInsMode()

{

return GetActiveView()->GetInsMode();

}

int CApiEdit::GetOffFromPara(int pr, int pc)

{

return GetActiveView()->GetOffFromPara(pr,pc);

}

void CApiEdit::BeginPrint(Ae_PrintInfo *pi)

{

GetActiveView()->BeginPrint(pi);

}

BOOL CApiEdit::PrintPage(Ae_PrintInfo *pi,int nPage)

{

return GetActiveView()->PrintPage(pi,nPage);

}

void CApiEdit::EndPrint(Ae_PrintInfo *pi)

{

GetActiveView()->EndPrint(pi);

}

함수의 개수가 많기는 하지만 방식은 거의 비슷하므로 대표적으로 GetWrap, SetWrap 함수의 코드만 구경해 보자. GetWrap 함수는 활성뷰의 자동 개행 상태를 리턴한다. nWrap 멤버는 뷰에 소속되는데 이 값을 어떻게 사용할 것인지는 뷰마다 다를 수 있다. 텍스트 뷰에서는 이 값에 따라 자동 개행 방식을 변경하지만 헥사 뷰에서는 자동 개행이라는 개념 자체가 없다. 어쨋든 GetWrap은 활성 뷰가 유지하고 있는 값을 조사한다. SetWrap은 모든 뷰에 대해 SetWrap 함수를 호출하는데 각 뷰가 이 함수 호출을 어떻게 처리할 것인가도 뷰마다 다르다. 텍스트 뷰는 자동 개행을 하므로 재정렬, 스크롤 바 관리 등을 하겠지만 헥사 뷰는 이 값을 사용하지 않으며 단순히 대입해 놓기만 할 것이다.

프레임의 Get/Set 함수들은 대체로 이런 식으로 작성되어 있다. Get할 때는 활성 뷰의 값을 조사하고 Set할 때는 모든 뷰의 상태를 변경한다. 물론 예외도 있다. SetSelect는 모든 뷰의 선택 영역을 바꾸는 것이 아니고 활성 뷰의 선택영역만 바꾼다. 색상 옵션을 변경하는 함수들은 값 변경 후 모든 뷰를 다시 그린다. 전에는 조건을 점검하여 해당 뷰가 그 옵션의 영향을 받을 때만 다시 그렸으나 이제는 무조건 그린다. 예를 들어 SetMarColor1 함수는 마진 색상을 변경하되 마진이 보일 때만 다시 그렸다. 각 뷰의 상태를 일일이 점검하기가 귀찮기 때문에 이런 조건 점검을 생략했다. 옵션을 자주 바꾸는 것이 아니므로 화면 처리상의 큰 문제는 없고 오히려 코드가 더 짧아지는 효과가 있다.

FindText나 PrintPage 등의 함수도 뷰의 특성에 따라 검색 및 인쇄 방법이 달라지므로 호스트로부터 함수 호출을 받아 뷰로 전달하는 역할만 하고 있다.

라. 텍스트 뷰 작성

프레임을 만들었으니 다음은 뷰를 만들 차례다. 앞에서 이미 했던 실습을 한번 더 반복하고 있는데 실습 과정이 비록 단순하지만 잔손이 많이 가기 때문에 무척 지루하다. SplitView 예제에서 객체를 분할하는 방법을 완벽하게 이해했다면 이 지겨운 실습을 굳이 따라해 볼 필요는 없다. 물론 같이 해 보면 좋기는 하겠지만 시간이 많이 들고 귀찮은 면이 있으므로 하기 싫은 사람은 실습을 생략해도 좋다. 하지만 어떤 과정을 거쳐 뷰가 만들어지는지 실습 과정은 눈여겨 봐 두기 바란다.

프레임은 뷰를 감싸는 껍데기에 불과하고 실제 텍스트 편집은 뷰가 하므로 원래 ApiEdit에 있던 대부분의 편집 코드들이 뷰에 다시 작성될 것이다. 키보드로 문자열을 입력받기, 화면에 문서 내용 출력하기, 마우스로 선택하기 등이 모두 뷰의 기능들이다. 다음 절차를 따라 실습을 진행하거나 아니면 실습 과정을 읽어 보기라도 하자.

앞장에서 이미 추가해 놓은 ApiEditText.h에 뷰 클래스를 선언한다. 이 클래스가 ApiEdit 컨트롤의 기본 뷰이다. 원래 CApiEdit 클래스의 멤버들 대부분을 가지지만 일부 제외된 것도 있고 필요에 따라 새로 추가된 것도 있다.

#ifndef __APIEDITTEXT_H

#define __APIEDITTEXT_H

class CApiEditText : public CWindow

{

friend class CApiEdit;

friend class CParse;

friend class CParseCpp;

friend class CParseNull;

friend class CParseHtml;

friend class CParseSql;

protected:

BOOL bComp;

int off;

int FontHeight;

int LineRatio;

int LineHeight;

int nWrap;

BOOL bNoFirstSpace;

int PrevX;

BOOL bLineEnd;

int yPos,xPos;

int yMax,xMax;

int FontWidth;

int TabWidth;

int TabSize;

int SelStart, SelEnd;

BOOL bCapture;

int arChWidth[128];

BYTE *arHanWidth;

tagLine *pLine;

int TotalLine;

HBITMAP hBit;

int MarginWidth;

RECT frt;

BOOL bShowLineNum;

int arMark[MAXBOOKMARK];

BOOL bShowTab;

BOOL bShowEnter;

BOOL bShowSpace;

int ShowTabType;

int ShowEnterType;

int ShowSpaceType;

BOOL bSelLine;

int SelStartLine;

BOOL bDragSel;

BOOL bOvr;

int Linelen;

int SumDelta;

BOOL bHideCaret;

LOGFONT logfont;

int RightWrap;

int ColMark;

BOOL bPrevCompoGroup;

CParse *Parser;

BOOL bFindSelect;

HFONT hMainFont;

public:

CApiEditText();

CApiEdit *pFrame;

int ViewType;

BOOL Create(int x,int y,int w,int h,DWORD style,UINT id,HWND hParent);

LRESULT OnMessage(UINT iMessage,WPARAM wParam,LPARAM lParam);

BOOL OnCreate(HWND hWnd, LPCREATESTRUCT lpCreateStruct);

void OnChar(HWND hWnd, TCHAR ch, int cRepeat);

void OnKey(HWND hWnd, UINT vk, BOOL fDown, int cRepeat, UINT flags);

void OnPaint(HWND hWnd);

void OnSetFocus(HWND hWnd, HWND hwndOldFocus);

void OnKillFocus(HWND hWnd, HWND hwndNewFocus);

void OnDestroy(HWND hWnd);

LRESULT OnImeComposition(HWND hWnd, WPARAM wParam, LPARAM lParam);

LRESULT OnImeChar(HWND hWnd, WPARAM wParam, LPARAM lParam);

void OnLButtonDown(HWND hWnd, BOOL fDoubleClick, int x, int y, UINT keyFlags);

void OnMouseMove(HWND hWnd, int x, int y, UINT keyFlags);

void OnLButtonUp(HWND hWnd, int x, int y, UINT keyFlags);

void OnTimer(HWND hWnd, UINT id);

void OnSize(HWND hWnd, UINT state, int cx, int cy);

void OnHScroll(HWND hWnd, HWND hwndCtl, UINT code, int pos);

void OnVScroll(HWND hWnd, HWND hwndCtl, UINT code, int pos);

void OnContextMenu(HWND hWnd, HWND hwndContext, UINT xPos, UINT yPos);

virtual void OnCommand(HWND hWnd, int id, HWND hwndCtl, UINT codeNotify);

BOOL OnSetCursor(HWND hWnd, HWND hwndCursor, UINT codeHitTest, UINT msg);

UINT OnGetDlgCode(HWND hWnd, LPMSG lpmsg);

void OnMouseWheel(HWND hWnd, WPARAM wParam, LPARAM lParam);

virtual int GetCharWidth(TCHAR *ch, int len);

virtual void SetCaret(BOOL bUpdatePrevX=TRUE, BOOL bScrollToCaret=TRUE);

virtual void Insert(int nPos, TCHAR *str, BOOL bRec=TRUE);

virtual void Delete(int nPos, int nCount, BOOL bRec=TRUE);

virtual void GetLine(int Line, int &s, int &e);

virtual int GetRowCount();

virtual void GetRCFromOff(int nPos, int &r, int &c);

virtual int GetOffFromRC(int r, int c);

virtual void GetXYFromOff(int nPos, int &x, int &y);

virtual void SetWrap(int aWrap);

virtual int GetXPosOnLine(int r,int DestX);

virtual void UpdateScrollInfo();

virtual int DrawLine(HDC hdc, int Line);

virtual void DrawSegment(HDC hdc, int &x, int y, int SegOff, int len, BOOL ignoreX,

COLORREF fore, COLORREF back);

virtual int GetOffFromXY(int x, int y);

virtual BOOL IsDelimiter(int nPos);

virtual int GetPrevWord(int nPos);

virtual int GetNextWord(int nPos);

virtual void ClearSelection();

virtual void ExpandSelection(int Start, int End);

virtual BOOL DeleteSelection();

virtual void PrepareCharWidth(HDC hdc);

virtual int MyGetTextExtent(TCHAR *text, int len);

virtual void UpdateLineInfo(int nPos=-1, int nCount=-1);

virtual void Invalidate(int Pos1, int Pos2=-1);

virtual void ClearBookmark();

virtual void ToggleBookmark(int Para, int Mark);

virtual void GotoBookmark(int Mark);

virtual void GotoLine(int Line, int Col=0, int Type=0);

virtual int FindBookmark(int Para);

virtual void DisplayTab(HDC hdc, int x1, int x2, int y,COLORREF back);

virtual void DisplayEnter(HDC hdc, int x, int y,COLORREF back);

virtual void DisplaySpace(HDC hdc, int x, int y, TCHAR *text, int len);

virtual void GetNowWord(int nPos, int &s, int &e);

virtual BOOL IsInSelection(int x,int y);

virtual void CopyString(BOOL bCopy, int from, int &to, int len, BOOL bRec=TRUE);

virtual void GetSelect(int &s, int &e);

virtual void SetSelect(int s, int e, BOOL bFind);

virtual BOOL GetShowState(int nIndex);

virtual void SetShowState(int nIndex, BOOL aValue);

virtual int GetLineRatio() { return LineRatio; }

virtual void SetLineRatio(int aLineHeight);

virtual int GetWrap() { return nWrap; }

virtual int GetTabWidth() { return TabWidth; }

virtual void SetTabWidth(int aTabWidth);

virtual void GetFont(LOGFONT *alogfont);

virtual void SetFont(LOGFONT *alogfont);

virtual BOOL GetNoFirstSpace() { return bNoFirstSpace; }

virtual void SetNoFirstSpace(BOOL aNoFirstSpace);

virtual int GetShowTabType() { return ShowTabType; }

virtual void SetShowTabType(int aShowTabType);

virtual int GetShowEnterType() { return ShowEnterType; }

virtual void SetShowEnterType(int aShowEnterType);

virtual int GetShowSpaceType() { return ShowSpaceType; }

virtual void SetShowSpaceType(int aShowSpaceType);

virtual void SetDefaultSetting();

virtual int GetRightWrap() { return RightWrap; }

virtual void SetRightWrap(int aRightWrap);

virtual int GetColMark() { return ColMark; }

virtual void SetColMark(int aColMark);

virtual CParse* GetParser() { return Parser; }

virtual void SetParser(int ParseType);

virtual BOOL FindText(int nPos, TCHAR *what, DWORD dwFlag);

virtual int ReplaceText(int nPos, TCHAR *what, DWORD dwFlag, TCHAR *to);

virtual int GetOffset() { return off; }

virtual void GetSelRect(RECT &srt);

virtual int GetInfoFromOff(int Type, int nPos=-1);

virtual void FindParen(BOOL bSelect);

virtual void GotoLastEditOff();

virtual int GetDocInfo(int type);

virtual BOOL GetInsMode() { return bOvr; }

virtual void ChangeCase(int action);

virtual void ConvertSpaceTab(BOOL bToSpace);

virtual void RemoveExtraSpace();

virtual void GetParaFromOff(int nPos, int &pr, int &pc);

virtual int GetOffFromPara(int pr, int pc);

virtual int GetParaFirstLine(int nPara);

virtual int GetParaLastLine(int nPara);

virtual void ProcessIndent(TCHAR ch);

virtual BOOL IsParaEmpty(TCHAR *p);

virtual int GetPrevPara(int nPos);

virtual int GetIndentLevel(TCHAR *p);

virtual void GetIndentString(int nPara,TCHAR *szIndent,int len);

virtual void MakeIndentString(int nTab, TCHAR *str, int len);

virtual BOOL IsPrevParaBlockOpen(int nPos);

virtual void BlockIndent(BOOL bUnindent);

virtual void InsertComment(BOOL bUnComment);

virtual void InsertText(TCHAR *Text);

virtual void CopyChar(int dir);

virtual void BeginPrint(Ae_PrintInfo *pi);

virtual BOOL PrintPage(Ae_PrintInfo *pi,int nPage);

virtual void EndPrint(Ae_PrintInfo *pi);

virtual void GetLine(int Line, int &s, int &e,Ae_PrintInfo *pi);

virtual void InitView();

virtual void SetOffset(int aoff);

};

#endif // __APIEDITTEXT_H

프레임에서 뷰의 멤버를 마음대로 액세스할 수 있도록 프랜드로 선언했다. 뷰는 프레임의 프랜드이고 프레임은 뷰의 프랜드이므로 상호 서로의 멤버를 제약없이 읽고 쓸 수 있다. 모든 멤버 변수의 액세스 지정을 protected로 변경했는데 다른 타입의 뷰에서도 기본 뷰의 모든 멤버를 액세스할 수 있어야 하기 때문이다. 이후 추가되는 뷰 클래스들은 모두 이 클래스로부터 파생될 것이다.

buf, doclen 등 문서와 상관있는 변수들은 멤버에서 삭제되었으며 CWindow로부터 상속받았으므로 hWnd윈도우 핸들은 따로 가질 필요가 없다. 추가된 것도 몇가지 있는데 pFrame은 자신과 연결된 프레임의 포인터를 가리킨다. 프레임의 CreateView 함수에서 뷰를 생성할 때 pFrame에 자신의 포인터를 대입하므로 뷰는 pFrame으로부터 프레임의 모든 멤버를 자유롭게 참조할 수 있다. 예를 들어 프레임의 버퍼를 읽고 싶으면 pFrame->buf로 읽으면 된다. ViewType은 뷰의 타입을 기억하는데 텍스트 뷰는 0번(TEXT_VIEW)값을 가진다.

여기까지 만들어진 클래스의 계층도는 CWindow를 루트로 하고 그 파생 클래스로 CApiEdit와 CApiEditText를 정의한다. 텍스트 뷰외에 다른 뷰를 추가로 만든다면 다음과 같은 계층을 이룰 것이다.

추가되는 뷰들은 기본 뷰인 CApiEditText를 상속받아 만들어진다. 따라서 텍스트 편집 뷰와 동일하게 처리할 수 있는 코드는 모두 상속받으며 다르게 동작하는 부분은 재정의될 것이다. 이런 방법외에 CWindow로부터 뷰의 일반적인 속성을 가지는 CView를 파생시키고 CView로부터 여러 가지 뷰를 다시 상속하는 방법을 생각해 볼 수 있다. 일반적인 뷰를 정의하기 위한 단계를 가지게 됨으로써 프레임은 CView의 포인터로 모든 뷰를 일괄 관리할 수 있다는 이점이 있고 이것이 훨씬 더 좋은 디자인이다.

그러나 이 예제에서 그렇게 하지 않은 이유는 CView에 너무 많은 빈 함수들이 작성되어야 하기 때문이다. 뷰간에 차이점이 거의 없다면 뷰의 루트 클래스를 선언하고 루트와 다른 부분만 부분적으로 재정의하면 되지만 차이점이 많아지면 대부분을 재정의해야 하기 때문에 오히려 비효율적이다. 또한 CView가 일반적인 뷰의 특성을 가지기 위해서는 기존의 멤버 함수를 조금씩 수정해야 하고 실습 과정이 번거로와지는 문제도 있다. 원래 CApiEdit에 작성되어 있던 코드를 최대한 수정없이 재활용하기 위해서 저런 구조가 나왔다.

프레임은 자신에게 연결된 뷰의 포인터를 배열로 관리하며 뷰의 함수를 부를 때는 arView[n]->멤버함수; 호출문을 사용한다. 포인터로부터 멤버 함수를 호출하기 때문에 뷰의 멤버 함수들은 대부분 가상 함수가 되어야 한다. 사실 전부 다 가상 함수로 만들 필요는 없고 외부에서 포인터로부터 호출되는 함수만 가상 함수로 만들면 되나 이것을 구분하기가 너무 귀찮아 전부 가상 함수로 선언했다. vtable이 조금 커질뿐 성능상의 별 차이는 없으므로 차후에 최적화 과정에서 일부 함수를 다시 비가상으로 만들 것이다.

ApiEditText.cpp에 이 클래스의 코드를 작성한다. 먼저 표준 헤더 파일을 포함시키기 위해 stdafx.h를 인클루드한다. 주석으로 처리된 #include도 당장은 필요없지만 컴파일된 헤더를 쓰지 않는 프로젝트를 위해 미리 포함시켜 두는 것이 좋다.

//#define _WIN32_WINNT 0x400

//#define _WIN32_WINDOWS 0x401

//#include <windows.h>

//#include <windowsx.h>

//#include <imm.h>

//#include <stdio.h>

//#include <io.h>

//#include <malloc.h>

//#include <commctrl.h>

//#include <Shlwapi.h>

//#include <Shlobj.h>

//#include <wininet.h>

//#include <stdio.h>

//#include "Parse.h"

//#include "AeUtil.h"

//#include "ApiEdit.h"

//#include "ApiEditText.h"

#include "stdafx.h"

멤버 함수들의 코드는 대부분 원래 ApiEdit의 코드와 같기 때문에 일단 원래의 ApiEdit.cpp를 복사해온 후 수정하는 것이 좋다. Danguen13의 ApiEdit.cpp에서 생성자 이후를 모두 이 파일로 복사해 온다. 도우미나 ApiEditProc 따위는 프레임에 있으므로 가져올 필요가 없다.

뷰에 속하지 않는 멤버 함수들을 삭제한다. 다음이 삭제 대상 함수들이며 공유 리소스를 관리하는 정적 함수이거나 문서, 취소 레코드를 다루는 함수들이다. 이 함수들은 프레임에만 있으며 뷰에게는 필요가 없다는 것을 직관적으로 이해할 수 있을 것이다.

파괴자(~ApiEdit)

IsDBCS, GetPrevOff, GetNextOff(3개)

FindParaStart, IncludeEnter

LoadAeResource~ SetReadOnly(8개)

SetUseLineEnd, SetAllowDrag

CanUndo~ EndUndoGroup(16개)

SendNotify

SetFormat, AnalyzeFormat, ConvertFormat

SetShowCurLine, SetHideSelType

SetForeColor~SetSelBackColor(4개)

SetMarColor1~SetNumColor(6개)

SetCaretWidth~SetCalcTabWidthAvg(3개)

원래 ApiEdit.cpp에 이 순서대로 연속적으로 작성되어 있으므로 순서대로 검색하면서 삭제하면 된다. 사실 헤더 파일에 인라인으로 선언되어 있던 함수까지 포함해서 이보다 훨씬 더 많은 함수들이 삭제되었다. 남은 함수들은 이제 모두 텍스트 뷰에 소속되므로 CApiEdit::을 CApiEditText::으로 일괄 변경한다. 비주얼 스튜디오 편집기의 일괄 치환 기능을 사용하면 한꺼번에 문자열을 변경할 수 있다.

남아 있는 함수들은 뷰에 맞게 수정해야 하는데 먼저 초기화 관련 함수부터 수정해 보자. 생성자와 Create 함수는 다음과 같이 수정한다.

CApiEditText::CApiEditText()

{

arHanWidth=NULL;

pLine=NULL;

hBit=NULL;

Parser=NULL;

bFindSelect=FALSE;

ViewType=TEXT_VIEW;

}

BOOL CApiEditText::Create(int x,int y,int w,int h,DWORD style,UINT id,HWND hParent)

{

CreateWindow("ApiEditText",NULL, style | WS_CLIPCHILDREN,

x,y,w,h,hParent,(HMENU)id,GetModuleHandle(NULL),this);

return TRUE;

}

buf와 pUR등 프레임의 멤버에 대한 초기화가 빠지는 대신 ViewType을 TEXT_VIEW로 초기화하여 0번 타입의 뷰임을 스스로 기억하도록 하였다. Create 함수는 ApiEditText 윈도우 클래스로 텍스트 뷰를 생성한다. 창 분할 기능을 위해 스크롤 바 컨트롤을 사용할 예정인데 뷰가 차일드 컨트롤의 영역을 그리지 않도록 WS_CLIPCHILDREN 스타일을 주었다. OnCreate와 OnDestroy는 다음처럼 수정된다.

BOOL CApiEditText::OnCreate(HWND hWnd, LPCREATESTRUCT lpCreateStruct)

{

bComp=FALSE;

bCapture=FALSE;

bSelLine=FALSE;

SelStartLine=0;

bDragSel=FALSE;

SumDelta=0;

bHideCaret=FALSE;

SetDefaultSetting();

InitView();

return TRUE;

}

void CApiEditText::OnDestroy(HWND hWnd)

{

free(arHanWidth);

free(pLine);

if (hBit) {

DeleteObject(hBit);

hBit=NULL;

}

SetParser(-1);

if (hMainFont) {

DeleteObject(hMainFont);

}

뷰의 주요 플래그들이 초기화되며 InitDoc 대신 InitView 함수를 호출하여 뷰를 초기화한다. 뷰가 파괴될 때는 글꼴 정보, 더블 버퍼링 비트맵 등을 제거하고 분석기를 분리한다. 취소 레코드는 더 이상 뷰의 멤버가 아니므로 OnDestroy에서 해제할 필요가 없다.

새로 추가된 두 개의 멤버 함수를 작성한다.

void CApiEditText::InitView()

{

int i;

Parser->InitInfo(TRUE);

Linelen=100;

if (pLine) {

free(pLine);

}

pLine=(tagLine *)malloc(sizeof(tagLine)*Linelen);

for (i=0;i<Linelen;i++) {

pLine[i].Start=-1;

}

bOvr=FALSE;

off=0;

PrevX=0;

bLineEnd=FALSE;

xMax=1024;

xPos=0;

yPos=0;

SelStart=SelEnd=0;

ClearBookmark();

UpdateLineInfo();

UpdateScrollInfo();

if (GetFocus()==hWnd) {

SetCaret();

}

bPrevCompoGroup=FALSE;

Invalidate(-1);

}

void CApiEditText::SetOffset(int aoff)

{

off=aoff;

SetCaret();

}

InitView 함수에는 원래 InitDoc에 있는 코드 중 문서와 직접 관련이 없고 보기 상태와 관련있는 변수들에 대한 초기화 코드가 작성되어 있다. 생성자나 OnCreate에서의 초기화와는 달리 이 함수의 초기화는 일회적이지 않으며 뷰가 다른 용도로 사용될 때마다 필요한 것들이다. SetOffset 함수는 오프셋을 변경하고 캐럿을 옮기는데 프레임의 Undo, Redo를 지원하기 위해 필요하다. 프레임은 취소, 재실행시 뷰의 SetOffset 함수를 호출하여 뷰의 편집 위치를 직접 옮긴다.

Insert, Delete 함수를 수정한다. 이 함수는 특이하게도 프레임에도 있고 뷰에도 있는데 문서가 편집될 때 buf의 내용이 변함은 물론이고 뷰에서도 재정렬, 북마크 관리, 스크롤 정보 갱신 등의 작업을 해야 하기 때문이다.

void CApiEditText::Insert(int nPos, TCHAR *str, BOOL bRec/*=TRUE*/)

{

int nCrLf=0,i;

int r,c;

int nowPara;

TCHAR *p=str;

if (bReadOnly)

return;

pFrame->Insert(nPos,str,bRec);

bLineEnd=FALSE;

UpdateLineInfo(nPos,lstrlen(str));

UpdateScrollInfo();

while (*p) {

if (*p=='\r')

nCrLf++;

p++;

}

if (nCrLf) {

GetRCFromOff(nPos,r,c);

nowPara=pLine[r].nPara;

if (c != 0) {

nowPara++;

}

for (i=0;i<MAXBOOKMARK;i++) {

if (arMark[i] >= nowPara) {

arMark[i]+=nCrLf;

}

void CApiEditText::Delete(int nPos, int nCount, BOOL bRec/*=TRUE*/)

{

int nCrLf=0,i;

int sr,sc,er,ec;

int sPara,ePara;

TCHAR *p=buf+nPos;

if (bReadOnly)

return;

if (nCount == 0) return;

if (doclen < nPos+nCount) return;

for (i=0;i<nCount;i++) {

if (p[i]=='\r')

nCrLf++;

}

if (nCrLf) {

GetRCFromOff(nPos,sr,sc);

sPara=pLine[sr].nPara;

GetRCFromOff(nPos+nCount,er,ec);

ePara=pLine[er].nPara;

for (i=0;i<MAXBOOKMARK;i++) {

if (arMark[i] >= sPara && arMark[i] < ePara) {

arMark[i]=-1;

}

if (arMark[i] >= ePara) {

arMark[i]-=nCrLf;

}

pFrame->Delete(nPos,nCount,bRec);

UpdateLineInfo(nPos,-nCount);

UpdateScrollInfo();

}

실제 문서를 변경하는 작업은 프레임의 Insert, Delete 함수를 호출하여 처리하며 뷰는 문서 변경에 따른 추가 작업만 처리한다. 이런 작업은 문서가 변경될 때마다 해야 하지만 뷰의 타입에 따라 달라질 수 있으므로 프레임이 직접 할 수 있으며 개별 뷰가 자신에게 맞는 작업을 직접 해야 한다. 예를 들어 헥사뷰는 bLineEnd라는 변수를 사용하지 않으며 정렬도 하지 않는다.

프레임에 있는 멤버를 참조하는 모든 문장을 수정한다. 이 작업은 아주 지겨운 치환 과정이며 머리는 필요없고 손만 부지런히 놀리면 된다. 좋아하는 음악이나 감상하면서 작업하면 좀 덜 지겹다. 먼저 정적 변수들을 치환한다.

hLineNumFont,hCSel,hCCopy,hCMove,hCMargin,hCNoDrop;

이 변수들은 모두 프레임에 소속되어 있으므로 앞에 CApiEdit::을 붙인다. 정적 변수이므로 클래스 이름으로 소속을 밝혔다. 뷰가 참조하는 프레임의 변수들도 모두 치환한다. 예를 들어 buf를 참조하는 모든 문장은 pFrame->buf로 일괄 치환해야 한다. 다음이 치환대상이다.

buf, doclen, bReadOnly, LastEditOff, bWantTab, bUseLineEnd, bAllowDrag, bSpaceForTab, bAutoIndent, bBlockIndentWithTab, bHomeToFirstChar, HideSelType, nShowCurLine, bHideCurLine, bCalcTabWithAvg

MarColor1, MarColor2, NumColor, MarkColor, CodeColor, CurColor, cFore, cBack, cSelFore, cSelBack

비주얼 스튜디오의 일괄 치환 기능을 사용하되 반드시 단어 단위로 옵션을 선택해 놓고 작업해야 한다. 이 옵션을 선택하지 않으면 LastEditOff를 변경할 때 GotoLastEditOff가 GotopFrame->LastEditOff가 되어 버릴 것이고 tbuf는 tpFrame->buf가 될 것이다. 반드시 단어 단위로 치환해야 한다.

CaretWidth를 바꿀 때는 대소문자 일치 옵션도 같이 선택해야 하므로 손으로 직접 바꾸는 것이 속편하다. 딱 한군데 뿐이다.

void CApiEditText::SetCaret(BOOL bUpdatePrevX/*=TRUE*/, BOOL bScrollToCaret/*=TRUE*/)

{

....

if (bComp) {

toff=off-2;

caretwidth=GetCharWidth(pFrame->buf+toff,2);

} else {

toff=off;

caretwidth=pFrame->CaretWidth;

}

지역 변수에 caretwidth가 있어 일괄 치환하면 이 변수까지 같이 바뀐다. 전역 변수와 대소문자 구성만 다르고 철자가 같아 치환하기 불편한데 아무래도 변수 이름을 좀 잘못 지은 것 같다. 프레임의 함수를 호출하는 문장들도 치환한다. 멤버 변수와 마찬가지로 함수 호출문 앞에 pFrame->을 붙이면 된다. 예를 들어 Undo()는 pFrame->Undo()로 치환된다.

IsDBCS, GetPrevOff, GetNextOff, FindParaStart, IncludeEnter, SendNotify, CanUndo, CanRedo, Undo, Redo, StartUndoGroup, EndUndoGroup, AnalyzeFormat, ConvertFormat, URInsert, URMove

ApiEdit가 워낙 많은 멤버를 가지고 있기 때문에 분할 후에 각 멤버를 참조하는 모든 문장을 일일이 수정해야 하는 귀찮음이 있다. 다행히 편집기의 일괄 치환 기능을 사용하면 시간이 좀 걸리기는 하지만 큰 어려움없이 작업을 완료할 수 있다.

기본 설정 상태로 돌아가는 SetDefaultSetting 함수도 대폭 수정된다. 자신의 멤버가 아닌 변수는 초기화할 필요가 없다. 또한 SetFont 함수도 약간 수정된다.

void CApiEditText::SetDefaultSetting()

{

if (pLine) {

SetLineRatio(120);

SetWrap(0);

SetTabWidth(4);

SetShowState(SHOWMARGIN,TRUE);

} else {

LineRatio=120;

nWrap=0;

TabWidth=4;

MarginWidth=25;

}

logfont.lfHeight=0;

hMainFont=NULL;

SetFont(&logfont);

bShowEnter=FALSE;

bShowTab=FALSE;

bShowSpace=FALSE;

bShowLineNum=FALSE;

bNoFirstSpace=FALSE;

ShowTabType=1;

ShowEnterType=1;

ShowSpaceType=0;

RightWrap=0;

ColMark=0;

SetParser(0);

}

void CApiEditText::SetFont(LOGFONT *alogfont)

{

....

if (pLine) {

UpdateLineInfo();

....

설정값을 변경하는 함수를 부를 것인가 아니면 변수를 직접 변경할 것인가를 판단하기 위해서 원래 ApiEdit의 코드는 if (buf) 조건문을 사용하였다. buf가 할당되어 있으면 실행중에 설정값을 바꾸는 것이므로 멤버 함수를 불러 추가 작업까지 같이 했으며 그렇지 않다면 변수에 직접 값을 대입하였으나 이제 buf가 프레임으로 옮겨졌으므로 이 변수값을 봐서는 뷰의 초기화 여부를 알 수 없다. 대신 동일한 목적으로 pLine을 보고 뷰의 초기화 여부를 판단한다.

기존의 CApiEdit 객체를 프레임과 뷰로 분할하는 지겨운 실습이 끝났으며 CApiEdit 클래스는 CApiEdit와 CApiEditText로 분할되었다. 객체 분할의 마지막 작업은 이미 분할되어 있는 분석기 객체도 분할된 프레임과 뷰를 인식하도록 하는 것이다. 분석기는 프레임이 가지고 있는 buf의 내용과 뷰가 가지고 있는 pLine 정렬 정보를 참조하여 구문 분석을 하므로 양쪽 객체에 흩어져 있는 정보를 모두 읽을 수 있어야 한다.

현재 분석기는 CApiEdit 클래스의 포인터를 인수로 전달받아 이 객체의 buf와 pLine을 참조하는데 뷰의 포인터를 인수로 전달받도록 변경한다. 이렇게 되면 buf는 뷰의 pFrame->buf로 참조할 수 있게 되고 pLine은 기존 방법대로 참조하면 된다. 프레임의 포인터를 인수로 전달받으면 buf는 기존 방법대로 참조할 수 있지만 pLine을 참조하기 위해서 활성 뷰를 찾아야 하는데다 구문 분석 동작이 뷰의 동작이기 때문에 뷰의 포인터를 받는 것이 합당하다. 분석기의 모듈인 Parse.h, Parse.cpp의 다음 단어들을 일괄 치환하여 프레임 대신 뷰 객체를 참조하고 뷰로부터 프레임을 찾아 buf를 참조한다. 이 작업도 일괄 치환 기능을 사용하면 쉽게 완료할 수 있다.

CApiEdit → CApiEditText

ae.buf → ae.pFrame->buf

모든 분석기들은 ApiEditText와 ApiEdit 클래스에 프랜드로 선언되어 있으므로 buf나 pLine은 참조하는데 아무런 제약이 없다. 참조하는 정보를 찾는 방법이 바뀌었을 뿐 분석 방법 자체에 변화가 생긴 것은 아니다.

마. 호스트 수정

컨트롤이 바뀌었다고 해서 이 컨트롤의 호스트를 수정하는 것은 바람직하지 않다. 컨트롤의 버전이 바뀌더라도 가급적이면 이전 버전의 인터페이스를 유지하는 것이 좋고 그래야 제대로 된 컨트롤이라고 할 수 있다. 하지만 ApiEdit는 완전히 릴리즈된 것이 아니라 아직 개발중이며 인터페이스도 확정된 것이 아니기 때문에 불가피하게 호스트가 영향을 받게 되었다. 컨트롤의 기능을 대대적으로 확장하면서 인터페이스를 그대로 유지한다는 것은 사실 무척 어려운 일이다.

특히 ApiEdit는 분할창과 다양한 보기 모드 지원을 위해 근본적인 구조를 변경했기 때문에 과거의 인터페이스를 그대로 유지하기 어렵다. ApiEdit의 유일한 호스트는 아직까지 당근밖에 없기 때문에(사실 NonSool이라는 예제도 있었다) 이 단계에서 컨트롤의 인터페이스를 수정하는 것은 큰 문제가 되지 않는다. 당근을 만든 사람은 ApiEdit의 변화에 대해 아주 긍정적인 평가를 내리고 있기 때문에 더 좋은 기능 구현을 위한 인터페이스의 변화를 기꺼이 받아들일 것이다.

물론 꼭 필요하다면 인터페이스를 바꾸지 않고도 기능을 확장할 수 있다. 그러나 그렇게 하자면 좋지 않은 구조를 그대로 유지해야 하고 많은 군더더기 코드가 남게 되므로 인터페이스의 변화를 감수하더라도 깔끔하게 다시 작성하는 것이 더 좋으며 따라서 호스트도 불가피하게 이 변화의 영향을 받게 된다. 주로 ApiEdit 프레임에서 삭제된 멤버에 대한 액세스문이 바뀌는 정도에 불과하며 질적으로 큰 변화는 없을 것이다. 먼저 가장 중요한 수정 사항은 DgChildProc의 WM_DESTROY에서 문서창을 파괴할 때 ApiEdit 컨트롤의 윈도우도 명시적으로 파괴해야 한다는 점이다. DGChildProc에 다음 코드 한 줄을 추가한다.

LRESULT CALLBACK DGChildProc(HWND hWnd,UINT iMessage,WPARAM wParam,LPARAM lParam)

{

....

case WM_DESTROY:

pSi=(SInfo *)GetWindowLong(hWnd,0);

DeleteFileTab(pSi->NowFile);

DestroyWindow(pSi->Ae.hWnd);

delete pSi;

g_ChildNum--;

if (g_ChildNum==0) {

....

상속된 파괴자가 가상 함수를 제대로 찾지 못하므로 윈도우 파괴가 수동 방식으로 전환되었으며 왜 그렇게 했는지에 대해서는 앞에서 이론적 점검을 이미 마쳤다. pSi를 파괴할 때 이 구조체의 멤버인 Ae도 같이 파괴되는데 그 전에 DestroyWindow로 Ae.hWnd 윈도우만 파괴하면 된다. 윈도우 수동 파괴 방식으로 인해 호스트가 부담해야 할 작업은 여기 한 군데 뿐이다.

당근의 메뉴에는 ApiEdit 컨트롤의 멤버 함수를 직접 호출하는 항목들이 많이 있다. 예를 들어 대소문자 변환 항목은 ChangeCase 함수를 호출하며 시간, 날짜 삽입 명령은 InsertText 함수를 호출한다. 호스트의 입장에서 ApiEdit는 프레임인데 이 함수들이 프레임에서 뷰로 이동되었으므로 뷰의 함수를 호출하도록 수정해야 한다. OnCommand의 메뉴 항목 처리 코드를 다음과 같이 수정한다.

void OnCommand(HWND hWnd,WPARAM wParam,LPARAM lParam)

{

....

CApiEditText *pView;

hActive=(HWND)SendMessage(g_hMDIClient,WM_MDIGETACTIVE,0,NULL);

if (hActive==NULL) {

if (TestNeedActive(LOWORD(wParam)))

return;

} else {

pSi=(SInfo *)GetWindowLong(hActive,0);

pView=pSi->Ae.GetActiveView();

}

....

case IDM_EDIT_UPPER:

pView->ChangeCase(0);

break;

case IDM_EDIT_LOWER:

pView->ChangeCase(1);

break;

case IDM_EDIT_REVERSE:

pView->ChangeCase(2);

break;

case IDM_EDIT_UPPERFIRST:

pView->ChangeCase(3);

break;

case IDM_EDIT_UPPERSENT:

pView->ChangeCase(4);

break;

case IDM_EDIT_TOTAB:

pView->ConvertSpaceTab(FALSE);

break;

case IDM_EDIT_TOSPACE:

pView->ConvertSpaceTab(TRUE);

break;

case IDM_EDIT_REMOVESPACE:

pView->RemoveExtraSpace();

break;

case IDM_EDIT_INDENT:

pView->BlockIndent(FALSE);

break;

case IDM_EDIT_UNINDENT:

pView->BlockIndent(TRUE);

break;

case IDM_EDIT_COMMENT:

pView->InsertComment(FALSE);

break;

case IDM_EDIT_UNCOMMENT:

pView->InsertComment(TRUE);

break;

case IDM_EDIT_DATE:

GetLocalTime(&st);

wsprintf(szTemp,"%d년 %d월 %d일 ",st.wYear, st.wMonth, st.wDay);

pView->InsertText(szTemp);

break;

case IDM_EDIT_TIME:

GetLocalTime(&st);

wsprintf(szTemp,"%d시 %d분 %d초 ",st.wHour, st.wMinute, st.wSecond);

pView->InsertText(szTemp);

break;

case IDM_EDIT_COPYUP:

pView->CopyChar(0);

break;

case IDM_EDIT_COPYDOWN:

pView->CopyChar(1);

break;

....

case IDM_SEARCH_WORD:

case IDM_SEARCH_WORDUP:

int nStart;

pSi->Ae.GetSelect(s,e);

if (s==e) {

pView->GetNowWord(pSi->Ae.GetOffset(),s,e);

}

....

case IDM_SEARCH_PAREN:

pView->FindParen(FALSE);

break;

case IDM_SEARCH_PARENSEL:

pView->FindParen(TRUE);

break;

이 함수들은 이제 CApiEdit프레임에 있지 않고 CApiEditText에만 있으므로 GetActiveView 함수로 활성 뷰를 구한 후 뷰의 함수를 호출했다. OnCommand외에 뷰의 함수를 직접 호출하는 곳이 한군데 더 있는데 Find.cpp에서 GetNowWord를 두 번 호출한다. 이 코드도 수정하여 활성 뷰의 GetNowWord를 호출하자.

BOOL CALLBACK FindDlgProc(HWND hDlg,UINT iMessage,WPARAM wParam,LPARAM lParam)

{

pSi->Ae.GetActiveView()->GetNowWord(pSi->Ae.GetOffset(),s,e);

....

BOOL CALLBACK FileFindDlgProc(HWND hDlg,UINT iMessage,WPARAM wParam,LPARAM lParam)

{

pSi->Ae.GetActiveView()->GetNowWord(pSi->Ae.GetOffset(),s,e);

....

모든 뷰는 CApiEditText로부터 파생되므로 뷰 타입에 상관없이 이 함수들은 항상 존재할 것이다. 그러나 함수는 있지만 뷰 타입에 따라서 의미없는 동작인 경우는 많이 있다. 예를 들어 검색/단어찾기 기능은 헥사 뷰에서는 의미가 없으며 괄호짝찾기, 공백과 탭 변환 등의 동작도 텍스트 뷰에서만 실질적인 의미가 있다. 윗줄 문자 반복 같은 기능은 문단의 개념이 있어야만 가능하며 들여쓰기도 마찬가지다.

하지만 호스트는 뷰의 타입을 판별하지 않고 무조건 활성 뷰의 해당 함수를 호출해 버리는데 이것은 호스트가 뷰의 타입을 고려하지 않겠다는 뜻이다. 뷰는 자신이 지원하지 못하는 동작에 대해서는 상위 클래스에게 위임하거나 아니면 아예 아무 동작도 하지 않아야 한다. 예를 들어 헥사뷰의 CopyChar 함수는 비워 둔 채로 재정의하거나 아니면 호출전에 뷰의 타입을 판별해 보면 아무 말썽이 없다. Find.cpp의 다음 함수도 수정한다.

void SendOutputToWindow()

{

TCHAR *buf;

HWND hActive;

SInfo *pSi;

hActive=(HWND)SendMessage(g_hMDIClient,WM_MDIGETACTIVE,0,NULL);

if (hActive==NULL)

return;

pSi=(SInfo *)GetWindowLong(hActive,0);

ExtractOutputToText(buf);

pSi->Ae.GetActiveView()->Insert(pSi->Ae.GetOffset(),buf);

pSi->Ae.Invalidate(-1);

free(buf);

}

활성 뷰의 Insert를 불러야 화면 갱신과 북마크 조정까지 된다. 마지막으로 꼭 필요한 것은 아니지만 소스를 보기 좋게 조금 편집한다. 멤버 앞에 pFrame-> 같은 포인터 연산문이 삽입됨으로써 가로로 너무 길어진 행이 있는데 적당히 개행하는 것이 좋다. 예를 들어 GetXPosOnLine 함수의 아래쪽을 보면 다음과 같은 코드가 있다.

int CApiEditText::GetXPosOnLine(int r,int DestX)

{

....

bLineEnd=(p-pFrame->buf==pLine[r].End && pFrame->buf[p-pFrame->buf]!='\r' && pFrame->buf[p-pFrame->buf]!=0);

return p-pFrame->buf;

}

pFrame->가 다섯 번이나 삽입되다보니 수평 길이가 113컬럼이나 되는데 이렇게 긴 행이 있으면 소스를 볼 때 옆으로 스크롤해야 하므로 불편하다. 적당한 곳에 개행 코드를 삽입하여 두 줄에 쓰는 것이 더 좋다.

bLineEnd=(p-pFrame->buf==pLine[r].End && pFrame->buf[p-pFrame->buf]!='\r' &&

pFrame->buf[p-pFrame->buf]!=0);

물론 이런 편집은 어디까지나 개인적인 기호의 문제일 뿐이므로 어디다 개행 코드를 삽입할 것인가는 전혀 중요하지 않고 모니터가 충분히 크다면 그냥 두어도 무관하다. 하지만 이 프로젝트는 지면에 보여야 할 소스이기 때문에 수평 길이가 너무 길면 곤란하다. 그래서 ApiEdit.cpp를 일괄 편집하여 가급적 90컬럼을 넘지 않게 편집했다.

여기까지 객체 분할이 완료되었다. 컴파일 결과 에러가 발생한다면 아마 실습 과정중 하나를 누락했을 것이다. 객체 분할 과정이 워낙 복잡하고 잔손이 많이 가기 때문에 웬만큼 꼼꼼한 성격이 아니면 이 실습을 완수하기 무척 어려울 것이다. 실행해 보면 Dangeun13과 완전히 동일하게 동작하며 추가된 기능도 없고 삭제된 기능도 없다. 하지만 겉모습만 같을 뿐 내부적으로는 엄청난 변화가 있었으며 이후 기능을 확장하기 위한 구조 조정이 완료되었다.

"에구! 지금까지 힘들게 실습을 했는데 아무 것도 달라진 것이 없단 말이야?" 라는 불만이 혹시 있을지 모르겠다. 하긴 실습이란 뭔가 조금씩 좋아지는 것을 눈으로 확인하면서 진행해야 재미가 있는 법이다. 하지만 아무런 기능 추가없이 내부적인 구조만 바꾸도록 실습 과정을 짜는 것도 과히 쉬운 일이 아니었다. 여기서 힘들게 객체 분할을 해 놓았으니 다음 장에서 이 구조를 바탕으로 많은 새롭고 재미있는 기능을 추가할 수 있을 것이다.