예제 #1
0
/*----------------------------------------------------------------------------------------------
	The hwnd has been attached.
----------------------------------------------------------------------------------------------*/
void DcMainWnd::PostAttach(void)
{
	StrAppBuf strbT; // Holds temp string

	// Set the default caption text.
	strbT.Load(kstidDllClient);
	::SendMessage(m_hwnd, WM_SETTEXT, 0, (LPARAM)strbT.Chars());

	// This creates the main frame window and sets it as the current window. It also
	// creates the rebar and status bar.
	SuperClass::PostAttach();

	// Create the menu bar.
	AfMenuBarPtr qmnbr;
	qmnbr.Create();
	qmnbr->Initialize(m_hwnd, kridAppMenu, kridAppMenu, "Menu Bar");
	m_vqtlbr.Push(qmnbr.Ptr());
	CreateToolBar(qmnbr, true, true, 200);

	// Load window settings.
	LoadSettings(NULL, false);

	g_app.AddCmdHandler(this, 1);
	m_qstbr->RestoreStatusText();

	// Create the client window.
	const int kwidChild = 1000;
	WndCreateStruct wcs;
	wcs.InitChild("DcClientWnd", m_hwnd, kwidChild);
	wcs.dwExStyle |= WS_EX_CLIENTEDGE;
	m_dccw.Create();
	m_dccw->CreateHwnd(wcs);
	::ShowWindow(m_dccw->Hwnd(), SW_SHOW);
}
예제 #2
0
// Append a measurement, never with preceding comma. stid contains a %s which is replaced
// with the nVal (initially mp) converted to the appropriate display units.
void AppendMeasurement(StrApp & strDesc, int nVal, MsrSysType nMsrSys, int stid)
{
	if (nVal == knNinch)
		return;
	StrAppBuf strb;
	AfUtil::MakeMsrStr(nVal , nMsrSys, &strb);
	StrApp strFmt(stid);
	strDesc.FormatAppend(strFmt.Chars(), strb.Chars());
}
예제 #3
0
// Append information about one border, if it is defined
void AppendBorderInfo(StrApp & strDesc, int mp, int stid, bool & fFirst)
{
	if (mp == knNinch)
		return;
	StrAppBuf strb;
	AfUtil::MakeMsrStr (mp , knpt, &strb);
	StrApp strFmt(stid);
	StrApp strT;
	strT.Format(strFmt.Chars(), strb.Chars());
	AppendDescPart(strDesc, strT, fFirst);
}
예제 #4
0
/*----------------------------------------------------------------------------------------------
	Called by the framework to initialize the dialog. All one-time initialization should be
	done here (that is, all controls have been created and have valid hwnd's, but they
	need initial values.)

	See ${AfDialog#FWndProc}
	@param hwndCtrl (not used)
	@param lp (not used)

	@return true if Successful
----------------------------------------------------------------------------------------------*/
bool FwPropDlg::OnInitDlg(HWND hwndCtrl, LPARAM lp)
{
	StrApp str;
	str.Format(_T("%r %r"), AfApp::Papp()->GetAppPropNameId(), kstidPropProperties);
	::SendMessage(m_hwnd, WM_SETTEXT, 0, (LPARAM)str.Chars());

	m_pszHelpUrl = m_strHelpF.Chars();
	GeneralPropDlgTabPtr qgenp;
	qgenp.Attach(NewObj GeneralPropDlgTab(this, m_ctidName));
	qgenp->EnableLocation(true);
	qgenp->EnableSize(true);
	qgenp->EnableModified(true);
	qgenp->EnableDescription(true);
	AfDialogViewPtr qdlgv;
	qdlgv = qgenp;
	m_vqdlgv.Push(qdlgv);

	m_hwndTab = ::GetDlgItem(m_hwnd, kcidLangProjPropDlgTab);

	// WARNING: If this ever gets changed to anything but a fixed length buffer, make sure
	// ti.pszText is set after loading each string, since the memory pointed to by strb
	// could be different each time.
	StrAppBuf strb;
	TCITEM ti;
	ti.mask = TCIF_TEXT;
	ti.pszText = const_cast<achar *>(strb.Chars());

	// Add a tab to the tab control for each dialog view.
	strb.Load(kstidGeneralPropTab);
	TabCtrl_InsertItem(m_hwndTab, 0, &ti);

	// This section must be after at least one tab gets added to the tab control.
	RECT rcTab;
	::GetWindowRect(m_hwndTab, &rcTab);
	TabCtrl_AdjustRect(m_hwndTab, false, &rcTab);
	POINT pt = { rcTab.left, rcTab.top };
	::ScreenToClient(m_hwnd, &pt);
	m_dxsClient = pt.x;
	m_dysClient = pt.y;

	// Subclass the Help button.
	AfButtonPtr qbtn;
	qbtn.Create();
	qbtn->SubclassButton(m_hwnd, kctidHelp, kbtHelp, NULL, 0);

	ShowChildDlg(m_itabInitial);

	AfApp::Papp()->EnableMainWindows(false);

	::SetFocus(m_hwndTab);

	return SuperClass::OnInitDlg(hwndCtrl, lp);
}
예제 #5
0
void AppendOffsetInfo(StrApp & strDesc, int mpOffset, bool & fFirst)
{
	if (mpOffset && mpOffset != knNinch)
	{
		StrApp strFmt;
		if (mpOffset < 0)
			strFmt.Load(kstidLoweredFmt);
		else
			strFmt.Load(kstidRaisedFmt);
		StrApp strAmt;
		StrAppBuf strb;
		AfUtil::MakeMsrStr (abs(mpOffset) , knpt, &strb);
		StrApp strT;
		strT.Format(strFmt.Chars(), strb.Chars());
		AppendDescPart(strDesc, strT, fFirst);
	}
}
예제 #6
0
/*----------------------------------------------------------------------------------------------
	Called by the framework to initialize the dialog. All one-time initialization should be
	done here (that is, all controls have been created and have valid hwnd's, but they
	need initial values.)

	See ${AfDialog#FWndProc}
	@param hwndCtrl (not used)
	@param lp (not used)

	@return true if Successful
----------------------------------------------------------------------------------------------*/
bool GeneralPropDlgTab::OnInitDlg(HWND hwndCtrl, LPARAM lp)
{
	HICON hicon = m_ppropd->GetIconHandle();
	if (hicon)
	{
		::SendMessage(::GetDlgItem(m_hwnd, kridGeneralPropTabObjIcon), STM_SETICON,
			(WPARAM)hicon, (LPARAM)0);
	}

	m_hfontLarge = AfGdi::CreateFont(16, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, ANSI_CHARSET,
		OUT_CHARACTER_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
		_T("MS Sans Serif"));
	if (m_hfontLarge)
	{
		::SendMessage(::GetDlgItem(m_hwnd, kridGeneralPropTabBigName), WM_SETFONT,
			(WPARAM)m_hfontLarge, false);
	}
	::SetWindowText(::GetDlgItem(m_hwnd, kridGeneralPropTabBigName), m_ppropd->GetName());

	// Replace the kctidGeneralPropTabName editbox with a bespoke version, so that the
	// "what's this" help will work differently for the different circumstances:
	HWND hwndEdit = ::GetDlgItem(m_hwnd, kctidGeneralPropTabName);
	Rect rc;
	// Get the current edit box's size, font, previous sibling, style and extended style:
	::GetWindowRect(hwndEdit, &rc);
	::MapWindowPoints(NULL, m_hwnd, (POINT *)&rc, 2);
	HFONT hfontEdit = (HFONT)(::SendMessage(hwndEdit, WM_GETFONT, 0, 0));
	HWND hwndPrev = ::GetWindow(hwndEdit, GW_HWNDPREV);
	DWORD dwStyle = ::GetWindowLong(hwndEdit, GWL_STYLE);
	DWORD dwExStyle =  ::GetWindowLong(hwndEdit, GWL_EXSTYLE);
	// Get rid of original edit box:
	::DestroyWindow(hwndEdit);
	// Put in an identical one, but with the id that we want:
	hwndEdit = ::CreateWindowEx(dwExStyle, _T("EDIT"), _T(""), dwStyle, 0, 0, 0, 0, m_hwnd,
		(HMENU)m_ctidName, NULL, NULL);
	::SetWindowPos(hwndEdit, hwndPrev, rc.left, rc.top, rc.Width(), rc.Height(), 0);
	::SendMessage(hwndEdit, WM_SETFONT, (WPARAM)hfontEdit, 0);

	::SetWindowText(hwndEdit, m_ppropd->GetName());

	const achar * pszType = m_ppropd->GetType();
	::SetWindowText(::GetDlgItem(m_hwnd, kridGeneralPropTabType), pszType);

	if (m_fLocationEnb)
	{
		const achar * pszLoc = m_ppropd->GetLocation();
		::SetWindowText(::GetDlgItem(m_hwnd, kridGeneralPropTabLocation), pszLoc);
	}
	else
	{
		::ShowWindow(::GetDlgItem(m_hwnd, kridGeneralPropTabLocationLabel), SW_HIDE);
		::ShowWindow(::GetDlgItem(m_hwnd, kridGeneralPropTabLocation), SW_HIDE);
	}

	if (m_fSizeEnb)
	{
		const achar * pszSize = m_ppropd->GetSizeString();
		::SetWindowText(::GetDlgItem(m_hwnd, kridGeneralPropTabSize), pszSize);
	}
	else
	{
		::ShowWindow(::GetDlgItem(m_hwnd, kridGeneralPropTabSizeLabel), SW_HIDE);
		::ShowWindow(::GetDlgItem(m_hwnd, kridGeneralPropTabSize), SW_HIDE);
	}

	StrAppBuf strb;
	GetDateString(m_ppropd->GetDateCreatedFlid(), strb);
	::SetWindowText(::GetDlgItem(m_hwnd, kridGeneralPropTabCreated), strb.Chars());

	if (m_fModifiedEnb)
	{
		GetDateString(m_ppropd->GetDateModifiedFlid(), strb);
		::SetWindowText(::GetDlgItem(m_hwnd, kridGeneralPropTabModified), strb.Chars());
	}
	else
	{
		::ShowWindow(::GetDlgItem(m_hwnd, kridGeneralPropTabModifiedLabel), SW_HIDE);
		::ShowWindow(::GetDlgItem(m_hwnd, kridGeneralPropTabModified), SW_HIDE);
	}

	if (m_fDescriptionEnb)
	{
		const achar * pszDesc = m_ppropd->GetDescription();
		::SetWindowText(::GetDlgItem(m_hwnd, kctidGeneralPropTabDescription), pszDesc);
	}
	else
	{
		::ShowWindow(::GetDlgItem(m_hwnd, kridGeneralPropTabDescriptionLabel), SW_HIDE);
		::ShowWindow(::GetDlgItem(m_hwnd, kctidGeneralPropTabDescription), SW_HIDE);
	}

	m_fInitialized = true;

	return SuperClass::OnInitDlg(hwndCtrl, lp);
}
예제 #7
0
/*----------------------------------------------------------------------------------------------
	Set the values for the dialog controls based on the style styi.
	@param vwsProj Union of the current Vernacular and Analysis encodings for the project.
----------------------------------------------------------------------------------------------*/
void FmtGenDlg::SetDialogValues(StyleInfo & styi, Vector<int> & vwsProj)
{
	// During SetDialogValues we never need to handle loss of focus in the name control,
	// because if anything needed to be done about updating that, it was done during
	// GetDialogValues, which is always called before SetDialogValues. We need to suppress it
	// because during this call the current style index and the current value of the control
	// may not agree: the purpose of this method is to update the control from the new style.
	// The normal loss-of-focus code is trying to synchronize in the opposite direction, and
	// can cause problems, for example, when we are disabling the control. For example:
	//  - Disabling the window causes it to lose focus if it previously had focus.
	//  - There is a kill focus event that tries to make the contents of the box agree with
	//		the name of the current style.
	//	- when this method is called, the old style is still the current one, so if we
	//		already changed the text in the box, we wind up trying to rename the old style
	//		to the name of the 'provided' style and produce a name conflict error.

	try
	{
		m_vwsProj = vwsProj;

		StrApp strDesc;
		m_fSuppressLossOfFocus = true;
		StrApp strName = styi.m_stuName;
		StrApp strTemp; // Temporary string.
		bool fProtectedStyle = m_pafsd->IsStyleProtected(styi.m_stuName);

		// Name edit box.
		::SetDlgItemText(m_hwnd, kctidFgEdName, strName.Chars());
		// Diable the control for styles originally provided by FieldWorks.
		::EnableWindow(m_hwndName, !fProtectedStyle);

		// Style type ltext.
		switch (styi.m_st)
		{
		case kstParagraph:
			strTemp.Load(kstidParagraph);
			break;
		case kstCharacter:
			strTemp.Load(kstidCharacter);
			break;
		default:
			Assert(false); // Should not happen.
		}
		::SetWindowText(m_hwndType, strTemp.Chars());

		// Update the "next" and "basedOn" comboboxes
		LoadNextStyleCombobox(styi);
		SetNextStyleComboboxValue(styi);
		LoadBasedOnStyleCombobox(styi);
		SetBasedOnStyleComboboxValue(styi);

		// ENHANCE LarryW(JohnT): When shortcut is implemented initialize the value instead.
		::EnableWindow(m_hwndShortcut, false); // Disables it.

		// **************************************
		m_vesi.Clear();
		strDesc = m_pafsd->GetNameOfStyle(styi.m_hvoBasedOn);
		strDesc.Append(" + ");

		ITsTextProps * pttp = styi.m_qttp;
		if (pttp)
		{
			StrApp strT;
			StrAppBuf strb; // a temp, used for making strings with units

			// Add default font info
			bool fFirstPart = true;
			SmartBstr sbstr;
			CheckHr(pttp->GetStrPropValue(ktptFontFamily, &sbstr));
			StrUni stuFont(sbstr.Chars());
			AppendDescPart(strDesc, FwStyledText::FontStringMarkupToUi(false, stuFont), fFirstPart);
			int val, var;
			CheckHr(pttp->GetIntPropValues(ktptFontSize, &var, &val));
			if (var != -1)
			{
				AfUtil::MakeMsrStr (val , knpt, &strb);
				AppendDescPart(strDesc, strb, fFirstPart);
			}
			CheckHr(pttp->GetIntPropValues(ktptBold, &var, &val));
			if (val == kttvForceOn || val == kttvInvert)
				AppendDescPart(strDesc, kstidBold, fFirstPart);
			CheckHr(pttp->GetIntPropValues(ktptItalic, &var, &val));
			if (val == kttvForceOn || val == kttvInvert)
				AppendDescPart(strDesc, kstidItalic, fFirstPart);
			CheckHr(pttp->GetIntPropValues(ktptSuperscript, &var, &val));
			if (val == kssvSuper)
				AppendDescPart(strDesc, kstidFfdSuperscript, fFirstPart);
			else if (val == kssvSub)
				AppendDescPart(strDesc, kstidFfdSubscript, fFirstPart);

			AppendTextIs(strDesc, (COLORREF)ReadValOrNinch(pttp, ktptForeColor),
				(COLORREF)ReadValOrNinch(pttp, ktptBackColor), fFirstPart);

			AppendUnderlineInfo(strDesc, (COLORREF)ReadValOrNinch(pttp, ktptUnderColor),
				ReadValOrNinch(pttp, ktptUnderline), fFirstPart);

			AppendOffsetInfo(strDesc, ReadValOrNinch(pttp, ktptOffset), fFirstPart);

			// Add info about other tabs
			int nDir = ReadValOrNinch(pttp, ktptRightToLeft);
			AddIf(strDesc, nDir == 0, kstidLeftToRight, fFirstPart);
			AddIf(strDesc, nDir == 1, kstidRightToLeft, fFirstPart);

			static const Keyval rgkeyvals[] =
			{
				{ktalLeading, kstidFpAlignLead},
				{ktalLeft, kstidFpAlignLeft},
				{ktalCenter, kstidFpAlignCenter},
				{ktalRight, kstidFpAlignRight},
				{ktalTrailing, kstidFpAlignTrail},
				{ktalJustify, kstidFpAlignJustify}, //TODO: support when in use.
				{0, 0}
			};
			AddFromList(strDesc, ReadValOrNinch(pttp, ktptAlign), rgkeyvals, fFirstPart);

			int nLeadIndent = ReadValOrNinch(pttp, ktptLeadingIndent);
			int nTrailIndent = ReadValOrNinch(pttp, ktptTrailingIndent);
			int nFirstIndent = ReadValOrNinch(pttp, ktptFirstIndent);
			if (nLeadIndent != knNinch || nTrailIndent != knNinch || nFirstIndent != knNinch)
			{
				AppendDescPart(strDesc, kstidIndentColon, fFirstPart);
				AppendMeasurement(strDesc, nLeadIndent, m_nMsrSys, kstidLeadingFmt);
				if (nFirstIndent != knNinch)
				{
					if (nFirstIndent < 0)
						AppendMeasurement(strDesc, -nFirstIndent, m_nMsrSys, kstidHangingFmt);
					else
						AppendMeasurement(strDesc, nFirstIndent, m_nMsrSys, kstidFirstLineFmt);
				}
				AppendMeasurement(strDesc, nTrailIndent, m_nMsrSys, kstidTrailingFmt);
			}
			// line spacing
			CheckHr(pttp->GetIntPropValues(ktptLineHeight, &var, &val));
			StrApp strSpacing;
			StrApp strFmt;
			if (var == ktpvMilliPoint)
			{
				if (val < 0)
					strFmt.Load(kstidFpLsExactFmt);
				else
					strFmt.Load(kstidFpLsAtLeastFmt);
				StrAppBuf strb;
				AfUtil::MakeMsrStr (val , knpt, &strb);
				strSpacing.Format(strFmt.Chars(), strb.Chars());
			}
			else if (var == ktpvRelative)
			{
				if (val >= kdenTextPropRel * 2)
					strSpacing.Load(kstidFpLsDouble);
				else if (val >= kdenTextPropRel * 3 / 2)
					strSpacing.Load(kstidFpLs15Lines);
				else
					strSpacing.Load(kstidFpLsSingle);
			}
			if (strSpacing.Length() != 0)
			{
				strFmt.Load(kstidLineSpacingFmt);
				strT.Format(strFmt.Chars(), strSpacing.Chars());
				AppendDescPart(strDesc, strT, fFirstPart);
			}

			int mpBefore = ReadValOrNinch(pttp, ktptSpaceBefore);
			int mpAfter = ReadValOrNinch(pttp, ktptSpaceAfter);
			if (mpBefore != knNinch || mpAfter != knNinch)
			{
				AppendDescPart(strDesc, kstidSpace, fFirstPart);
				AppendMeasurement(strDesc, mpBefore, knpt, kstidBeforeFmt);
				AppendMeasurement(strDesc, mpAfter, knpt, kstidAfterFmt);
			}

			int bulnum = ReadValOrNinch(pttp, ktptBulNumScheme);
			AddIf(strDesc, bulnum >= kvbnBulletBase && bulnum < kvbnBulletMax,
				kstidBulleted, fFirstPart);
			AddIf(strDesc, bulnum >= kvbnNumberBase && bulnum < kvbnNumberMax,
				kstidNumbered, fFirstPart);

			int mpBTop = ReadValOrNinch(pttp, ktptBorderTop);
			int mpBB = ReadValOrNinch(pttp, ktptBorderBottom);
			int mpBL = ReadValOrNinch(pttp, ktptBorderLeading);
			int mpBTr = ReadValOrNinch(pttp, ktptBorderTrailing);

			if (mpBTop != knNinch || mpBB != knNinch || mpBL != knNinch || mpBTr != knNinch)
			{
				AppendDescPart(strDesc, kstidBorderColon, fFirstPart);
				int clrBorder = ReadValOrNinch(pttp, ktptBorderColor);
				bool fFirstBorder = true;
				if (clrBorder != knNinch)
				{
					StrApp strClr;
					strClr.Load(g_ct.GetColorRid(g_ct.GetIndexFromColor(clrBorder)));
					strDesc.Append(strClr.Chars());
					fFirstBorder = false;
				}
				AppendBorderInfo(strDesc, mpBTop, kstidTopBdrFmt, fFirstBorder);
				AppendBorderInfo(strDesc, mpBB, kstidBottomBdrFmt, fFirstBorder);
				AppendBorderInfo(strDesc, mpBL, kstidLeadingBdrFmt, fFirstBorder);
				AppendBorderInfo(strDesc, mpBTr, kstidTrailingBdrFmt, fFirstBorder);
			}


			// Add info about writing-system overrides of font info.
			Vector<int> vwsSoFar;


			// Get the appropropriate writing system factory.
			ILgWritingSystemFactoryPtr qwsf;
			AssertPtr(m_pafsd);
			m_pafsd->GetLgWritingSystemFactory(&qwsf);
			AssertPtr(qwsf);
		//-		IWritingSystemPtr qws;

			// Each iteration of this loop processes information about one writing system.
			SmartBstr sbstrCharStyles;
			CheckHr(pttp->GetStrPropValue(kspWsStyle, &sbstrCharStyles));
			if (sbstrCharStyles.Length())
			{
				FwStyledText::DecodeFontPropsString(sbstrCharStyles, m_vesi, vwsSoFar);

				SmartBstr sbstrWs;
				StrApp strWs;
				int wsUser;
				CheckHr(qwsf->get_UserWs(&wsUser));
				SmartBstr sbstrAbbr;
				for (int iesi = 0; iesi < m_vesi.Size(); iesi++)
				{
					WsStyleInfo & esi = m_vesi[iesi];
					if (vwsSoFar[iesi] == 0)
						continue;		// Ignore writing system set to 0.
					fFirstPart = true;
					StrApp strT;
					StrApp strT2;
					strT.Format(_T("\n"));
					// Use the abbreviation in the user ws if it exists.
					// else try for an abbreviation in each ws in m_vwsProj in turn,
					// else use the ICU locale name as a last resort.
					IWritingSystemPtr qws;
					CheckHr(qwsf->GetStrFromWs(vwsSoFar[iesi], &sbstrWs));
					CheckHr(qwsf->get_Engine(sbstrWs, &qws));
					CheckHr(qws->get_Abbr(wsUser, &sbstrAbbr));
					if (sbstrAbbr.Length() == 0)
					{
						for (int iws = 0; iws < m_vwsProj.Size(); ++iws)
						{
							CheckHr(qws->get_Abbr(m_vwsProj[iws], &sbstrAbbr));
							if (sbstrAbbr.Length() != 0)
								break;
						}
					}
					if (sbstrAbbr.Length() == 0)
						strWs.Assign(sbstrWs.Chars(), sbstrWs.Length());
					else
						strWs.Assign(sbstrAbbr.Chars(), sbstrAbbr.Length());
					strT2.Format(_T("%s: "), strWs.Chars());
					if (strT2 == _T("___: "))
						strT2.Load(kctidFgUnknown);
					strT.Append(strT2);
					strDesc.Append (strT);
					AppendDescPart(strDesc,
						FwStyledText::FontStringMarkupToUi(false, esi.m_stuFontFamily),
						fFirstPart);
					if (esi.m_mpSize != knNinch)
					{
						AfUtil::MakeMsrStr (esi.m_mpSize , knpt, &strb);
						AppendDescPart(strDesc, strb, fFirstPart);
					}
					if (esi.m_fBold == kttvForceOn || esi.m_fBold == kttvInvert)
						AppendDescPart(strDesc, kstidBold, fFirstPart);
					if (esi.m_fItalic == kttvForceOn || esi.m_fItalic == kttvInvert)
						AppendDescPart(strDesc, kstidItalic, fFirstPart);
					if (esi.m_ssv == kssvSuper)
						AppendDescPart(strDesc, kstidFfdSuperscript, fFirstPart);
					else if (esi.m_ssv == kssvSub)
						AppendDescPart(strDesc, kstidFfdSubscript, fFirstPart);
					AppendTextIs(strDesc, esi.m_clrFore, esi.m_clrBack, fFirstPart);

					AppendUnderlineInfo(strDesc, esi.m_clrUnder, esi.m_unt, fFirstPart);

					AppendOffsetInfo(strDesc, esi.m_mpOffset, fFirstPart);
				} // 'for' loop
			}
		}
		::SetDlgItemText(m_hwnd, kctidFgDescription, strDesc.Chars());
// **************************************
	}
	catch(...)
	{
		m_fSuppressLossOfFocus = false;
		throw;
	}
	m_fSuppressLossOfFocus = false;
} //:> FmtGenDlg::SetDialogValues.
예제 #8
0
void AppendDescPart(StrApp & strDesc, StrAppBuf strbPart, bool & fFirst)
{
	AppendDescPart(strDesc, strbPart.Chars(), fFirst);
}
예제 #9
0
/*----------------------------------------------------------------------------------------------
	Called by the framework to initialize the dialog. All one-time initialization should be
	done here (that is, all controls have been created and have valid hwnd's, but they
	need initial values.)

	See ${AfDialog#FWndProc}
	@param hwndCtrl (not used)
	@param lp (not used)
	@return true if Successful
----------------------------------------------------------------------------------------------*/
bool RnTlsOptDlg::OnInitDlg(HWND hwndCtrl, LPARAM lp)
{
	m_qrmw = dynamic_cast<RecMainWnd *>(MainWindow());
	AfMdiClientWndPtr qmdic = m_qrmw->GetMdiClientWnd();
	AssertPtr(qmdic);
	// Cancel the dialog if we aren't allowed to make changes.
	AfClientRecWndPtr qafcrw = dynamic_cast<AfClientRecWnd *>(qmdic->GetCurChild());
	// This might not exist yet if the filter doesn't match anything during startup.
	if (qafcrw && !qafcrw->IsOkToChange())
	{
		SuperClass::OnCancel();
		return true;
	}

	Assert(m_cTabs == 6); // Ensure that the number of dialogs is what we expect.
	m_hwndTab = GetDlgItem(m_hwnd, kcidTlsOptDlgTab);

	AfLpInfo * plpi = m_qrmw->GetLpInfo();
	AssertPtr(plpi);

	// Setup m_vuvs
	plpi->GetDbInfo()->GetCopyUserViewSpecs(&m_vuvs);
	SetVuvsCopy();

	AfViewBarShell * pvwbrs = m_qrmw->GetViewBarShell();
	AssertPtr(pvwbrs);

	// CAUTION! The order these are inserted is important since we use constant indexes to
	// access them (e.g., kidlgGeneral).
	AfDialogViewPtr qadv;
	qadv.Attach(NewObj TlsOptDlgCst(this));
	m_vdlgv.Push(qadv);
	qadv.Attach(NewObj TlsOptDlgVw(this));
	m_vdlgv.Push(qadv);
	qadv.Attach(NewObj FwFilterDlg(this));
	m_vdlgv.Push(qadv);
	qadv.Attach(NewObj TlsOptDlgSort(this));
	m_vdlgv.Push(qadv);
	qadv.Attach(NewObj TlsOptDlgOvr(this));
	m_vdlgv.Push(qadv);
	qadv.Attach(NewObj TlsOptDlgGen(this));
	m_vdlgv.Push(qadv);

	// Initialize the object classes that we can create in this dialog.
	TlsObject to;
	to.m_clsid = kclidRnEvent;
	to.m_nLevel = 0;
	to.m_strName.Load(kstidEventEntry);
	m_vto.Push(to);
	to.m_clsid = kclidRnAnalysis;
	to.m_nLevel = 0;
	to.m_strName.Load(kstidAnalEntry);
	m_vto.Push(to);

	// Initialize the Custom Define In vector.
	to.m_clsid = kclidRnEvent;
	to.m_nLevel = 0;
	to.m_strName.Load(kstidEventEntry);
	to.m_strClsName = "RnEvent";
	m_vcdi.Push(to);
	to.m_clsid = kclidRnAnalysis;
	to.m_nLevel = 0;
	to.m_strName.Load(kstidAnalEntry);
	to.m_strClsName = "RnAnalysis";
	m_vcdi.Push(to);
	to.m_clsid = kclidRnGenericRec;
	to.m_nLevel = 1000; // Level 1000 means ALL Entries
	to.m_strName.Load(kstidTlsOptCstAllEnt);
	to.m_strClsName = "RnGenericRec";
	m_vcdi.Push(to);
	m_iDefaultCstDfn = m_vcdi.Size() - 1;

	// If we don't get a reasonable values from GetCurClsLevel, we just default to 0 for the
	// index.
	m_ivto = 0;
	for (int ivto = 0; ivto < m_vto.Size(); ++ivto)
	{
		if (m_vto[ivto].m_clsid == m_tgv.clsid
			&& m_vto[ivto].m_nLevel == m_tgv.nLevel)
		{
			m_ivto = ivto;
			break;
		}
	}

	// Initialize the master view types supported by this dialog.
	TlsView tv;
	tv.m_vwt = kvwtBrowse;
	tv.m_fMaster = false;
	m_vtv.Push(tv);
	tv.m_vwt = kvwtDE;
	tv.m_fMaster = true;
	m_vtv.Push(tv);
	tv.m_vwt = kvwtDoc;
	tv.m_fMaster = false;
	m_vtv.Push(tv);

	// Update the General tab.
	TlsOptDlgGen * ptodg = dynamic_cast<TlsOptDlgGen *>(m_vdlgv[kidlgGeneral].Ptr());
	AssertPtr(ptodg);
	ptodg->SetDialogValues(m_vuvs, &m_siwndClientDel);

	// Update the Custom Fields tab.
	TlsOptDlgCst * ptodc = dynamic_cast<TlsOptDlgCst *>(m_vdlgv[kidlgCustom].Ptr());
	AssertPtr(ptodc);
	ptodc->SetDialogValues(m_vuvs, &m_siwndClientDel, &m_siCustFldDel);

	int iv1;

	// Update the Views tab.
	TlsOptDlgVw * ptodv = dynamic_cast<TlsOptDlgVw *>(m_vdlgv[kidlgViews].Ptr());
	AssertPtr(ptodv);
	if (m_tgv.itabInitial == kidlgViews && m_tgv.iv1 >= 0)
	{
		iv1 = m_tgv.iv1;
	}
	else
	{
		// Use the current view that is selected.
		Set<int> sisel;
		pvwbrs->GetSelection(m_qrmw->GetViewbarListIndex(kvbltView), sisel);
		if (sisel.Size())
			iv1 = *sisel.Begin();
		else
		{
			iv1 = -1;
			Assert(!qafcrw);
		}
	}
	if (iv1 >= 0)
		ptodv->SetDialogValues(m_vuvs, &m_siwndClientDel, iv1);

	// Update the Filters tab.
	FwFilterDlg * pfltdlg = dynamic_cast<FwFilterDlg *>(m_vdlgv[kidlgFilters].Ptr());
	AssertPtr(pfltdlg);
	if (m_tgv.itabInitial == kidlgFilters && m_tgv.iv1 >= 0)
	{
		iv1 = m_tgv.iv1;
	}
	else
	{
		// Use the current filter that is selected.
		Set<int> sisel;
		pvwbrs->GetSelection(m_qrmw->GetViewbarListIndex(kvbltFilter), sisel);
		if (sisel.Size())
			iv1 = *sisel.Begin() - 1; // Subtract one for the No Filter item.
		else
		{
			iv1 = -1;
			Assert(!qafcrw);
		}
	}
	pfltdlg->SetDialogValues(m_qrmw, Max(0, iv1));

	// Update the Sort Methods tab.
	TlsOptDlgSort * psrtdlg = dynamic_cast<TlsOptDlgSort *>(m_vdlgv[kidlgSortMethods].Ptr());
	AssertPtr(psrtdlg);
	if (m_tgv.itabInitial == kidlgSortMethods && m_tgv.iv1 >= 0)
	{
		iv1 = m_tgv.iv1;
	}
	else
	{
		// Use the current sort method that is selected.
		Set<int> sisel;
		pvwbrs->GetSelection(m_qrmw->GetViewbarListIndex(kvbltSort), sisel);
		if (sisel.Size())
			iv1 = *sisel.Begin() - 1; // Subtract one for the No sort item.
		else
		{
			iv1 = -1;
			Assert(!qafcrw);
		}
	}
	psrtdlg->SetDialogValues(m_qrmw, Max(0, iv1));

	// Update the Overlays tab.
	TlsOptDlgOvr * ptodo = dynamic_cast<TlsOptDlgOvr *>(m_vdlgv[kidlgOverlays].Ptr());
	AssertPtr(ptodo);
	if (m_tgv.itabInitial == kidlgOverlays && m_tgv.iv1 >= 0)
	{
		iv1 = m_tgv.iv1;
	}
	else
	{
		// Use the first overlay that is selected.
		Set<int> sisel;
		pvwbrs->GetSelection(m_qrmw->GetViewbarListIndex(kvbltOverlay), sisel);
		if (sisel.Size())
			iv1 = *sisel.Begin() - 1; // Subtract one for the No Overlay item.
		else
		{
			iv1 = -1;
			Assert(!qafcrw);
		}
	}
	ptodo->SetDialogValues(plpi, Max(0, iv1),
		(m_tgv.itabInitial == kidlgOverlays && m_tgv.iv2 >= 0) ? m_tgv.iv2 : 0);

	// WARNING: If this ever gets changed to anything but a fixed length buffer, make sure
	// ti.pszText is set after loading each string, since the memory pointed to by strb
	// could be different each time.
	StrAppBuf strb;
	TCITEM ti;
	ti.mask = TCIF_TEXT;
	ti.pszText = const_cast<achar *>(strb.Chars());

	// Add a tab to the tab control for each dialog view.
	strb.Load(kstidTlsOptCust);
	TabCtrl_InsertItem(m_hwndTab, kidlgCustom, &ti);
	strb.Load(kstidTlsOptView);
	TabCtrl_InsertItem(m_hwndTab, kidlgViews, &ti);
	strb.Load(kstidTlsOptFltr);
	TabCtrl_InsertItem(m_hwndTab, kidlgFilters, &ti);
	strb.Load(kstidTlsOptSort);
	TabCtrl_InsertItem(m_hwndTab, kidlgSortMethods, &ti);
	strb.Load(kstidTlsOptOvr);
	TabCtrl_InsertItem(m_hwndTab, kidlgOverlays, &ti);
	strb.Load(kstidTlsOptGen);
	TabCtrl_InsertItem(m_hwndTab, kidlgGeneral, &ti);

	// This section must be after at least one tab gets added to the tab control.
	RECT rcTab;
	::GetWindowRect(m_hwndTab, &rcTab);
	TabCtrl_AdjustRect(m_hwndTab, false, &rcTab);
	POINT pt = { rcTab.left, rcTab.top };
	::ScreenToClient(m_hwnd, &pt);
	m_dxsClient = pt.x;
	m_dysClient = pt.y;

	// Subclass the Help button.
	AfButtonPtr qbtn;
	qbtn.Create();
	qbtn->SubclassButton(m_hwnd, kctidHelp, kbtHelp, NULL, 0);

	ShowChildDlg(m_tgv.itabInitial);
	m_siwndClientDel.Clear();
	m_siCustFldDel.Clear();

	AfApp::Papp()->EnableMainWindows(false);

	SetFocus(::GetDlgItem(m_hwnd, kcidTlsOptDlgTab));
	return SuperClass::OnInitDlg(hwndCtrl, lp);
}
예제 #10
0
/*----------------------------------------------------------------------------------------------
	Called by the framework to initialize the dialog. All one-time initialization should be
	done here (that is, all controls have been created and have valid hwnd's, but they
	need initial values.)

	See ${AfDialog#FWndProc}
	@param hwndCtrl (not used)
	@param lp (not used)

	@return true if Successful
----------------------------------------------------------------------------------------------*/
bool DetailsPropDlgTab::OnInitDlg(HWND hwndCtrl, LPARAM lp)
{
	HICON hicon = m_ppropd->GetIconHandle();
	if (hicon)
	{
		::SendMessage(::GetDlgItem(m_hwnd, kridDetailsPropTabObjIcon), STM_SETICON,
			(WPARAM)hicon, (LPARAM)0);
	}

	m_hfontLarge = AfGdi::CreateFont(16, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, ANSI_CHARSET,
		OUT_CHARACTER_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
		_T("MS Sans Serif"));
	if (m_hfontLarge)
	{
		::SendMessage(::GetDlgItem(m_hwnd, kridDetailsPropTabBigName), WM_SETFONT,
			(WPARAM)m_hfontLarge, false);
	}
	::SetWindowText(::GetDlgItem(m_hwnd, kridDetailsPropTabBigName), m_ppropd->GetName());

	::SetWindowText(::GetDlgItem(m_hwnd, kctidDetailsPropTabAbbr), m_ppropd->GetAbbr());
	::SetWindowText(::GetDlgItem(m_hwnd, kctidDetailsPropTabHelpF), m_ppropd->GetHelpFile());

	::SendDlgItemMessage(m_hwnd, kctidDetailsPropTabSort, BM_SETCHECK, m_ppropd->GetSorted(), 0);
	::SendDlgItemMessage(m_hwnd, kctidDetailsPropTabDup, BM_SETCHECK, m_ppropd->GetDuplicates(), 0);
	if (m_ppropd->GetDepth() > 1)
		::SendDlgItemMessage(m_hwnd, kctidDetailsPropTabHeir, BM_SETCHECK, BST_CHECKED, 0);
	else
		::SendDlgItemMessage(m_hwnd, kctidDetailsPropTabHeir, BM_SETCHECK, BST_UNCHECKED, 0);

	// Initialize values for the Display combo box.
	HWND hwndCbo = ::GetDlgItem(m_hwnd, kctidDetailsPropTabDisp);
	StrAppBuf strb;
	strb.Load(kstidListsDetailsName);
	::SendMessage(hwndCbo, CB_ADDSTRING, 0, (LPARAM)strb.Chars());
	strb.Load(kstidListsDetailsAN);
	::SendMessage(hwndCbo, CB_ADDSTRING, 0, (LPARAM)strb.Chars());
	strb.Load(kstidListsDetailsAbbr);
	::SendMessage(hwndCbo, CB_ADDSTRING, 0, (LPARAM)strb.Chars());
	::SendMessage(hwndCbo, CB_SETCURSEL , (WPARAM)m_ppropd->GetDispOpt(), 0);

	// Load "Writing System" Combo Box
	hwndCbo = ::GetDlgItem(m_hwnd, kctidDetailsPropTabWS);
	strb.Load(kstidWSAnals);
	::SendMessage(hwndCbo, CB_ADDSTRING, 0, (LPARAM)strb.Chars());
	strb.Load(kstidWSVerns);
	::SendMessage(hwndCbo, CB_ADDSTRING, 0, (LPARAM)strb.Chars());
	strb.Load(kstidWSAnalVerns);
	::SendMessage(hwndCbo, CB_ADDSTRING, 0, (LPARAM)strb.Chars());
	strb.Load(kstidWSVernAnals);
	::SendMessage(hwndCbo, CB_ADDSTRING, 0, (LPARAM)strb.Chars());
	int iWSCboSel;
	int ws = m_ppropd->GetWs();
		switch (ws)
		{
		case kwsAnals:
			iWSCboSel = 0;
			break;
		case kwsVerns:
			iWSCboSel = 1;
			break;
		case kwsAnalVerns:
			iWSCboSel = 2;
			break;
		case kwsVernAnals:
			iWSCboSel = 3;
			break;
		}
	::SendMessage(hwndCbo, CB_SETCURSEL , (WPARAM)iWSCboSel, 0);

	m_fInitialized = true;

	return SuperClass::OnInitDlg(hwndCtrl, lp);
}
예제 #11
0
/*----------------------------------------------------------------------------------------------
	The hwnd has been attached.
----------------------------------------------------------------------------------------------*/
void HwMainWnd::PostAttach(void)
{
	StrAppBuf strbT; // Holds temp string

	// Set the default caption text.
	strbT.Load(kstidHelloWorld);
	::SendMessage(m_hwnd, WM_SETTEXT, 0, (LPARAM)strbT.Chars());

	// This creates the main frame window and sets it as the current window. It also
	// creates the rebar and status bar.
	SuperClass::PostAttach();

	const int rgrid[] =
	{
		kridTBarStd,
		kridHwTBarIns,
		kridHwTBarTools,
		kridHwTBarWnd,
	};

	GetMenuMgr()->LoadToolBars(rgrid, SizeOfArray(rgrid));

	// Create the menu bar.
	AfMenuBarPtr qmnbr;
	qmnbr.Create();
	qmnbr->Initialize(m_hwnd, kridAppMenu, kridAppMenu, "Menu Bar");
	m_vqtlbr.Push(qmnbr.Ptr());

	// Create the toolbars.
	AfToolBarPtr qtlbr;

	qtlbr.Create();
	qtlbr->Initialize(kridTBarStd, kridTBarStd, "Standard");
	m_vqtlbr.Push(qtlbr);

	qtlbr.Create();
	qtlbr->Initialize(kridHwTBarIns, kridHwTBarIns, "Insert");
	m_vqtlbr.Push(qtlbr);

	qtlbr.Create();
	qtlbr->Initialize(kridHwTBarTools, kridHwTBarTools, "Tools");
	m_vqtlbr.Push(qtlbr);

	qtlbr.Create();
	qtlbr->Initialize(kridHwTBarWnd, kridHwTBarWnd, "Window");
	m_vqtlbr.Push(qtlbr);

	// Load window settings.
	LoadSettings(NULL, false);

	g_app.AddCmdHandler(this, 1);
	m_qstbr->RestoreStatusText();

	// Create the client window.
	const int kwidChild = 1000;
	WndCreateStruct wcs;
	wcs.InitChild("STATIC", m_hwnd, kwidChild);
	m_qwndHost.Create();
	m_qwndHost->CreateAndSubclassHwnd(wcs);

	Assert(memcmp(&CLSID_SaCtrlEvent, &DIID__DSAEvents, isizeof(GUID)) == 0);

	CComCoClass<SaCtrlEvent>::CreateInstance(&m_qsce);
	IUnknownPtr qunk;
	CheckHr(AtlAxCreateControlEx(L"SA.SACtrl.1", m_qwndHost->Hwnd(), NULL, NULL, &qunk,
		DIID__DSAEvents, (IUnknown *)m_qsce.Ptr()));
	CheckHr(qunk->QueryInterface(DIID__DSA, (void **)&m_qctrl));
	m_qsce->Init(this, m_qctrl);
	StrUni stu(L"baluchi.wav");
	CheckHr(m_qctrl->put_WaveFile(stu.Bstr()));
	CheckHr(m_qctrl->raw_SetGraphs(GRAPH_MAGNITUDE, GRAPH_MAGNITUDE));
	CheckHr(m_qctrl->put_ShowContextMenu(false));
	CheckHr(m_qctrl->put_ShowCursorContextMenu(false));

	::ShowWindow(m_qwndHost->Hwnd(), SW_SHOW);

	g_app.AddCmdHandler(this, 1);
}