nsresult
StartupCacheDebugOutputStream::WriteSingleRefObject(nsISupports* aObject)
{
nsCOMPtr<nsISupports> rootObject(do_QueryInterface(aObject));
NS_ASSERTION(rootObject.get() == aObject,
"bad call to WriteSingleRefObject -- call WriteCompoundObject!");
bool check = CheckReferences(aObject);
NS_ENSURE_TRUE(check, NS_ERROR_FAILURE);
return mBinaryStream->WriteSingleRefObject(aObject);
}
nsresult
StartupCacheDebugOutputStream::WriteCompoundObject(nsISupports* aObject,
const nsIID& aIID,
bool aIsStrongRef)
{
nsCOMPtr<nsISupports> rootObject(do_QueryInterface(aObject));
nsCOMPtr<nsISupports> roundtrip;
rootObject->QueryInterface(aIID, getter_AddRefs(roundtrip));
NS_ASSERTION(roundtrip.get() == aObject,
"bad aggregation or multiple inheritance detected by call to "
"WriteCompoundObject!");
bool check = CheckReferences(aObject);
NS_ENSURE_TRUE(check, NS_ERROR_FAILURE);
return mBinaryStream->WriteCompoundObject(aObject, aIID, aIsStrongRef);
}
void tcNumberEditControl::SetValue(const wxString& s)
{
double x = 0;
wxString convertedValue = "";
if (s.ToDouble(&x))
{
x *= databaseToDisplay;
convertedValue.Printf(formatString.c_str(), x);
}
tcEditControl::SetValue(convertedValue);
textCtrl->SetLabel(editValue);
IndicateChanges();
CheckReferences();
}
/*----------------------------------------------------------------------
CheckReferences On vient de coller le sous-arbre de racine
pRoot dans le document pDoc. Verifie la coherence des elements
reference's et des references presents dans ce sous-arbre.
----------------------------------------------------------------------*/
void CheckReferences (PtrElement pRoot, PtrDocument pDoc)
{
PtrElement pEl, pElRef, pSource;
PtrReference pRef, pNextRef;
PtrAttribute pAttr, pNextAttr;
PtrElement pElemRef;
LabelString oldLabel;
PtrReference pRefClipboard;
PtrDocument pDocRef;
int l;
ThotBool delAttr;
/* on se souvient du label de l'original */
strncpy (oldLabel, pRoot->ElLabel, MAX_LABEL_LEN);
if (ChangeLabel || pDoc != DocOfSavedElements)
{
/* on affecte un nouveau label a l'element */
l = NewLabel (pDoc);
ConvertIntToLabel (l, pRoot->ElLabel);
}
if (pRoot->ElReferredDescr != NULL)
/* l'original de l'element colle' est reference' */
{
/* l'element original */
pSource = pRoot->ElReferredDescr->ReReferredElem;
pRoot->ElReferredDescr = NULL;
/* l'element colle' n'est pas reference', il prend le label de son
element original (celui qui est dans le tampon Couper-Copier)
si la commande precedente etait Couper et s'il ne change pas de
document. Dans les autres cas (commande precedente Copier ou
changement de document), il prend un nouveau label. */
/* alloue a l'element un descripteur d'element reference' */
pRoot->ElReferredDescr = NewReferredElDescr (pDoc);
pRoot->ElReferredDescr->ReReferredElem = pRoot;
if (!ChangeLabel && pSource != NULL && pDoc == DocOfSavedElements)
/* l'element prend le meme label que l'element original */
strncpy (pRoot->ElLabel, pSource->ElLabel, MAX_LABEL_LEN);
/* on cherche toutes les references a l'element original et on les */
/* fait pointer sur l'element colle'. */
/* cherche d'abord la premiere reference */
pDocRef = DocOfSavedElements;
pRef = NextReferenceToEl (pSource, DocOfSavedElements, NULL);
while (pRef)
{
/* cherche la reference suivante a l'original avant de modifier */
/* la reference courante */
pNextRef = NextReferenceToEl (pSource, DocOfSavedElements, pRef);
/* traite la reference courante */
/* si elle est dans le tampon, on n'y touche pas : sa copie dans
le document ou on colle a deja ete traitee ou sera traitee
dans cette boucle */
if (!IsASavedElement (pRef->RdElement))
/* on fait pointer la reference sur l'element colle' */
{
if (IsWithinANewElement (pRef->RdElement))
pDocRef = pDoc;
if (pRef->RdAttribute)
pElemRef = NULL;
else
pElemRef = pRef->RdElement;
SetReference (pElemRef, pRef->RdAttribute, pRoot, pDocRef,
pDoc, FALSE, FALSE);
}
pRef = pNextRef; /* passe a la reference suivante */
pDocRef = DocOfSavedElements;
}
}
/* Traite les attributs de type reference porte's par l'element */
pAttr = pRoot->ElFirstAttr;
while (pAttr != NULL)
/* examine tous les attributs de l'element */
{
pNextAttr = pAttr->AeNext;
if (pAttr->AeAttrType == AtReferenceAttr)
/* c'est un attribut de type reference */
/* cherche l'element reference', pElRef */
{
pElRef = NULL;
delAttr = FALSE;
if (pAttr->AeAttrReference != NULL)
if (pAttr->AeAttrReference->RdReferred != NULL)
{
pElRef = pAttr->AeAttrReference->RdReferred->ReReferredElem;
/* si l'element reference' est aussi colle', */
/* on ne fait rien: ce cas est traite' plus haut */
if (pElRef != NULL)
if (!IsASavedElement (pElRef))
if (!IsWithinANewElement (pElRef))
{
if (DocOfSavedElements != pDoc)
/* reference et objet reference' sont */
/* dans des documents differents, on */
/* supprime l'attribut, sauf dans le */
/* cas particulier des tableaux. */
{
RemoveAttribute (pRoot, pAttr);
delAttr = TRUE;
}
}
if (delAttr)
DeleteAttribute (pRoot, pAttr);
}
}
pAttr = pNextAttr;
}
/* Lorsqu'on fait un copier/coller d'un element LtReference, */
/* il faut chainer les references entre element ancien et */
/* element nouveau : la reference de la copie qui est dans */
/* le tampon est dechainee entre les deux elements. */
/* pRoot est le nouvel element cree : son descripteur */
/* a ete chaine devant le descripteur de la copie qui est */
/* dans le tampon, qui est devant celui de l'element copie */
if (pRoot->ElTerminal && pRoot->ElLeafType == LtReference)
{
/* c'est un element reference */
pRef = pRoot->ElReference;
if (pRef != NULL) /* on cherche le suivant */
{
pRefClipboard = pRef->RdNext;
if (pRefClipboard != NULL
&& IsASavedElement (pRefClipboard->RdElement))
/* il faut retirer pRefClipboard du chainage */
{
pRef->RdNext = pRefClipboard->RdNext;
if (pRefClipboard->RdNext != NULL)
pRefClipboard->RdNext->RdPrevious = pRef;
}
}
}
if (!pRoot->ElTerminal && pRoot->ElSource == NULL)
/* ce n'est ni une inclusion ni un terminal, on traite tous les fils */
{
pEl = pRoot->ElFirstChild;
while (pEl != NULL)
{
CheckReferences (pEl, pDoc);
pEl = pEl->ElNext;
}
}
}
