/************************************************************************************************ * cStrings * * inputs: * * return: * ************************************************************************************************/ cStrings::cStrings(unsigned int initFlags, char *initReference) { Flags = initFlags; Reference = NULL; SetReference(initReference); }
cStringPackage::cStringPackage(const char *in, unsigned char initID, char *initDescription, char *initReference) { ID = initID; Registration = 0; name = in; Reference = NULL; SetReference(initReference); }
// For token elements, mBoundingMetrics is computed at the ReflowToken // pass, it is not computed here because our children may be text frames // that do not implement the GetBoundingMetrics() interface. /* virtual */ nsresult nsMathMLTokenFrame::Place(nsRenderingContext& aRenderingContext, bool aPlaceOrigin, nsHTMLReflowMetrics& aDesiredSize) { mBoundingMetrics = nsBoundingMetrics(); for (nsIFrame* childFrame = GetFirstPrincipalChild(); childFrame; childFrame = childFrame->GetNextSibling()) { nsHTMLReflowMetrics childSize(aDesiredSize.GetWritingMode()); GetReflowAndBoundingMetricsFor(childFrame, childSize, childSize.mBoundingMetrics, nullptr); // compute and cache the bounding metrics mBoundingMetrics += childSize.mBoundingMetrics; } nsRefPtr<nsFontMetrics> fm; nsLayoutUtils::GetFontMetricsForFrame(this, getter_AddRefs(fm)); nscoord ascent = fm->MaxAscent(); nscoord descent = fm->MaxDescent(); aDesiredSize.mBoundingMetrics = mBoundingMetrics; aDesiredSize.Width() = mBoundingMetrics.width; aDesiredSize.SetTopAscent(std::max(mBoundingMetrics.ascent, ascent)); aDesiredSize.Height() = aDesiredSize.TopAscent() + std::max(mBoundingMetrics.descent, descent); if (aPlaceOrigin) { nscoord dy, dx = 0; for (nsIFrame* childFrame = GetFirstPrincipalChild(); childFrame; childFrame = childFrame->GetNextSibling()) { nsHTMLReflowMetrics childSize(aDesiredSize.GetWritingMode()); GetReflowAndBoundingMetricsFor(childFrame, childSize, childSize.mBoundingMetrics); // place and size the child; (dx,0) makes the caret happy - bug 188146 dy = childSize.Height() == 0 ? 0 : aDesiredSize.TopAscent() - childSize.TopAscent(); FinishReflowChild(childFrame, PresContext(), childSize, nullptr, dx, dy, 0); dx += childSize.Width(); } } SetReference(nsPoint(0, aDesiredSize.TopAscent())); return NS_OK; }
bool MODULE::IncrementReference( bool aFillSequenceGaps ) { BOARD* board = GetBoard(); if( !board ) return false; bool success = false; const wxString prefix = GetReferencePrefix(); const wxString newReference = board->GetNextModuleReferenceWithPrefix( prefix, aFillSequenceGaps ); if( !newReference.IsEmpty() ) { SetReference( newReference ); success = true; } return success; }
bool cStringPackage::UnderstandToken(char *&Data, int &Size, int token, char *data ) { switch(token) { case TK_ID: ID = (unsigned char)atol(data); return true; case TK_CONFIG: return true; case TK_REFERENCE: SetReference(data); return true; } if (token == TK_INVALID) { return false; } return true; }
bool cStringPackage::UnderstandToken(char *&Data, int &Size, int token, char *data ) { cCriteria FullCriteria; switch(token) { case TK_ID: ID = (unsigned char)atol(data); return true; case TK_CONFIG: #ifdef _STRIPED_ ConfigFile.Load(data,FullCriteria); #endif return true; case TK_REFERENCE: #ifdef _STRIPED_ if (Reference) { char temp[1024]; sprintf(temp, "Please get RJ about this error! Do NOT save or do anything! OldRefeence: %s, New: %s", Reference, data); MessageBox(NULL, temp, "RJ Error!", MB_OK); } #endif SetReference(data); return true; } if (token == TK_INVALID) { return false; } return true; }
bool cStrings::UnderstandToken(int token, char *data) { sFlagPair *FlagPair; switch(token) { case TK_FLAGS: while(token != TK_INVALID) { token = FindToken(data, false); for(FlagPair = FlagPairs; FlagPair->Name != TK_INVALID; FlagPair++) { if (FlagPair->Name == token) { Flags |= FlagPair->Value; break; } } } return true; case TK_REFERENCE: SetReference(data); return true; case TK_RIGHT_BRACE: return false; } if (token == TK_INVALID) { return false; } return true; }
NS_IMETHODIMP nsMathMLmfencedFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, const nsHTMLReflowState& aReflowState, nsReflowStatus& aStatus) { nsresult rv; aDesiredSize.width = aDesiredSize.height = 0; aDesiredSize.ascent = 0; aDesiredSize.mBoundingMetrics = nsBoundingMetrics(); PRInt32 i; const nsStyleFont* font = GetStyleFont(); nsRefPtr<nsFontMetrics> fm; nsLayoutUtils::GetFontMetricsForFrame(this, getter_AddRefs(fm)); aReflowState.rendContext->SetFont(fm); nscoord axisHeight, em; GetAxisHeight(*aReflowState.rendContext, fm, axisHeight); GetEmHeight(fm, em); // leading to be left at the top and the bottom of stretched chars nscoord leading = NSToCoordRound(0.2f * em); ///////////// // Reflow children // Asking each child to cache its bounding metrics // Note that we don't use the base method nsMathMLContainerFrame::Reflow() // because we want to stretch our fences, separators and stretchy frames using // the *same* initial aDesiredSize.mBoundingMetrics. If we were to use the base // method here, our stretchy frames will be stretched and placed, and we may // end up stretching our fences/separators with a different aDesiredSize. // XXX The above decision was revisited in bug 121748 and this code can be // refactored to use nsMathMLContainerFrame::Reflow() at some stage. nsReflowStatus childStatus; nsSize availSize(aReflowState.ComputedWidth(), NS_UNCONSTRAINEDSIZE); nsIFrame* firstChild = GetFirstChild(nsnull); nsIFrame* childFrame = firstChild; nscoord ascent = 0, descent = 0; if (firstChild || mOpenChar || mCloseChar || mSeparatorsCount > 0) { // We use the ASCII metrics to get our minimum height. This way, // if we have borders or a background, they will fit better with // other elements on the line. ascent = fm->MaxAscent(); descent = fm->MaxDescent(); } while (childFrame) { nsHTMLReflowMetrics childDesiredSize(aDesiredSize.mFlags | NS_REFLOW_CALC_BOUNDING_METRICS); nsHTMLReflowState childReflowState(aPresContext, aReflowState, childFrame, availSize); rv = ReflowChild(childFrame, aPresContext, childDesiredSize, childReflowState, childStatus); //NS_ASSERTION(NS_FRAME_IS_COMPLETE(childStatus), "bad status"); if (NS_FAILED(rv)) { // Call DidReflow() for the child frames we successfully did reflow. DidReflowChildren(firstChild, childFrame); return rv; } SaveReflowAndBoundingMetricsFor(childFrame, childDesiredSize, childDesiredSize.mBoundingMetrics); nscoord childDescent = childDesiredSize.height - childDesiredSize.ascent; if (descent < childDescent) descent = childDescent; if (ascent < childDesiredSize.ascent) ascent = childDesiredSize.ascent; childFrame = childFrame->GetNextSibling(); } ///////////// // Ask stretchy children to stretch themselves nsBoundingMetrics containerSize; nsStretchDirection stretchDir = NS_STRETCH_DIRECTION_VERTICAL; GetPreferredStretchSize(*aReflowState.rendContext, 0, /* i.e., without embellishments */ stretchDir, containerSize); childFrame = firstChild; while (childFrame) { nsIMathMLFrame* mathmlChild = do_QueryFrame(childFrame); if (mathmlChild) { nsHTMLReflowMetrics childDesiredSize; // retrieve the metrics that was stored at the previous pass GetReflowAndBoundingMetricsFor(childFrame, childDesiredSize, childDesiredSize.mBoundingMetrics); mathmlChild->Stretch(*aReflowState.rendContext, stretchDir, containerSize, childDesiredSize); // store the updated metrics SaveReflowAndBoundingMetricsFor(childFrame, childDesiredSize, childDesiredSize.mBoundingMetrics); nscoord childDescent = childDesiredSize.height - childDesiredSize.ascent; if (descent < childDescent) descent = childDescent; if (ascent < childDesiredSize.ascent) ascent = childDesiredSize.ascent; } childFrame = childFrame->GetNextSibling(); } // bug 121748: for surrounding fences & separators, use a size that covers everything GetPreferredStretchSize(*aReflowState.rendContext, STRETCH_CONSIDER_EMBELLISHMENTS, stretchDir, containerSize); ////////////////////////////////////////// // Prepare the opening fence, separators, and closing fence, and // adjust the origin of children. // we need to center around the axis nscoord delta = NS_MAX(containerSize.ascent - axisHeight, containerSize.descent + axisHeight); containerSize.ascent = delta + axisHeight; containerSize.descent = delta - axisHeight; ///////////////// // opening fence ... ReflowChar(aPresContext, *aReflowState.rendContext, mOpenChar, NS_MATHML_OPERATOR_FORM_PREFIX, font->mScriptLevel, axisHeight, leading, em, containerSize, ascent, descent); ///////////////// // separators ... for (i = 0; i < mSeparatorsCount; i++) { ReflowChar(aPresContext, *aReflowState.rendContext, &mSeparatorsChar[i], NS_MATHML_OPERATOR_FORM_INFIX, font->mScriptLevel, axisHeight, leading, em, containerSize, ascent, descent); } ///////////////// // closing fence ... ReflowChar(aPresContext, *aReflowState.rendContext, mCloseChar, NS_MATHML_OPERATOR_FORM_POSTFIX, font->mScriptLevel, axisHeight, leading, em, containerSize, ascent, descent); ////////////////// // Adjust the origins of each child. // and update our bounding metrics i = 0; nscoord dx = 0; nsBoundingMetrics bm; PRBool firstTime = PR_TRUE; if (mOpenChar) { PlaceChar(mOpenChar, ascent, bm, dx); aDesiredSize.mBoundingMetrics = bm; firstTime = PR_FALSE; } childFrame = firstChild; while (childFrame) { nsHTMLReflowMetrics childSize; GetReflowAndBoundingMetricsFor(childFrame, childSize, bm); if (firstTime) { firstTime = PR_FALSE; aDesiredSize.mBoundingMetrics = bm; } else aDesiredSize.mBoundingMetrics += bm; FinishReflowChild(childFrame, aPresContext, nsnull, childSize, dx, ascent - childSize.ascent, 0); dx += childSize.width; if (i < mSeparatorsCount) { PlaceChar(&mSeparatorsChar[i], ascent, bm, dx); aDesiredSize.mBoundingMetrics += bm; } i++; childFrame = childFrame->GetNextSibling(); } if (mCloseChar) { PlaceChar(mCloseChar, ascent, bm, dx); if (firstTime) aDesiredSize.mBoundingMetrics = bm; else aDesiredSize.mBoundingMetrics += bm; } aDesiredSize.width = aDesiredSize.mBoundingMetrics.width; aDesiredSize.height = ascent + descent; aDesiredSize.ascent = ascent; SetBoundingMetrics(aDesiredSize.mBoundingMetrics); SetReference(nsPoint(0, aDesiredSize.ascent)); // see if we should fix the spacing FixInterFrameSpacing(aDesiredSize); // Finished with these: ClearSavedChildMetrics(); // Set our overflow area GatherAndStoreOverflow(&aDesiredSize); aStatus = NS_FRAME_COMPLETE; NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize); return NS_OK; }
inline void OnStart(RefType* t) { SetReference(t); }
void UtilityVisitor::startElement(const char *name, const XMLAttributes &atts) { const char *attval; // clear data at the start of each element m_data = ""; if (m_state == 0) { if (!strcmp(name, "UtilityCollection")) { m_state = 1; } else { string message = "Root element name is "; message += name; message += "; expected UtilityCollection"; throw xh_io_exception(message, "XML Reader"); } return; } if (m_state == 1) { if (!strcmp(name, "OverheadLine")) { m_pRoute = new vtRoute(GetCurrentTerrain()); // Create new route (should this be in vtUtilityMap ??) attval = atts.getValue("name"); if (attval) m_pRoute->SetName(attval); // TODO Set Name of the overhead line GetCurrentTerrain()->AddRoute(m_pRoute); m_state = 2; } return; } if (m_state == 2) // Conductor { if (!strcmp(name, "Conductor")) { attval = atts.getValue("width"); if (attval) m_pRoute->SetThickness(atof(attval)); attval = atts.getValue("color"); if (attval) m_pRoute->SetColor(ParseHexColor(attval)); m_state = 3; } return; } if (m_state == 3) // Pylon { if (!strcmp(name, "Pylon")) { attval = atts.getValue("name"); if (attval) SetName(attval); attval = atts.getValue("reference"); if (attval) SetReference(attval); attval = atts.getValue("rotation"); if (attval) SetRotation(atof(attval)); m_state = 4; // now read in the coordinate ... } else m_state = 1; // then it is a new overhead line return; } }
/*---------------------------------------------------------------------- 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; } } }