191 COORDINATES IN SILVERLIGHT 4. Next, we’ll code up the pn]i*t]ih*_o file. Start with a publicly accessible `kq^ha to hold the application width. Following that, add a private velocity integer variable and a Boolean that will be used to determine if the claw is in motion: lq^he_`kq^ha]llSe`pd7 lner]paejprahk_epuT7 lner]pa^kkh_h]sIkrejc9b]hoa7 5. Inside the pn]i$% constructor, add code to begin the pn]iPeian storyboard, and create event handlers for the ?kilhapa` event of the pn]iPeian storyboard and the ?kilhapa` event of the _h]s@ksj storyboard. The _h]s@ksj storyboard contains an animation that opens the claw as it drops toward the bottom of the screen, and then closes the claw and rises back up. pdeo*pn]iPeian*>acej$%7 pdeo*pn]iPeian*?kilhapa`'9jasArajpD]j`han$pn]iPeian[?kilhapa`%7 pdeo*_h]s@ksj*?kilhapa`'9jasArajpD]j`han$_h]s@ksj[?kilhapa`%7 6. Create the _h]s@ksj[?kilhapa`$% event handler function. The code that goes inside the func- tion is simple. It does nothing more than switch our Boolean flag _h]sIkrejc to b]hoa. lner]parke`_h]s@ksj[?kilhapa`$k^fa_poaj`an(Arajp=ncoa% w pdeo*_h]sIkrejc9b]hoa7 y 7. Create the pn]iPeian[?kilhapa`$% event handler function. This function handles the motion and boundary checking for the pn]i object. At each completion cycle of the timer storyboard, the tram is moved by the current value contained in the rahk_epuT variable. Tests are done to see if either the left or right walls were hit, and if so, the direction of the velocity vector is reversed. The function finishes off by restarting the timer that is used to move the tram. lner]parke`pn]iPeian[?kilhapa`$k^fa_poaj`an(Arajp=ncoa% w  ?]jr]o*OapHabp$pdeo(?]jr]o*CapHabp$pdeo%'rahk_epuT%7 ++_da_gebdepnecdps]hh eb$?]jr]o*CapHabp$pdeo%'pdeo*Se`pd:9$pdeo*]llSe`pd).,%% w rahk_epuT&9)-7 y ++_da_gebdephabps]hh eb$?]jr]o*CapHabp$pdeo%89)1% w rahk_epuT&9)-7 y pdeo*pn]iPeian*>acej$%7 y 192 CHAPTER 5 8. Two more functions need to be added to this code-behind. The first, OapPn]iRah$%, will accept an integer argument. When called, this function checks to see if the _h]sIkrejc flag is pnqa, which will only happen if the storyboard animation for the claw is playing. If the storyboard for the claw is not playing, the current value of rahk_epuT is increased by the velocity amount passed to the function. Then some simple tests are done to keep the speed of the tram within the range of +2 and –2. lq^he_rke`oapPn]iRah$ejprahk_epu% w eb$_h]sIkrejc% w rahk_epuT'9rahk_epu7 ++gaalpdarahk_epusepdej'.+).n]jca eb$rahk_epuT:,""rahk_epuT:.% w rahk_epuT9.7 y ahoaeb$rahk_epuT8,""rahk_epuT8).% w rahk_epuT9).7 y y y 9. The final function to add to this code-behind will be called when the down arrow key is pressed on the keyboard. The function is called `ksjGau$%. When called, the code will check to see if the _h]s storyboard is playing. If not, it will set the x velocity vector of the tram object to 0, set the _h]sIkrejc Boolean to pnqa, and start the _h]s@ksj animation. lq^he_rke``ksjGau$% w eb$_h]sIkrejc% w rahk_epuT9,7 pdeo*_h]sIkrejc9pnqa7 pdeo*_h]s@ksj*>acej$%7 y y 10. That does it for the pn]i object. Since we added the ]llSe`pd property, we’ll need to add that into the I]ejL]ca*t]ih*_o file, in the I]ejL]ca$% constructor: lq^he_I]ejL]ca$% w Ejepe]heva?kilkjajp$%7 ?]jr]o*OapPkl$n]eh(.,%7 ?]jr]o*OapPkl$pn]i(.,%7 pn]i*]llSe`pd9pdeo*Se`pd7 193 COORDINATES IN SILVERLIGHT H]ukqpNkkp*?deh`naj*=``$pn]i%7 H]ukqpNkkp*?deh`naj*=``$n]eh%7 y 11. The input for the application will be handled via the keyboard, so inside the I]ejL]ca$% con- structor, add a GauQl event listener to gather user input from the keyboard: pdeo*GauQl'9jasGauArajpD]j`han$gauD]j`han%7 12. Create the event handler function after the closing curly brace of the I]ejL]ca$% construc- tor: lner]parke`gauD]j`han$k^fa_poaj`an(GauArajp=ncoa% w y 13. The event handler code for the keyboard input handles three cases. When the left arrow key is pressed, the tram’s x velocity is adjusted by a value of –1. If the right arrow key is pressed, the tram’s x velocity is incremented by 1. Remember that the oapPn]iRah$% function is passed a value that is added to the current x velocity. This means that if the tram’s velocity is 2, when the left arrow key is pressed, the velocity gets decremented by –1, which results in a slowing motion (and an eventual change of direction if the arrow key is pressed repeatedly). When the down arrow key is pressed, the `ksjGau$% method for the tram object is called. osep_d$a*Gau% w _]oaGau*Habp6 pn]i*oapPn]iRah$)-%7 ^na]g7 _]oaGau*Necdp6 pn]i*oapPn]iRah$-%7 ^na]g7 _]oaGau*@ksj6 pn]i*`ksjGau$%7 ^na]g7 y Compile and run the project. Click the main application to gain focus, and then use the arrow keys to manipulate the tram’s direction. The claw will drop when you press the down arrow key. The finalized code for this project is available in the clawGameCompleted project. Take some time to examine the XAML for the objects. The tram object is composed of three parts: the roller tram that is the main part of the object, the claw that hangs below the tram, and the cable that lowers and raises the claw. The cable canvas has a clipping region applied that hides the cable. Figure 5-11 shows the tram object with the cable selected. Notice that only the area where the cable should be allowed to show is inside the clipping region. The clipping region helps to give the illusion that the cable is dropping when the storyboard is played, as shown in Figure 5-12. 194 CHAPTER 5 Figure 5-11. The cable portion of the tram is hidden with a clipping region. Figure 5-12. When the claw project is in action, the user controls the movement of the claw and when it drops. 195 COORDINATES IN SILVERLIGHT Vector math How you choose to store vectors for your objects is entirely up to you—you can store vectors as individual x,y components in different variables, as in the previous examples, or you can use a Lkejp object to store both vector components in a single variable. One caveat to be aware of is that if you attempt to store a vector as a Lkejp property using a getter and setter, you will not be able to access the individual components of the point. However, using Lkejp data types as shown here—as public variables—will work OK. Whichever method you choose to store your vectors, there is a bit of math that can be done with them. Next, we’re going to take a look at how that is done. We’ll start with vector addition. Vectors are pretty simple to add—you simply add the x components of the vectors and the y components of the vectors. Figure 5-13 illustrates an example. Given the pair of vectors drawn in white, which are 8,10 and 0,10, the resultant vector, 8,20, is drawn in black. The magnitude of the vectors used in this example are exaggerated a bit to demonstrate the addition, but the idea is what we’re after. Vector addition can be used to look ahead and see where your object will be the next time it moves. Figure 5-13. To add vectors, add the individual components. Vectors can also be scaled by multiplying. To scale a vector by 2, for example, you multiply both of the vector’s components by 2. This will result in a vector that points in the same direction but is twice as long. The vectorMath project contains a couple of examples for you to experiment with. There’s nothing that you really need to code up here, so you can take a breather. I’ll just go through the code so you can modify it if you’d like. 196 CHAPTER 5 In the I]ejL]ca*t]ih*_o file, two Lkejp objects are declared, each of which will be used to store a vector: lner]paLkejpra_pkn-9jasLkejp$%7 lner]paLkejpra_pkn.9jasLkejp$%7 To get started, I assigned some arbitrary values to the vector objects. The first is 8,10, and the second is 0,10: ra_pkn-*T947 ra_pkn-*U9-,7 ra_pkn.*T9,7 ra_pkn.*U9-,7 Once that’s done, both vectors are passed to a function called snepaRa_pkno$%, which simply outputs the values to the screen: lner]parke`snepaRa_pkno$Lkejpra_pkn=(Lkejpra_pkn>% w ioc>hk_g*Patp9Ra_pkn-6'ra_pkn=7 ioc>hk_g*Patp'9XjRa_pkn.6'ra_pkn>7 y Following that, the values are passed to the ]``Ra_pkno$% function: ]``Ra_pkno$ra_pkn-(ra_pkn.%7 This function takes both vectors, adds their components, and places the result on the screen: lner]parke`]``Ra_pkno$Lkejpra_pkn=(Lkejpra_pkn>% w LkejpjasRa_pkn9jasLkejp$%7 jasRa_pkn*T9ra_pkn=*T'ra_pkn>*T7 jasRa_pkn*U9ra_pkn=*U'ra_pkn>*U7 ioc>hk_g*Patp'9XjRa_pkn=``epekj6'jasRa_pkn7 y Once that’s done, a vector and a scaling factor are passed to the o_]haRa_pkn$% function: o_]haRa_pkn$ra_pkn-(.%7 The o_]haRa_pkn$% function multiplies each component of the vector passed by the scale value that was passed and then writes the output to the screen: lner]parke`o_]haRa_pkn$Lkejpra_pkn=(ejpo_]ha% w LkejpjasRa_pkn9jasLkejp$%7 jasRa_pkn*T9ra_pkn=*T&o_]ha7 jasRa_pkn*U9ra_pkn=*U&o_]ha7 ioc>hk_g*Patp'9XjRa_pkn-O_]ha`^u'o_]ha'6 'jasRa_pkn'7 y 197 COORDINATES IN SILVERLIGHT Take a little time and play around with the values that are set for the vectors to see what type of results the math operations you’re performing will have. Angles in Silverlight As you saw earlier when working through the transform types, rotational angles in Silverlight are expressed in degrees and can be additive or subtractive—for example, both 720 degrees and –720 degrees will rotate an object around twice. The former will rotate an object clockwise, while the latter will rotate an object counterclockwise. As you have seen along the way, Rotate transforms are accessible through code. By adding an t6J]ia property to an object’s Rotate transform, you can easily access the angle of rotation. Take, for exam- ple, the following rectangle XAML: 8Na_p]jchat6J]ia9iuNa_pDaecdp9-,, Dknevkjp]h=hecjiajp9Habp Ranpe_]h=hecjiajp9Pkl Se`pd9-,,Behh9BBBBBBBB Opnkga9BB,,,,,, Naj`anPn]jobkniKnecej9,*1(,*1: 8Na_p]jcha*Naj`anPn]jobkni: 8Pn]jobkniCnkql: 8Nkp]paPn]jobknit6J]ia9iuNa_pNkp]pa=jcha95,+: 8+Pn]jobkniCnkql: 8+Na_p]jcha*Naj`anPn]jobkni: 8+Na_p]jcha: You should be able to tell from this code that the rectangle has been rotated 90 degrees via a Rotate transform. Notice that an t6J]ia attribute, iuNa_pNkp]pa, was added to the Nkp]paPn]jobkni defini- tion. To modify this value via code, you can directly access the =jcha member of iuNa_pNkp]pa as follows: iuNa_pNkp]pa*=jcha9).,7 You may have noticed when working with vectors that the line a vector makes kind of looks like an angle. With just a bit of code, you can convert a vector into an angle. To do this, however, you’ll need to know three things. First off, mathematics uses a unit of measure called a radian to measure angles—1 radian is equal to about 57.2958 degrees. Second, we use a math function called =p]j.$% (arctangent) to determine the radians. Finally, we need a way to convert the radians to a useful number that represents an angle for us. If you’re starting to get nervous because we’re using some mathematics, don’t worry. The math is presented here as kind of a plug-and-play solution. For now, we want to focus on how vectors and angles are related. All of this radian and =p]j.$% talk is a fancy way of saying we need the following two lines of code, into which we plug a vector. The result will be the angle of the vector. 198 CHAPTER 5 `kq^han]`e]jo9I]pd*=p]j.$ra_pknHajcpd*U(ra_pknHajcpd*T%7 ]jcha9?kjranp*PkEjp-2$-4,+I]pd*LE&n]`e]jo%7 The first line uses the =p]j.$% math method to calculate the radians from the vector that was passed. You can see the usage of the =p]j.$% function, and how we pass the vector to the function. Notice that the vector is passed y,x (not x,y). The second line of code contains the formula for converting radians to degrees. Converting vectors to angles To see this code in action, visit the vectorAngleConversion project. This is a simple project that sets up a Lkejp object that contains a vector and a variable called ]jcha: lner]paLkejpra_pknHajcpd9jasLkejp$%7 lner]pa`kq^ha]jcha7 A value that represents a vector is assigned to the ra_pknHajcpd variable, and the angle of the vector is calculated and output to a TextBlock: ra_pknHajcpd*T917 ra_pknHajcpd*U917 `kq^han]`e]jo9I]pd*=p]j.$ra_pknHajcpd*U(ra_pknHajcpd*T%7 ]jcha9?kjranp*PkEjp-2$-4,+I]pd*LE&n]`e]jo%7 ioc>hk_g*Patp9]jcha'7 The result produced by this bit of code is 45, which is the correct angle (in degrees) for a vector of 5,5. Go ahead and play with the values of the ra_pknHajcpd variable, and run the program to see what kind of results you get. Don’t worry if you see a few results that surprise you—we’ll be visiting these two math functions again later. Let’s take a look at a project that graphically illustrates the math. This project allows a user to adjust the endpoints of a line. As the endpoints are adjusted, the application calculates the length of the vector that the line creates, calculates the angle of that vector, and applies the angle to a separate heja object as a sanity check for the calculations. All the code we’re about to discuss is available in the vectorAngles project. The I]ejL]ca*t]ih file for this project contains four sliders and several TextBlock objects that are used to provide user feedback. In addition, there is a Path object that is used to draw a simple line. The default orientation for the line is horizontal. In the I]ejL]ca*t]ih*_o file, the objects needed in the project are declared. The first one is the user- adjustable line, called iuHeja. The next two objects are Lkejp objects, l- and l., and are used to store the endpoints of the iuheja object. The last two declarations are similar to those illustrated in the previous project—ra_pknHajcpd is used to determine the length of the line as a user manipulates it, and ]jcha is used to store the angle of the line. lner]paHejaiuHeja9jasHeja$%7 lner]paLkejpl-9jasLkejp$%7 lner]paLkejpl.9jasLkejp$%7 lner]paLkejpra_pknHajcpd9jasLkejp$%7 lner]pa`kq^ha]jcha7 199 COORDINATES IN SILVERLIGHT The code starts by assigning some default values to the l- and l. Lkejp objects: l-*T9,7 l-*U9,7 l.*T9.1,7 l.*U9.1,7 Next, the values in the l- and l. Lkejp objects are used to create starting and ending points for the iuheja object. In Silverlight, a line is defined by two pairs of coordinates: the start point and the end- point. They are referenced as T-,U- and T.,U Once values are assigned to the iuheja object, the line’s OpnkgaPde_gjaoo and ?khkn are set. iuHeja*T-9l-*T7 iuHeja*U-9l-*U7 iuHeja*T.9l.*T7 iuHeja*U.9l.*U7 iuHeja*OpnkgaPde_gjaoo9-7 Okhe`?khkn>nqodopnkga9jasOkhe`?khkn>nqod$%7 opnkga*?khkn9?khkno*>h]_g7 iuHeja*Opnkga9opnkga7 Prior to adding the line to the canvas, a function called `k=jcha$% is called with the code `k=jcha$%7. This function uses the start point and endpoint of the iuheja object to determine the length of the vector created by the line. You should recognize the next couple of lines of code from the previous example—this is where the vector created by the line is converted into an angle. The paopHeja=jcha object is our sanity check—this object will be rotated the number of degrees cal- culated by our code, and the angle of the line should match the angle of the iuheja object, assuming the code is functioning correctly. The values are converted to integers for display as they are output to the canvas. lner]parke``k=jcha$% w ra_pknHajcpd*T9iuHeja*T.)iuHeja*T-7 ra_pknHajcpd*U9iuHeja*U.)iuHeja*U-7 `kq^han]`e]jo9I]pd*=p]j.$ra_pknHajcpd*U(ra_pknHajcpd*T%7 ]jcha9?kjranp*PkEjp-2$-4,+I]pd*LE&n]`e]jo%7 paopHeja=jcha*=jcha9]jcha7 ioc>hk_g*Patp9Ra_pknT(U6' ?kjranp*PkEjp-2$ra_pknHajcpd*T%'(' ?kjranp*PkEjp-2$ra_pknHajcpd*U%' Xj=jcha6']jcha7 y Now that the initial state of the line has been used to determine the angle and the screen output is current, the line is added to the H]ukqpNkkp Canvas: H]ukqpNkkp*?deh`naj*=``$iuHeja%7 Next, the maximum limits for the sliders are set. The sliders will be used to allow a user to change the starting and ending points of the iuheja object, and the application will not allow either point’s x 200 CHAPTER 5 value to be greater than the width of the canvas or either point’s y value to be greater than the height of the canvas. l-TOhe`an*I]teiqi9l.TOhe`an*I]teiqi9H]ukqpNkkp*Se`pd7 l-UOhe`an*I]teiqi9l.UOhe`an*I]teiqi9H]ukqpNkkp*Daecdp7 Each of the four sliders is then preset to the default value for the endpoints of iuHeja, and the text that displays the current value for each slider is updated: l-TOhe`an*R]hqa9iuHeja*T-7 l-UOhe`an*R]hqa9iuHeja*U-7 l.TOhe`an*R]hqa9iuHeja*T.7 l.UOhe`an*R]hqa9iuHeja*U.7 iocL-TOhe`an*Patp9Lkejp-T6'$Ejp-2%iuHeja*T-7 iocL-UOhe`an*Patp9Lkejp-U6'$Ejp-2%iuHeja*U-7 iocL.TOhe`an*Patp9Lkejp.T6'$Ejp-2%iuHeja*T.7 iocL.UOhe`an*Patp9Lkejp.U6'$Ejp-2%iuHeja*U.7 With all of the preliminary setup out of the way, the application then sets up an event listener for each slider’s R]hqa?d]jca` event. This event will be raised when a slider is manipulated by a user. l-TOhe`an*R]hqa?d]jca`'9jasNkqpa`Lnklanpu?d]jca`ArajpD]j`han£ 8`kq^ha:$l-TOhe`an[R]hqa?d]jca`%7 l-UOhe`an*R]hqa?d]jca`'9jasNkqpa`Lnklanpu?d]jca`ArajpD]j`han£ 8`kq^ha:$l-UOhe`an[R]hqa?d]jca`%7 l.TOhe`an*R]hqa?d]jca`'9jasNkqpa`Lnklanpu?d]jca`ArajpD]j`han£ 8`kq^ha:$l.TOhe`an[R]hqa?d]jca`%7 l.UOhe`an*R]hqa?d]jca`'9jasNkqpa`Lnklanpu?d]jca`ArajpD]j`han£ 8`kq^ha:$l.UOhe`an[R]hqa?d]jca`%7 The event handler code for each of the four sliders is fairly similar. The value of the slider is used to update the corresponding point of the iuheja object. The text that shows the slider’s value to the user is updated, and the `k=jcha$% function is called to update the angle output on the screen. lner]parke`l-TOhe`an[R]hqa?d]jca`$k^fa_poaj`an( Nkqpa`Lnklanpu?d]jca`Arajp=nco8`kq^ha:a% w iuHeja*T-9l-TOhe`an*R]hqa7 iocL-TOhe`an*Patp9Lkejp-T6' ?kjranp*PkEjp-2$l-TOhe`an*R]hqa%7 `k=jcha$%7 y The l- y slider event handler is shown in the following listing. Notice that the functionally it is identi- cal except that it references a different point of the iuheja object, and outputs text to a different TextBlock. lner]parke`l-UOhe`an[R]hqa?d]jca`$k^fa_poaj`an( Nkqpa`Lnklanpu?d]jca`Arajp=nco8`kq^ha:a% w iuHeja*U-9l-UOhe`an*R]hqa7 [...]... degrees must be 2 pi radians Figure 6 -3 shows some common angle measurements in both degrees and radians to help get you oriented 217 CHAPTER 6 Figure 6 -3 Some common angle measurements shown in both degrees and radians So other than being a little overwhelming, what does all this mean to the way you code an animation? You need to be thinking in radians, but remember that Silverlight objects are rotated... centered in front of the ship avoids this problem 3 The majority of the code necessary to fire a missile goes into the codebehind, so go ahead and open that file Begin by declaring two variables One will contain the acceleration vector for the missile, and the other will contain a thrust value This code goes before the constructor: 208 COORDINATES IN SILVERLIGHT 4 Inside of the property to handler for... the code described in this example can be found in vectorShipMissileCompleted Summary We started out this chapter talking about the coordinate system in Silverlight We’re all familiar with the Cartesian coordinate system, but the coordinates used in Silverlight don’t quite work the same way In order to move an object toward the bottom of an application, you use an increasing y value To move an object... developed to help study astronomy Today, the use of trigonometry is critical in science, technology, and programming Silverlight! That doesn’t sound too scary, does it? We’re going to take a nice, long look at trigonometry and trigonometric functions, and what they can do for us in Silverlight However, since trig is about measuring angles, it makes sense to start with a deeper look at the topic of... would be 6.2 831 85[ ] Figure 6-2 Measuring a “straight” angle of 180 degrees Because our arc is a semicircle, it is equivalent to half that value, or simply pi r Since the radius of this particular circle is 1, that means that 180 degrees = pi radians To determine the measure of each radian, we divide 180 degrees by pi, and we get 1 radian = 57.2958 degrees Since 180 degrees equals pi radians, 36 0 degrees... curly brace of the constructor: 12 Inside the function, add the following two lines of code that will change the ship’s position by adding the and components to the and top properties of the ship: 2 03 CHAPTER 5 13 Follow that with some boundary-checking code If the ship moves completely off the canvas in any direction, it is wrapped to the opposite side of the canvas 14 After the boundary checks, restart... order to rotate variable as an argu- 26 Finally, add the code to handle the right arrow key This code calls the the 206 object, and like the method, also passes the method of variable COORDINATES IN SILVERLIGHT Press F5 to compile and run the program Click the application to get focus for input Press the left arrow key, and the ship will rotate counterclockwise 5 degrees Pressing the right arrow key... star field The other is called and contains a 45 45 spaceship and a timer called that will be used to make the spaceship move 2 Start coding in the and a data type called variables are placed before the 3 Inside the file by declaring an instance of the rocket called that will be used to generate random numbers These two constructor: constructor, add code to position the ship at the center of the application:... called, the method is passed the rocket’s rotational value, and the rocket’s and top properties The method then rotates and positions the missile appropriately before starting the timer 210 COORDINATES IN SILVERLIGHT That should be all it takes Press F5 to compile and run the program Click the application to gain focus, and use the left and right arrow keys to spin the ship, the up arrow key to thrust,... function creates a new object, which is randomly positioned Once the position has been set, a random color is generated for the star and assigned to the property The is then added to the 202 COORDINATES IN SILVERLIGHT 6 Call the function from inside the constructor, passing an integer that determines how many stars are created: 7 Press F5 to compile and run the program The application will display the ship . constructor: lq^he_I]ejL]ca$% w Ejepe]heva?kilkjajp$%7 ?]jr]o*OapPkl$n]eh(.,%7 ?]jr]o*OapPkl$pn]i(.,%7 pn]i*]llSe`pd9pdeo*Se`pd7 1 93 COORDINATES IN SILVERLIGHT H]ukqpNkkp*?deh`naj*=``$pn]i%7 H]ukqpNkkp*?deh`naj*=``$n]eh%7 y 11 screen: lner]parke`o_]haRa_pkn$Lkejpra_pkn=(ejpo_]ha% w LkejpjasRa_pkn9jasLkejp$%7 jasRa_pkn*T9ra_pkn=*T&o_]ha7 jasRa_pkn*U9ra_pkn=*U&o_]ha7 ioc>hk_g*Patp'9XjRa_pkn-O_]ha`^u'o_]ha'6 'jasRa_pkn'7 y 197 COORDINATES IN SILVERLIGHT Take a little time and play around with the values that are set for the vectors to see what type of results the math operations you’re performing will have. Angles in Silverlight As. op]n?]jr]o. bkn$ejpe9,7e8jqiOp]no7e''% w op]njasOp]n9jasop]n$%7 Lkejplkoepekj9jasLkejp$njc*Jatp@kq^ha$%&Se`pd( njc*Jatp@kq^ha$%&Daecdp%7 ?]jr]o*OapHabp$jasOp]n(lkoepekj*T%7 ?]jr]o*OapPkl$jasOp]n(lkoepekj*U%7 ^upaWY_khkno9jas^upaW/Y7 njc*Jatp>upao$_khkno%7 2 03 COORDINATES IN SILVERLIGHT ?khkn_9?khkn*Bnki=nc^$.11(_khknoW,Y(_khknoW-Y(_khknoW.Y%7 jasOp]n*op]nAhheloa*Behh9jasOkhe`?khkn>nqod$_%7 op]n?]jr]o*?deh`naj*=``$jasOp]n%7 y 6.