Code

PDF of slides

You can find it here: http://manning.com/free/green_carrero.html

This paper tries to give you an introduction on what the ruby language is and how it could work for you. If you want to know more than what’s on those pages there is always the book: http://manning.com/carrero

You can read more about it on my blog: http://flanders.co.nz/2008/08/07/ironnails-introduction/

It’s still very early days for this project but if you like the concept and you have some free time please feel free to contribute. You can contact me through my blog or through github.

The github project can be found here: http://github.com/casualjim/ironnails

The DLR based languages don’t compile into static assemblies and this means that you can’t use those xml namespace definitons to reference your assemblies.  I wrote a fairly trivial control that acts like a hook for DLR based controls in the XAML tree.

You can check it out at codeplex.
http://codeplex.com/dynamicscriptcontrol

The idea behind this control is that you can "hook" your DLR based control into the visual tree by setting some properties.  You can set properties on the DLR based control by setting the Attributes property on the DynamicScriptControl

Let’s look at a quick example:

1. The ruby file defining a custom TextBox. But you can do whatever  you want in that ruby file of course.

All this textbox does is preset it’s text property to "I’m prefilled"

2. The xaml for the window

You first declare a namespace for the assembly that has the DynamicScriptControl. Next I have a StackPanel that contains 2 DynamicScriptControls. The first just contains the 2 mandatory properties. We need to know which class you want to instantiate in the file you provide by setting the ScriptFile property. This script file property is a path to your ruby file in my case prefilled_text_box.rb.
The second DynamicScriptControl is one where I want to initialize the control with my own text property. To declare those properties you have to add them to the Attributes collection of the DynamicScriptControl. At this moment it’s not smart enough to know which datatype you give it so you can specify a format string which was necessary in this case because text is a string.

3. The result

Michael Foord the author of IronPython In Action will provide the python integration in this control.

There was a release of the Dynamic Silverlight SDK earlier this week which contained the necessary source code files to compile a common DLR for both IronRuby and IronPython.  That is what makes it possible to support multiple scripting languages from the start. 

I’ve hosted the source code on google and you can find that at:

http://code.google.com/p/dynamic-script-control

You can find the book at http://manning.com/carrero
There is also a forum there where you can post suggestions and/or problems you may encounter when running the code samples. I look at it as my issue tracker

I’m currently working on a chapter where I build a complete twitter client with IronRuby and WPF (not silverlight as indicated on the current TOC). It is based on Witty but uses IronRuby instead of C# to drive the xaml. Also some storyboards have been replaced by IronRuby instead of by xaml stuff. It’s also not a straight port of Witty because I haven’t really looked at their code apart from the xaml that is.

Happy reading

Today we are going to use the files that get generated by the DSL script. We’re going to add some classes to silverlight.rb to enable a nicer api for generating elements from ruby.  We left off last time with some code to generate 3 elements. That code wasn’t the prettiest code I’ve ever seen, apparently John Lam agrees and he has written a little DSL script for generating those elements. In today’s post we’ll be using that little script to generate the StackPanel etc.

Download the completed code

Just a refresher, here’s the code we ended up with the last time.

Let’s start replacing that code with something a little nicer. Open up the silverlight.rb file in your app folder and add the require directives at the top of your file. Next we’re going to need the Wpf::Builders module created by John Lam it’s included in the download.  We’re going to need to add the following code in the silverlight.rb file:

That module takes care of dispatching the correct property names etc. Now that we have the module we can alter the SilverlightApplication a little bit. Let’s add a method add to that class that will be our entry point into the Wpf::Builders dsl.

Ok we still need to monkey patch a couple other classes before we’re ready to go. The first thing we see is that StackPanel has a setter method for Margin that takes an instance of Thickness. The property margin is defined on FrameworkElement, so that we can use it on every object that inherits of FrameworkElement. We’re also going to be addressing objects by their name. Not all of them have a name setter method so we’re going to ensure that all of them have one by monkey patching DependencyObject

This gives us the ability to set margins as if it were normal integer values.

The next thing we see is that there is an Orientation property that we’re going to set and that seems to take an enumeration of some sort. To accomplish this we’re going to monkey patch StackPanel.

We’re almost there don’t worry :). The next thing we see is that we need to be able to add child elements to that element. A StackPanel, DockPanel and so forth are all children of Panel so let’s patch Panel and enable this for more containers. To do this we need to include the module Wpf::Builders in the Panel class and we need to make sure we have all the necessary methods in there that will allow us to add children to that Panel.

We’ve now got us a little DSL for generating the necessary elements for this demo. All that is left to do now is write the initialize method in app.rb so that we get the same result as the last demo. Below we’ve got the content of the app.rb file

I hope you can see that Silverlight and IronRuby can really work together to help you build some cool things easily. The next post will deal with some animation, hope to see you there

del.icio.us Tags: IronRuby,Silverlight

Technorati Tags: IronRuby,Silverlight

The next thing that is really cool about using silverlight is that it’s so easy to change the appearance of a silverlight control by using skinning. Corrina Barber explains how to go about that and she also has 4 sets of skins for the standard controls available for download.
See online previews of each skin:

• http://www.corrina_b.members.winisp.net/skins/bubbly/Testpage.html
• http://www.corrina_b.members.winisp.net/skins/red/Testpage.html
• http://www.corrina_b.members.winisp.net/skins/flat/Testpage.html
• http://www.corrina_b.members.winisp.net/skins/rough/Testpage.html

Are you still here? Great Let’s look at some simple examples of using the standard controls that come with the Silverlight SDK. We won’t look into skinning those controls yet but for now will just look at how to use some of them. Like yesterday we’re going to look at 2 examples one that uses predominantly xaml and one that uses mostly ruby.

You can view the completed examples online:

• http://flanders.co.nz/silverlight/controls/
• http://flanders.co.nz/silverlight/controls2/

I got my Ruby In Steel to work again so in the code download I’ve included the Visual studio solution and project files.

Download the completed code

The first sample will be mostly using xaml. The first thing we need to do is create a silverlight application. Just like yesterday I’ve removed the silverlight.rb file, but unlike yesterday we are not done preparing our app yet. The controls we’re going to be using for our samples live in Microsoft.Silverlight.Controls.dll and Microsoft.Silverlight.Controls.Extended.dll. These dll’s can be found on my pc in C:\Program Files\Microsoft SDKs\Silverlight\v2.0\Libraries\Client.  Copy those controls to the app folder of your application.  We’re now one step away from completing the preparations. The last thing we need to do is tell our application it requires the assemblies that contain the controls. To do this we need to add them in an AppManifest.xaml file. To generate such an AppManifest.xaml file we can use chiron with the parameters /m and /d:app

The file that got generated contains references to Microsoft.Silverlight.dll, as well as for the DLR (Microsoft.Scripting.dll) and for IronRuby (IronRuby.dll and IronRuby.Library.dll). We need to add the assemblies for the controls in this file.

We’re now ready to start developing an application. The xaml file for the first sample is a little bit too long to show here but feel free to download the code and have a look. Instead we’ll highlight the most important bits. For the xaml to work for the Button control we need to reference Microsoft.Silverlight.Controls and for the watermarked textbox we need Microsoft.Silverlight.Controls.Extended. We need to add reference to those in our app.xaml file by adding a namespace declaration of which the content looks like: clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls

We then added some controls to the app.xaml file as you can see in the download, but in mean time have a look at the live demo.  The ruby file that drives this xaml is very basic and only has 3 lines of code, all the code that is necessary to load the xaml file.

Our next example will allow us to do something more useful like responding to a click event on a button. This demo is more ruby centric and uses a very small xaml file, without references to the assemblies containing the controls.

Instead of adding the references in xaml we’re going to add them to our ruby file by using the ruby require statement.

Yesterday we saw how we could use find_name to retrieve a control and manipulate it. Today I added the method missing implementation from the silverlight.rb file to the ruby file. This will give us the ability to write xaml.control_name instead of xaml.find_name(’control_name’)

The next part is adding some more controls to the canvas like a StackPanel that will contain a Button and a WatermarkedTextbox.   Tomorrow we’ll look at how we can pretty up that ruby code but for now we’re just going to use the standard api. We first create the instances of the controls and configure them. Next we add them to the panel and then we add the panel to the canvas.

The last step for our mini application to actually respond to an action from the user is to handle the click event on the button. Ruby makes this as easy as assigning a block to the click attribute on the button instance.

And that’s all for today. Tomorrow we’ll look at putting ruby to work for us and prettying up that api for adding elements to a silverlight control.

Technorati Tags: silverlight,ironruby

del.icio.us Tags: silverlight,ironruby

The highlights from the commit logs :

• r89 Minor updates to Ruby to support hosting in ASP.NET
• r93 A bunch of String specs have were re-enabled since we no longer crash when parsing them
• A bunch of regex functionality (still using .NET regex) is enabled - =~, sub,gsub etc. are now implemented in this release.
• There was a split in the way the DLR is organized. Microsoft.Scripting.Core.dll is the DLR, and Microsoft.Scripting.dll are where libraries like the Math libraries for the DLR will live from now on.

To view the complete set of commit comments click here

Seo Sanghyeon also updated the HOWTO and patches for working with IronRuby from within Mono.

John Lam has also mentioned that since the release of r93 he has bee working heavily on String, specifically the parts of String required for running Rails. He reports 70% of String required to run Rails is passing!

Thanks again to the IronRuby team, both inside and outside Microsoft for their hard work!

Download the completed code

You can see the end result of these 2 examples in action:
http://flanders.co.nz/silverlight/minimal/index.html
http://flanders.co.nz/silverlight/minimal2/index.html

To run a silverlight website you don’t need a server side configuration. I’m hosting those examples on a linux box without mono installed. It’s just serving up files.

The first thing we need to do is create a skeleton for our application.

I did this by opening up Powershell (or the command prompt) and navigating to c:\projects\silverlight and executing the command dsl minimal_ir_project

Now that that’s done we’re going to delete silverlight.rb from the app folder. We can do that by going into that folder ( cd minimal_ir_project\app ) and executing del silverlight.rb Next we’re going to navigate one level up ( cd .. ) and start the webserver and default browser by executing chiron /b

At this point we’re entirely ready to start developing Let’s fire up an editor. For these examples I used notepad++ because Ruby In Steel has been acting up and it seemed a bit overkill to start up visual studio for the amount of coding we need to do in these 2 examples.

I first opened up the app.xaml file and gave it the following content.

This xaml ensures us that we will have a canvas container object and a TextBlock with name textblock. We’ve also set the font size of the text to 30 and if we don’t change the text through ruby it will read Hello world from XAML. To be able to show this xaml we need to edit the app.rb file and give it the following content:

include System::Windows
include System::Windows::Controls
Application.current.load_root_visual Canvas.new, “app.xaml”

The first 2 lines in that file are just like using statements in C# and provide access to the types living in those namespaces without having to fully qualify them. So instead of having to write System::Windows::Controls::Canvas you can use Canvas. And the next line tells our silverlight application that the visual root control has to be loaded as a Canvas type from the file app.xaml

If you switch now to your browser and click on the index.html file you will see Hello world from XAML in your browser. Very impressive, feel free to say woohoo Let’s take it a little further and change the text of that text block to Hello world from IronRuby because after all it’s all about IronRuby.  To do that change the content from app.rb to:

And the end result looks like this in Internet Explorer (Firefox 3 crashes with silverlight currently)

I think this would be the least amount of code you have to write to get going with silverlight development.

Let’s look at how that code would look when we don’t use xaml.

Let’s create a second project minimal_ir_project2 like before but now we delete both silverlight.rb and app.xml. The only file that is left now is app.rb Again you can start the webserver.

The content of app.rb should look like this:

This ruby code has the same effect as the previous app.xaml. We first create a canvas object, next we create a TextBlock object and configure it’s properties. After that we add the textblock objects to the children collection of the canvas instance. And lastly we set the canvas object to be the root visual of our silverlight application. And all that hard work yields the following result:

This concludes the first article in our series on Silverlight and IronRuby. Today we covered the very basics of silverlight development.

Technorati Tags: ironruby,silverlight

del.icio.us Tags: ironruby,silverlight

When the beta for Silverlight 2.0 was released it got support for IronRuby. I personally think that Silverlight and IronRuby is a winning team.  But when you come from normal web development or windows forms development it does have little bit of a learning curve because of XAML.
But once you get passed that learning curve it’s a pretty sweet technology to master

There are other people that have blogged about silverlight and IronRuby before, it might be a good idea to check them out as well.

• http://dynamicsilverlight.net/
• http://www.iunknown.com/2008/03/dynamic-silverl.html
• http://www.iunknown.com/2008/03/dynamic-silve-1.html
• http://www.iunknown.com/2008/03/dynamic-silve-2.html
• http://silverlight.net/Quickstarts/ProgramDlr.aspx
• http://blog.jimmy.schementi.com/2008/03/dynamic-silverlight.html
• http://www.dotnetguru2.org/tbarrere/index.php?title=step_by_step_debugging_with_silverlight_&more=1&c=1&tb=1&pb=1
• http://flanders.co.nz/2008/04/06/an-ironruby-digg-client/

The guys in the IronPython world have a bunch of samples that were created by Michael Foord. I thought it might be interesting to port those samples to IronRuby.

http://www.voidspace.org.uk/ironpython/silverlight/index.shtml

Over the next couple of days I’ll post those on this site. Tomorrow we’ll start with the basics of using silverlight and IronRuby to write applications.