/*----------------------------------------------------------------------------------------------
Initialize variables prior to creating the control, i.e. create/attach a ISilDataAccess
and add TsString to cache
(may be explicitly called when created by ATL, because in this case TssEdit::Create() will
not be called)
----------------------------------------------------------------------------------------------*/
void TssEdit::PreCreate(ILgWritingSystemFactory * pwsf, int ws, ITsString * ptss,
IActionHandler * pacth)
{
AssertPtr(pwsf);
AssertPtrN(ptss);
ITsStringPtr qtss = ptss;
if (!ptss)
{
ITsStrFactoryPtr qtsf;
qtsf.CreateInstance(CLSID_TsStrFactory);
CheckHr(qtsf->MakeStringRgch(L"", 0, ws, &qtss));
}
if (pacth)
{
// We want actions in this edit box to be undoable.
VwUndoDaPtr quda;
quda.Attach(NewObj VwUndoDa);
CheckHr(quda->SetActionHandler(pacth));
m_qcda.Attach(quda.Detach());
}
else
{
m_qcda.Attach(NewObj VwCacheDa);
}
m_qcda->putref_WritingSystemFactory(pwsf);
m_qcda->CacheStringProp(khvoString, ktagString, qtss);
}
/*----------------------------------------------------------------------------------------------
Set the text of the control to be equal to ptss. If ptss is NULL, the edit box is cleared.
Message: FW_EM_SETTEXT.
----------------------------------------------------------------------------------------------*/
void TssEdit::SetText(ITsString * ptss)
{
AssertPtrN(ptss); // NULL can be used to clear string.
Assert(m_qcda);
ITsStringPtr qtss = ptss;
if (!ptss)
{
ITsStrFactoryPtr qtsf;
qtsf.CreateInstance(CLSID_TsStrFactory);
CheckHr(qtsf->MakeStringRgch(L"", 0, m_wsBase, &qtss));
}
ITsStringPtr qtssOld;
CheckHr(m_qcda->get_StringProp(khvoString, ktagString, &qtssOld));
int cchOld;
CheckHr(qtssOld->get_Length(&cchOld));
CheckHr(m_qcda->CacheStringProp(khvoString, ktagString, qtss));
int cchNew;
CheckHr(qtss->get_Length(&cchNew));
// Pretend the whole length has been deleted and the whole new inserted.
CheckHr(m_qcda->PropChanged(NULL, kpctNotifyAll, khvoString, ktagString, 0, cchNew, cchOld));
OnUpdate();
::UpdateWindow(m_hwnd);
OnChange();
}
/*----------------------------------------------------------------------------------------------
This initializes the string based after the pssl and pss have been set. It takes into
account whether the view is hierarchical or not.
@param fHier
@param pnt
----------------------------------------------------------------------------------------------*/
void AfDeFeCliRef::InitContents(bool fHier, PossNameType pnt)
{
Assert(m_hvoPssl); // This must be set prior to calling this method.
Assert(pnt < kpntLim);
SuperClass::Init(); // Initialize the superclass.
m_fHier = fHier;
m_pnt = pnt;
if (!m_pss)
return; // If the reference isn't set, we don't have anything to display.
ITsStringPtr qtss;
ITsStrFactoryPtr qtsf;
StrUni stu;
PossListInfoPtr qpli;
PossItemInfo * ppii;
int ipss;
qtsf.CreateInstance(CLSID_TsStrFactory);
GetLpInfo()->LoadPossList(m_hvoPssl, m_wsMagic, &qpli);
AssertPtr(qpli);
ipss = qpli->GetIndexFromId(m_pss);
ppii = qpli->GetPssFromIndex(ipss);
AssertPtr(ppii);
if (m_fHier)
ppii->GetHierName(qpli, stu, m_pnt);
else
ppii->GetName(stu, m_pnt);
int ws = ppii->GetWs();
qtsf->MakeStringRgch(stu.Chars(), stu.Length(), ws, &qtss);
m_qtss = qtss;
qpli->AddNotify(this);
}
/*----------------------------------------------------------------------------------------------
Initialize the data from the given file, or create a new empty string.
----------------------------------------------------------------------------------------------*/
void WpDa::InitNew(StrAnsi staFileName)
{
if (staFileName == "")
{
InitNewEmpty();
return;
}
Vector<StrUni> vstu;
ReadTextFromFile(staFileName, vstu);
HVO * prghvoPara = NewObj HVO[vstu.Size()];
for (int istu = 0; istu < vstu.Size(); istu++)
prghvoPara[istu] = istu + 2;
CacheVecProp(1, kflidStText_Paragraphs, prghvoPara, vstu.Size());
ITsStrFactoryPtr qtsf;
qtsf.CreateInstance(CLSID_TsStrFactory);
int enc = 100; // replace by the right number when we figure out what it is
for (istu = 0; istu < vstu.Size(); istu++)
{
StrUni stuPara = vstu[istu];
ITsStringPtr qtss;
CheckHr(qtsf->MakeStringRgch(stuPara.Chars(), stuPara.Length(), enc, &qtss));
CacheStringProp(istu + 2, kflidStTxtPara_Contents, qtss);
}
ITsPropsBldrPtr qtpb;
qtpb.CreateInstance(CLSID_TsPropsBldr);
StrUni stuNormal = L"Normal";
CheckHr(qtpb->SetStrPropValue(kspNamedStyle,stuNormal.Bstr()));
delete[] prghvoPara;
}
/*----------------------------------------------------------------------------------------------
Load the data from the given file into an empty window.
----------------------------------------------------------------------------------------------*/
void WpDa::LoadIntoEmpty(StrAnsi staFileName, WpChildWnd * pwcw)
{
Assert(staFileName != "");
int ctss;
CheckHr(get_VecSize(1, kflidStText_Paragraphs, &ctss));
Assert(ctss <= 1);
Vector<StrUni> vstu;
ReadTextFromFile(staFileName, vstu);
HVO * prghvoPara = NewObj HVO[vstu.Size()];
for (int istu = 0; istu < vstu.Size(); istu++)
prghvoPara[istu] = istu + 2;
CacheVecProp(1, kflidStText_Paragraphs, prghvoPara, vstu.Size());
ITsStrFactoryPtr qtsf;
qtsf.CreateInstance(CLSID_TsStrFactory);
int enc = 100; // replace by the right number when we figure out what it is
for (istu = 0; istu < vstu.Size(); istu++)
{
StrUni stuPara = vstu[istu];
ITsStringPtr qtss;
CheckHr(qtsf->MakeStringRgch(stuPara.Chars(), stuPara.Length(), enc, &qtss));
CacheStringProp(istu + 2, kflidStTxtPara_Contents, qtss);
}
ITsPropsBldrPtr qtpb;
qtpb.CreateInstance(CLSID_TsPropsBldr);
StrUni stuNormal = L"Normal";
CheckHr(qtpb->SetStrPropValue(kspNamedStyle, stuNormal.Bstr()));
delete[] prghvoPara;
pwcw->ChangeNumberOfStrings(vstu.Size());
}
/*----------------------------------------------------------------------------------------------
This method works like TrackPopupMenu (supplying m_hwnd as the menu argument, and the
required nulls for the last two arguments), except that if we are in what's this help mode,
it instead tries to find the 'what's this' help for the selected item and displays it. If
it does this, it also calls ToggleHelpMode when done. For it to work, the cid must identify
a string containing multi-part names from which the krstWhatsThisEnabled option can be
retrieved.
@param hMenu handle to shortcut menu
@param uFlags options
@param x horizontal position
@param y vertical position
@param wsUser user interface writing system id.
@param ptpm contains the area not to overlap (defaults to NULL)
----------------------------------------------------------------------------------------------*/
BOOL AfWnd::TrackPopupWithHelp(HMENU hMenu, UINT uFlags, int x, int y, int wsUser,
TPMPARAMS * ptpm)
{
if (AfMainWnd::InHelpMode())
{
// Trackit without notifing the parent and get the command id.
bool fReturnCmd = uFlags & TPM_RETURNCMD;
uFlags |= TPM_NONOTIFY | TPM_RETURNCMD;
// Do this BEFORE we show the menu, so it shows normally.
AfMainWnd::ToggleHelpMode();
// This is dirty trick played by Windows that works because BOOL is really a short.
BOOL cid = ::TrackPopupMenuEx(hMenu, uFlags, x, y, m_hwnd, ptpm);
StrApp staMsg;
AfUtil::GetResourceStr(krstWhatsThisEnabled, cid, staMsg);
StrUni stuMsg = staMsg;
ITsStrFactoryPtr qtsf;
qtsf.CreateInstance(CLSID_TsStrFactory);
ITsStringPtr qtssMsg;
qtsf->MakeStringRgch(stuMsg.Chars(), stuMsg.Length(), wsUser, &qtssMsg);
AfContextHelpWndPtr qchw;
qchw.Attach(NewObj AfContextHelpWnd);
Point pt (x, y);
qchw->Create(m_hwnd, qtssMsg, pt);
if (fReturnCmd)
return cid;
else
return cid ? TRUE : 0;
}
else
{
return ::TrackPopupMenuEx(hMenu, uFlags, x, y, m_hwnd, ptpm);
}
}
/*----------------------------------------------------------------------------------------------
This is the main interesting method of displaying objects and fragments of them.
Here a text is displayed by displaying its paragraphs;
and a paragraph is displayed by invoking its style rule, making a paragraph,
and displaying its contents.
----------------------------------------------------------------------------------------------*/
STDMETHODIMP TestStVc::Display(IVwEnv * pvwenv, HVO hvo, int frag)
{
try
{
switch(frag)
{
case kfrText:
{// BLOCK for var skip warnings
// We need to show something, since the current view code can't handle a property
// containing no boxes.
// Review JohnT: should we show an empty string or something?
// Should we prevent the occurrence of texts with no paragraphs?
int cpara = 0;
ISilDataAccessPtr qsda;
CheckHr(pvwenv->get_DataAccess(&qsda));
if (hvo)
CheckHr(qsda->get_VecSize(hvo, kflidStText_Paragraphs, &cpara));
if (!cpara)
{
// Either we have no ST object at all, or it is empty of paragraphs. The
// current view code can't handle either, so stick something in.
ITsStrFactoryPtr qtsf;
qtsf.CreateInstance(CLSID_TsStrFactory);
ITsStringPtr qtssMissing;
CheckHr(qtsf->MakeStringRgch(L"<no paragraphs>", 15, 0, &qtssMissing));
CheckHr(pvwenv->AddString(qtssMissing));
break;
}
CheckHr(pvwenv->AddObjVecItems(kflidStText_Paragraphs, this, kfrPara));
}
break;
case kfrPara:
{ // BLOCK
// Invoke the paragraph's style rule if any
ISilDataAccessPtr qsda;
CheckHr(pvwenv->get_DataAccess(&qsda));
ITsTextPropsPtr qttp;
CheckHr(qsda->get_UnknownProp(hvo, kflidStPara_StyleRules, IID_ITsTextProps,
(void **) &qttp));
if (qttp)
CheckHr(pvwenv->put_Props(qttp));
// And make the paragraph containing the paragraph contents.
CheckHr(pvwenv->OpenParagraph());
CheckHr(pvwenv->AddStringProp(kflidStTxtPara_Contents));
CheckHr(pvwenv->CloseParagraph());
}
break;
}
}
catch (Throwable & thr)
{
return thr.Error();
}
catch (...)
{
return WarnHr(E_FAIL);
}
return S_OK;
}
/*----------------------------------------------------------------------------------------------
DisplayVariant is used for times and enumerations.
----------------------------------------------------------------------------------------------*/
STDMETHODIMP CleCustDocVc::DisplayVariant(IVwEnv * pvwenv, int tag, VARIANT v, int frag,
ITsString ** pptss)
{
BEGIN_COM_METHOD;
ChkComArgPtr(pvwenv);
ChkComOutPtr(pptss);
ITsStrFactoryPtr qtsf;
qtsf.CreateInstance(CLSID_TsStrFactory);
int ws = m_qlpi->GetDbInfo()->UserWs();
if (tag == kflidCmPerson_Gender || tag == kflidCmPerson_IsResearcher)
{
int itss = v.intVal;
int stid;
switch (tag)
{
case kflidCmPerson_Gender:
stid = kstidEnumGender;
break;
case kflidCmPerson_IsResearcher:
stid = kstidEnumNoYes;
if (itss)
itss = 1;
break;
default:
Assert(false);
break;
}
StrUni stuEnum(stid);
const wchar * pszEnum = stuEnum.Chars();
const wchar * pszEnumLim = stuEnum.Chars() + stuEnum.Length();
ITsStringPtr qtss;
//ITsStrFactoryPtr qtsf;
//qtsf.CreateInstance(CLSID_TsStrFactory);
int itssTry = 0;
while (pszEnum < pszEnumLim && itssTry <= itss)
{
const wchar * pszEnumNl = wcschr(pszEnum, '\n');
if (!pszEnumNl)
pszEnumNl = pszEnumLim;
if (itss == itssTry)
{
return qtsf->MakeStringRgch(pszEnum, (pszEnumNl - pszEnum), ws, pptss);
}
itssTry++;
pszEnum = pszEnumNl + 1;
}
// Fall-back behavior if we couldn't find a string: use the integer value.
char rgch[20];
_itoa_s(itss, rgch, 10);
StrUni stu(rgch);
return qtsf->MakeStringRgch(stu.Chars(), stu.Length(), ws, pptss);
}
return SuperClass::DisplayVariant(pvwenv, tag, v, frag, pptss);
END_COM_METHOD(g_fact1, IID_IVwViewConstructor)
}
/*----------------------------------------------------------------------------------------------
Construct the view constructor. Pass the RecordSpec of the view it is for, which allows it
to find its block specs.
ENHANCE JohnT: This is a rather low level object to know about the application and its list
of views. Should we just pass in the list of block specs?
----------------------------------------------------------------------------------------------*/
CleCustDocVc::CleCustDocVc(UserViewSpec * puvs, AfLpInfo * plpi, CleMainWnd * pcmw)
: VwCustDocVc(puvs, plpi, 0, kflidCmPossibilityList_Possibilities)
{
ITsStrFactoryPtr qtsf;
qtsf.CreateInstance(CLSID_TsStrFactory);
StrUni stu;
stu.Load(kstidSpaces0);
CheckHr(qtsf->MakeStringRgch(stu.Chars(), stu.Length(), m_qlpi->GetDbInfo()->UserWs(),
&m_qtssMissing));
ITsPropsBldrPtr qtpb;
qtpb.CreateInstance(CLSID_TsPropsBldr);
// Border thickness below about 1/96 inch, a single pixel on a typical display.
CheckHr(qtpb->SetIntPropValues(ktptBorderTop, ktpvMilliPoint, kdzmpInch / 96));
// About a line (say 12 point) of white space above and below the border.
CheckHr(qtpb->SetIntPropValues(ktptPadTop, ktpvMilliPoint, 12000));
CheckHr(qtpb->SetIntPropValues(ktptMarginTop, ktpvMilliPoint, 12000));
CheckHr(qtpb->GetTextProps(&m_qttpMain));
CheckHr(qtpb->SetIntPropValues(ktptBorderBottom, ktpvMilliPoint, kdzmpInch / 96));
CheckHr(qtpb->SetIntPropValues(ktptPadBottom, ktpvMilliPoint, 12000));
CheckHr(qtpb->GetTextProps(&m_qttpMainLast));
qtpb.CreateInstance(CLSID_TsPropsBldr);
CheckHr(qtpb->SetIntPropValues(ktptMarginTop, ktpvMilliPoint, 12000));
CheckHr(qtpb->GetTextProps(&m_qttpMainFirst));
qtpb.CreateInstance(CLSID_TsPropsBldr);
// Border thickness below about 1/96 inch, a single pixel on a typical display.
CheckHr(qtpb->SetIntPropValues(ktptBorderBottom, ktpvMilliPoint, kdzmpInch / 96));
CheckHr(qtpb->SetIntPropValues(ktptPadBottom, ktpvMilliPoint, 12000));
CheckHr(qtpb->SetIntPropValues(ktptMarginBottom, ktpvMilliPoint, 12000));
CheckHr(qtpb->GetTextProps(&m_qttpMainFlat));
// And make the one for subentries.
qtpb.CreateInstance(CLSID_TsPropsBldr);
CheckHr(qtpb->SetIntPropValues(ktptPadTop, ktpvMilliPoint, 12000));
CheckHr(qtpb->SetIntPropValues(ktptBorderTop, ktpvMilliPoint, 0));
CheckHr(qtpb->SetIntPropValues(ktptMarginBottom, ktpvMilliPoint, 0));
// The value below is sort of a default for one level of indentation; it will be
// adjusted for lower levels.
CheckHr(qtpb->SetIntPropValues(ktptPadLeading, ktpvMilliPoint, kdzmpInch * 3 / 10));
CheckHr(qtpb->GetTextProps(&m_qttpSub));
CheckHr(qtpb->SetIntPropValues(ktptBorderBottom, ktpvMilliPoint, kdzmpInch / 96));
CheckHr(qtpb->SetIntPropValues(ktptPadBottom, ktpvMilliPoint, 12000));
CheckHr(qtpb->GetTextProps(&m_qttpSubLast));
m_qRecVc.Attach(NewObj CleRecVc);
m_qcmw.Attach(pcmw);
AddRefObj(pcmw);
PossListInfoPtr qpli;
m_qlpi->LoadPossList(pcmw->GetHvoPssl(), pcmw->AnalysisEnc(), &qpli);
m_hvoPssl = qpli->GetPsslId();
}
/*----------------------------------------------------------------------------------------------
Return the what's-this help string for the Date Dialog ellipsis button.
@param pt not used.
@param pptss Address of a pointer to an ITsString COM object for returning the help string.
@return true.
----------------------------------------------------------------------------------------------*/
bool AfDeFeEdBoxBut::DeButton::GetHelpStrFromPt(Point pt, ITsString ** pptss)
{
AssertPtr(pptss);
StrApp str;
str.Load(kstidEllipsisBtnDateWhatsThisHelp); // No context help available
ITsStrFactoryPtr qtsf;
qtsf.CreateInstance(CLSID_TsStrFactory);
StrUni stu(str);
CheckHr(qtsf->MakeString(stu.Bstr(), m_pdee->UserWs(), pptss));
return true;
}
/*----------------------------------------------------------------------------------------------
Refresh the field from the data cache.
----------------------------------------------------------------------------------------------*/
void AfDeFeCliRef::UpdateField()
{
// Get the item info from the cache.
CustViewDaPtr qcvd;
GetDataAccess(&qcvd);
AssertPtr(qcvd);
HVO hvoPss;
CheckHr(qcvd->get_ObjectProp(m_hvoObj, m_flid, &hvoPss));
m_pss = hvoPss;
// Get the string from the poss cache.
ITsStringPtr qtss;
ITsStrFactoryPtr qtsf;
StrUni stu;
PossListInfoPtr qpli;
PossItemInfo * ppii;
int ipss;
qtsf.CreateInstance(CLSID_TsStrFactory);
int ws = m_ws;
if (m_pss)
{
GetLpInfo()->LoadPossList(m_hvoPssl, m_wsMagic, &qpli);
AssertPtr(qpli);
ipss = qpli->GetIndexFromId(m_pss);
if (ipss >= 0)
{
ppii = qpli->GetPssFromIndex(ipss);
AssertPtr(ppii);
if (m_fHier)
ppii->GetHierName(qpli, stu, m_pnt);
else
ppii->GetName(stu, m_pnt);
ws = ppii->GetWs();
}
}
qtsf->MakeStringRgch(stu.Chars(), stu.Length(), ws, &qtss);
m_qtss = qtss;
// If we have an edit box, update the contents.
if (m_hwnd)
{
// Setting the property causes a recursive call to OnChange, so we want to block it
// from making a further change. (e.g., when you backspace to set the string to null
// then tab to the next field, we want it to stay null, not go to the first item in
// the list.)
m_fRecurse = true;
::SendMessage(m_hwnd, FW_EM_SETTEXT, 0, (LPARAM)m_qtss.Ptr());
}
}
/*----------------------------------------------------------------------------------------------
Initialize an empty document. It has a document object (always ID 1!) and one paragraph
containing (implicitly) an empty string. Style is set to Normal
Review SharonC(JohnT): what encoding should the empty string have??
----------------------------------------------------------------------------------------------*/
void WpDa::InitNewEmpty()
{
HVO hvoPara = 2;
CacheVecProp(1, kflidStText_Paragraphs, &hvoPara, 1);
ITsStrFactoryPtr qtsf;
qtsf.CreateInstance(CLSID_TsStrFactory);
ITsStringPtr qtss;
int enc = 100;
CheckHr(qtsf->MakeStringRgch(L"", 0, enc, &qtss));
CacheStringProp(hvoPara, kflidStTxtPara_Contents, qtss);
ITsPropsBldrPtr qtpb;
qtpb.CreateInstance(CLSID_TsPropsBldr);
StrUni stuNormal = L"Normal";
CheckHr(qtpb->SetStrPropValue(kspNamedStyle, stuNormal.Bstr()));
}
/*----------------------------------------------------------------------------------------------
Create a new TssEdit. psz can be NULL if the control should start out empty.
----------------------------------------------------------------------------------------------*/
void TssEdit::Create(HWND hwndPar, int cid, DWORD dwStyle, HWND hwndToolTip, const achar * psz,
ILgWritingSystemFactory * pwsf, int ws, IActionHandler * pacth)
{
AssertPtrN(psz);
AssertPtr(pwsf);
ITsStringPtr qtss;
if (psz)
{
ITsStrFactoryPtr qtsf;
qtsf.CreateInstance(CLSID_TsStrFactory);
StrUni stu(psz);
CheckHr(qtsf->MakeString(stu.Bstr(), ws, &qtss));
}
Create(hwndPar, cid, dwStyle, hwndToolTip, qtss, pwsf, ws, pacth);
}
/*----------------------------------------------------------------------------------------------
The Ok button in the list chooser has been hit. Process the results from the list chooser.
@param pplc Pointer to the dialog box being closed.
----------------------------------------------------------------------------------------------*/
void AfDeFeCliRef::ChooserApplied(PossChsrDlg * pplc)
{
// Get the output values.
StrUni stu;
ITsStringPtr qtss;
ITsStrFactoryPtr qtsf;
HVO pssId;
qtsf.CreateInstance(CLSID_TsStrFactory);
pplc->GetDialogValues(pssId);
m_pss = pssId;
m_fRecurse = true;
if (pssId)
{
PossListInfoPtr qpli;
AfLpInfo * plpi = GetLpInfo();
AssertPtr(plpi);
plpi->LoadPossList(m_hvoPssl, m_wsMagic, &qpli);
AssertPtr(qpli);
int ipss = qpli->GetIndexFromId(pssId);
PossItemInfo * ppii = qpli->GetPssFromIndex(ipss);
if (m_fHier)
ppii->GetHierName(qpli, stu, m_pnt);
else
ppii->GetName(stu, m_pnt);
int ws = ppii->GetWs();
qtsf->MakeStringRgch(stu.Chars(), stu.Length(), ws, &qtss);
m_qtss = qtss;
::SendMessage(m_hwnd, FW_EM_SETTEXT, 0, (LPARAM)qtss.Ptr());
}
else
{
m_qtss = NULL;
::SendMessage(m_hwnd, FW_EM_SETTEXT, 0, NULL);
}
// I (KenZ) don't fully understand this. But if a user enters the chooser, and opens a
// list editor from there and adds a new item, closes the list editor, checks the new
// item in the chooser, selects OK, then moves to the next record without moving from
// the field, the added item is lost. We get ksyncPossList and ksyncAddPss sync messages
// from the list editor, but for some reason we are getting an extra ksyncPossList
// message after this method completes. That extra message is calling ListChanged which
// calls UpdateField, which reloads our temporary cache from the main cache and wipes out
// the change we just made. So until we can do something better, we'll save the changes
// here to make sure the UpdateField doesn't wipe out our change.
SaveEdit();
::InvalidateRect(m_hwnd, NULL, true);
}
void AfDeFeSt::MakeRoot(IVwGraphics * pvg, ILgWritingSystemFactory * pwsf, IVwRootBox ** pprootb)
{
AssertPtrN(pwsf);
*pprootb = NULL;
// Do we have a real text object? If not, make a fake one.
int cpara = 0;
ISilDataAccessPtr qsda = m_qcvd;
if (m_hvoText)
CheckHr(qsda->get_VecSize(m_hvoText, kflidStText_Paragraphs, &cpara));
if (!cpara)
{
// We make a dummy text that is complete enough to edit, in a separate data access
// object. On loss of focus, if this data access is dirty, we make corresponding
// real objects.
if (!m_hvoText)
m_hvoText = -1;
HVO hvoPara = -2;
m_qvcdMissing.CreateInstance(CLSID_VwCacheDa);
CheckHr(m_qvcdMissing->QueryInterface(IID_ISilDataAccess, (void **)&qsda));
m_qvcdMissing->CacheVecProp(m_hvoText, kflidStText_Paragraphs, &hvoPara,1);
ITsStrFactoryPtr qtsf;
qtsf.CreateInstance(CLSID_TsStrFactory);
ITsStringPtr qtssMissing;
CheckHr(qtsf->MakeStringRgch(L"", 0, m_ws, &qtssMissing));
m_qvcdMissing->CacheStringProp(hvoPara, kflidStTxtPara_Contents, qtssMissing);
}
IVwRootBoxPtr qrootb;
qrootb.CreateInstance(CLSID_VwRootBox);
CheckHr(qrootb->SetSite(this)); // pass root site
int frag = kfrText;
IVwViewConstructor * pvvc = m_qstvc;
if (pwsf)
CheckHr(qsda->putref_WritingSystemFactory(pwsf));
CheckHr(qrootb->putref_DataAccess(qsda));
CheckHr(qrootb->SetRootObjects(&m_hvoText, &pvvc, &frag,
GetLpInfo()->GetAfStylesheet(), 1));
*pprootb = qrootb;
(*pprootb)->AddRef();
RecMainWnd * prmw = dynamic_cast<RecMainWnd *>(m_qadsc->MainWindow());
if (prmw)
prmw->RegisterRootBox(qrootb);
}
/*----------------------------------------------------------------------------------------------
Close the current editor, saving changes that were made. This also updates the the cache
if the name or abbr fields were edited, this then causing the treebar to be updated.
@param fForce True if we want to force the editor closed without making any
validity checks or saving any changes.
----------------------------------------------------------------------------------------------*/
void CleDeFeString::EndEdit(bool fForce)
{
if (fForce)
{
SuperClass::EndEdit(fForce);
return;
}
CleMainWnd * pcmw = dynamic_cast<CleMainWnd *>(MainWindow());
Assert(pcmw);
PossListInfoPtr qpli = pcmw->GetPossListInfoPtr();
int ipss = qpli->GetIndexFromId(m_hvoObj);
if (ipss < 0)
{
SuperClass::EndEdit(fForce); // Closing an old editor after an item was removed.
return;
}
PossItemInfo * ppii = qpli->GetPssFromIndex(ipss);
AssertPtr(ppii);
StrUni stu;
const OLECHAR * prgwch;
int cch;
ITsStringPtr qtss;
AssertPtr(m_qadsc->MainWindow());
AfLpInfo * plpi = m_qadsc->MainWindow()->GetLpInfo();
AssertPtr(plpi);
AfDbInfo * pdbi;
pdbi = plpi->GetDbInfo();
AssertPtr(pdbi);
int wsMagic = qpli->GetWs();
int ws = plpi->ActualWs(wsMagic);
// At this point, all strings in a PossList cache are assumed to have the same writing system.
// However, if that writing system is missing, a non-null string from a different writing system is
// loaded. Thus if FRN is the writing system for the PossList cache, we can't tell from the
// cache whether the string we are getting is FRN or ENG, or some other writing system. When
// we display strings in this editor, we show actual strings for each writing system shown.
// Suppose we are showing FRN and ENG, but FRN is missing. If a person edits the ENG
// string that is showing, the user would expect the tree to reflect this change, since
// FRN is still missing. However we can't do this at this point because we don't know
// which writing system is actually being substituted in the tree. It could actually be a GER
// string because there also wasn't an ENG string. So until we cache encodings with each
// string, the best we can do is only modify the PossList cache if the string for the
// primary writing system changed. In that case, we now have a FRN string, so it should show
// in the tree as well.
CustViewDaPtr qcvd = pcmw->MainDa();
AssertPtr(qcvd);
// Get the current primary string.
CheckHr(qcvd->get_MultiStringAlt(m_hvoObj, m_flid, ws, &qtss));
if (qtss)
{
qtss->LockText(&prgwch, &cch);
qtss->UnlockText(prgwch);
}
// Trim leading and trailing space characters.
UnicodeString ust(prgwch, cch);
ust.trim();
stu.Assign(ust.getBuffer(), ust.length());
// We don't expect to use this for anything except name or abbr.
Assert(m_flid == kflidCmPossibility_Name || m_flid == kflidCmPossibility_Abbreviation);
// We don't allow long strings.
if (stu.Length() > kcchPossNameAbbrMax) // Need constant here and the line below.
{
::MessageBeep(MB_ICONEXCLAMATION); // Beep if we truncated the length.
stu.Replace(kcchPossNameAbbrMax, stu.Length(), L"");
}
ITsStrFactoryPtr qtsf;
qtsf.CreateInstance(CLSID_TsStrFactory);
qtsf->MakeStringRgch(stu.Chars(), stu.Length(), ws, &qtss);
// If we changed the length, store the trimmed string.
if (cch != stu.Length())
{
// Check if the record has been edited by someone else since we first loaded the data.
HRESULT hrTemp;
if ((hrTemp = qcvd->CheckTimeStamp(m_hvoObj)) != S_OK)
{
// If it was changed and the user does not want to overwrite it, perform a refresh
// so the displayed field will revert to its original value.
CheckHr(qcvd->PropChanged(NULL, kpctNotifyAll, m_hvoObj, m_flid, 0, 1, 1));
return;
}
// Update the value in the cache and refresh views.
CheckHr(qcvd->SetMultiStringAlt(m_hvoObj, m_flid, ws, qtss));
CheckHr(qcvd->PropChanged(NULL, kpctNotifyAll, m_hvoObj, m_flid, 0, 1, 1));
}
SuperClass::EndEdit(fForce);
// See if the primary string has changed.
ComBool fEqual;
CheckHr(qtss->Equals(m_qtssOld, &fEqual));
if (fEqual)
return; // No change was made, so we don't need to do anything else.
// A change was made.
if (m_flid != kflidCmPossibility_Name && m_flid != kflidCmPossibility_Abbreviation)
return; // Nothing more to do if it isn't a name or abbreviation.
// We've changed the primary name or abbreviation, so update the PossList cache.
ppii->SetName(stu, m_flid == kflidCmPossibility_Name ? kpntName : kpntAbbreviation);
if (qpli->GetIsSorted())
{
// The list is sorted, so we need to move the item to its new location.
if (qpli->PutInSortedPosition(m_hvoObj, false))
{
int ihvo;
pcmw->LoadData();
HvoClsidVec & vhc = pcmw->Records();
for (ihvo = vhc.Size(); --ihvo >= 0; )
{
if (vhc[ihvo].hvo == m_hvoObj)
break;
}
Assert(ihvo >= 0); // Should have found item.
pcmw->SetCurRecIndex(ihvo);
}
}
// We can't do a sync in this method that opens new editors, so just flag
// that it needs to be done.
// We need to sync if either name or abbreviation has changed. Even though we may only
// be showing one or the other in our lists, there may be overlays or something else
// showing the other, so to be safe, we need to do a sync if either changed.
dynamic_cast<CleDeSplitChild *>(m_qadsc.Ptr())->SetNeedSync(true);
}
/*----------------------------------------------------------------------------------------------
Something has changed in the possibility list.
----------------------------------------------------------------------------------------------*/
void RnDeFeRoleParts::ListChanged(int nAction, HVO hvoPssl, HVO hvoSrc, HVO hvoDst, int ipssSrc,
int ipssDst)
{
if (hvoPssl != m_psslRole)
{
// Process changes for people lists.
SuperClass::ListChanged(nAction, hvoPssl, hvoSrc, hvoDst, ipssSrc, ipssDst);
return;
}
// If someone deleted the role we are interested in we need to clean up.
if (hvoSrc == m_pssRole && nAction == kplnaDelete)
{
// Remove the notifier for the role list.
Assert(m_psslRole);
PossListInfoPtr qpli;
GetLpInfo()->LoadPossList(m_psslRole, m_wsMagic, &qpli);
AssertPtr(qpli);
qpli->RemoveNotify(this);
m_psslRole = 0;
m_pssRole = 0;
}
// At this point we are not getting kplnaMerged at all since we are just deleting all
// fields and recreating new ones. But at some point down the road we may want to switch
// to where we don't delete and recreate. This would be the right action to take then.
if (hvoSrc == m_pssRole && nAction == kplnaMerged)
{
// Switch to the new role.
m_pssRole = hvoDst;
}
// Now reset the label in case we changed.
// Use Participants for the unspecified editor label.
ITsStringPtr qtssName;
int wsUser = GetLpInfo()->GetDbInfo()->UserWs();
AfUtil::GetResourceTss(kstidTlsOptParticipants, wsUser, &qtssName);
ITsStringPtr qtssHelp = m_qfsp->m_qtssHelp;
ITsStrFactoryPtr qtsf;
qtsf.CreateInstance(CLSID_TsStrFactory);
if (m_pssRole)
{
PossItemInfo * ppii;
GetLpInfo()->GetPossListAndItem(m_pssRole, wsUser, &ppii, NULL);
StrUni stuName; // the Role's name
ppii->GetName(stuName, m_pnt);
qtsf->MakeStringRgch(stuName.Chars(), stuName.Length(), wsUser, &qtssName);
ITsIncStrBldrPtr qtisb;
qtisb.CreateInstance(CLSID_TsIncStrBldr);
// Add the first substring.
qtisb->AppendTsString(m_qfsp->m_qtssHelp);
// Add the second substring.
StrUni stuTemp;
stuTemp.Load(kstidRnRoledPartic_HelpA);
qtisb->AppendRgch(stuTemp.Chars(), stuTemp.Length());
// Turn bold on.
qtisb->SetIntPropValues(ktptBold, ktpvEnum, kttvForceOn);
// Add the Role's name
qtisb->AppendRgch(stuName.Chars(), stuName.Length());
// Turn bold off.
qtisb->SetIntPropValues(ktptBold, ktpvEnum, kttvOff);
// Add the third substring.
stuTemp.Load(kstidRnRoledPartic_HelpB);
qtisb->AppendRgch(stuTemp.Chars(), stuTemp.Length());
// Get the completed TsString.
qtisb->GetString(&qtssHelp);
}
m_qtssLabel = qtssName;
m_qtssHelp = qtssHelp;
// Force the label to redraw.
Rect rcLabel;
::GetClientRect(m_qadsc->Hwnd(),&rcLabel);
Rect rcEdit(m_rcClip);
if (m_hwnd)
{
// We have an open edit box, so get the correct coordinates for the client window.
::GetClientRect(m_hwnd, &rcEdit);
::MapWindowPoints(m_hwnd, m_qadsc->Hwnd(), (POINT *)&rcEdit, 2);
}
rcLabel.top = rcEdit.top;
rcLabel.bottom = rcEdit.bottom;
rcLabel.right = m_qadsc->GetTreeWidth();
::InvalidateRect(m_qadsc->Hwnd(), &rcLabel, false);
}
/*----------------------------------------------------------------------------------------------
This processes Windows messages on the window. In general, it normally calls the
appropriate method on the edit class.
----------------------------------------------------------------------------------------------*/
bool TssEdit::FWndProc(uint wm, WPARAM wp, LPARAM lp, long & lnRet)
{
bool fRet;
switch (wm)
{
case WM_GETDLGCODE:
// This is essential when embedded in a dialog to tell the dialog manager that it
// wants to get key strokes. (We could try DLGC_WANTALLKEYS but I think we would then
// get the Tab and Return keys...we may get them anyway with this combination...)
// The last value tells Windows that when tabbing to this control we should use
// EM_SETSEL to select all the text.
lnRet = DLGC_WANTCHARS | DLGC_WANTARROWS | DLGC_HASSETSEL;
return true;
case EM_GETLINE: // Use FW_EM_GETLINE.
case EM_REPLACESEL: // Use FW_EM_REPLACESEL.
// We don't support these methods. Use the replacement TsString versions instead.
Assert(false);
lnRet = LB_ERR;
return true;
// NOTE: DO NOT send this message to a TssEdit if you want the actual text. Send the
// FW_EM_GETTEXT message instead. This method is required for TssEdit controls on a
// dialog because Windows will send the message to the control anytime the user hits a
// key.
case WM_GETTEXT:
{
ITsStringPtr qtss;
GetText(&qtss);
const wchar * pwrgch;
int cch;
HRESULT hr;
IgnoreHr(hr = qtss->LockText(&pwrgch, &cch));
if (FAILED(hr))
return true;
StrApp str(pwrgch, cch);
qtss->UnlockText(pwrgch);
lnRet = Min(cch + 1, (int)wp);
achar * psz = reinterpret_cast<achar *>(lp);
StrCpyN(psz, str.Chars(), lnRet);
}
return true;
// NOTE: You should be sending an FW_EM_SETTEXT message instead of this.
case WM_SETTEXT:
{
achar * psz = reinterpret_cast<achar *>(lp);
StrUni stu(psz);
ITsStrFactoryPtr qtsf;
qtsf.CreateInstance(CLSID_TsStrFactory);
ITsStringPtr qtss;
CheckHr(qtsf->MakeStringRgch(stu.Chars(), stu.Length(), m_wsBase, &qtss));
SetText(qtss);
}
return true;
case EM_CANUNDO:
case EM_CHARFROMPOS:
case EM_EMPTYUNDOBUFFER:
case EM_FMTLINES:
case EM_GETFIRSTVISIBLELINE:
case EM_GETHANDLE:
case EM_GETMODIFY:
case EM_GETPASSWORDCHAR:
case EM_GETRECT:
case EM_GETTHUMB:
case EM_GETWORDBREAKPROC:
case EM_POSFROMCHAR:
case EM_SETHANDLE:
case EM_SETMODIFY:
case EM_SETPASSWORDCHAR:
case EM_SETRECT:
case EM_SETRECTNP:
case EM_SETTABSTOPS:
case EM_SETWORDBREAKPROC:
case EM_UNDO:
case WM_GETFONT:
case WM_SETFONT:
// We don't support these methods.
Assert(false);
lnRet = LB_ERR;
return true;
case EM_GETLIMITTEXT:
lnRet = GetLimitText();
return true;
case FW_EM_GETLINE:
lnRet = GetLine(wp, (ITsString **)lp);
return true;
case EM_GETLINECOUNT:
lnRet = GetLineCount();
return true;
case EM_GETMARGINS:
lnRet = GetMargins();
return true;
case FW_EM_GETSTYLE:
GetStyle((StrUni *)lp, (COLORREF *)wp);
return true;
case EM_GETSEL:
lnRet = GetSel((int *)wp, (int *)lp);
return true;
case EM_LINEFROMCHAR:
lnRet = LineFromChar(wp);
return true;
case EM_LINEINDEX:
lnRet = LineIndex(wp);
return true;
case EM_LINELENGTH:
lnRet = LineLength(wp);
return true;
case EM_LINESCROLL:
LineScroll(lp, wp);
return true;
case FW_EM_REPLACESEL:
ReplaceSel((ITsString *)lp);
return true;
case EM_SCROLL:
lnRet = ::SendMessage(m_hwnd, WM_VSCROLL, LOWORD(wp), 0);
return true;
case EM_SCROLLCARET:
ScrollCaret();
return true;
case EM_SETLIMITTEXT:
SetLimitText(wp);
return true;
case EM_SETMARGINS:
SetMargins(wp, LOWORD(lp), HIWORD(lp));
return true;
case EM_SETREADONLY:
SetReadOnly(wp);
return true;
case EM_SETSEL:
SetSel(wp, lp);
return true;
case FW_EM_SETSTYLE:
SetStyle((StrUni *)lp, (COLORREF)wp);
return true;
case WM_GETTEXTLENGTH:
lnRet = GetTextLength();
return true;
case FW_EM_GETTEXT:
GetText((ITsString **)lp);
return true;
case FW_EM_SETTEXT:
SetText((ITsString *)lp);
return true;
case WM_COPY:
Copy();
return true;
case WM_CUT:
Cut();
return true;
case WM_PASTE:
Paste();
return true;
case WM_HSCROLL:
if (!OnHScroll(LOWORD(wp), HIWORD(wp), (HWND)lp))
{
::SendMessage(::GetParent(m_hwnd), WM_COMMAND,
MAKEWPARAM(::GetDlgCtrlID(m_hwnd), EN_HSCROLL), (LPARAM)m_hwnd);
}
return true;
case WM_VSCROLL:
if (!OnVScroll(LOWORD(wp), HIWORD(wp), (HWND)lp))
{
::SendMessage(::GetParent(m_hwnd), WM_COMMAND,
MAKEWPARAM(::GetDlgCtrlID(m_hwnd), EN_VSCROLL), (LPARAM)m_hwnd);
}
return true;
case WM_KILLFOCUS:
if (!OnKillFocus((HWND)wp))
{
::SendMessage(::GetParent(m_hwnd), WM_COMMAND,
MAKEWPARAM(::GetDlgCtrlID(m_hwnd), EN_KILLFOCUS), (LPARAM)m_hwnd);
}
return true;
case WM_SETFOCUS:
if (!OnSetFocus((HWND)wp))
{
::SendMessage(::GetParent(m_hwnd), WM_COMMAND,
MAKEWPARAM(::GetDlgCtrlID(m_hwnd), EN_SETFOCUS), (LPARAM)m_hwnd);
}
return true;
// Calling SuperClass here causes two OnSetFocus calls for each OnKillFocus.
//return SuperClass::FWndProc(wm, wp, lp, lnRet);
case WM_CHAR:
fRet = false;
if (wp == VK_TAB) // '\t'
{
fRet = OnCharTab();
}
else if (wp == VK_RETURN) // '\r'
{
fRet = OnCharEnter();
}
else if (wp == VK_ESCAPE) // '\33'
{
fRet = OnCharEscape();
}
if (fRet)
return fRet;
else
return SuperClass::FWndProc(wm, wp, lp, lnRet);
case WM_LBUTTONDOWN:
case WM_LBUTTONUP:
case WM_MBUTTONDOWN:
case WM_MBUTTONUP:
case WM_RBUTTONDOWN:
case WM_RBUTTONUP:
case WM_MOUSEMOVE:
if (HasToolTip())
{
// Notify the tooltip belonging to the parent toolbar of the mouse message.
Assert(m_hwndToolTip);
MSG msg;
msg.hwnd = m_hwnd; // ::GetParent(m_hwnd);
msg.message = wm;
msg.wParam = wp;
msg.lParam = lp;
::SendMessage(m_hwndToolTip, TTM_RELAYEVENT, 0, (LPARAM)&msg);
}
break;
default:
break;
}
return SuperClass::FWndProc(wm, wp, lp, lnRet);
}
/*----------------------------------------------------------------------------------------------
Return the text string that gets shown to the user when this object needs to be displayed.
This is the method for displaying the name of a single reference. This view shows the
name for an RnGenericRec consisting of the type of record, hyphen, title, hyphen,
creation date. "Subevent - Fishing for pirana - 3/22/2001"
@param pguid Pointer to a database object's assigned GUID.
@param pptss Address of a pointer to an ITsString COM object used for returning the text
string.
@return S_OK, E_POINTER, or E_FAIL.
----------------------------------------------------------------------------------------------*/
STDMETHODIMP CleRecVc::GetStrForGuid(BSTR bstrGuid, ITsString ** pptss)
{
Assert(false); // rework
BEGIN_COM_METHOD;
ChkComBstrArg(bstrGuid);
ChkComOutPtr(pptss);
if (BstrLen(bstrGuid) != 8)
ReturnHr(E_INVALIDARG);
CleMainWnd * pcmw = dynamic_cast<CleMainWnd *>(AfApp::Papp()->GetCurMainWnd());
AssertPtr(pcmw);
CleLpInfo * plpi = dynamic_cast<CleLpInfo *>(pcmw->GetLpInfo());
AssertPtr(plpi);
HVO hvo = plpi->GetDbInfo()->GetIdFromGuid((GUID *)bstrGuid);
CustViewDaPtr qcvd;
plpi->GetDataAccess(&qcvd);
AssertPtr(qcvd);
int clid;
HVO hvoOwn;
int64 ntim;
ITsStringPtr qtssTitle;
CheckHr(qcvd->get_IntProp(hvo, kflidCmObject_Class, &clid));
CheckHr(qcvd->get_ObjectProp(hvo, kflidCmObject_Owner, &hvoOwn));
// REVIEW KenZ(RandyR) Whey are DN flids in this app?
CheckHr(qcvd->get_TimeProp(hvo, kflidRnGenericRec_DateCreated, &ntim));
CheckHr(qcvd->get_StringProp(hvo, kflidRnGenericRec_Title, &qtssTitle));
int stid;
// REVIEW KenZ(RandyR) Whey are DN flids in this app?
if (clid == kclidRnEvent)
{
if (pcmw->GetRootObj() == hvoOwn)
stid = kstidEvent;
else
stid = kstidSubevent;
}
else if (clid == kclidRnAnalysis)
{
if (pcmw->GetRootObj() == hvoOwn)
stid = kstidAnalysis;
else
stid = kstidSubanalysis;
}
StrUni stu(stid);
StrUni stuSep(kstidSpHyphenSp);
ITsStrFactoryPtr qtsf;
ITsIncStrBldrPtr qtisb;
qtsf.CreateInstance(CLSID_TsStrFactory);
CheckHr(qtsf->GetIncBldr(&qtisb));
CheckHr(qtisb->Append(stu.Bstr()));
CheckHr(qtisb->Append(stuSep.Bstr()));
CheckHr(qtisb->AppendTsString(qtssTitle)); // The title.
CheckHr(qtisb->Append(stuSep.Bstr()));
// Leave the date blank if a date doesn't exist.
if (ntim)
{
// Convert the date to a system date.
SilTime tim = ntim;
SYSTEMTIME stim;
stim.wYear = (unsigned short) tim.Year();
stim.wMonth = (unsigned short) tim.Month();
stim.wDay = (unsigned short) tim.Date();
// Then format it to a time based on the current user locale.
achar rgchDate[50]; // Tuesday, August 15, 2000 mardi 15 août 2000
::GetDateFormat(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &stim, NULL, rgchDate, 50);
stu = rgchDate;
CheckHr(qtisb->Append(stu.Bstr()));
}
CheckHr(qtisb->GetString(pptss));
return S_OK;
END_COM_METHOD(g_fact2, IID_IVwViewConstructor)
}
/*----------------------------------------------------------------------------------------------
This is the method for displaying the name of a single reference. This view shows the
name for an RnGenericRec consisting of the type of record, hyphen, title, hyphen,
creation date. "Subevent - Fishing for pirana - 3/22/2001"
@param pvwenv Pointer to the view environment.
@param hvo The id of the object we are displaying.
@param frag Identifies the part of the view we are currently displaying.
@return HRESULT indicating success (S_OK), or failure (E_FAIL).
----------------------------------------------------------------------------------------------*/
STDMETHODIMP CleRecVc::Display(IVwEnv * pvwenv, HVO hvo, int frag)
{
BEGIN_COM_METHOD;
ChkComArgPtr(pvwenv);
Assert(false); // Is this needed for poss lists?
switch (frag)
{
case kfrRefName:
case kfrListName:
{
SmartBstr bstrClass = L"UnLoaded";
ITsStringPtr qtss;
ITsStringPtr qtssTitle;
// Make sure data is loaded.
LoadDataFor(pvwenv, hvo, frag);
AfMainWnd * pafw = AfApp::Papp()->GetCurMainWnd();
AssertPtr(pafw);
AfLpInfo * plpi = pafw->GetLpInfo();
AssertPtr(plpi);
AfDbInfo * pdbi = plpi->GetDbInfo();
AssertPtr(pdbi);
#define HYPERLINK_CHANGE
#ifdef HYPERLINK_CHANGE
// Update the string with the new object.
GUID uid;
if (!pdbi->GetGuidFromId(hvo, uid))
ReturnHr(E_FAIL);
StrUni stuData;
OLECHAR * prgchData;
// Make large enough for a guid plus the type character at the start.
stuData.SetSize(isizeof(GUID) / isizeof(OLECHAR) + 1, &prgchData);
*prgchData = kodtNameGuidHot;
memmove(prgchData + 1, &uid, isizeof(uid));
ITsPropsFactoryPtr qtpf;
ITsPropsBldrPtr qtpb;
ITsTextPropsPtr qttp;
ITsStrFactoryPtr qtsf;
qtpf.CreateInstance(CLSID_TsPropsFactory);
CheckHr(qtpf->GetPropsBldr(&qtpb));
CheckHr(qtpb->SetIntPropValues(ktptWs, ktpvDefault, pdbi->UserWs()));
CheckHr(qtpb->SetStrPropValue(ktptObjData, stuData.Bstr()));
CheckHr(qtpb->GetTextProps(&qttp));
qtsf.CreateInstance(CLSID_TsStrFactory);
OLECHAR chObj = kchObject;
CheckHr(qtsf->MakeStringWithPropsRgch(&chObj, 1, qttp, &qtss));
CheckHr(pvwenv->OpenSpan());
// REVIEW KenZ(RandyR) Whey are DN flids in this app?
int flid = kflidRnGenericRec_Title;
CheckHr(pvwenv->NoteDependency(&hvo, &flid, 1));
CheckHr(pvwenv->AddString(qtss)); // The class name.
CheckHr(pvwenv->CloseSpan());
#else // !HYPERLINK_CHANGE
int clid;
HVO hvoOwn;
int64 ntim;
int ws = pdbi->UserWs();
ISilDataAccessPtr qsda;
CheckHr(pvwenv->get_DataAccess(&qsda));
AssertPtr(qsda);
CheckHr(qsda->get_IntProp(hvo, kflidCmObject_Class, &clid));
CheckHr(qsda->get_ObjectProp(hvo, kflidCmObject_Owner, &hvoOwn));
// REVIEW KenZ(RandyR) Whey are DN flids in this app?
CheckHr(qsda->get_TimeProp(hvo, kflidRnGenericRec_DateCreated, &ntim));
CheckHr(qsda->get_StringProp(hvo, kflidRnGenericRec_Title, &qtssTitle));
int stid;
// Sharon! Not needed?
// if (clid == kclidRnEvent)
// {
// if (plpi->GetRnId() == hvoOwn)
// stid = kstidEvent;
// else
// stid = kstidSubevent;
// }
// else if (clid == kclidRnAnalysis)
// {
// if (plpi->GetRnId() == hvoOwn)
// stid = kstidAnalysis;
// else
// stid = kstidSubanalysis;
// }
StrUni stu(stid);
StrUni stuSep(kstidSpHyphenSp);
ITsStrFactoryPtr qtsf;
qtsf.CreateInstance(CLSID_TsStrFactory);
CheckHr(qtsf->MakeStringRgch(stu.Chars(), stu.Length(), ws, &qtss));
CheckHr(pvwenv->OpenSpan());
CheckHr(pvwenv->AddString(qtss)); // The class name.
CheckHr(qtsf->MakeStringRgch(stuSep.Chars(), stuSep.Length(), ws, &qtss));
CheckHr(pvwenv->AddString(qtss)); // The separator
//CheckHr(pvwenv->AddString(qtssTitle)); // The title.
// The following gives the title of the owning object instead of the ref.
CheckHr(pvwenv->AddStringProp(kflidRnGenericRec_Title, this)); // The title.
CheckHr(pvwenv->AddString(qtss)); // The separator
// Leave the date blank if a date doesn't exist.
if (ntim)
{
// Convert the date to a system date.
SilTime tim = ntim;
SYSTEMTIME stim;
stim.wYear = (unsigned short) tim.Year();
stim.wMonth = (unsigned short) tim.Month();
stim.wDay = (unsigned short) tim.Date();
// Then format it to a time based on the current user locale.
char rgchDate[50]; // Tuesday, August 15, 2000 mardi 15 août 2000
::GetDateFormat(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &stim, NULL, rgchDate, 50);
stu = rgchDate;
CheckHr(qtsf->MakeStringRgch(stu.Chars(), stu.Length(), ws, &qtss));
CheckHr(pvwenv->AddString(qtss)); // The date.
}
CheckHr(pvwenv->CloseSpan());
#endif // HYPERLINK_CHANGE
break;
}
}
return S_OK;
END_COM_METHOD(g_fact2, IID_IVwViewConstructor)
}
/*----------------------------------------------------------------------------------------------
Check to see if the edit box has valid data. if so return true. If not then put up a
message to the user, then return false.
----------------------------------------------------------------------------------------------*/
bool CleDeFeString::IsOkToClose(bool fWarn)
{
CleMainWnd * pcmw = dynamic_cast<CleMainWnd *>(m_qadsc->MainWindow());
Assert(pcmw);
IVwSelectionPtr qvwsel;
CheckHr(m_qrootb->get_Selection(&qvwsel));
if (qvwsel)
{
ComBool fOk;
CheckHr(qvwsel->Commit(&fOk));
}
PossListInfoPtr qpli = pcmw->GetPossListInfoPtr();
int ipss = qpli->GetIndexFromId(m_hvoObj);
StrUni stuNew;
const OLECHAR * prgwch;
int cch;
ITsStringPtr qtss;
CustViewDaPtr qcvd;
GetDataAccess(&qcvd);
AssertPtr(qcvd);
int ws = m_qsvc->WritingSystems()[0];
CheckHr(qcvd->get_MultiStringAlt(m_hvoObj, m_flid, ws, &qtss));
Assert(qtss);
qtss->LockText(&prgwch, &cch);
qtss->UnlockText(prgwch);
// Trim leading and trailing space characters.
UnicodeString ust(prgwch, cch);
ust.trim();
stuNew.Assign(ust.getBuffer(), ust.length());
// Obtain pointer to IOleDbEncap interface.
IOleDbEncapPtr qode;
IOleDbCommandPtr qodc;
StrUni stuSql;
ComBool fIsNull;
ComBool fMoreRows;
AssertPtr(m_qadsc->MainWindow());
AfLpInfo * plpi = m_qadsc->MainWindow()->GetLpInfo();
AssertPtr(plpi);
AfDbInfo * pdbi = plpi->GetDbInfo();
AssertPtr(pdbi);
pdbi->GetDbAccess(&qode);
AssertPtr(qode);
CheckHr(qode->CreateCommand(&qodc));
int cpii = qpli->GetCount();
if ((m_flid == kflidCmPossibility_Name) || (m_flid == kflidCmPossibility_Abbreviation))
{
// Make sure it does not have a ":" or a " - " in the string
int ich = stuNew.FindStr(L":");
StrUni stuTmp;
bool fFixed = false;
while (ich > 0)
{
stuNew.Replace(ich,ich + 1,"-");
fFixed = true;
ich = stuNew.FindStr(L":");
}
ich = stuNew.FindStr(L" - ");
while (ich > 0)
{
stuNew.Replace(ich,ich + 3,"-");
fFixed = true;
ich = stuNew.FindStr(L" - ");
}
if (fFixed)
{
if (fWarn)
{
ITsStrFactoryPtr qtsf;
qtsf.CreateInstance(CLSID_TsStrFactory);
qtsf->MakeStringRgch(stuNew.Chars(), stuNew.Length(), pcmw->UserWs(), &qtss);
CheckHr(qcvd->SetMultiStringAlt(m_hvoObj, m_flid, ws, qtss));
CheckHr(qcvd->PropChanged(NULL, kpctNotifyAll, m_hvoObj, m_flid, 0, 1, 1));
StrApp strMsg(kstidFixedStr);
StrApp strTitle(kstidFixedStrTitle);
::MessageBox(m_hwnd, strMsg.Chars(), strTitle.Chars(),
MB_OK | MB_ICONINFORMATION);
}
return false;
}
}
if (qpli->GetAllowDup())
return true;
ILgWritingSystemFactoryPtr qwsf;
pdbi->GetLgWritingSystemFactory(&qwsf);
AssertPtr(qwsf);
switch (m_flid)
{
case kflidCmPossibility_Name:
{
for (int ipii = 0; ipii < cpii; ipii++)
{
if (ipii == ipss)
continue;
PossItemInfo * ppii = qpli->GetPssFromIndex(ipii);
AssertPtr(ppii);
StrUni stu;
ppii->GetName(stu, kpntName);
if (stu == stuNew)
{
stuSql.Format(L"select ws from CmPossibility_Name "
L"where obj = %d and ws = %d",
ppii->GetPssId(), ws);
CheckHr(qode->CreateCommand(&qodc));
CheckHr(qodc->ExecCommand(stuSql.Bstr(), knSqlStmtSelectWithOneRowset));
CheckHr(qodc->GetRowset(0));
CheckHr(qodc->NextRow(&fMoreRows));
if (fMoreRows)
{
if (fWarn)
{
// this name already exists
IWritingSystemPtr qws;
CheckHr(qwsf->get_EngineOrNull(ws, &qws));
AssertPtr(qws);
SmartBstr sbstr;
qws->get_Name(ws, &sbstr);
StrUni stu(kstidDupItemName);
StrUni stuMsg;
stuMsg.Format(stu,sbstr.Chars());
StrApp str(stuMsg);
StrApp strTitle(kstidDupItemTitle);
::MessageBox(m_hwnd, str.Chars(), strTitle.Chars(),
MB_OK | MB_ICONINFORMATION);
}
return false;
}
}
}
break;
}
case kflidCmPossibility_Abbreviation:
{
for (int ipii = 0; ipii < cpii; ipii++)
{
if (ipii == ipss)
continue;
PossItemInfo * ppii = qpli->GetPssFromIndex(ipii);
AssertPtr(ppii);
StrUni stu;
ppii->GetName(stu, kpntAbbreviation);
if (stu == stuNew)
{
stuSql.Format(L"select ws from CmPossibility_Abbreviation "
L"where obj = %d and ws = %d",
ppii->GetPssId(), ws);
CheckHr(qode->CreateCommand(&qodc));
CheckHr(qodc->ExecCommand(stuSql.Bstr(), knSqlStmtSelectWithOneRowset));
CheckHr(qodc->GetRowset(0));
CheckHr(qodc->NextRow(&fMoreRows));
if (fMoreRows)
{
if (fWarn)
{
// this abbreviation already exists
IWritingSystemPtr qws;
CheckHr(qwsf->get_EngineOrNull(ws, &qws));
AssertPtr(qws);
SmartBstr sbstr;
qws->get_Name(ws, &sbstr);
StrUni stu(kstidDupItemAbbr);
StrUni stuMsg;
stuMsg.Format(stu,sbstr.Chars());
StrApp str(stuMsg);
StrApp strTitle(kstidDupItemTitle);
::MessageBox(m_hwnd, str.Chars(), strTitle.Chars(),
MB_OK | MB_ICONINFORMATION);
}
return false;
}
}
}
break;
}
}
return true;
}
/*----------------------------------------------------------------------------------------------
The edit box changed. We need to validate what was done.
@param pedit
@return
----------------------------------------------------------------------------------------------*/
bool AfDeFeCliRef::OnChange(AfDeFeEdBoxBut::DeEdit * pedit)
{
if (m_fRecurse)
{
m_fRecurse = false;
return true;
}
if (!m_hwnd)
return true; // We aren't completely set up yet, so ignore this.
// Get the characters from the edit box.
ITsStringPtr qtss;
::SendMessage(m_hwnd, FW_EM_GETTEXT, 0, (LPARAM)&qtss);
int ichMin;
int ichLim;
::SendMessage(m_hwnd, EM_GETSEL, (WPARAM)&ichMin, (LPARAM)&ichLim);
int cchTyped; // number of characters in the typed string
// JohnT: use a StrUni rather than an StrUniBuf, because some user sometime will accidentally
// paste something long here, and performance here is not critical.
StrUni stuTyped;
OLECHAR * pchBuf;
qtss->get_Length(&cchTyped);
if (cchTyped > kcchPossNameAbbrMax)
{
if (ichMin == cchTyped)
ichMin = kcchPossNameAbbrMax;
if (ichLim == cchTyped)
ichLim = kcchPossNameAbbrMax;
cchTyped = kcchPossNameAbbrMax;
m_fRecurse = true; // Stop the recursion caused by the next instruction.
// Note: This recursively calls this procedure.
::SendMessage(m_hwnd, FW_EM_SETTEXT, 0, (LPARAM)qtss.Ptr());
::SendMessage(m_hwnd, EM_SETSEL, ichMin, ichMin);
}
stuTyped.SetSize(cchTyped, &pchBuf);
qtss->FetchChars(0, cchTyped, pchBuf);
#ifdef DEBUG_THIS_FILE
StrAnsi sta;
sta.Format("AfDeFeCliRef::OnChange: pedit->m_ch=%d; ichMin=%d; ichLim=%d; pedit->m_cchMatched=%d; cchTyped=%d.\n",
pedit->m_ch, ichMin, ichLim, pedit->m_cchMatched, cchTyped);
OutputDebugString(sta.Chars());
#endif
bool fTypeAhead = false; // allow type ahead only when adding characters at end of current item
// or backspacing at end of current item.
bool fNeedCompare;
if (pedit->m_ch == 0) // (see kcidEditPaste special code)
{
// If we pasted something, force a compare.
fNeedCompare = true;
}
else if (ichMin == pedit->m_cchMatched + 1 && pedit->m_ch != VK_BACK && pedit->m_ch != VK_DELETE)
{
// Need to compare if we typed a character and we are one greater than last match.
fNeedCompare = true;
if (cchTyped == ichMin)
{
fTypeAhead = true;
#ifdef DEBUG_THIS_FILE
sta.Format("OnChange: 1 - setting fTypeAhead to true.\n");
OutputDebugString(sta.Chars());
#endif
}
}
else if (ichMin > pedit->m_cchMatched)
{
// Don't compare any other time we are past the last match.
fNeedCompare = false;
}
// else if ((cchTyped == ichMin) && (ichMin == ichLim) && (pedit->m_ch != kscDelForward))
else if ((cchTyped == ichMin) && (ichMin == ichLim) && (pedit->m_ch != 46))
{
// Need to compare if we typed a character and we are at the end of the item
// Need to compare if we delete the last character in the non-type-ahead string
fNeedCompare = true;
fTypeAhead = true;
#ifdef DEBUG_THIS_FILE
sta.Format("OnChange: kscDelForward=%d.\n");
OutputDebugString(sta.Chars());
sta.Format("OnChange: 2 - setting fTypeAhead to true.\n");
OutputDebugString(sta.Chars());
#endif
}
else
{
// Always compare if we are not past the last match.
fNeedCompare = true;
}
int cch;
// Since the edit box deletes the selection on backspace, we need to use
// some extra logic to make backspace actually move the selection back.
if (pedit->m_cchMatched && pedit->m_ch == VK_BACK && m_pss)
{
// If we had a previous match and we got a backspace, we always decrement the matched
// characters and start looking at that point.
cch = --pedit->m_cchMatched;
}
else
{
// Otherwise we start looking at the cursor location.
cch = ichMin;
}
AfLpInfo * plpi = GetLpInfo();
AssertPtr(plpi);
PossListInfoPtr qpli;
plpi->LoadPossList(m_hvoPssl, m_wsMagic, &qpli);
AssertPtr(qpli);
PossItemInfo * ppii = NULL;
ComBool fExactMatch = false;
fNeedCompare = true;
if (cchTyped == 0)
{
// If nothing to match, get the first item in the possibility list. If we are
// already at that item, remove the item. If we are already cleared, do nothing.
if (!m_pss)
return true;
// If everything is highlighted, we want to clear the item with Del or Bsp.
// But when we are backspacing, if there is only one character left and we backspace
// over that, we want to switch to the first item in the list.
ppii = qpli->GetPssFromIndex(0);
if (ichMin != 1)
{
m_pss = 0;
m_qtss = NULL;
pedit->m_cchMatched = 0; // Keep cursor at beginning of item.
m_fRecurse = true;
::SendMessage(m_hwnd, FW_EM_SETTEXT, 0, (LPARAM)m_qtss.Ptr());
return true;
}
}
else if (fNeedCompare)
{
// Try to find an item that matches what the user typed in the possibility list.
StrUni stuMatch(stuTyped);
///// stuMatch.Replace(cch, stuMatch.Length(), L"");// Delete chars to right of cursor.
Locale loc = GetLpInfo()->GetLocale(m_ws);
if (m_fHier)
{
ppii = qpli->FindPssHier(stuMatch.Chars(), loc, m_pnt, fExactMatch);
}
else
{
ppii = qpli->FindPss(stuMatch.Chars(), loc, m_pnt);
}
if (ppii)
{
// found a match that starts with stuTyped
int ipssTemp;
// TODO TimP: check for hierarchy. If stuTyped contains hierarchy,
// Was the match exact (rather than just starting with stuTyped) ?
if (fExactMatch) // May have matched in the FindPssHier() call above.
{
#ifdef DEBUG_THIS_FILE
sta.Format("OnChange: Exact match (hier).\n");
OutputDebugString(sta.Chars());
#endif
}
else
{
fExactMatch = ! qpli->PossUniqueName(-1, stuTyped, m_pnt, ipssTemp);
if (fExactMatch)
{
#ifdef DEBUG_THIS_FILE
sta.Format("OnChange: Exact match.\n");
OutputDebugString(sta.Chars());
#endif
// in case FindPss() above matches "ABC" but "AB" is also in list.
ppii = qpli->GetPssFromIndex(ipssTemp);
}
else
{
#ifdef DEBUG_THIS_FILE
sta.Format("OnChange: Not exact match.\n");
OutputDebugString(sta.Chars());
#endif
}
}
}
}
else
ppii = NULL;
StrUni stuFound;
int ws = m_ws;
if (ppii && (fTypeAhead || fExactMatch))
{
// If found, process the new item.
int pss = ppii->GetPssId();
m_pss = pss;
if (m_fHier)
ppii->GetHierName(qpli, stuFound, m_pnt);
else
ppii->GetName(stuFound, m_pnt);
ws = ppii->GetWs();
// If the last character was a delimiter, we need to set cch accordingly.
if (m_fHier && (stuTyped.Length() > 0) && (pedit->m_ch != VK_BACK) &&
(stuTyped.GetAt(stuTyped.Length() - 1) == kchHierDelim))
{
// Need to set cch to the position of the last delimiter.
cch = stuFound.FindCh(kchHierDelim, cch - 1) + 1;
}
pedit->m_cchMatched = cch;
}
else
{
// Something illegal was typed. Assume they are adding a new item.
if (pedit->m_cchMatched + 1 == cch && pedit->m_ch != VK_BACK)
::MessageBeep(MB_ICONEXCLAMATION); // Beep on the first unmatched character.
// Underline the string with a red squiggly.
ITsIncStrBldrPtr qtisb;
qtisb.CreateInstance(CLSID_TsIncStrBldr);
qtisb->SetIntPropValues(ktptWs, ktpvDefault, m_ws);
CheckHr(qtisb->SetIntPropValues(ktptUnderColor, ktpvDefault, kclrRed));
CheckHr(qtisb->SetIntPropValues(ktptUnderline, ktpvEnum, kuntSquiggle));
qtisb->AppendRgch(stuTyped.Chars(), stuTyped.Length());
qtisb->GetString(&m_qtss);
m_fRecurse = true; // Stop the recursion caused by the next instruction.
// Note: This recursively calls this procedure.
::SendMessage(m_hwnd, FW_EM_SETTEXT, 0, (LPARAM)m_qtss.Ptr());
::SendMessage(m_hwnd, EM_SETSEL, ichMin, ichMin);
m_pss = 0; // We no longer have a matched HVO.
return true;
}
// Update the edit box text and selection.
ITsStrFactoryPtr qtsf;
qtsf.CreateInstance(CLSID_TsStrFactory);
qtsf->MakeStringRgch(stuFound.Chars(), stuFound.Length(), ws, &qtss);
m_qtss = qtss;
#ifdef DEBUG_THIS_FILE
sta.Format("AfDeFeCliRef::OnChange: pedit->m_cchMatched=%d; stuFound.Length()=%d; ichMin=%d; ichLim=%d.\n",
pedit->m_cchMatched, stuFound.Length(), ichMin, ichLim);
OutputDebugString(sta.Chars());
#endif
m_fRecurse = true; // Shortcut the recursion caused by the next instruction.
if (fTypeAhead)
{
// Note: This recursively calls this procedure.
::SendMessage(m_hwnd, FW_EM_SETTEXT, 0, (LPARAM)qtss.Ptr());
::SendMessage(m_hwnd, EM_SETSEL, pedit->m_cchMatched, stuFound.Length());
#ifdef DEBUG_THIS_FILE
sta.Format("AfDeFeCliRef::OnChange: type ahead.\n");
OutputDebugString(sta.Chars());
#endif
}
else
{
// Note: This recursively calls this procedure.
::SendMessage(m_hwnd, FW_EM_SETTEXT, 0, (LPARAM)qtss.Ptr());
::SendMessage(m_hwnd, EM_SETSEL, ichMin, ichMin);
#ifdef DEBUG_THIS_FILE
sta.Format("AfDeFeCliRef::OnChange: NOT type ahead.\n");
OutputDebugString(sta.Chars());
#endif
}
return true;
}
HRESULT ViewTest2::Run()
{
// Make a special VwGraphics (#define BASELINE in compiling it turns on special features).
// This VwGraphics will not draw (2nd arg false) but will record attempts at drawing into
// the baseline.
m_psts = NewObj SilTestSite();
m_qst.Attach(m_psts);
m_qvg.Attach(NewObj VwGraphics(m_psts, false, true));
m_qst->SetBaselineFile(SmartBstr(L"c:\\fw\\testlog\\log\\VwGraphics").Bstr());
// Todo LukeU(JohnT): make an off-screen bitmap HDC and initialize the VwGraphics to use it.
// Here is your off-screen bitmap and memory surface
HDC hdcScr, hdcMem;
hdcScr = GetDC(NULL);
hdcMem = CreateCompatibleDC(hdcScr);
HBITMAP hBitmap = CreateCompatibleBitmap(hdcMem, 400, 400);
SelectObject(hdcMem, hBitmap);
ReleaseDC(NULL, hdcScr);
m_qvg->Initialize(hdcMem);
// Make a dummy root site for the Root box to talk back to
m_qtrs.Attach(NewObj VwTestRootSite);
m_qtrs->SetVgObject(m_qvg);
Rect rcSrc(0, 0, 96, 96);
Rect rcDst(0, 0, 96, 96);
m_qtrs->SetSrcRoot(rcSrc);
m_qtrs->SetDstRoot(rcDst);
// Make our view constructor.
m_qtvc.Attach(NewObj TestStVc);
// Put some dummy data into a cache. HVO 1 identifies the text as a whole.
// Arbitrarily objects 2, 3, and 4 are the three paragraphs of our test data.
m_qda.Attach(NewObj VwCacheDa);
HVO rghvoPara[3] = {2, 3, 4};
m_qda->CacheVecProp(1, kflidStText_Paragraphs, rghvoPara, 3);
ITsStrFactoryPtr qtsf;
qtsf.CreateInstance(CLSID_TsStrFactory);
ITsStringPtr qtss;
int enc = 100;
StrUni stuPara0 = L"This is the first paragraph";
StrUni stuPara1 = L"Here is another paragraph, quite silly and trivial but it should "
L"help test things";
StrUni stuPara2 = L"I try to keep the text in these quite different so they can't be "
L"confused";
CheckHr(qtsf->MakeStringRgch(stuPara0.Chars(), stuPara0.Length(), enc, &qtss));
m_qda->CacheStringProp(rghvoPara[0], kflidStTxtPara_Contents, qtss);
CheckHr(qtsf->MakeStringRgch(stuPara1.Chars(), stuPara1.Length(), enc, &qtss));
m_qda->CacheStringProp(rghvoPara[1], kflidStTxtPara_Contents, qtss);
CheckHr(qtsf->MakeStringRgch(stuPara2.Chars(), stuPara2.Length(), enc, &qtss));
m_qda->CacheStringProp(rghvoPara[2], kflidStTxtPara_Contents, qtss);
ITsPropsBldrPtr qtpb;
qtpb.CreateInstance(CLSID_TsPropsBldr);
StrUni stuNormal = L"Normal";
CheckHr(qtpb->SetStrPropValue(kspNamedStyle, stuNormal.Bstr()));
// Make the root box and initialize it.
m_qrootb.CreateInstance(CLSID_VwRootBox);
// OK, we have a root box set up. Now we can try some tests on it!
TestInit();
TestDataAccess();
TestLayout(350);
TestDrawRoot();
TestOverlay();
TestMakeSimpleSel();
TestMakeTextSelection();
TestKeys();
TestMouse();
Testget_Site();
TestLoseFocus();
TestListener();
m_qrootb->Close();
m_qrootb.Clear();
m_qda.Clear();
DeleteDC(hdcMem);
DeleteObject(hBitmap);
return S_OK;
}
/*----------------------------------------------------------------------------------------------
Load data into the cache from the record set defined by hstmt, according to the specs
in prgocs/cocs. Columns with m_icolID = 0 give properties of hvoBase.
Load properties of at most crowMax objects; this may only be used if there is no vector
property being loaded, since we could not be sure of having a complete record of the
value of a vector without loading the next row. If crowMax is zero, load everything.
Note: call from inside try/catch block; may throw exceptions.
Note that prgocs[i] describes the column which ODBC indexes as [i+1].
----------------------------------------------------------------------------------------------*/
void VwRsOdbcDa::Load(SQLHSTMT hstmt, OdbcColSpec * prgocs, int cocs, HVO hvoBase,
int crowMax)
{
AssertArray(prgocs, cocs);
Assert((uint)cocs <= (uint) 200); // limit because of size of rghvoBaseIds
Assert(crowMax >= 0);
ITsStrFactoryPtr qtsf;
qtsf.CreateInstance(CLSID_TsStrFactory);
ITsPropsFactoryPtr qtpf;
qtpf.CreateInstance(CLSID_TsPropsFactory);
// Block of variables for binary fields
Vector<byte> vbData; // used to buffer data from binary fields
const int kcbMaxData = 1000; // amount of binary data to read in one go
byte rgbData[kcbMaxData]; // buffer for short binary data fields
long cbData; // how many bytes in prgbData hold valid data
byte * prgbData; // points to rgbData or vbData.Begin(), as appropriate
// Similar block for Unicode text
Vector<wchar> vchData;
const int kcchMaxData = 1000;
wchar rgchData[kcchMaxData];
long cchData;
wchar * prgchData;
Vector<HVO> vhvo; // accumulate objects for sequence property
int nrows = 0;
if (crowMax == 0)
crowMax = INT_MAX;
HVO rghvoBaseIds[200];
int icolVec = -1; // index of (one and only) column of type koctObjVec
int hvoVecBase; // object that is base of vector property
while (CheckSqlRc(SQLFetch(hstmt)) != SQL_NO_DATA)
{
// We have a record.
for (int icol = 0; icol < cocs; icol++)
{
int nVal;
HVO hvoVal;
ITsStringPtr qtssVal;
// TOxDO JohnT: fill this in...
HVO hvoCurBase; // object whose property we will read.
if (prgocs[icol].m_icolID == 0)
hvoCurBase = hvoBase;
else
{
// Must refer to a previous column; use <= because m_icolID is 1-based, so
// if equal to i, it refers to the immediate previous column.
Assert(prgocs[icol].m_icolID <= icol);
hvoCurBase = rghvoBaseIds[prgocs[icol].m_icolID - 1];
}
switch (prgocs[icol].m_oct)
{
default:
Assert(false);
ThrowHr(WarnHr(E_UNEXPECTED));
case koctInt:
CheckSqlRc(SQLGetData(hstmt, (unsigned short)(icol + 1), SQL_C_SLONG, &nVal, 4, NULL));
CacheIntProp(hvoCurBase, prgocs[icol].m_tag, nVal);
break;
case koctUnicode:
ReadUnicode(hstmt, icol + 1, rgchData, kcchMaxData,
vchData, prgchData, cchData);
CacheUnicodeProp(hvoCurBase, prgocs[icol].m_tag, prgchData, cchData);
break;
case koctString:
case koctMlsAlt:
case koctMltAlt:
// Next column must give format; both are for the same property
ReadUnicode(hstmt, icol + 1, rgchData, kcchMaxData,
vchData, prgchData, cchData);
if (koctMltAlt != prgocs[icol].m_oct)
{
Assert(icol < cocs - 1 && prgocs[icol + 1].m_oct == koctFmt);
Assert(prgocs[icol].m_tag == prgocs[icol + 1].m_tag);
// Leave the data in prgchData and cchData, to be processed next iteration
// when we read the format.
break;
}
// A MS alt without a FMT column, use the specified writing system both for the string
// formatting and to indicate the alternative.
CheckHr(qtsf->MakeStringRgch(prgchData, cchData, prgocs[icol].m_ws, &qtssVal));
CacheStringAlt(hvoCurBase, prgocs[icol].m_tag,
prgocs[icol].m_ws, qtssVal);
break;
case koctFmt:
// Previous column must be string or multistring; we have already checked same tag.
Assert(icol > 0 &&
(prgocs[icol - 1].m_oct == koctString || prgocs[icol - 1].m_oct == koctMlsAlt));
ReadBinary(hstmt, icol + 1, rgbData, kcbMaxData,
vbData, prgbData, cbData);
int cbDataInt;
cbDataInt = cbData;
int cchDataInt;
cchDataInt = cchData;
if (cchDataInt == 0 && cbDataInt == 0)
CheckHr(qtsf->MakeStringRgch(NULL, 0, prgocs[icol - 1].m_ws, &qtssVal));
else
CheckHr(qtsf->DeserializeStringRgch(prgchData, &cchDataInt, prgbData,
&cbDataInt, &qtssVal));
if (prgocs[icol - 1].m_oct == koctString)
{
CacheStringProp(hvoCurBase, prgocs[icol].m_tag, qtssVal);
}
else
{
CacheStringAlt(hvoCurBase, prgocs[icol].m_tag,
prgocs[icol - 1].m_ws, qtssVal);
}
break;
case koctObj:
case koctBaseId:
long nIndicator;
CheckSqlRc(SQLGetData(hstmt, (unsigned short)(icol + 1), SQL_C_SLONG,
&hvoVal, 4, &nIndicator));
// Treat null as zero.
if (nIndicator == SQL_NULL_DATA)
hvoVal = 0;
if (prgocs[icol].m_oct == koctObj)
CacheObjProp(hvoCurBase, prgocs[icol].m_tag, hvoVal);
rghvoBaseIds[icol] = hvoVal;
break;
case koctObjVec:
CheckSqlRc(SQLGetData(hstmt, (unsigned short)(icol + 1), SQL_C_SLONG,
&hvoVal, 4, NULL));
rghvoBaseIds[icol] = hvoVal;
// See if there has been a change in the base column, if so, record value and
// start a new one.
if (icolVec < 0)
{
// First iteration, ignore previous object
icolVec = icol;
hvoVecBase = hvoCurBase;
}
else
{
// Only one vector column allowed!
Assert(icolVec == icol);
if (hvoVecBase != hvoCurBase)
{
// Started a new vector! Record the old one
CacheVecProp(hvoVecBase, prgocs[icolVec].m_tag, vhvo.Begin(),
vhvo.Size());
// clear the list out and note new base object
vhvo.Clear();
hvoVecBase = hvoCurBase;
}
}
vhvo.Push(hvoVal);
break;
case koctTtp:
ReadBinary(hstmt, icol + 1, rgbData, kcbMaxData,
vbData, prgbData, cbData);
if (cbData > 0) // otherwise field is null, cache nothing
{
cbDataInt = cbData;
ITsTextPropsPtr qttp;
qtpf->DeserializePropsRgb(prgbData, &cbDataInt, &qttp);
CacheUnknown(hvoCurBase, prgocs[icol].m_tag, qttp);
}
break;
}
}
// Stop if we have processed the requested number of rows.
nrows++;
if (nrows >= crowMax)
break;
}
// If we are processing a vector, we need to fill in the last occurrence
if (icolVec >= 0)
{
CacheVecProp(hvoVecBase, prgocs[icolVec].m_tag, vhvo.Begin(),
vhvo.Size());
}
}
/*----------------------------------------------------------------------------------------------
Add a field editor for a given field at the location and indent specified.
@param hvoRoot Id of the root object that holds the fields we want to display.
@param clid Class of the root object.
@param nLev Level (main/sub) of the root object in the window.
@param pfsp The FldSpec that defines this field.
@param pcvd Pointer to the CustViewDa specifying what fields to display.
@param idfe Index where the new fields are to be inserted. On return it contains
an index to the field following any inserted fields.
@param nInd Indent of the fields to be added.
@param fAlwaysVisible If true, show field regardless of pbsp->m_eVisibility
----------------------------------------------------------------------------------------------*/
void CleDeSplitChild::AddField(HVO hvoRoot, int clid, int nLev, FldSpec * pfsp,
CustViewDa * pcvd, int & idfe, int nInd, bool fAlwaysVisible)
{
AssertPtr(pcvd);
AssertPtr(pfsp);
bool fCheckMissingData = fAlwaysVisible ? false : pfsp->m_eVisibility == kFTVisIfData;
// If the user never wants to see this field, skip it.
if (pfsp->m_eVisibility == kFTVisNever)
return;
ITsStringPtr qtss;
AfLpInfo * plpi = pcvd->GetLpInfo();
AssertPtr(plpi);
AfStatusBarPtr qstbr = MainWindow()->GetStatusBarWnd();
Assert(qstbr);
switch(pfsp->m_ft)
{
case kftEnum:
{
AfDeFeComboBox * pdecb = NewObj AfDeFeComboBox();
ITsStrFactoryPtr qtsf;
qtsf.CreateInstance(CLSID_TsStrFactory);
int itss;
CheckHr(pcvd->get_IntProp(hvoRoot, pfsp->m_flid, &itss));
pdecb->Initialize(hvoRoot, pfsp->m_flid, nInd, pfsp->m_qtssLabel,
pfsp->m_qtssHelp, this, pfsp);
pdecb->Init(pfsp->m_pnt);
ComVector<ITsString> * pvtss;
pvtss = pdecb->GetVec();
int stid;
switch (pfsp->m_flid)
{
case kflidCmPerson_Gender:
stid = kstidEnumGender;
break;
#ifdef ADD_LEXTEXT_LISTS
case kflidCmAnnotationDefn_AllowsComment: // Fall through.
case kflidCmAnnotationDefn_AllowsFeatureStructure: // Fall through.
case kflidCmAnnotationDefn_AllowsInstanceOf: // Fall through.
case kflidCmAnnotationDefn_UserCanCreate: // Fall through.
case kflidCmAnnotationDefn_CanCreateOrphan: // Fall through.
case kflidCmAnnotationDefn_PromptUser: // Fall through.
case kflidCmAnnotationDefn_CopyCutPastable: // Fall through.
case kflidCmAnnotationDefn_ZeroWidth: // Fall through.
case kflidCmAnnotationDefn_Multi: // Fall through.
#endif
case kflidMoInflAffixSlot_Optional: // Fall through.
case kflidCmPerson_IsResearcher:
stid = kstidEnumNoYes;
if (itss)
itss = 1;
break;
default:
Assert(false); // A list must be provided above.
break;
}
StrUni stuEnum(stid);
const wchar * pszEnum = stuEnum.Chars();
const wchar * pszEnumLim = stuEnum.Chars() + stuEnum.Length();
while (pszEnum < pszEnumLim)
{
const wchar * pszEnumNl = wcschr(pszEnum, '\n');
if (!pszEnumNl)
pszEnumNl = pszEnumLim;
AfDbInfo * pdbi = plpi->GetDbInfo();
AssertPtr(pdbi);
int wsUser = pdbi->UserWs();
qtsf->MakeStringRgch(pszEnum, pszEnumNl - pszEnum, wsUser,
&qtss);
pvtss->Push(qtss);
pszEnum = pszEnumNl + 1;
}
pdecb->SetIndex(itss);
m_vdfe.Insert(idfe++, pdecb);
}
return;
case kftMsa: // Fall through.
case kftMta:
{
Vector<int> vwsT;
Vector<int> & vws = vwsT;
// We need a special editor for name and address to catch changes to update the
// tree views.
if ((pfsp->m_flid == kflidCmPossibility_Name) ||
(pfsp->m_flid == kflidCmPossibility_Abbreviation))
{
CleMainWnd * pcmw = dynamic_cast<CleMainWnd *>(MainWindow());
Assert(pcmw);
// PossListInfoPtr qpli = pcmw->GetPossListInfoPtr();
int wsPL= pcmw->GetWsPssl();
switch (wsPL)
{
case kwsAnals:
vws = plpi->AnalWss();
break;
case kwsVerns:
vws = plpi->VernWss();
break;
case kwsAnal:
vwsT.Push(plpi->AnalWs());
break;
case kwsVern:
vwsT.Push(plpi->VernWs());
break;
case kwsAnalVerns:
vws = plpi->AnalVernWss();
break;
case kwsVernAnals:
vws = plpi->VernAnalWss();
break;
default:
vwsT.Push(wsPL);
break;
}
if (fCheckMissingData)
{
ITsStringPtr qtss;
int iws;
for (iws = vws.Size(); --iws >= 0; )
{
CheckHr(pcvd->get_MultiStringAlt(hvoRoot, pfsp->m_flid, vws[iws],
&qtss));
int cch;
CheckHr(qtss->get_Length(&cch));
if (cch)
break;
}
if (iws < 0)
return; // All writing systems are empty.
}
// An extra ref cnt is created here which is eventually assigned to the vector.
CleDeFeStringPtr qdfs = NewObj CleDeFeString;
qdfs->Initialize(hvoRoot, pfsp->m_flid, nInd, pfsp->m_qtssLabel,
pfsp->m_qtssHelp, this, pfsp);
if (pfsp->m_ft == kftMta)
qdfs->Init(&vws, ktptSemiEditable);
else
qdfs->Init(&vws, ktptIsEditable);
m_vdfe.Insert(idfe++, qdfs);
}
else
{
switch (pfsp->m_ws)
{
case kwsAnals:
vws = plpi->AnalWss();
break;
case kwsVerns:
vws = plpi->VernWss();
break;
case kwsAnal:
vwsT.Push(plpi->AnalWs());
break;
case kwsVern:
vwsT.Push(plpi->VernWs());
break;
case kwsAnalVerns:
vwsT = plpi->AnalVernWss();
break;
case kwsVernAnals:
vwsT = plpi->VernAnalWss();
break;
default:
vwsT.Push(pfsp->m_ws);
Assert(pfsp->m_ws);
break;
}
if (fCheckMissingData)
{
ITsStringPtr qtss;
int iws;
for (iws = vws.Size(); --iws >= 0; )
{
CheckHr(pcvd->get_MultiStringAlt(hvoRoot, pfsp->m_flid, vws[iws],
&qtss));
int cch;
CheckHr(qtss->get_Length(&cch));
if (cch)
break;
}
if (iws < 0)
return; // All writing systems are empty.
}
// An extra ref cnt is created here which is eventually assigned to the vector.
AfDeFeStringPtr qdfs = NewObj AfDeFeString;
qdfs->Initialize(hvoRoot, pfsp->m_flid, nInd, pfsp->m_qtssLabel,
pfsp->m_qtssHelp, this, pfsp);
if (pfsp->m_ft == kftMta)
qdfs->Init(&vws, ktptSemiEditable);
else
qdfs->Init(&vws, ktptIsEditable);
m_vdfe.Insert(idfe++, qdfs);
}
}
return;
case kftExpandable: // Fall through.
case kftSubItems:
return;
case kftObjRefAtomic: // Fall through.
case kftObjRefSeq:
{
bool fMultiRefs;
if (pfsp->m_ft == kftObjRefAtomic)
{
HVO hvoRef;
CheckHr(pcvd->get_ObjectProp(hvoRoot, pfsp->m_flid, &hvoRef));
fMultiRefs = false;
if (fCheckMissingData && !hvoRef)
return;
}
else
{
fMultiRefs = true;
if (fCheckMissingData) // otherwise no need to check
{
int chvo;
CheckHr(pcvd->get_VecSize(hvoRoot, pfsp->m_flid, &chvo));
if (!chvo)
return;
}
}
AfDeFeRefs * pdfr = NewObj AfDeFeRefs;
pdfr->Initialize(hvoRoot, pfsp->m_flid, nInd, pfsp->m_qtssLabel,
pfsp->m_qtssHelp, this, pfsp);
switch (pfsp->m_flid)
{
default:
// Standard kftObjRefAtomic & kftObjRefSeq fields are all handled in the superclass.
SuperClass::AddField(hvoRoot, clid, nLev, pfsp, pcvd, idfe, nInd, fAlwaysVisible);
return;
}
m_vdfe.Insert(idfe++, pdfr);
}
return;
}
qstbr->StepProgressBar(10);
// Standard fields are all handled in the superclass.
SuperClass::AddField(hvoRoot, clid, nLev, pfsp, pcvd, idfe, nInd, fAlwaysVisible);
return;
}
