void Database::RemoveGenre(QString genre) { if(!open) return; QMutexLocker locker(&lock); TRN; RemoveAttribute(nGenre, genre); }
void Database::RenameAttribute(const QString attr, QString oldval, QString newval) { if(!open) return; QSqlQuery q("", db); q.prepare("select ID, art from "+attr+" where value = :newval"); q.bindValue(":newval", newval); q.exec(); if(q.next()) { bool ok; int newID = q.value(0).toInt(&ok); QString newArt = q.value(1).toString(); if(ok) { int oldID = AddAttribute(attr, oldval); q.prepare("update Song set "+attr+" = "+QString::number(newID)+" where "+attr+" = "+QString::number(oldID)); q.exec(); q.prepare("select refs, rating, art from "+attr+" where ID = "+QString::number(oldID)); q.exec(); if(q.next()) { int oldref = q.value(0).toString().toInt(); int oldrat = q.value(1).toString().toInt(); QString oldArt = q.value(2).toString(); RefAttribute(attr, newID, oldref, oldrat); if(!newArt.size() && oldArt.size()) ArtForAttribute(attr, newval, oldArt); } RemoveAttribute(attr, oldval); } } else { q.prepare("update "+attr+" set value = :newval where value = :oldval"); q.bindValue(":oldval", oldval); q.bindValue(":newval", newval); q.exec(); } }
void Database::RemoveArtist(QString artist) { if(!open) return; QMutexLocker locker(&lock); TRN; RemoveAttribute(nArtist, artist); }
void SipccSdpAttributeList::Clear() { for (size_t i = 0; i < kNumAttributeTypes; ++i) { RemoveAttribute(static_cast<AttributeType>(i)); } }
// DeleteAttribute status_t Node::DeleteAttribute(Attribute *attribute) { status_t error = RemoveAttribute(attribute); if (error == B_OK) delete attribute; return error; }
// Sets the disabled status of the form control. void ElementFormControl::SetDisabled(bool disable) { if (disable) { SetAttribute("disabled", ""); Blur(); } else RemoveAttribute("disabled"); }
void VertexBuffer::InnerDispose() { InvalidateVBO(); vector<VertexAttribute> attribs = GetAttributes(); for(unsigned int i = 0; i < attribs.size(); ++i) RemoveAttribute(attribs[i].name); SetNumVerts(0); }
void SipccSdpAttributeList::SetAttribute(SdpAttribute* attr) { if (!IsAllowedHere(attr->GetType())) { MOZ_ASSERT(false, "This type of attribute is not allowed here"); return; } RemoveAttribute(attr->GetType()); mAttributes[attr->GetType()] = attr; }
// Enables or disables word-wrapping in the text area. void ElementFormControlTextArea::SetWordWrap(bool word_wrap) { if (word_wrap != GetWordWrap()) { if (word_wrap) RemoveAttribute("wrap"); else SetAttribute("wrap", "nowrap"); } }
int main(void) { Attributes attr; WORD result; printf("\f\t\tANSI Terminal Emulation Test\n"); printf( "\t\t============================\n\n\n"); setvbuf(stdin, NULL, _IONBF, 0); if ((result = GetAttributes(Heliosno(stdout), &attr)) < 0) { printf("Failed to get stdout attributes : %lx. Exiting.\n", result); exit((int)result); } printf("Window size : %d rows, %d columns.\n\n", attr.Min, attr.Time); rows = attr.Min; cols = attr.Time; AddAttribute(&attr, ConsoleRawOutput); RemoveAttribute(&attr, ConsolePause); RemoveAttribute(&attr, ConsoleEcho); if ((result = SetAttributes(Heliosno(stdout), &attr)) < 0) { printf("Failed to set stdout attributes : %lx. Exiting.\n", result); exit((int)result); } if ((result = GetAttributes(Heliosno(stdin), &attr)) < 0) { printf("Failed to get stdin attributes : %lx. Exiting.\n", result); exit((int)result); } AddAttribute(&attr, ConsoleRawInput); RemoveAttribute(&attr, ConsolePause); RemoveAttribute(&attr, ConsoleEcho); if ((result = SetAttributes(Heliosno(stdin), &attr)) < 0) { printf("Failed to set stdin attributes : %lx. Exiting.\n", result); exit((int) result); } wait_for_user(); main_menu(); printf("\r\n\n\n"); }
void VertexBuffer::AddAttribute(string name, VertexAttributeType type, int n_per_vertex) { RemoveAttribute(name); // in case it already exists! VertexAttribute attribute = VertexAttribute(name, type, n_per_vertex); attributes[name] = attribute; int num_elements = n_per_vertex * allocated_size; if(type == Float) attribute_data[name].floats = num_elements > 0 ? new float[num_elements] : NULL; }
nsresult nsDOMAttributeMap::GetNamedItemNSInternal(const nsAString& aNamespaceURI, const nsAString& aLocalName, nsIDOMNode** aReturn, bool aRemove) { NS_ENSURE_ARG_POINTER(aReturn); *aReturn = nsnull; if (!mContent) { return NS_OK; } PRInt32 nameSpaceID = kNameSpaceID_None; if (!aNamespaceURI.IsEmpty()) { nameSpaceID = nsContentUtils::NameSpaceManager()->GetNameSpaceID(aNamespaceURI); if (nameSpaceID == kNameSpaceID_Unknown) { return NS_OK; } } PRUint32 i, count = mContent->GetAttrCount(); for (i = 0; i < count; ++i) { const nsAttrName* name = mContent->GetAttrNameAt(i); PRInt32 attrNS = name->NamespaceID(); nsIAtom* nameAtom = name->LocalName(); if (nameSpaceID == attrNS && nameAtom->Equals(aLocalName)) { nsCOMPtr<nsINodeInfo> ni; ni = mContent->NodeInfo()->NodeInfoManager()-> GetNodeInfo(nameAtom, name->GetPrefix(), nameSpaceID, nsIDOMNode::ATTRIBUTE_NODE); NS_ENSURE_TRUE(ni, NS_ERROR_OUT_OF_MEMORY); if (aRemove) { return RemoveAttribute(ni, aReturn); } NS_ADDREF(*aReturn = GetAttribute(ni, true)); return NS_OK; } } return NS_OK; }
void CAttributeLinkTableDialog::OnRemoveButton() { int selected_item[MAX_CHOSEN_ATTRIBUTES_COUNT]; int I=0; POSITION pos = m_CaptionsList.GetFirstSelectedItemPosition(); while (pos != NULL ) { selected_item[I] = m_CaptionsList.GetNextSelectedItem(pos); I++; } while (I>=0) { RemoveAttribute(selected_item[I]); I--; } }
void Database::_RemoveAlbum(QString album, int artist) { if(!artist) RemoveAttribute(nAlbum, album); else { if(!open) return; int id = _AddAlbum(album, artist); if(id > 0) { QSqlQuery q("", db); q.prepare("select File from Song where Album = "+QString::number(id)); q.exec(); while(q.next()) { _RemoveFile(q.value(0).toString()); } QSqlQuery q1("delete from Album where ID = "+QString::number(id), db); } } }
PUBLIC BYTE GetAKey() { BYTE c; #ifdef SUN if ( TermMode == ORG_MODE ) { CurMode.c_iflag &= ~ICRNL; CurMode.c_lflag &= ~(ICANON | ECHO); CurMode.c_cc[VTIME] = 0; CurMode.c_cc[VMIN] = 1; ioctl( 0, TCSETS, &CurMode ); TermMode = GET_MODE; } else if ( TermMode == POLL_MODE ) { CurMode.c_cc[VTIME] = 0; CurMode.c_cc[VMIN] = 1; ioctl( 0, TCSETS, &CurMode ); TermMode = GET_MODE; } (void)read(0, &c, 1); #endif #ifdef MSC c = getch(); #endif #ifdef HELIOS if ( TermMode == ORG_MODE ) { RemoveAttribute(&CurAttributes,ConsoleEcho); AddAttribute(&CurAttributes,ConsoleRawInput); SetAttributes(InputStream,&CurAttributes); TermMode = GET_MODE; } (void)Read(InputStream, &c, 1, -1); #endif #ifdef VMS (void)SYS$QIOW(0, InputChan, (IO$_READVBLK | IO$M_NOECHO | IO$M_NOFILTR ), &iosb_desc, 0, 0, &c, 1, 0, 0L, 0, 0); #endif return(c); }
nsresult nsDOMAttributeMap::SetNamedItemInternal(nsIDOMNode *aNode, nsIDOMNode **aReturn, bool aWithNS) { NS_ENSURE_ARG_POINTER(aNode); NS_ENSURE_ARG_POINTER(aReturn); nsresult rv = NS_OK; *aReturn = nsnull; nsCOMPtr<nsIDOMNode> tmpReturn; if (mContent) { // XXX should check same-origin between mContent and aNode however // nsContentUtils::CheckSameOrigin can't deal with attributenodes yet nsCOMPtr<nsIAttribute> iAttribute(do_QueryInterface(aNode)); if (!iAttribute) { return NS_ERROR_DOM_HIERARCHY_REQUEST_ERR; } nsDOMAttribute *attribute = static_cast<nsDOMAttribute*>(iAttribute.get()); // Check that attribute is not owned by somebody else nsDOMAttributeMap* owner = iAttribute->GetMap(); if (owner) { if (owner != this) { return NS_ERROR_DOM_INUSE_ATTRIBUTE_ERR; } // setting a preexisting attribute is a no-op, just return the same // node. NS_ADDREF(*aReturn = aNode); return NS_OK; } if (!mContent->HasSameOwnerDoc(iAttribute)) { nsCOMPtr<nsIDOMDocument> domDoc = do_QueryInterface(mContent->OwnerDoc(), &rv); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIDOMNode> adoptedNode; rv = domDoc->AdoptNode(aNode, getter_AddRefs(adoptedNode)); NS_ENSURE_SUCCESS(rv, rv); NS_ASSERTION(adoptedNode == aNode, "Uh, adopt node changed nodes?"); } // Get nodeinfo and preexisting attribute (if it exists) nsAutoString name; nsCOMPtr<nsINodeInfo> ni; // SetNamedItemNS() if (aWithNS) { // Return existing attribute, if present ni = iAttribute->NodeInfo(); if (mContent->HasAttr(ni->NamespaceID(), ni->NameAtom())) { rv = RemoveAttribute(ni, getter_AddRefs(tmpReturn)); NS_ENSURE_SUCCESS(rv, rv); } } else { // SetNamedItem() attribute->GetName(name); // get node-info of old attribute ni = mContent->GetExistingAttrNameFromQName(name); if (ni) { rv = RemoveAttribute(ni, getter_AddRefs(tmpReturn)); NS_ENSURE_SUCCESS(rv, rv); } else { if (mContent->IsInHTMLDocument() && mContent->IsHTML()) { nsContentUtils::ASCIIToLower(name); } rv = mContent->NodeInfo()->NodeInfoManager()-> GetNodeInfo(name, nsnull, kNameSpaceID_None, nsIDOMNode::ATTRIBUTE_NODE, getter_AddRefs(ni)); NS_ENSURE_SUCCESS(rv, rv); // value is already empty } } nsAutoString value; attribute->GetValue(value); // Add the new attribute to the attribute map before updating // its value in the element. @see bug 364413. nsAttrKey attrkey(ni->NamespaceID(), ni->NameAtom()); mAttributeCache.Put(attrkey, attribute); iAttribute->SetMap(this); rv = mContent->SetAttr(ni->NamespaceID(), ni->NameAtom(), ni->GetPrefixAtom(), value, true); if (NS_FAILED(rv)) { DropAttribute(ni->NamespaceID(), ni->NameAtom()); } } tmpReturn.swap(*aReturn); // transfers ref. return rv; }
PUBLIC VOID SpGetkey() { #if (BOARD_ID == UDP) /* the udp version of iserver requires that the link is kept active, if it is inactive for X seconds the transputer will reset itself. Therefore this function polls the keyboard & sends an ACTIVE frame every X seconds to keep the transputer alive. */ BUFFER_DECLARATIONS; BYTE c; int timeval1,timeval2,finished; #ifdef VMS struct CHARACTERISTICS { short Count; char ch; char res1; long res2; } Chars; #endif DEBUG(( "SP.GETKEY {udp}" )); INIT_BUFFERS; finished = FALSE; time (&timeval1); while (!finished) { time (&timeval2); /* if 10 seconds elapsed, check link still active */ if ((timeval2-timeval1) >= QUIETTIMEOUT) { if (TestLink(TheLink) != SUCCEEDED) { finished = TRUE; PUT_BYTE( SP_ERROR ); break; } else { time (&timeval1); }; }; #ifdef MSC if (kbhit()) { c = getch(); PUT_BYTE( SP_SUCCESS ); PUT_BYTE( c ); finished = TRUE; }; #endif #ifdef SUN if ( TermMode == ORG_MODE ) { CurMode.c_iflag &= ~ICRNL; CurMode.c_lflag &= ~(ICANON | ECHO); CurMode.c_cc[VTIME] = 1; CurMode.c_cc[VMIN] = 0; ioctl( 0, TCSETS, &CurMode ); TermMode = POLL_MODE; } else { if ( TermMode == GET_MODE ) { CurMode.c_cc[VTIME] = 1; CurMode.c_cc[VMIN] = 0; ioctl( 0, TCSETS, &CurMode ); TermMode = POLL_MODE; }; }; if (read(0, &c, 1) != 0) { PUT_BYTE( SP_SUCCESS ); PUT_BYTE( c ); finished = TRUE; }; #endif #ifdef VMS (void)SYS$QIOW( 0, InputChan, (IO$_SENSEMODE | IO$M_TYPEAHDCNT ), &iosb_desc, 0, 0, &Chars, sizeof(struct CHARACTERISTICS), 0, 0, 0, 0 ) ; if (Chars.Count > 0) { (void)SYS$QIOW( 0, InputChan, (IO$_READVBLK | IO$M_NOECHO | IO$M_NOFILTR ), &iosb_desc, 0, 0, &c, 1, 0, 0L, 0, 0 ); PUT_BYTE( SP_SUCCESS ); PUT_BYTE( c ); finished = TRUE; }; #endif #ifdef HELIOS if ( TermMode == ORG_MODE ) { RemoveAttribute(&CurAttributes,ConsoleEcho); AddAttribute(&CurAttributes,ConsoleRawInput); AddAttribute(&CurAttributes,ConsoleBreakInterrupt); SetAttributes(InputStream,&CurAttributes); TermMode = POLL_MODE; } if ( Read( InputStream, &c, 1, OneSec/10 ) == 1 ) { PUT_BYTE( SP_SUCCESS ); PUT_BYTE( c ); finished = TRUE; }; #endif }; /* end of while */ DEBUG(("key was %c",c)); REPLY; #else BUFFER_DECLARATIONS; BYTE c; DEBUG(( "SP.GETKEY {non-udp}" )); INIT_BUFFERS; c = GetAKey(); DEBUG(("key was %c",c)); PUT_BYTE( SP_SUCCESS ); PUT_BYTE( c ); REPLY; #endif }
bool XMLElement::RemoveAttribute(const String& name) { return RemoveAttribute(name.CString()); }
void EC_DynamicComponent::DeserializeCommon(std::vector<DeserializeData>& deserializedAttributes, AttributeChange::Type change) { // Sort both lists in alphabetical order. AttributeVector oldAttributes = NonEmptyAttributes(); std::stable_sort(oldAttributes.begin(), oldAttributes.end(), &CmpAttributeById); std::stable_sort(deserializedAttributes.begin(), deserializedAttributes.end(), &CmpAttributeDataById); std::vector<DeserializeData> addAttributes; std::vector<DeserializeData> remAttributes; AttributeVector::iterator iter1 = oldAttributes.begin(); std::vector<DeserializeData>::iterator iter2 = deserializedAttributes.begin(); // Check what attributes we need to add or remove from the dynamic component (done by comparing two list differences). while(iter1 != oldAttributes.end() || iter2 != deserializedAttributes.end()) { // No point to continue the iteration if other list is empty. We can just push all new attributes into the dynamic component. if(iter1 == oldAttributes.end()) { for(;iter2 != deserializedAttributes.end(); ++iter2) addAttributes.push_back(*iter2); break; } // Only old attributes are left and they can be removed from the dynamic component. else if(iter2 == deserializedAttributes.end()) { for(;iter1 != oldAttributes.end(); ++iter1) remAttributes.push_back(DeserializeData((*iter1)->Id())); break; } // Attribute has already created and we only need to update it's value. if((*iter1)->Id() == (*iter2).id_) { //SetAttribute(QString::fromStdString(iter2->name_), QString::fromStdString(iter2->value_), change); for(AttributeVector::const_iterator attr_iter = attributes.begin(); attr_iter != attributes.end(); ++attr_iter) if((*attr_iter)->Id() == iter2->id_) (*attr_iter)->FromString(iter2->value_.toStdString(), change); ++iter2; ++iter1; } // Found a new attribute that need to be created and added to the component. else if((*iter1)->Id() > (*iter2).id_) { addAttributes.push_back(*iter2); ++iter2; } // Couldn't find the attribute in a new list so it need to be removed from the component. else { remAttributes.push_back(DeserializeData((*iter1)->Id())); ++iter1; } } while(!addAttributes.empty()) { DeserializeData attributeData = addAttributes.back(); IAttribute *attribute = CreateAttribute(attributeData.type_, attributeData.id_); if (attribute) attribute->FromString(attributeData.value_.toStdString(), change); addAttributes.pop_back(); } while(!remAttributes.empty()) { DeserializeData attributeData = remAttributes.back(); RemoveAttribute(attributeData.id_); remAttributes.pop_back(); } }
/* ---------------------------------------------------------------------- TtaRemoveAttribute Removes an attribute from an element and release that attribute. Parameters: element: the element with which the attribute is associated. attribute: the attribute to be removed. document: the document to which the element belongs. ---------------------------------------------------------------------- */ void TtaRemoveAttribute (Element element, Attribute attribute, Document document) { PtrAttribute pAttr; ThotBool found; ThotBool mandatory; UserErrorCode = 0; if (element == NULL || attribute == NULL) TtaError (ERR_invalid_parameter); else if (((PtrAttribute) attribute)->AeAttrSSchema == NULL || ((PtrElement) element)->ElStructSchema == NULL) { TtaError (ERR_invalid_parameter); // should never occur pAttr = (PtrAttribute) attribute; if (pAttr == ((PtrElement) element)->ElFirstAttr) { ((PtrElement) element)->ElFirstAttr = pAttr->AeNext; FreeAttribute (pAttr); } } else { pAttr = ((PtrElement) element)->ElFirstAttr; found = FALSE; while (pAttr != NULL && !found) { if (pAttr->AeAttrNum == ((PtrAttribute) attribute)->AeAttrNum && !strcmp (pAttr->AeAttrSSchema->SsName, ((PtrAttribute) attribute)->AeAttrSSchema->SsName)) found = TRUE; if (!found) pAttr = pAttr->AeNext; } if (!found) TtaError (ERR_attribute_element_mismatch); else { (void) CanAssociateAttr ((PtrElement) element, pAttr, pAttr, &mandatory); if (!mandatory) /* We prohibit to suppress the attbibute language of an element */ /* which is the root of an abstract tree */ if (((PtrElement) element)->ElParent == NULL) if (pAttr->AeAttrNum == 1) mandatory = TRUE; if (mandatory && (LoadedDocument[document - 1])->DocCheckingMode & STR_CHECK_MASK) /* The attribute is required for this kind of element */ TtaError (ERR_mandatory_attribute); else { RemoveAttribute ((PtrElement) element, pAttr); #ifndef NODISPLAY UndisplayInheritedAttributes ((PtrElement) element, pAttr, document, TRUE); UndisplayAttribute ((PtrElement) element, (PtrAttribute) attribute, document); #endif DeleteAttribute ((PtrElement) element, pAttr); } } } }
/*---------------------------------------------------------------------- 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; } } }
void HTMLEditor::SetFinalSize(int32_t aX, int32_t aY) { if (!mResizedObject) { // paranoia return; } if (mActivatedHandle) { mActivatedHandle->UnsetAttr(kNameSpaceID_None, nsGkAtoms::_moz_activated, true); mActivatedHandle = nullptr; } // we have now to set the new width and height of the resized object // we don't set the x and y position because we don't control that in // a normal HTML layout int32_t left = GetNewResizingX(aX, aY); int32_t top = GetNewResizingY(aX, aY); int32_t width = GetNewResizingWidth(aX, aY); int32_t height = GetNewResizingHeight(aX, aY); bool setWidth = !mResizedObjectIsAbsolutelyPositioned || (width != mResizedObjectWidth); bool setHeight = !mResizedObjectIsAbsolutelyPositioned || (height != mResizedObjectHeight); int32_t x, y; x = left - ((mResizedObjectIsAbsolutelyPositioned) ? mResizedObjectBorderLeft+mResizedObjectMarginLeft : 0); y = top - ((mResizedObjectIsAbsolutelyPositioned) ? mResizedObjectBorderTop+mResizedObjectMarginTop : 0); // we want one transaction only from a user's point of view AutoEditBatch batchIt(this); if (mResizedObjectIsAbsolutelyPositioned) { if (setHeight) { mCSSEditUtils->SetCSSPropertyPixels(*mResizedObject, *nsGkAtoms::top, y); } if (setWidth) { mCSSEditUtils->SetCSSPropertyPixels(*mResizedObject, *nsGkAtoms::left, x); } } if (IsCSSEnabled() || mResizedObjectIsAbsolutelyPositioned) { if (setWidth && mResizedObject->HasAttr(kNameSpaceID_None, nsGkAtoms::width)) { RemoveAttribute(mResizedObject, nsGkAtoms::width); } if (setHeight && mResizedObject->HasAttr(kNameSpaceID_None, nsGkAtoms::height)) { RemoveAttribute(mResizedObject, nsGkAtoms::height); } if (setWidth) { mCSSEditUtils->SetCSSPropertyPixels(*mResizedObject, *nsGkAtoms::width, width); } if (setHeight) { mCSSEditUtils->SetCSSPropertyPixels(*mResizedObject, *nsGkAtoms::height, height); } } else { // we use HTML size and remove all equivalent CSS properties // we set the CSS width and height to remove it later, // triggering an immediate reflow; otherwise, we have problems // with asynchronous reflow if (setWidth) { mCSSEditUtils->SetCSSPropertyPixels(*mResizedObject, *nsGkAtoms::width, width); } if (setHeight) { mCSSEditUtils->SetCSSPropertyPixels(*mResizedObject, *nsGkAtoms::height, height); } if (setWidth) { nsAutoString w; w.AppendInt(width); SetAttribute(mResizedObject, nsGkAtoms::width, w); } if (setHeight) { nsAutoString h; h.AppendInt(height); SetAttribute(mResizedObject, nsGkAtoms::height, h); } if (setWidth) { mCSSEditUtils->RemoveCSSProperty(*mResizedObject, *nsGkAtoms::width, EmptyString()); } if (setHeight) { mCSSEditUtils->RemoveCSSProperty(*mResizedObject, *nsGkAtoms::height, EmptyString()); } } // keep track of that size mResizedObjectWidth = width; mResizedObjectHeight = height; RefreshResizers(); }
void nsHTMLEditor::SetFinalSize(PRInt32 aX, PRInt32 aY) { if (!mResizedObject) { // paranoia return; } if (mActivatedHandle) { mActivatedHandle->RemoveAttribute(NS_LITERAL_STRING("_moz_activated")); mActivatedHandle = nsnull; } // we have now to set the new width and height of the resized object // we don't set the x and y position because we don't control that in // a normal HTML layout PRInt32 left = GetNewResizingX(aX, aY); PRInt32 top = GetNewResizingY(aX, aY); PRInt32 width = GetNewResizingWidth(aX, aY); PRInt32 height = GetNewResizingHeight(aX, aY); PRBool setWidth = !mResizedObjectIsAbsolutelyPositioned || (width != mResizedObjectWidth); PRBool setHeight = !mResizedObjectIsAbsolutelyPositioned || (height != mResizedObjectHeight); PRInt32 x, y; x = left - ((mResizedObjectIsAbsolutelyPositioned) ? mResizedObjectBorderLeft+mResizedObjectMarginLeft : 0); y = top - ((mResizedObjectIsAbsolutelyPositioned) ? mResizedObjectBorderTop+mResizedObjectMarginTop : 0); // we need to know if we're in a CSS-enabled editor or not PRBool useCSS; GetIsCSSEnabled(&useCSS); // we want one transaction only from a user's point of view nsAutoEditBatch batchIt(this); NS_NAMED_LITERAL_STRING(widthStr, "width"); NS_NAMED_LITERAL_STRING(heightStr, "height"); PRBool hasAttr = PR_FALSE; if (mResizedObjectIsAbsolutelyPositioned) { if (setHeight) mHTMLCSSUtils->SetCSSPropertyPixels(mResizedObject, nsEditProperty::cssTop, y, PR_FALSE); if (setWidth) mHTMLCSSUtils->SetCSSPropertyPixels(mResizedObject, nsEditProperty::cssLeft, x, PR_FALSE); } if (useCSS || mResizedObjectIsAbsolutelyPositioned) { if (setWidth && NS_SUCCEEDED(mResizedObject->HasAttribute(widthStr, &hasAttr)) && hasAttr) RemoveAttribute(mResizedObject, widthStr); hasAttr = PR_FALSE; if (setHeight && NS_SUCCEEDED(mResizedObject->HasAttribute(heightStr, &hasAttr)) && hasAttr) RemoveAttribute(mResizedObject, heightStr); if (setWidth) mHTMLCSSUtils->SetCSSPropertyPixels(mResizedObject, nsEditProperty::cssWidth, width, PR_FALSE); if (setHeight) mHTMLCSSUtils->SetCSSPropertyPixels(mResizedObject, nsEditProperty::cssHeight, height, PR_FALSE); } else { // we use HTML size and remove all equivalent CSS properties // we set the CSS width and height to remove it later, // triggering an immediate reflow; otherwise, we have problems // with asynchronous reflow if (setWidth) mHTMLCSSUtils->SetCSSPropertyPixels(mResizedObject, nsEditProperty::cssWidth, width, PR_FALSE); if (setHeight) mHTMLCSSUtils->SetCSSPropertyPixels(mResizedObject, nsEditProperty::cssHeight, height, PR_FALSE); if (setWidth) { nsAutoString w; w.AppendInt(width); SetAttribute(mResizedObject, widthStr, w); } if (setHeight) { nsAutoString h; h.AppendInt(height); SetAttribute(mResizedObject, heightStr, h); } if (setWidth) mHTMLCSSUtils->RemoveCSSProperty(mResizedObject, nsEditProperty::cssWidth, EmptyString(), PR_FALSE); if (setHeight) mHTMLCSSUtils->RemoveCSSProperty(mResizedObject, nsEditProperty::cssHeight, EmptyString(), PR_FALSE); } // finally notify the listeners if any PRInt32 listenersCount = objectResizeEventListeners.Count(); if (listenersCount) { nsCOMPtr<nsIHTMLObjectResizeListener> listener; PRInt32 index; for (index = 0; index < listenersCount; index++) { listener = objectResizeEventListeners[index]; listener->OnEndResizing(mResizedObject, mResizedObjectWidth, mResizedObjectHeight, width, height); } } // keep track of that size mResizedObjectWidth = width; mResizedObjectHeight = height; RefreshResizers(); }
int main(void) { Object *root_obj = Locate(NULL, "/"); Object *mouse_obj; Object *keyboard_obj; Attributes attr; WORD result; setvbuf(stdin, NULL, _IONBF, 0); if ((result = GetAttributes(Heliosno(stdin), &attr)) < 0) { printf("Failed to get stdin attributes : %x. Exiting.\n", result); exit(result); } AddAttribute(&attr, ConsoleRawOutput); AddAttribute(&attr, ConsoleRawInput); RemoveAttribute(&attr, ConsolePause); RemoveAttribute(&attr, ConsoleEcho); if ((result = SetAttributes(Heliosno(stdin), &attr)) < 0) { printf("Failed to set stdin attributes : %x. Exiting.\n", result); exit(result); } printf("\f\t\tX Support Test\r\n"); printf( "\t\t==============\r\n\n\n"); mouse_obj = Locate(root_obj, "/mouse"); if (mouse_obj eq Null(Object)) { printf("Failed to find a mouse device : %x.\r\n", Result2(root_obj)); exit(Result2(root_obj)); } printf("Found a mouse server : %s.\r\n", mouse_obj->Name); mouse_stream = Open(mouse_obj, NULL, O_ReadOnly); if (mouse_stream eq Null(Stream)) { printf("Failed to open stream : %x.\n", Result2(mouse_obj)); exit(Result2(mouse_obj)); } Close(mouse_obj); keyboard_obj = Locate(root_obj, "/keyboard"); if (keyboard_obj eq Null(Object)) { printf("Failed to find a keyboard device : %x.\r\n", Result2(root_obj)); exit(Result2(root_obj)); } printf("Found a keyboard server : %s.\r\n", keyboard_obj->Name); keyboard_stream = Open(keyboard_obj, NULL, O_ReadOnly); if (keyboard_stream eq Null(Stream)) { printf("Failed to open stream : %x.\n", Result2(keyboard_obj)); exit(Result2(keyboard_obj)); } Close(keyboard_obj); Close(root_obj); wait_for_user(); main_menu(); Close(mouse_stream); Close(keyboard_stream); printf("\r\n\n\n"); return(0); }
void UsdMayaAdaptor::SchemaAdaptor::RemoveAttribute(const TfToken& attrName) { MDGModifier modifier; RemoveAttribute(attrName, modifier); }
PUBLIC VOID SpPollkey() { BUFFER_DECLARATIONS; char c; #ifdef VMS struct CHARACTERISTICS { short Count; char ch; char res1; long res2; } Chars; #endif DEBUG(( "SP.POLLKEY" )); INIT_BUFFERS; #ifdef MSC if ( kbhit() ) { c = getch(); PUT_BYTE( SP_SUCCESS ); PUT_BYTE( c ); } else { PUT_BYTE( SP_ERROR ); } #endif #ifdef SUN if ( TermMode == ORG_MODE ) { CurMode.c_iflag &= ~ICRNL; CurMode.c_lflag &= ~(ICANON | ECHO); CurMode.c_cc[VTIME] = 1; CurMode.c_cc[VMIN] = 0; ioctl( 0, TCSETS, &CurMode ); TermMode = POLL_MODE; } else if ( TermMode == GET_MODE ) { CurMode.c_cc[VTIME] = 1; CurMode.c_cc[VMIN] = 0; ioctl( 0, TCSETS, &CurMode ); TermMode = POLL_MODE; } if ( read(0, &c, 1) == 0 ) { PUT_BYTE( SP_ERROR ); } else { PUT_BYTE( SP_SUCCESS ); PUT_BYTE( c ); } #endif #ifdef VMS (void)SYS$QIOW( 0, InputChan, (IO$_SENSEMODE | IO$M_TYPEAHDCNT ), &iosb_desc, 0, 0, &Chars, sizeof(struct CHARACTERISTICS), 0, 0, 0, 0 ) ; if ( Chars.Count > 0 ) { (void)SYS$QIOW( 0, InputChan, (IO$_READVBLK | IO$M_NOECHO | IO$M_NOFILTR ), &iosb_desc, 0, 0, &c, 1, 0, 0L, 0, 0 ); PUT_BYTE( SP_SUCCESS ); PUT_BYTE( c ); } else { PUT_BYTE( SP_ERROR ); } #endif #ifdef HELIOS if ( TermMode == ORG_MODE ) { RemoveAttribute(&CurAttributes,ConsoleEcho); AddAttribute(&CurAttributes,ConsoleRawInput); AddAttribute(&CurAttributes,ConsoleBreakInterrupt); SetAttributes(InputStream,&CurAttributes); TermMode = POLL_MODE; } if ( Read( InputStream, &c, 1, OneSec/10 ) == 1 ) { PUT_BYTE( SP_SUCCESS ); PUT_BYTE( c ); } else { PUT_BYTE( SP_ERROR ); } #endif REPLY; }
bool XMLElement::RemoveAttribute(const ea::string& name) { return RemoveAttribute(name.c_str()); }
// ClearAttrDir void ShareAttrDir::ClearAttrDir() { while (Attribute* attribute = GetFirstAttribute()) RemoveAttribute(attribute); }