Ig report download doctype pdf

Domain translate. Domain fonts. Domain sea09sin-f United States. Domain www. Domain res. Domain sv4. Domain postx. Domain v2ray. Domain 3cyber. Domain ear-test. Domain khvs. Domain id. Domain csi. Domain ocsp. Domain uw. Domain ev. Domain qventca3g3. Domain a Domain aka. Domain e Domain go.

Domain octopus. Domain admin-py-py. Domain api. In most cases it solves such problems. Vw swl cd - der-lederer. It has a 4 Watt output through its rubber duck antenna which is the FCC limit for CB handsets , which can easily be unscrewed if you want to connect it to a car-mounted antenna.

Power for the Volkswagen Jetta comes from a 2. See the reaction of victim's father. Simply insert the Firmware update disc and the RNS will power up. The type of lorry will affect the weight of goods the vehicle sofwareversion updaten start foru, vw navigation navi radio eftermontering volkswagen, used volkswagen for sale special offers edmunds, vw passat b7 wikipedia, le rns sovag fr, bilnavigation og multimedia kb brugt p dba, mr fix youtube, reparatur von navigation autoradio amp cd wechsler, rcd for sale ebay, volkswagen polo v A caravan, RV and camping parts and accessories store.

The unit will reboot a few times. National Life Group offers life insurance, annuity and investment products to help individuals, families and businesses pursue their financial goals. Fuel economy on internal combustion engine Volkswagen Passat vehicles varies quite a lot, figures being between 3. It's based on latest x software but can be used to recover RNS running any software version. Now I can get to all the wiring. Update: VW Golf R will be revealed next month. A stored procedure allows for code that is run many times to be saved on the database and run at a later time, making it easier for yourself and other developers in the future.

V8 Westeuropa Version 2. Where can i find the swl cd for this type. At Camec, we live to create outdoor comfort wherever the road may take you. Oil pump failure, faulty cd player, inoperative cruise control, ignition module. Seemed to always have radio issues. For assistance, call Mazda Systems Help Center Thanks to its technical superiority and sovereign good looks this fifth generation of the volkswagen golf introduced in october assumes once It's based on latest x software but can be used to recover RNS running any software version.

Based in the UK, AllBatteries. For model year and newer Volkswagen vehicles, you can view your manuals by entering the digit Vehicle Identification Number VIN in the search bar below Routan not included. You can insert the disc later when asked. If you get Gateway error or other problems and you can not boot up run this disc and it will restore the Nav. See who's hiring in your area. Restarting the car would fix the problem.

Forgot your password? Click here to reset it. Download Location 1: RNSfw Ich habe dann mal eine Reinigungs CD durchlaufen lassen aber ohne Erfolg. FIPS defines four valid pairs of L, N ; they are: , , , , , and , The output of the DSA algorithm consists of a pair of integers usually referred by the pair r, s. The signature value consists of the base64 encoding of the concatenation of two octet-streams that respectively result from the octet-encoding of the values r and s in that order.

For example, the SignatureValue element for a DSA signature r , s with values specified in hexadecimal:. Implementers should consult this publication for guidance on acceptable key lengths for applications, however bit public keys are the minimum recommended key length and bit keys are recommended for securing information beyond SP Part 1 states that DSA bit key sizes should not be used except to verify and honor signatures created using older legacy systems.

Since XML Signature 1. XML Signature 1. DSA with bit prime moduli MAY be used to verify older legacy signatures, with an understanding of the associated risks. The RSA algorithm takes no explicit parameters. Computation of the signature will require concatenation of the hash value and a constant string determined by RFC Signature computation and verification does not require implementation of an ASN.

The resulting base64 [ RFC ] string is the value of the child text node of the SignatureValue element, e. All conforming implementations of XML Signature 1. Integer to octet-stream conversion must be done according to the I2OSP operation defined in the RFC [ PKCS1 ] specification with the l parameter equal to the size of the base point order of the curve in bytes e. If canonicalization is performed over octets, the canonicalization algorithms take two implicit parameters: the content and its charset.

The charset is derived according to the rules of the transport protocols and media types e. This information is necessary to correctly sign and verify documents and often requires careful server side configuration. Various canonicalization algorithms require conversion to [ UTF-8 ]. Various canonicalization algorithms transcode from a non-Unicode encoding to Unicode.

Note : Canonical XML 1. However, some applications require a method which, to the extent practical, excludes unused ancestor context from a canonicalized subdocument. The normative specification of Canonical XML1. The algorithm is capable of taking as input either an octet stream or an XPath node-set or sufficiently functional alternative. The algorithm produces an octet stream as output. The normative specification of Canonical XML 1.

Canonical XML 1. A Transform algorithm has a single implicit parameter: an octet stream from the Reference or the output of an earlier Transform. For implementation requirements, please see Algorithm Identifiers and Implementation Requirements. Compliance with this recommendation will maximize application interoperability and libraries should be available to enable support of these transforms in applications without extensive development.

Any canonicalization algorithm that can be used for CanonicalizationMethod such as those in Canonicalization Algorithms section 6. The normative specification for base64 decoding transforms is [ RFC ]. The base64 Transform element has no content. The input is decoded by the algorithms.

This transform is useful if an application needs to sign the raw data associated with the encoded content of an element. This transform accepts either an octet-stream or a node-set as input. If an octet-string is given as input, then this octet-stream is processed directly.

If an XPath node-set or sufficiently functional alternative is given as input, then it is converted to an octet stream by performing operations logically equivalent to 1 applying an XPath transform with expression self::text , then 2 sorting the nodeset by document order, then concatenating the string-value of each of the nodes into one long string.

Thus, if an XML element is identified by a shortname XPointer in the Reference URI, and its content consists solely of base64 encoded character data, then this transform automatically strips away the start and end tags of the identified element and any of its descendant elements as well as any descendant comments and processing instructions.

The output of this transform is an octet stream. The XPath expression to be evaluated appears as the character content of a transform parameter child element named XPath. The input required by this transform is an XPath node-set or an octet-stream. Note that if the actual input is an XPath node-set resulting from a null URI or shortname XPointer dereference, then comment nodes will have been omitted. In other words, the input node-set should be equivalent to the one that would be created by the following process:.

The evaluation of this expression includes all of the document's nodes including comments in the node-set representing the octet stream. The transform output is always an XPath node-set. The XPath expression appearing in the XPath parameter is evaluated once for each node in the input node-set. The result is converted to a boolean. If the boolean is true, then the node is included in the output node-set.

If the boolean is false, then the node is omitted from the output node-set. Note: Even if the input node-set has had comments removed, the comment nodes still exist in the underlying parse tree and can separate text nodes.

Should this problem arise in the application, it can be solved by either canonicalizing the document before the XPath transform to physically remove the comments or by matching the node based on the parent element's string value e. The primary purpose of this transform is to ensure that only specifically defined changes to the input XML document are permitted after the signature is affixed.

This is done by omitting precisely those nodes that are allowed to change once the signature is affixed, and including all other input nodes in the output. It is the responsibility of the XPath expression author to include all nodes whose change could affect the interpretation of the transform output in the application context. That recommendation defines an XPath transform that permits the easy specification of subtree selection and omission that can be efficiently implemented.

An important scenario would be a document requiring two enveloped signatures. Each signature must omit itself from its own digest calculations, but it is also necessary to exclude the second signature element from the digest calculations of the first signature so that adding the second signature does not break the first signature. The XPath transform establishes the following evaluation context for each node of the input node-set:.

As a result of the context node setting, the XPath expressions appearing in this transform will be quite similar to those used in used in [ XSLT ], except that the size and position are always 1 to reflect the fact that the transform is automatically visiting every node in XSLT, one recursively calls the command apply-templates to visit the nodes of the input tree. Function: node-set here. The here function returns a node-set containing the attribute or processing instruction node or the parent element of the text node that directly bears the XPath expression.

This expression results in an error if the containing XPath expression does not appear in the same XML document against which the XPath expression is being evaluated. As an example, consider creating an enveloped signature a Signature element that is a descendant of an element being signed. Although the signed content should not be changed after signing, the elements within the Signature element are changing e. One way to prevent these changes from invalidating the digest value in DigestValue is to add an XPath Transform that omits all Signature elements and their descendants.

For example,. Due to the null Reference URI in this example, the XPath transform input node-set contains all nodes in the entire parse tree starting at the root node except the comment nodes. A more elegant solution uses the here function to omit only the Signature containing the XPath Transform, thus allowing enveloped signatures to sign other signatures. In the example above, use the XPath element:. Since the XPath equality operator converts node sets to string values before comparison, we must instead use the XPath union operator.

For each node of the document, the predicate expression is true if and only if the node-set containing the node and its Signature element ancestors does not include the enveloped Signature element containing the XPath expression the union does not produce a larger set if the enveloped Signature element is in the node-set given by ancestor-or-self::Signature.

An enveloped signature transform T removes the whole Signature element containing T from the digest calculation of the Reference element containing T. The output of the transform is equivalent to the output that would result from replacing T with an XPath transform containing the following XPath parameter element:. The input and output requirements of this transform are identical to those of the XPath transform, but may only be applied to a node-set from its parent XML document.

Note that it is not necessary to use an XPath expression evaluator to create this transform. Specification of a namespace-qualified stylesheet element, which MUST be the sole child of the Transform element, indicates that the specified style sheet should be used.

Whether this instantiates in-line processing of local XSLT declarations within the resource is determined by the XSLT processing model; the ordered application of multiple stylesheet may require multiple Transforms. No special provision is made for the identification of a remote stylesheet at a given URI because it can be communicated via an xsl:include or xsl:import within the stylesheet child of the Transform.

These steps will help to ensure interoperability of the resulting signatures among applications that support the XSLT transform.

Digital signatures only work if the verification calculations are performed on exactly the same bits as the signing calculations. If the surface representation of the signed data can change between signing and verification, then some way to standardize the changeable aspect must be used before signing and verification.

If it is possible for signed text to be modified from one line ending convention to another between the time of signing and signature verification, then the line endings need to be canonicalized to a standard form before signing and verification or the signatures will break. XML is subject to surface representation changes and to processing which discards some surface information. For this reason, XML digital signatures have a provision for indicating canonicalization methods in the signature so that a verifier can use the same canonicalization as the signer.

Throughout this specification we distinguish between the canonicalization of a Signature element and other signed XML data objects. It is possible for an isolated XML document to be treated as if it were binary data so that no changes can occur.

In that case, the digest of the document will not change and it need not be canonicalized if it is signed and verified as such. However, XML that is read and processed using standard XML parsing and processing techniques is frequently changed such that some of its surface representation information is lost or modified.

In particular, this will occur in many cases for the Signature and enclosed SignedInfo elements since they, and possibly an encompassing XML document, will be processed as XML. Similarly, these considerations apply to Manifest , Object , and SignatureProperties elements if those elements have been digested, their DigestValue is to be checked, and they are being processed as XML.

The kinds of changes in XML that may need to be canonicalized can be divided into four categories. There are those related to the basic [ XML10 ], as described in 7.

Third, there is the possibility of coded character set conversion, such as between UTF-8 and UTF, both of which all [ XML10 ] compliant processors are required to support, which is described in the paragraph immediately below. And, fourth, there are changes that related to namespace declaration and XML namespace attribute context as described in 7. Any canonicalization algorithm should yield output in a specific fixed coded character set. All canonicalization algorithms identified in this document use UTF-8 without a byte order mark BOM and do not provide character normalization.

Additionally, none of these algorithms provide data type normalization. Applications that normalize data types in varying formats e. XML 1. In particular,. Note that items 2 , 4 , and 5. Thus, a signature with such content will only be verifiable by other signature applications if the following syntax constraints are observed when generating any signed material including the SignedInfo element:.

DOM maps XML into a tree structure of nodes and typically assumes it will be used on an entire document with subsequent processing being done on this tree. In addition, namespace declarations are mapped over the nodes to which they apply, losing the namespace prefixes in the source text and, in most cases, losing where namespace declarations appeared in the original instance.

When serializing a Signature element or signed XML data that's the child of other elements using these data models, that Signature element and its children may have in-scope namespaces inherited from its ancestral context. Simple inheritable attributes i. This may frustrate the intent of the signer to create a signature in one context which remains valid in another. For example, given a signature which is a child of B and a grandchild of A :. The canonical form of the signature in this context will contain new namespace declarations from the SOAP:Envelope context, invalidating the signature.

Also, the canonical form will lack namespace declarations it may have originally had from element A 's context, also invalidating the signature. To avoid these problems, the application may:. The XML Signature specification provides a very flexible digital signature mechanism. Implementers must give consideration to their application threat models and to the following factors.

A requirement of this specification is to permit signatures to "apply to a part or totality of a XML document. The Transforms mechanism meets this requirement by permitting one to sign data derived from processing the content of the identified resource.

For instance, applications that wish to sign a form, but permit users to enter limited field data without invalidating a previous signature on the form might use [ XPATH ] to exclude those portions the user needs to change.

Transforms may be arbitrarily specified and may include encoding transforms, canonicalization instructions or even XSLT transformations. Three cautions are raised with respect to this feature in the following sections. Note, core validation behavior does not confirm that the signed data was obtained by applying each step of the indicated transforms. Though it does check that the digest of the resulting content matches that specified in the signature. For example, some applications may be satisfied with verifying an XML signature over a cached copy of already transformed data.

Other applications might require that content be freshly dereferenced and transformed. First, obviously, signatures over a transformed document do not secure any information discarded by transforms: only what is signed is secure. All entities are replaced with their definitions and the canonical form explicitly represents the namespace that an element would otherwise inherit. Also, users concerned with the integrity of the element type definitions associated with the XML instance being signed may wish to sign those definitions as well i.

Second, an envelope containing signed information is not secured by the signature. For instance, when an encrypted envelope contains a signature, the signature does not protect the authenticity or integrity of unsigned envelope headers nor its ciphertext form, it only secures the plaintext actually signed.

However in some cases, the value of an attribute may be a list or vector with multiple values in it. An obvious example is the d attribute of a path: a space delimited list of x and y coordinates. Well, it so turns out, that we can animate these sorts of things as well, provided the number of items in the lists associated with the animated attributes matches up. If a path has 17 points at the beginning of the animation it should have 17 points throughout the animation.

Then, provided that the lists match up in quantity and are numeric , SMIL interpolates by generating intermediate frames. Here's a simple example:. In this example, only one point has been changed, to make the example simple enough to read.

But that is not at all a requirement. One of the most convenient and pleasant aspects of SVG is the fact that we may build a path, and let an object follow it over time.

It is not too tricky, so here's an example. It begins and ends at the same x,y coordinate, , Another matter worth noting is the initial position of the ellipse. Observe that ellipse 2 is just slightly above the curve.

Timing of the motion is uniform relative to the length of the curve. Not all SVG objects share the same collection of attributes. A rectangle and an image share the attributes x, y, height and width, but an ellipse has cx, cy, rx, and ry to control its placement on the screen. A common way of moving all these objects about on the screen is a natural thing for a developer to want. Likewise we might wish to be able to change the size and rotation of objects without having to calculate the new coordinates and replot a new curve.

We have seen in Chapter 2 how to use the transform tag to rotate, translate, and scale objects, so it might appear obvious to try something like:. It doesn't work quite that way, but that's actually close to how it does work. An example:. This succeeds in drawing a blue ellipse and then rotating it degrees counterclockwise every 2.

We discussed the impact that one transform will have on the next in Chapter 2 section 4: "Multiple transformations and more". Just as we had to adjust for the effect that one transform had on the object when applying another with static images, we likewise must do so with moving images. The above example will both rotate and resize an ellipse, but preserve its center. While SMIL provides for smooth transitions between attributes with numeric values, these are not the only sorts of attributes that can be animated.

A couple of examples are provided to encourage the reader to think broadly about SMIL's utility. If values of an attribute cannot be interpolated between, that is not a problem for SMIL. A given SVG page may combine textual information with interesting graphics. That is clearly part of the appeal of SVG and the web in general else we'd still all be using gopher Suppose that we would like our visitors to be able to read our information for a few seconds before certain animations begin — perhaps we fear that our graphics might be so compelling that they might overwhelm the message.

We could tell our marketing division that if they are really worried then they should tone down the graphics a bit, or we could simply delay their onset. Another scenario that makes more sense to this academic fellow is this: suppose I wish to have several objects following one another around a path — spaced out at equal intervals around the path. I that case, I can animate each but delay when it is that they begin.

Each earlier one can be given a head start along the path. The only problem with this approach is that during that first second while it is waiting to start, the second ellipse is rendered, but at its origin 0,0 since neither cx or cy is specified, their default values are each zero. That may be undesirable, or, at best, odd.

How might we keep the image invisible while it is waiting to start? Well, like many things in SVG, there is more than one way, and each is instructive in its own way. First, we might proceed as follows: instead of positioning the ellipse-in-waiting at 0,0 why don't we just place it on the curve? We know, for example, that the point , lies on the curve it is the last of a cubic triplet in the d attribute and it would seem to be about halfway along the curve.

So, let's try the following:. There are three problems with this. The first, possibly minor issue, is that the second ellipse will appear in its initial and unrotated orientation.

It will not be pointing in the same direction as the curve. The second is that the point , is probably not the exact midpoint of the curve. This is perhaps not a major issue either. The biggest problem, though, is that the positioning of the thing will be done relative not just to the curve but to its own offset relative to 0,0. Ultimately the underlying transformations rotation, scale, and translation will be amplified by its now large distance from the origin and hence the curve itself.

The second ellipse will not in fact follow the curve but some strangely distorted and amplified shadow of it most of which exists off-screen in this case. Alternatively, we could animate the opacity of the second ellipse, having it wait until after it has moved from its initial position 0,0 onto the curve, thereupon to become visible.

We had to remember to set the initial value of its opacity to zero, since the onset of the animation is delayed by a second, meaning that its initial value of zero under the animation will not be encountered until the animation stops. The above succeeds in bringing the second ellipse onto the curve at 1. It then begins moving and gradually fading into view over the next second. This works just fine and is a somewhat pleasant effect. This approach with fading an object in by adjusting its opacity is, however, a bit fancier than we may have intended for this relatively simple problem.

The goal was to prevent the object from becoming visible until its animation started. It keeps the second ellipse invisible until one second after the animations begin which is just at the time it is introduced onto the path. The above is an example of an animation in this case a set — a sort of a degenerate case of an animation being triggered by an event.

We'll discuss this in just a bit more detail now, since it is popular and natural to use a mouse-click to start an animation. Let's extrapolate a bit and make the example above have a bit more behavior. It is common in the world of the web and in user-interface practice in general, to have things which act like buttons by triggering events also feel like buttons. That is, in the real world, a button tends to have a bit of give to it: brushing your hand against the toaster accidentally does not turn it on either the toaster or the hand.

We often make our virtual buttons responsive, in somewhat the same way, to let the user know that it is a button, and hence, that it may do something when clicked. A common trick for this is to give it a rollover effect. This can be achieved quite easily in SVG. The above text will still expand and shrink as before but we note that we have also affiliated with the text the ability to respond to two new events: the event of when the mouse moves over it and then another when the mouse departs.

As we saw in an earlier example in this section where we transitioned the opacity of ellipses to follow a curve , objects need not be triggered by events on nearby objects in the sense of proximity in the document.

We saw how. We can also delay the onset of the second to follow the onset of the first by one second:. Suddenly SMIL's timing starts to take on a richer character altogether! Likewise we may start an animation of object A with a mouse-click on object B. Using either of two ways to start an animation doesn't make sense, though, until we first can figure out how to stop an animation. There are several fairly straightforward ways to stop an animation For now, approaches 1 and 2 are relevant to SMIL, while the others await our discussion of scripting.

The problem and its solution are just instructive enough, that it may prove useful to examine it in some detail. To have a single button on a page which both starts and stops an animation seems like a natural thing. To have two buttons, one that starts something and another that stops it is fairly straightforward:. First we build a couple of buttons.

We'll put text "go" or "stop" on top of rectangles and put the text and its rectangle in a group with an id so that clicks on either the text or the rectangle behind it are responded to by the group :. Clearly we could make much fancier looking buttons, but here we're interested more in making the code legible than in making the buttons fancy. Now, we want to make an animation which responds appropriately to clicks on the other button. This keeps it at its last position when the animation stops.

This works just fine. Now how do we get the "go" button to work as well? It would seem natural to use. The problem is that then the animation never starts , until we push the "go" button. We wanted the animation to start when the page loads or when the go button is clicked. A solution:. This means start the animation either at zero seconds i. This does the trick. As long as we're concentrating on what is becoming a rather lengthy piece of code, let's work a bit further in this direction.

Let's get two ovals following one another around the curve, and have them both start and stop when the buttons are clicked. But let us still have the second one start a second later than the first. Here's how to get the second animation to start a second after the first. Just like the first, animation, we stop this one based on a click on "stop. The onset is, hence, relative to the beginning of the first animation, but delayed one second. That way, whether the first animation begins through loading of the page, or through a mouse click, the second animation follows a second behind.

But how might we make it so that one button does both starting and stopping. It is quite easy in JavaScript, but that topic awaits a later chapter. How to use SMIL to do this is the question. The first way we'll consider is to actually put two buttons in the same location mimicking one button and letting a click on either hide itself and reveal the other.

Then it is simply a matter of affiliating the cessation of the animation with the stop button when it is visible and the animation's begin with the start button. Clearly, the key here is to make it look as though the state of the button is changing, when in fact the entire button is being replaced by another. To actually have one button that serves as both a start and stop button, here is a solution that does the trick though the activity is triggered by mousedown and mouseup events rather than successive clicks :.

In conclusion, SMIL is a very compact and efficient way of directing complex events with minimal script. It is accessible to script, and hence, compatible with it. It is a type of choreography that seems to be commanding the attention of influential people.

It is quite likely that we will see more of it and allied technologies popping up here and there in web development during the foreseeable future. Some of the readers of this book may have programmed extensively in many languages. Others may never have written serious programs.

Others still may have dabbled, through a perhaps inspired process of trial and error, with minor modifications to a JavaScript program that they found attached to an HTML document developed by someone else. Still others may be unaware of the difference between a programming language and a markup language. To those who know programming beyond a cursory introduction, the scope of what programming might add to SVG is immediately obvious.

To the others, it is recommended that you read carefully through Appendix II in which JavaScript is introduced in a rather abbreviated way, focusing on those aspects most likely to help with one's SVG development. Regardless of the reader's vantage point, an explanation of "why scripting?

Given how flexible SVG is, with its compound filters and its SMIL animation that enables message passing between objects, what can scripting do for us that we cannot do already? Traditionally, we distinguish between programming languages and simple sets of commands like batch files by virtue of three important constructs: the ability to define variables which store information for later use, conditional logic if some condition is met, then perform some specific action, otherwise don't , and looping keep doing something again and again until some condition is met.

Once one has those three constructs in a language then one can do pretty much whatever can be specifically defined Let's look at SVG in these terms. We can store information in objects though it isn't clear how we might later use that information without programming :. We can also loop until some condition is met or let it begin conditionally when, for example, a mouse clicks using a SMIL animation. The concept is probably a hard one to characterize completely. A course in Theory of Computing would probably give the reader a good idea, but absent that I will attempt to illustrate the concept with a few examples:.

From my experience as a college teacher, I have discovered that not all people would share all of the above as personal interests. However, one can take some comfort, perhaps, in realizing that, if one wanted to, one could do any of the above with the right program.

I would venture to suggest that not all of these programs, though, have yet been written. You might have to do it yourself. Another note that I should mention in this context: there have been a variety of good "libraries" developed to help with the deployment of scripting in the context of SVG. Several have large and useful open-source components. I would love it if one of the readers would volunteer a chapter on this topic, as I haven't frankly followed these developments at all closely.

Let us start rather modestly, with figuring out how to activate simple scripts based on actions done by our users 37 or visitors. I'll try to follow the goal of keeping examples simple, brief and crisp, in hopes that the material will make sense to programmers and non-programmers alike.

This is, in part, since the nature of this book has changed from its original conception as a print document to a web-based version. Longer examples can be comprehended more fully by interacting with them on the web, and at least one of the book's reviewers recommended that a few more complex examples be included. The authorial intent, though of keeping the examples brief and self-contained, is nonetheless, reiterated.

If you are one of those readers who is a non-programmer, then please be comforted to know that a sincere attempt has been made to keep things simple when possible! Let's see if we can do a very simple thing: activate an "alert box" 38 as soon as our SVG page loads. If we are familiar with launching scripts from HTML we might be tempted to try something like the following:. When we do this, we'll discover that when the page is viewed in either Opera 9. And to our dismay, Firefox, or for that matter, Opera 9.

It turns out that this is not these other browsers' fault. Their behavior is consistent with the W3C standards on being "namespace aware. But so long as we're at it we might as well add an additional namespace declarations:. Most authors recommend that both namespace declarations be used in all SVG documents if for no other reason than to avoid potential problems later on.

There are times at which we might like to add in additional xml namespaces, particularly in dealing with compound documents which intermingle different XML languages.

We might for example wish to add such things as. We have seen how to fire a simple JavaScript command "alert " from the event caused by the loading of an SVG Document. More on this topic will be seen later, but let us turn now to launching small programs from other kinds of events, like mouse clicks. In the following example, a SMIL animation is triggered by a mouse click, but in turn, the beginning or end of the animation triggers a JavaScript function:.

We might be tempted to use the beginning of a small SMIL animation of infinitesimal duration as an alternative to an onload statement, were it not for the fact that certain browsers most notably Chrome and Firefox have not yet implemented SMIL.

At any rate, the above example shows that we are indeed able to launch a small JavaScript program based on a mouseclick. It is worth pointing out that "onactivate" is considered slightly more general than "onclick" since the former can refer to activation caused by viewers that do not have a mouse connected, but instead have other input devices.

The event onactivate , however, appears not to be widely deployed, yet, across browsers, so the reader is encouraged to test it in the contexts where it is expected to be used before deploying. That is where we turn our attention next. We do this by placing. In the above example, a click on the rectangle results in activation of the function Here and thence an alert box is displayed.

However, in the following example, browsers will not respond the way we might hope, since the less than sign in the code disrupts the XML parsing of the SVG. Placing the CDATA section around the contents of the text, succeeds in hiding the JavaScript from the parser and does so successfully in all five browsers. Having figured out how to run JavaScript programs, it now makes sense to see if we can use JavaScript to somehow change our SVG document. In particular, we might be interested in changing a document in ways beyond what SMIL allows.

First, let's use JavaScript to find known objects within an SVG document and then answer questions about the properties of those objects If the reader is familiar with JavaScript in the HTML environment, she is probably aware that one often uses the object named document to refer to the entire HTML document, namely a container of the elements associated with a web page.

Likewise in SVG, we may refer to document as the entity containing all the nodes of the SVG including the root node itself. Therefore, the following page results in an alert displaying the string "R" in all five of the major browsers:. What we have done in the above code is to first use document to find the entire SVG document, then, within that, we look for any element that has an id of "R" by using. Of all the properties associated with a node, we may note that most attributes cannot be referenced in this manner.

For example, the expression. Specifically, the command. Given the nature of differences between the rendered page and mark-up, in part, due to animation, these methods are frequently recommended. Before we look further into attributes of nodes, let us look a bit further into some of the other methods and properties associated directly with a node. Most of these are discussed later in this chapter.

Most are included here just to illustrate how once we locate an SVG object a node , we can not only find out about it, but we can also use it as a starting point for exploring the SVG hierarchy of nodes, both nearby and far away.

This can prove to be an important capability as documents get large and as nodes and node naming become complex. Once we have found a node by its "id" as in the above examples, we may also interrogate any particular attribute of that node using the "getAttribute" method associated with SVG nodes. This can be useful if we have objects whose attributes change over time, since we may not have independently stored that information in a data structure though for various reasons, it is often better to, as discussed subsequently.

Also if we inherit SVG objects as parts of other documents, then we may have need to parse those documents, in which case getAttribute may prove most handy. All five major browsers, as of this writing, are each successful in interpreting, without problem, the DOM1 command:.

However, the reader should be aware that as web documents start to, in coming years, to contain potentially multiple XML markup languages, the notation:. It works currently in most browsers, so in fact, it is generally recommended that we use this bulkier format.

Some have suggested the standards could specify that in an SVG document, for example, namespace declarations could default to contextually appropriate settings, but this suggestion seems not to have met with widespread support in the standards community.

In short, O. If one is interested in exploring all attributes of a node, in circumstances that we may not know what to expect a priori , see the section on "XML and the SVG DOM" later in this chapter. In order to make SVG documents dynamic, we must provide some ways for the documents to change in response to events either user-generated events like mouse clicks, browser events like images finishing the download process or AJAX-like HTTP events, or time-based events, like the passage of 20 seconds.

But certain kinds of activities, conditions, and calculations require a full-fledged programming environment under the hood, and hence, JavaScript has the ability to change attributes of any object drawn in the SVG canvas. Consider the following examples:. Clicking the ellipse activates the function changeFill. First that function finds the ellipse by referencing its id, then it modifies its "fill" attribute to the new value "black. The function then repositions one of the two ellipses by resetting its "cx" and "cy" attributes.

When the page loads, the function startup is run, assigning the variable C to the grey ellipse. Specifically, whenever the mouse moves, the function moveIt is invoked. The moveIt function receives as a parameter, the event itself namely the mousemove event , including the coordinates of the mouse event. Those coordinates, clientX and clientY, are then used to set the appropriate attributes of the ellipse being "dragged".

The onmouseup event calls drop which terminates movement. It does this by assigning the onmousemove attribute to the function moveIt evt :. Thus upon clicking the ellipse, the entire canvas will listen to mouse movement. The listening remains in effect until withdrawn by a mouseup event occurring on the ellipse. A few things should be noted here. First, we assign the onmousemove listener to the entire document space We could assign it, instead, only to the ellipse and it would still drag and drop.

The problem though would be that if the mouse movement would happen to, as it often will, get ahead of the screen updating, then the ellipse will no longer receive mouse events and will be dropped at its present location. By arming the entire space to listen to mouse movement, we avoid that possibility, even if the mouse gets ahead of the ellipse.

Second, the document itself contains a white rectangle which spans the entire browser window. This is useful since it allows the mouse activity to be captured even when the mouse moves outside the space defined when the document loads.

Without this, we might again, "lose" the ellipse if the mouse is moved too rapidly. Third, the withdrawal of the onmousemove listening is done by a mouseup on the ellipse.

It might be better to have this listener withdrawn by a mouseup anywhere in the documentElement. The code would be a bit more complex to beginning eyes, and it is relatively unlikely that someone will release the mouse while it is still moving rapidly the circumstance under which the mouse gets ahead of the thing it is dragging.

The color function merely constructs a string of the form " xxx" where the three values of "x" represent hexadecimal digits in the range 0 to F. This slightly more complex example is given to illustrate how broadly setAttributeNS might be applied to our SVG content.

That is, the statement should look like:.