reitp.c

文本编辑器

		EnableMenuItem(hmenu, IDM_ALIGNCENTER, fReadOnly
												? uiMFDisabled : uiMFEnabled);
		EnableMenuItem(hmenu, IDM_ALIGNRIGHT, fReadOnly
												? uiMFDisabled : uiMFEnabled);
		EnableMenuItem(hmenu, IDM_INDENTFIRST, fReadOnly
												? uiMFDisabled : uiMFEnabled);
		EnableMenuItem(hmenu, IDM_OUTDENTFIRST, fReadOnly
												? uiMFDisabled : uiMFEnabled);
	}
		break;

	case 3:		// options
	{
		const DWORD eco = SendMessage(predoc->hwndRE, EM_GETOPTIONS, 0, 0);
		UINT uiSelBar = MF_UNCHECKED;
		UINT uiAutoWordSel = MF_UNCHECKED;
#ifdef DEBUG
		UINT uiReadOnly = MF_UNCHECKED;
		UINT uiAutoHScroll = MF_UNCHECKED;
		UINT uiAutoVScroll = MF_UNCHECKED;
		UINT uiAutoHideSel = MF_UNCHECKED;
#endif	// DEBUG

		if(eco & ECO_SELECTIONBAR)
			uiSelBar = MF_CHECKED;
		if(eco & ECO_AUTOWORDSELECTION)
			uiAutoWordSel = MF_CHECKED;
#ifdef DEBUG
		if(eco & ECO_READONLY)
			uiReadOnly = MF_CHECKED;
		if(eco & ECO_AUTOHSCROLL)
			uiAutoHScroll = MF_CHECKED;
		if(eco & ECO_AUTOVSCROLL)
			uiAutoVScroll = MF_CHECKED;
		if(!(eco & ECO_NOHIDESEL))
			uiAutoHideSel = MF_CHECKED;
#endif	// DEBUG

		CheckMenuItem(hmenu, IDM_SELBAR, uiSelBar);
		CheckMenuItem(hmenu, IDM_AUTOWORDSEL, uiAutoWordSel);
#ifdef DEBUG
		CheckMenuItem(hmenu, IDM_READONLY, uiReadOnly);
		CheckMenuItem(hmenu, IDM_AUTOHSCROLL, uiAutoHScroll);
		CheckMenuItem(hmenu, IDM_AUTOVSCROLL, uiAutoVScroll);
		CheckMenuItem(hmenu, IDM_AUTOHIDESEL, uiAutoHideSel);
#endif	// DEBUG
	}
		break;

	}
}


LOCAL LRESULT HandleCommand(REDOC *predoc, HWND hwnd, WPARAM wparam,
								LPARAM lparam)
{
	LRESULT lres = 0;
	INT		nID;

	if(GET_WM_COMMAND_HWND(wparam, lparam) == predoc->hwndRE && predoc->hwndRE)
	{
		WORD wNotification = GET_WM_COMMAND_CMD(wparam, lparam);
		ASSENSZ *passensz;

		switch(wNotification)
		{
		case EN_CHANGE:
			if(predoc->hwndFormatBar)
				UpdateFormatBar(predoc);
			break;

		case EN_ERRSPACE:
			if(fErrSpace)
				break;
			fErrSpace = fTrue;
			// fall through to default

		default:
			for(passensz = rgassenszErrors; passensz->szDescription; passensz++)
			{
				if(passensz->wNotification == wNotification)
				{
					MessageBeep(0);
					MessageBoxA(hwndMain, passensz->szDescription, NULL,
						MB_ICONSTOP | MB_OK);
					return 0;
				}
			}
			break;
		}
		return 0;
	}

	fErrSpace = fFalse;

	nID = GET_WM_COMMAND_ID(wparam, lparam);
	switch(nID)
	{
#ifdef DEBUG
	case IDM_CLSDBG:
		ClearDebugScreen();
		break;

	case IDM_TRACEDLG:
		DoTagsDialog();
		break;
#endif	// DEBUG

	case IDM_NEW:
		lres = NewREDoc(predoc, fTrue, fTrue);
#ifdef DEBUG
		if(predoc->hwndRE)
			SendMessage(predoc->hwndRE, EM_REQUESTRESIZE, 0, 0);
#endif	// DEBUG
		break;

	case IDM_OPEN:
		lres = OpenREDoc(predoc, FALSE);
		break;

	case IDM_REVERT:
		lres = RevertREDoc(predoc);
		break;

	case IDM_PRINT:
		PrintREDoc(predoc);
		break;

	case IDM_PRINTPREVIEW:
		DialogBoxParam(HinstFromHwnd(hwndMain), TEXT("PRINTPREVIEW"), hwndMain,
			(DLGPROC) PPDlgProc, (LPARAM) predoc);
		break;

	case IDM_PRINTSETUP:
		predoc->pd.lStructSize = sizeof(PRINTDLG);
		predoc->pd.Flags = PD_PRINTSETUP;
		if(PrintDlg(&predoc->pd) && predoc->fWysiwyg)
		{
			// illegal values to force SetWordWrap() to do something
			predoc->fWrap = fFalse;
			predoc->fWysiwyg = fTrue;
			SetWordWrap(predoc, fTrue, fTrue);
		}
		break;

	case IDM_EXIT:
		PostMessage(hwndMain, WM_CLOSE, 0, 0);
		return 0;

	case IDM_CLOSE:
		return CloseREDoc(predoc, fTrue, fTrue);

	case IDM_SAVE:
		lres = SaveREDoc(predoc);
		break;

	case IDM_SAVEAS:
		lres = SaveREDocAs(predoc, FALSE);
		break;

	case IDM_UNDO:
		lres = SendMessage(predoc->hwndRE, EM_UNDO, 0, 0);
		break;

	case IDM_CUT:
		lres = SendMessage(predoc->hwndRE, WM_CUT, 0, 0);
		break;

	case IDM_COPY:
		lres = SendMessage(predoc->hwndRE, WM_COPY, 0, 0);
		break;

	case IDM_PASTE:
		lres = SendMessage(predoc->hwndRE, WM_PASTE, 0, 0);
		break;

	case IDM_PASTESPECIAL:
		NYI("Paste special");
		break;

	case IDM_DELETE:
		lres = SendMessage(predoc->hwndRE, WM_KEYDOWN,
				(WPARAM) VK_DELETE, 0);
		break;

	case IDM_SELECTALL:
		lres = SendMessage(predoc->hwndRE, EM_SETSEL, 0, (LPARAM) -1);
		break;

	case IDM_FIND:
		FindReplace(predoc, fFalse);
		break;

	case IDM_REPLACE:
		FindReplace(predoc, fTrue);
		break;

	case IDM_OBJECT:
		NYI("Object");
		break;

	case IDM_OBJECTCONVERT:
		NYI("Object Convert");
		break;

	case IDM_INSOBJ:
		return InsertObject(predoc);

	case IDM_INSFILE:
		lres = OpenREDoc(predoc, TRUE);
		break;

	case IDM_SAVESEL:
		lres = SaveREDocAs(predoc, TRUE);
		break;

	case IDM_CHARFORMAT:
		SelectCharFormat(predoc);
		break;

	case IDM_APPLYTOWORD:
		predoc->scf = SCF_SELECTION;
		if(ToggleCheck(predoc, IDM_APPLYTOWORD))
			predoc->scf |= SCF_WORD;
		break;

	case IDM_SUPERSCRIPT:
		SetOffset(predoc, fTrue);
		break;

	case IDM_SUBSCRIPT:
		SetOffset(predoc, fFalse);
		break;

	case IDM_ALIGNLEFT:
		SetAlignment(predoc, PFA_LEFT);
		break;

	case IDM_ALIGNCENTER:
		SetAlignment(predoc, PFA_CENTER);
		break;

	case IDM_ALIGNRIGHT:
		SetAlignment(predoc, PFA_RIGHT);
		break;

	case IDM_INDENTFIRST:
		IndentFirst(predoc, fTrue);
		break;

	case IDM_OUTDENTFIRST:
		IndentFirst(predoc, fFalse);
		break;

	case IDM_MARGINS:
		NYI("set margins");
		break;

	case IDM_TABS:
		NYI("set tabs");
		break;

	case IDM_PROTECTED:
		ProtectSelection(predoc);
		break;

	case IDM_NOWRAP:
		SetWordWrap(predoc, fFalse, fFalse);
		break;

	case IDM_WRAP:
		SetWordWrap(predoc, fFalse, fTrue);
		break;

	case IDM_WYSIWYG:
		SetWordWrap(predoc, fTrue, fTrue);
		break;

	case IDM_SELBAR:
		SendMessage(predoc->hwndRE, EM_SETOPTIONS, ECOOP_XOR, ECO_SELECTIONBAR);
		ToggleCheck(predoc, IDM_SELBAR);
		break;

	case IDM_AUTOWORDSEL:
		SendMessage(predoc->hwndRE, EM_SETOPTIONS, ECOOP_XOR, ECO_AUTOWORDSELECTION);
		ToggleCheck(predoc, IDM_AUTOWORDSEL);
		break;

	case IDM_SHOWMARGINS:
		ShowMargins(predoc);
		break;

#ifdef DEBUG
	case IDM_READONLY:
		SendMessage(predoc->hwndRE, EM_SETOPTIONS, ECOOP_XOR, ECO_READONLY);
		predoc->fReadOnly = !!ToggleCheck(predoc, IDM_READONLY);
		EnableWindow(predoc->hwndFormatBar, !predoc->fReadOnly);
		break;

	case IDM_AUTOHSCROLL:
		SendMessage(predoc->hwndRE, EM_SETOPTIONS, ECOOP_XOR, ECO_AUTOHSCROLL);
		ToggleCheck(predoc, IDM_AUTOHSCROLL);
		break;

	case IDM_AUTOVSCROLL:
		SendMessage(predoc->hwndRE, EM_SETOPTIONS, ECOOP_XOR, ECO_AUTOVSCROLL);
		ToggleCheck(predoc, IDM_AUTOVSCROLL);
		break;

	case IDM_AUTOHIDESEL:
		SendMessage(predoc->hwndRE, EM_SETOPTIONS, ECOOP_XOR, ECO_NOHIDESEL);
		ToggleCheck(predoc, IDM_AUTOHIDESEL);
		break;
#endif	// DEBUG

	case IDM_GOTOCURSOR:
		{
			CHARRANGE cr;
			POINT pt;

			GetCursorPos(&pt);
			ScreenToClient(predoc->hwndRE, &pt);
			cr.cpMin = SendMessage(predoc->hwndRE, EM_CHARFROMPOS, 0,
									(LPARAM) &pt);
			cr.cpMost = cr.cpMin;
			SendMessage(predoc->hwndRE, EM_EXSETSEL, 0, (LPARAM) &cr);
		}
		break;

	case IDM_MOVECURSOR:
		{
			CHARRANGE cr;
			POINT pt;

			SendMessage(predoc->hwndRE, EM_EXGETSEL, 0, (LPARAM) &cr);
			SendMessage(predoc->hwndRE, EM_POSFROMCHAR, (WPARAM) &pt, cr.cpMin);
			ClientToScreen(predoc->hwndRE, &pt);
			SetCursorPos(pt.x, pt.y);
		}
		break;

	case TBI_IncreaseIndent:
	case TBI_DecreaseIndent:
		if(predoc->fReadOnly)
		{
			MessageBeep(0);
		}
		else
		{
			PARAFORMAT pf;

			pf.cbSize = sizeof(PARAFORMAT);

			if(GetFocus() == predoc->hwndFormatBar)
				SetFocus(predoc->hwndRE);
			pf.dwMask = PFM_OFFSETINDENT;
			pf.dxStartIndent = (nID == TBI_IncreaseIndent)
									? cxBulletIndent
									: -cxBulletIndent;
			if(!SendMessage(predoc->hwndRE, EM_SETPARAFORMAT, FALSE,
								(LPARAM) &pf))
			{
				MessageBeep(0);
			}
		}
		break;

	case TBI_Name:
	case TBI_Size:
	case TBI_Bold:
	case TBI_Italic:
	case TBI_Underline:
	case TBI_Color:
		{
			CHARFORMAT cf;

			cf.cbSize = sizeof(CHARFORMAT);
			if(GetFocus() == predoc->hwndFormatBar)
				SetFocus(predoc->hwndRE);
			SendMessage(predoc->hwndFormatBar, EM_GETCHARFORMAT, 0,
						(LPARAM) &cf);
			SendMessage(predoc->hwndRE, EM_SETCHARFORMAT, predoc->scf,
							(LPARAM) &cf);
		}
		break;

	case TBI_AccelBold:
	case TBI_AccelItalic:
	case TBI_AccelUnderline:
		{
			CHARFORMAT cf;
			DWORD dwEffects;

			cf.cbSize = sizeof(CHARFORMAT);
			SendMessage(predoc->hwndFormatBar, EM_GETCHARFORMAT, 0,
						(LPARAM) &cf);
			switch (nID)
			{
			case TBI_AccelBold:
				dwEffects = CFE_BOLD;
				break;
			case TBI_AccelItalic:
				dwEffects = CFE_ITALIC;
				break;
			case TBI_AccelUnderline:
				dwEffects = CFE_UNDERLINE;
				break;
			}

			cf.dwMask |= dwEffects;
			cf.dwEffects ^= dwEffects;

			if(GetFocus() == predoc->hwndFormatBar)
				SetFocus(predoc->hwndRE);
			SendMessage(predoc->hwndFormatBar, EM_SETCHARFORMAT, predoc->scf,
							(LPARAM) &cf);
			SendMessage(predoc->hwndRE, EM_SETCHARFORMAT, predoc->scf,
							(LPARAM) &cf);
		}
		break;

	case TBI_Bullet:
	case TBI_Left:
	case TBI_Center:
	case TBI_Right:
		{
			PARAFORMAT pf;

			pf.cbSize = sizeof(PARAFORMAT);

			if(GetFocus() == predoc->hwndFormatBar)
				SetFocus(predoc->hwndRE);
			SendMessage(predoc->hwndFormatBar, EM_GETPARAFORMAT, 0,
						(LPARAM) &pf);
			SendMessage(predoc->hwndRE, EM_SETPARAFORMAT, FALSE, (LPARAM) &pf);
		}
		break;


#ifdef DEBUG
	case IDM_DBGPED:
		SendMessage(predoc->hwndRE, EM_DBGPED, 0, 0);
		break;

	case IDM_GETTEXT:
		return GetText(predoc);

	case IDM_IGNORELEFTCLICK:
		IgnoreLeftClick(predoc);
		break;

	case IDM_EATES:
		EatEs(predoc);
		break;

	case IDM_BOTTOMLESS:
		Bottomless(predoc);
		break;

	case IDM_IGNOREDROPS:
	case IDM_TEXTONLY:
	case IDM_REFUSEGRAPH:
	case IDM_PPMETA:
	case IDM_ENABLECUTREADONLY:
	case IDM_ENABLEPASTEREADONLY:
	case IDM_ENABLEDRAGREADONLY:
	case IDM_SWAPDRAGEFFECT:
		ToggleCheck(predoc, nID);
		break;

	case IDM_HIDE:
		ShowWindow(predoc->hwndRE, ToggleCheck(predoc, IDM_HIDE) ? SW_HIDE : SW_SHOW);
		break;		

	case IDM_PASTEPLAINTEXT:
		lres = SendMessage(predoc->hwndRE, EM_PASTESPECIAL, CF_TEXT, 0);
		break;

	case IDM_PASTETXTOBJ:
		lres = SendMessage(predoc->hwndRE, EM_PASTESPECIAL, cfTxtObj, 0);
		break;

	case IDM_PASTERTFASTEXT:
		lres = SendMessage(predoc->hwndRE, EM_PASTESPECIAL, cfRTFAsText, 0);
		break;

	case IDM_BIGLIMIT:
		SetLimit(predoc);
		break;

	case IDM_FILLERUP:
		FillerUp(predoc);
		break;
#endif	// DEBUG

	default:
		// Pass through OLE verbs
		if(nID >= IDM_OBJECTMIN)
		{
			DoVerb(predoc, nID - IDM_OBJECTMIN);
		}
		return DefWindowProc(hwnd, WM_COMMAND, wparam, lparam);
	}

	return lres;
}


VOID DoVerb(REDOC * predoc, INT ioleverb)
{
	REOBJECT reobj = { 0 };
	POINT pt;
	RECT rc = { 0 };

	reobj.cbStruct = sizeof(REOBJECT);