/*
 * (C) Copyright The MITRE Corporation 1999  All rights reserved. 
 * 
 * The contents of this file are subject to the Mozilla Public License 
 * Version 1.0 (the "License"); you may not use this file except in 
 * compliance with the License. You may obtain a copy of the License at 
 * http://www.mozilla.org/MPL/ 
 * 
 * The program provided "as is" without any warranty express or 
 * implied, including the warranty of non-infringement and the implied 
 * warranties of merchantibility and fitness for a particular purpose. 
 * The Copyright owner will not be liable for any damages suffered by 
 * you as a result of using the Program. In no event will the Copyright 
 * owner be liable for any special, indirect or consequential damages or 
 * lost profits even if the Copyright owner has been advised of the 
 * possibility of their occurrence. 
 * 
 * Please see release.txt distributed with this file for more information. 
 * 
 */ 
// Tom Kneeland (01/13/2000) 
// 
//  Wrapper class to convert Mozilla's Attr Interface to TransforMIIX's Attr 
//  Interface. 
// 
//  NOTE:  The objects being wrapped are not deleted.  It is assumed that they 
//         will be deleted when the actual ("real") Mozilla Document is 
//         destroyed 
// 
// Modification History: 
// Who  When        What 
// 
 
#include "mozilladom.h" 
 
// 
//Construct an Attribute wrapper object using the specified nsIDOMAttr object 
// 
Attr::Attr(nsIDOMAttr* attr, Document* owner) : Node(attr, owner) 
{ 
  nsAttr = attr; 
} 
 
// 
//Destroy the delegate nsIDOMAttr object 
// 
Attr::~Attr() 
{ 
} 
 
// 
//Return the nsAttr data member to the caller. 
// 
nsIDOMAttr* Attr::getNSAttr() 
{ 
  return nsAttr; 
} 
 
void Attr::setNSObj(nsIDOMAttr* attr) 
{ 
  Node::setNSObj(attr); 
  nsAttr = attr; 
} 
 
// 
//Retrieve the name of the attribute storing it in a MozillaString wrapper 
//class.  The wrapper is retrieved from the Document so it can be hashed.  At 
//this time no one else will use this hased object since it has been  
//specifically created for the caller of this function, but at lease its  
//memory managment is handled automatically.  In the future, a more efficient 
//implementation can be created based on the characters stored in the string 
//or something.   
//   NOTE:  We don't need to worry about memory management here since the 
//          MozillaString object will delete its nsString object automatically 
// ( nsIDOMAttr::GetName(nsString&) ) 
// 
const DOMString& Attr::getName() 
{ 
  nsString* name = new nsString(); 
 
  if (nsAttr->GetName(*name) == NS_OK) 
    return *(ownerDocument->createDOMString(name)); 
  else 
    { 
      //name won't be used, so delete it. 
      delete name; 
      return NULL_STRING; 
    } 
} 
 
// 
//Retrieve the specified flag.  ( nsIDOMAttr::GetSpecified(PRBool*) ) 
// 
MBool Attr::getSpecified() const 
{ 
  MBool specified; 
 
  nsAttr->GetSpecified(&specified); 
 
  return specified; 
} 
 
// 
//Retrieve the value of the attribute. See getName above for hashing info 
// 
const DOMString& Attr::getValue() 
{ 
  nsString* value = new nsString(); 
 
  if (nsAttr->GetValue(*value) == NS_OK) 
    return *(ownerDocument->createDOMString(value)); 
  else 
    { 
      //value is not needed so delete it. 
      delete value; 
      return NULL_STRING; 
    } 
} 
 
// 
//Foward call to nsIDOMAttr::SetValue. 
// 
void Attr::setValue(const DOMString& newValue) 
{ 
  nsAttr->SetValue(newValue.getConstNSString()); 
} 
 
 
// 
//Override the set node value member function to create a new TEXT node with 
//the DOMString and to add it as the Attribute's child. 
//    NOTE:  Not currently impemented, just execute the default setNodeValue 
// 
//void Attr::setNodeValue(const DOMString& nodeValue) 
//{ 
//  setValue(nodeValue); 
//} 
 
// 
//Return a DOMString represening the value of this node.  If the value is an 
//Entity Reference then return the value of the reference.  Otherwise, it is a 
//simple conversion of the text value. 
//    NOTE: Not currently implemented, just execute the default getNodeValue 
// 
//const DOMString& Attr::getNodeValue() 
//{ 
//  return getValue(); 
//} 
 
 
// 
//First check to see if the new node is an allowable child for an Attr.  If it 
//is, call NodeDefinition's implementation of Insert Before.  If not, return 
//null as an error. 
// 
//Node* Attr::insertBefore(Node* newChild, Node* refChild) 
//{ 
//  Node* returnVal = NULL; 
// 
//  switch (newChild->getNodeType()) 
//    { 
//      case Node::TEXT_NODE : 
//      case Node::ENTITY_REFERENCE_NODE: 
//        returnVal = NodeDefinition::insertBefore(newChild, refChild); 
// 
//        if (returnVal) 
//          specified = MB_TRUE; 
//        break; 
//      default: 
//        returnVal = NULL; 
//    } 
// 
//  return returnVal; 
//}
