Class YAHOO.util.Get
                        
                        
                    
                    
                    
                
  
                    
                        Fetches and inserts one or more script or link nodes into the document.
This utility can fetch JavaScript and CSS files, inserting script
tags for script and link tags for CSS.  Note, this
is done via the normal browser mechanisms for inserting
these resources and making the content available to
code that would access it.  Be careful when retreiving
remote resources.  Only use this utility to fetch
files from sites you trust.
                    
                    
                    
                        
                            Properties
                            
                                    
                                    nidx
                                        - private int
                                    
                                    
                                        
                                            node index used to generate unique node ids
                                        
                                     
     
                                        
                                    
                                     
                                    
                                    
                                    
                                        
                                            The default poll freqency in ms, when needed
                                        
                                     
     
                                        
                                    
                                        Default Value: 10
                                    
        
                                    
                                     
                                    
                                    
                                    
                                        
                                            The number of request required before an automatic purge.
property PURGE_THRESH
                                        
                                     
     
                                        
                                    
                                        Default Value: 20
                                    
        
                                    
                                     
                                    
                                    purging
                                        - private boolean
                                    
                                    
                                        
                                            interal property used to prevent multiple simultaneous purge
processes
                                        
                                     
     
                                        
                                    
                                     
                                    
                                    qidx
                                        - private int
                                    
                                    
                                        
                                            queue index used to generate transaction ids
                                        
                                     
     
                                        
                                    
                                     
                                    
                                    queues
                                        - private object
                                    
                                    
                                        
                                            hash of queues to manage multiple requests
                                        
                                     
     
                                        
                                    
                                     
                                    
                                    
                                    
                                        
                                            The length time to poll for varName when loading a script in
Safari 2.x before the transaction fails.
property TIMEOUT
                                        
                                     
     
                                        
                                    
                                        Default Value: 2000
                                    
        
                                    
                                     
                             
                         
                     
                    
                        
                            Methods
                            
                                    
                                    
                                    
                                        
                                         private 
                                        
                                        
                                        void
                                            _autoPurge
                                           (
                                            )
                                        
                                        
                                        
                                            Removes processed queues and corresponding nodes
                                        
                                        
             
                                        
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                         private 
                                        
                                        
                                        void
                                            _finalize
                                           (
                                                
                                                        
                                                         id
                                                    
                                                
                                            )
                                        
                                        
                                        
                                            Called by the the helper for detecting script load in Safari
                                        
                                        
                                                
                                                    - Parameters:
- 
                                                        id
                                                        <string>
                                                        the transaction id
 
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                         private 
                                        
                                        
                                        void
                                            _finish
                                           (
                                                
                                                        
                                                         id
                                                    
                                                
                                            )
                                        
                                        
                                        
                                            The request is complete, so executing the requester's callback
                                        
                                        
                                                
                                                    - Parameters:
- 
                                                        id
                                                        <string>
                                                        the id of the request
 
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                         private 
                                        
                                        
                                        HTMLElement
                                            _linkNode
                                           (
                                                
                                                        
                                                         url
                                                    
                                                
                                                        , 
                                                         win
                                                    
                                                
                                            )
                                        
                                        
                                        
                                            Generates a link node
                                        
                                        
                                                
                                                    - Parameters:
- 
                                                        url
                                                        <string>
                                                        the url for the css file
- 
                                                        win
                                                        <Window>
                                                        optional window to create the node in
                                                    - Returns:
                                                    
                                                            HTMLElement
                                                    
- the generated node
 
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                         private 
                                        
                                        
                                        void
                                            _next
                                           (
                                                
                                                        
                                                         id
                                                    
                                                
                                                        , 
                                                         loaded
                                                    
                                                
                                            )
                                        
                                        
                                        
                                            Loads the next item for a given request
                                        
                                        
                                                
                                                    - Parameters:
- 
                                                        id
                                                        <string>
                                                        the id of the request
- 
                                                        loaded
                                                        <string>
                                                        the url that was just loaded, if any
 
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                         private 
                                        
                                        
                                        HTMLElement
                                            _node
                                           (
                                                
                                                        
                                                         type
                                                    
                                                
                                                        , 
                                                         attr
                                                    
                                                
                                                        , 
                                                         win
                                                    
                                                
                                            )
                                        
                                        
                                        
                                            Generates an HTML element, this is not appended to a document
                                        
                                        
                                                
                                                    - Parameters:
- 
                                                        type
                                                        <string>
                                                        the type of element
- 
                                                        attr
                                                        <string>
                                                        the attributes
- 
                                                        win
                                                        <Window>
                                                        optional window to create the element in
                                                    - Returns:
                                                    
                                                            HTMLElement
                                                    
- the generated node
 
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                         private 
                                        
                                        
                                        void
                                            _purge
                                           (
                                            )
                                        
                                        
                                        
                                            Removes the nodes for the specified queue
                                        
                                        
             
                                        
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                         private 
                                        
                                        
                                        void
                                            _returnData
                                           (
                                            )
                                        
                                        
                                        
                                            Returns the data payload for callback functions
                                        
                                        
             
                                        
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                         private 
                                        
                                        
                                        HTMLElement
                                            _scriptNode
                                           (
                                                
                                                        
                                                         url
                                                    
                                                
                                                        , 
                                                         win
                                                    
                                                
                                            )
                                        
                                        
                                        
                                            Generates a script node
                                        
                                        
                                                
                                                    - Parameters:
- 
                                                        url
                                                        <string>
                                                        the url for the script file
- 
                                                        win
                                                        <Window>
                                                        optional window to create the node in
                                                    - Returns:
                                                    
                                                            HTMLElement
                                                    
- the generated node
 
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                         private 
                                        
                                        
                                        void
                                            _timeout
                                           (
                                                
                                                        
                                                         id
                                                    
                                                
                                            )
                                        
                                        
                                        
                                            Timeout detected
                                        
                                        
                                                
                                                    - Parameters:
- 
                                                        id
                                                        <string>
                                                        the id of the request
 
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                         private 
                                        
                                        
                                        void
                                            _track
                                           (
                                                
                                                        
                                                         type
                                                    
                                                
                                                        , 
                                                         n
                                                    
                                                
                                                        , 
                                                         id
                                                    
                                                
                                                        , 
                                                         url
                                                    
                                                
                                                        , 
                                                         win
                                                    
                                                
                                                        , 
                                                         qlength
                                                    
                                                
                                                        , 
                                                         trackfn
                                                    
                                                
                                            )
                                        
                                        
                                        
                                            Detects when a node has been loaded.  In the case of
script nodes, this does not guarantee that contained
script is ready to use.
                                        
                                        
                                                
                                                    - Parameters:
- 
                                                        type
                                                        <string>
                                                        the type of node to track
- 
                                                        n
                                                        <HTMLElement>
                                                        the node to track
- 
                                                        id
                                                        <string>
                                                        the id of the request
- 
                                                        url
                                                        <string>
                                                        the url that is being loaded
- 
                                                        win
                                                        <Window>
                                                        the targeted window
- 
                                                        qlength
                                                        <object>
                                                        the number of remaining items in the queue,
including this one
- 
                                                        trackfn
                                                        <Function>
                                                        function to execute when finished
the default is _next
 
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                        
                                        
                                        
                                        void
                                            abort
                                           (
                                                
                                                        
                                                         either
                                                    
                                                
                                            )
                                        
                                        
                                        
                                            Abort a transaction
                                        
                                        
                                                
                                                    - Parameters:
- 
                                                        either
                                                        <string|object>
                                                        the tId or the object returned from
script() or css()
 
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                        
                                         static 
                                        
                                        tId: string
                                            css
                                           (
                                                
                                                        
                                                         url
                                                    
                                                
                                                        , 
                                                         opts
                                                    
                                                
                                            )
                                        
                                        
                                        
                                            Fetches and inserts one or more css link nodes into the
head of the current document or the document in a specified
window.
                                        
                                        
                                                
                                                    - Parameters:
- 
                                                        url
                                                        <string>
                                                        the url or urls to the css file(s)
- 
                                                        opts
                                                        <object>
                                                        Options:
- onSuccess
- 
callback to execute when the css file(s) are finished loading
The callback receives an object back with the following
data:
win 
- the window the link nodes(s) were inserted into
- data
- the data object passed in when the request was made
- nodes
- An array containing references to the nodes that were
inserted
- purge
- A function that, when executed, will remove the nodes
that were inserted
- 
 
- scope
- the execution context for the callbacks
- win
- a window other than the one the utility occupies
- data
- 
data that is supplied to the callbacks when the nodes(s) are
loaded.
- insertBefore
- node or node id that will become the new node's nextSibling
- charset
- Node charset, deprecated, use 'attributes'
- attributes
- A hash of attributes to apply to dynamic nodes.
YAHOO.util.Get.css("http://yui.yahooapis.com/2.7.0/build/menu/assets/skins/sam/menu.css");
YAHOO.util.Get.css(["http://yui.yahooapis.com/2.7.0/build/menu/assets/skins/sam/menu.css",
"http://yui.yahooapis.com/2.7.0/build/logger/assets/skins/sam/logger.css"]);
                                                        
                                                
                                                
                                                    - Returns:
                                                    
                                                            tId: string
                                                    
- an object containing info about the transaction
 
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                         private 
                                        
                                        
                                        void
                                            queue
                                           (
                                                
                                                        
                                                         type
                                                    
                                                
                                                        , 
                                                         url
                                                    
                                                
                                                        , 
                                                         opts
                                                    
                                                
                                            )
                                        
                                        
                                        
                                            Saves the state for the request and begins loading
the requested urls
                                        
                                        
                                                
                                                    - Parameters:
- 
                                                        type
                                                        <string>
                                                        the type of node to insert
- 
                                                        url
                                                        <string>
                                                        the url to load
- 
                                                        opts
                                                        <object>
                                                        the hash of options for this request
 
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                        
                                         static 
                                        
                                        tId: string
                                            script
                                           (
                                                
                                                        
                                                         url
                                                    
                                                
                                                        , 
                                                         opts
                                                    
                                                
                                            )
                                        
                                        
                                        
                                            Fetches and inserts one or more script nodes into the head
of the current document or the document in a specified window.
                                        
                                        
                                                
                                                    - Parameters:
- 
                                                        url
                                                        <string|string[]>
                                                        the url or urls to the script(s)
- 
                                                        opts
                                                        <object>
                                                        Options:
- onSuccess
- 
callback to execute when the script(s) are finished loading
The callback receives an object back with the following
data:
- win
- the window the script(s) were inserted into
- data
- the data object passed in when the request was made
- nodes
- An array containing references to the nodes that were
inserted
- purge
- A function that, when executed, will remove the nodes
that were inserted
- 
 
- onFailure
- 
callback to execute when the script load operation fails
The callback receives an object back with the following
data:
- win
- the window the script(s) were inserted into
- data
- the data object passed in when the request was made
- nodes
- An array containing references to the nodes that were
inserted successfully
- purge
- A function that, when executed, will remove any nodes
that were inserted
- 
 
- onTimeout
- 
callback to execute when a timeout occurs.
The callback receives an object back with the following
data:
- win
- the window the script(s) were inserted into
- data
- the data object passed in when the request was made
- nodes
- An array containing references to the nodes that were
inserted
- purge
- A function that, when executed, will remove the nodes
that were inserted
- 
 
- scope
- the execution context for the callbacks
- win
- a window other than the one the utility occupies
- autopurge
- 
setting to true will let the utilities cleanup routine purge
the script once loaded
- data
- 
data that is supplied to the callback when the script(s) are
loaded.
- varName
- 
variable that should be available when a script is finished
loading.  Used to help Safari 2.x and below with script load
detection.  The type of this property should match what was
passed into the url parameter: if loading a single url, a
string can be supplied.  If loading multiple scripts, you
must supply an array that contains the variable name for
each script.
- insertBefore
- node or node id that will become the new node's nextSibling
 
- charset
- Node charset, deprecated, use 'attributes'
- attributes
- A hash of attributes to apply to dynamic nodes.
- timeout
- Number of milliseconds to wait before aborting and firing the timeout event
// assumes yahoo, dom, and event are already on the page
  YAHOO.util.Get.script(
  ["http://yui.yahooapis.com/2.7.0/build/dragdrop/dragdrop-min.js",
   "http://yui.yahooapis.com/2.7.0/build/animation/animation-min.js"], {
    onSuccess: function(o) {
      YAHOO.log(o.data); // foo
      new YAHOO.util.DDProxy("dd1"); // also new o.reference("dd1"); would work
      this.log("won't cause error because YAHOO is the scope");
      this.log(o.nodes.length === 2) // true
      // o.purge(); // optionally remove the script nodes immediately
    },
    onFailure: function(o) {
      YAHOO.log("transaction failed");
    },
    data: "foo",
    timeout: 10000, // 10 second timeout
    scope: YAHOO,
    // win: otherframe // target another window/frame
    autopurge: true // allow the utility to choose when to remove the nodes
  });
                                                    - Returns:
                                                    
                                                            tId: string
                                                    
- an object containing info about the transaction