rubydoes.net

Both Silverlight and WPF use XAML markup to describe their user interface.  As I’m currently writing my chapter on WPF for my book IronRuby In Action and I want to use some xaml that has been generated before for a different project but with an IronRuby class to load the xaml I’m in trouble. This is because you can declare assembly references in the xml namespace declarations so you can use the types in that assembly from xaml. 

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

It’s been a bit of journey but my IronRuby in Action book finally went into EAP today. EAP means exactly what it means in the software world, still very much subject to change. This could be seen as a public review :)  I welcome any suggestions you may have.

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

I’m sorry I didn’t post the last 2 days, but we’re back with a new post. In my previous posts (1, 2) we didn’t use the files as they are generated by the little DSL script, this was chosen purposely so you would know that you don’t really need those files.

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

In yesterdays post we covered the very basics of using IronRuby with Silverlight. Today we’re going to look at how we can use some of the basic controls that have been released for silverlight. One of the cool things about the controls is that Microsoft released the source code for them. Along with this source code they also released a test framework for testing your own controls. I think that is pretty cool
Shawn Burke explains how to use the testing framework they built for silverlight controls. In his blog post he also points you to the correct location for downloading the bits you need.

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

John Lam has released revision 93 to SVN. This new release now passes 1541/2468 specs (62%). Click here to see the output of all the tests.

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!

I won’t be repeating the very basics of how to get started with silverlight here but will instead refer you to John Lam’s excellent blog post on the subject.  I do have to warn you for this series we won’t be using the silverlight.rb created by the dsl template generator.  I chose to do it this way so that you would better understand what is going on in the silverlight.rb file. I’ll assume from now on that you’re familiar with John’s post and move on.

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

This is my first post on this site and I hope there will be many more to come I’m Ivan Porto Carrero and am currently writing a book on IronRuby for Manning. I decided to use this blog to post about IronRuby so that this site can become a really useful resource for people that want to get into IronRuby.

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.

John Lam has posted revision 85 to SVN. Here are the commit comments

————————————————————————
r86 | jlam | 2008-03-24 19:51:39 -0400 (Mon, 24 Mar 2008) | 4 lines

Finished refactoring the Rakefile.
Fixed two bugs that blocked the specs from passing - one was RUBY_VERSION not de
fined as a MutableString and the other was treating $~ as read-only.

rake spec should report 1325 examples with 0 failures. Will check in a new revis
ion that resets the baseline using new features shortly.
————————————————————————

The specs are passing again! Here is the complete output. A diff shows that dir#tell specs have been removed, but 2 new examples are passing in fixnum and 2 more new examples are passing in string. Great job guys, thanks IR team!

John Lam has posted a few new revisions to SVN. Here are the commit comments for 79-84

————————————————————————
r78 | jlam | 2008-03-18 16:43:49 -0400 (Tue, 18 Mar 2008) | 1 line

removing stuff that was accidentally added in previous revision
————————————————————————
r79 | jlam | 2008-03-20 09:32:10 -0400 (Thu, 20 Mar 2008) | 1 line

Simple commit to get to a clean svn status
————————————————————————
r80 | jlam | 2008-03-20 11:23:29 -0400 (Thu, 20 Mar 2008) | 1 line

Removing rubytesthost (is renamed IronRuby.tests in current sources).
————————————————————————
r81 | jlam | 2008-03-21 00:43:26 -0400 (Fri, 21 Mar 2008) | 1 line

This build is an interim build that compiles and has basic tests passing. There
were a lot of renames etc. that happened here, as well as new features. There’s
also a lot of new Rake infrastructure in this build that works well enough to push
stuff out and compile in different contexts. There will be another build tomorrow
that will fix more issues.
————————————————————————
r82 | jlam | 2008-03-21 00:47:21 -0400 (Fri, 21 Mar 2008) | 1 line

Updated initializer.
————————————————————————
r83 | jlam | 2008-03-21 09:47:52 -0400 (Fri, 21 Mar 2008) | 1 line

Fixed some problems in the Rakefile to try and solve the build in arbitrary path
scenario. Note VS build is broken in this revision.
————————————————————————
r84 | jlam | 2008-03-21 10:23:05 -0400 (Fri, 21 Mar 2008) | 1 line

Fixes external build. rake compile should now work from arbitrary directories.
VS build still broken.
————————————————————————

At least 1 spec is broken in this revision so no update to specs, yet.

For some reason I have been lax in promoting the interesting IronRuby links from around the internet. Here is a new list of links, and expect weekly posts like this in the future.

Martin Maly has a set of posts for building a language on the DLR. Really interesting stuff, and he walks our through the ToyScript language that ships with IronPython.

Ivan Porto Carrero posted an update on his upcoming book, IronRuby in Action. Ivan also posts about a good looking IDE theme for Ruby in Steel, and building IronRuby and Mono in Leopard.

Michaeldotnet had posted a nice IronRuby getting started post months ago. Since then, he moved his blog to here, and posted some great stuff like semi practical IronRuby, and details about the zlib library he is writing in pure ruby.

Paul Ferrill walks through a WPF app written in IronRuby.

MSDN Blogs has a long list of DLR sites and resources within Microsoft.

Steve Eichert posted about getting started with IronRuby. If you get caught by the same compile issue he did when compiling via rake, these threads on the mailing list are talking about it. 1, 2

Lastly an oldie that I had missed, Cory Fox posted about some of the internals of IronRuby and walks through some of how IronRuby compiles and runs under the covers.