Download Rich Media ePub

1.  “Audio Book ” - this is a simple little audio player mockup and only the “play” button works (click it again to stop playback)

2. “Discuss on Forums” - this is simply a link out to a book discussion forum website

3. “Editorial Reviews”  - also just a website link right now

4. “Meet the Writer” - a video interview

5. “More by this Author” - a cover flow like list of EPUB files on Feedbooks.com

You’ll need Adobe Digital Editions to view the demo.

You can download the Rich Media Epub file here.

Enjoy! - Micah

The EPUB file format is definitely taking off like a rocket for ebooks and text-based “packaged” web content (such as RSS feeds).  But what about rich media?  Well, the format certainly can contain content that includes video, sound, animation, games, apps, etc.   And, Adobe Digital Editions will render that kind of content (if it is Flash-based) and Adobe Content Server 4 can apply copy protection to it (if you need that because you are a library, etc).   Ah, but what about mobile you might ask…

Yes, today the best thing one can say about EPUB is that you certainly can (and should) provide alternative content for the mobile devices that don’t support rich media.  For example, if you have a travel book with a video tour of a hotel on a given page, you could have a photo appear in that page instead when read on a low functionality device.  This is allowed for in the EPUB spec.  Surely though, it would be better if all mobile devices supported rich media in EPUBs, or at least more of them…

It seems that very soon, this situation will change.  Adobe has announced that it is working hard on Flash Player 10 for iPhone, has demoed it running on an Android phone, and Flash Light is already on millions of handsets.  And does anyone doubt that a touchscreen tablet netbook with a low power consumption screen could become the ebook device of choice?  ePaper devices, like the Sony Reader, lack the hardware necessary to render some rich media today, but I imagine that will also change quickly. I do note that the Sony Reader Digital Book already has a headphone jack.

That said, I think that it is important to step back and consider that for many years we may have digital displays in the market that don’t support rich media - or at least not fully.  Like disposable ePaper publications perhaps?  If not explicitly disposable, there certainly will be viable niches for low-cost, low-functionality devices/surfaces IMHO.  Does this mean we can’t ever use rich media in “packaged mixed media content”?  Of course not.  The challenges there are on the marketing side (and the distribution model is a huge component of the new digital marketplace).  We already have differing user experiences, for example with B&W ePaper screens versus color LCD (and some mobile apps don’t even support images).  Should no ebooks ever have color photos?  Keep in mind that not all MP3 players, or even ipods show video, or run apps. That does not seem to be slowing Apple down too much.

But what would you do with rich media in an EPUB?  Well, beyond the independent game developers, filmmakers, musicians, etc. who might actually make a buck leveraging a mainstream packaged content format, there are tons of ways to complement existing book content.  Here are just a few examples that appeal to me personally:

Travel Guides with: video tours of destinations, self guided audio walking tours, destination slideshows, interactive maps, hotel finder app, etc. (even cooler when the ebook has access to the device’s GPS data).

Cookbooks with how-to videos with some recipes - or a similar concept in any DIY book.

The Audio Book version included in the EPUB with a nifty player that remembers your spot.

Children’s book with animated flourishes and soundtrack music.

Marketing Content: meet the author video, movie previews, cross marketing (e.g. cover flow like browser of other similar books with one click purchasing) or a TV-like book review “show.”

Social Applications: shared annotations, send or post a quotation, interact with the author - either canned like in DVDs or live events, reader feedback to publisher, etc.

There are also some really interesting things you could do that go completely beyond linear content.  Consider a book that “customizes” itself to the reader - such as a travel book that you “tell” that you are a family of 4 with gramma along in a wheelchair, and it automatically “features” destinations, hotels, and activities that you might be interested in as you go through it.  Sound like science fiction?  It is not far off.  Check out the demo we did for Adobe’s new Text layout Framework for Flash Player 10.  Once you have full programmatic control over text in real time, it opens some amazing doors.  In my opinion, there’s not much of a “richer” media than dynamic text.

UPDATE: We put together a crude demo of a rich-media EPUB file and posted it here

-Micah

Micah Bowers is the UX director at Seattle-based interactive agency Bluefire Productions.

That has a code number underneath.  I go to the website, enter that code and download my ebook.  I keep the card, and if I should ever need to download the book again (e.g. in a different format for a new device), I can just use that same code.  My kids already buy something very similar  - check out the very awesome bellasara.com which had coded cards in retail stores across US and Europe.

There are trends a-happen’ here folks.  Look at Webkinz, or for that matter, check out  http://www.smithandtinker.com

Maybe there is a vending machine that prints these in the store so I can choose from a catalog.  Maybe there’s a chip in the card…

Maybe www.modsystems.com

The point is, ebook style packaging of content is the savior of publishing companies, because people are OK buying “objects” - even if they are virtual - but not so cool with buying subscriptions (well, except for those “Rhapsody meets Netflix” ebook subscripton services that will rock).  So let’s run with that objectification thing! (books, I’m talking books, put away the club!)

-Micah

Micah Bowers is the UX director at Seattle-based interactive agency Bluefire Productions.

Introduction

In Part 1 of this tutorial we stepped through the process of fetching and parsing an RSS feed from Feedbooks.com the results of which were bound to a DataGrid UI Control.

In this post we will detail how we can use the new WrapPanel and ViewBox controls, which are a part of the  Silverlight Toolkit December 2008 release to create grid of thumbnails from a Feedbooks RSS source.

Download Source

Feedbooks RSS Browser Application

See it in Action

The Silverlight Toolkit

From the Silverlight Toolkit codeplex site:

The Silverlight Toolkit is a collection of Silverlight controls, components and utilities made available outside the normal Silverlight release cycle. It adds new functionality quickly for designers and developers, and provides the community an efficient way to help shape product development by contributing ideas and bug reports. It includes full source code, unit tests, samples and documentation for 12 new controls covering charting, styling, layout, and user input.

Which means that we can expect new Silverlight goodies from Microsoft periodically.  In the December 2008 release of the Toolkit Microsoft added new UI Controls including WrapPanel and ViewBox which we can use to move our Feedbooks Browser UI from a boring, single column ListBox control to a glorious multi-column grid of thumbnails.

You can also check out the Silverlight Toolkit Online Example site for an interactive example of the other controls included in this release of the Toolkit.

Adding a Toolkit Assembly and Namespace to our Project

Assuming that we are starting from the source code from first part of this tutorial, we will need to add the Microsoft.Windows.Controls Assembly that came in the Dec 08 Toolkit to our project as a reference and then create a namespace for the XAML that will reference it.

If you have not already done so, download the Silverlight Toolkit December 2008 release.

After unzipping the toolkit download, you should save the dll files therein (the Toolkit Assemblies) to a known location on your hard drive.  I suggest somewhere like C:\Program Files\Microsoft SDKs\SilverLight\v2.0\Dec_08_Toolkit\ but it is up to you.

You can then add this Assembly to your project by choosing Add Reference… from the right click menu of the References folder and locating the Microsoft.Windows.Controls Assembly from the Browse tab.

Defining a namespace for this assembly looks like this:

…
xmlns:data=”clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Data”
xmlns:controls=”clr-namespace:Microsoft.Windows.Controls;assembly=Microsoft.Windows.Controls”>

Once this Assembly and namespace have been added to our project we can define XAML for the new toolkit controls.

Adding a Bitmap Member to our Value Object Class

Before we add the WrapPanel and ViewBox to Page.xaml, we will add one more public member to our FeedbooksBook Value Object Class.  Below the getter/setter for ThumbUrl, add a getter/setter for Thumbnail:

….
public string ThumbUrl { get; set; }
public BitmapImage Thumbnail { get; set; }

We will set this value of the BitmapImage in the setter for BookXml based on the value of ThumbUrl:

…
ThumbUrl = ThumbXml.Attribute(”src”).Value;
Thumbnail = new BitmapImage(new Uri(ThumbXml.Attribute(”src”).Value));

Now this bitmap can be bound to an Image control in our UI to create a thumbnail of the book cover.

Adding a ListBox in XAML

To start with, we will change our Page.xaml to use a ListBox UI Control instead of the DataGrid we looked at in the first tutorial.

To do this open Page.xaml and change this:

<!– Data Grid–>
<data:DataGrid Grid.Row=”1″ x:Name=”dgFeedbooks” AutoGenerateColumns=”True”/>

To this:

<!– Thumbnail Grid–>
<ScrollViewer Grid.Row=”1″ Margin=”7,0,7,0″ Background=”#FFDAE8F5″>

<ListBox  x:Name=”Thumbnails” Margin=”10″>
<ListBox.ItemTemplate>

<DataTemplate>

<Border BorderBrush=”#FFC9D6DF” BorderThickness=”1″ CornerRadius=”0″ Margin=”0,0,0,0″ Padding=”0″>

<StackPanel Orientation=”Vertical” Width=”145″ Background=”#ffe1edf9″>

<!– Book Thumbnail –>
<controls:Viewbox Height=”110″ Width=”70″ VerticalAlignment=”Bottom”>
<Image Source=”{Binding Thumbnail}” Margin=”5″ />
</controls:Viewbox>

<!– Book Title –>
<TextBox Text=”{Binding Title}” Height=”35″ Width=”150″ Margin=”0,5,0,10″  TextAlignment=”Center”  IsReadOnly=”True” TextWrapping=”Wrap” BorderThickness=”0″ Background=”#d3e3f4″/>

<!– Download Button –>
<Button Content=”Download” Width=”65″/>

</StackPanel>

</Border>

</DataTemplate>

</ListBox.ItemTemplate>
</ListBox>

</ScrollViewer>

Which substitutes a ListBox control for the DataGrid control.

Notice that our ListBox is using a DataTemplate as the ItemTemplate of the ListBox.  This allows us to control the way in which the data in the FeedbooksBook objects are displayed in the control.

Within the DataTemplate, we lay out our UI control using a vertical StackPanel and include an Image control displayed inside the new ViewBox control.  The Image source is bound to Thumbnail property of the FeedbooksBook object with the {Binding Thumbnail} directive. Likewise the {Binding Title} is used to bind the Title Property to our TextBlock control.

Notice also that we also changed the x:Name attribute of the control from dgFeedbooks to lbThumbnails which means we have to change the line in Page.xaml.cs that sets the ItemsSource property of the UI control.

//set the datagrid listbox to use the books list
lbThumbnails.ItemsSource = BooksList;

If we compile and test at this point we should get something that looks like this:

Creating a Multi-Column Thumbnail Grid with WrapPanel

To move from the one column layout of the ListBox, we will use the new WrapPanel control that comes in the December 08 Silverlight Toolkit.

Defining a horizontally oriented WrapPanel as the layout template for the data items (FeedbooksBooks) in our control should cause the list box to display as many thumbnails as it can across the control width, wrapping the extra one to the next line.  This works automatically when resizing the control with the browser window -without having to send resize events ourselves. [Thank You Silverlight Toolkit Team!]

From a XAML point of view this is quite simple.  Before the ListBox.ItemTemplate block we will add and ItemsPanelTemplate and then reset the ControlTemplate so that our control’s render tree is refreshed and the UI redrawn.

<ListBox  x:Name=”lbThumbnails” Margin=”10″>

<ListBox.ItemsPanel>

<ItemsPanelTemplate>
<controls:WrapPanel Orientation=”Horizontal” />
</ItemsPanelTemplate>

</ListBox.ItemsPanel>

<ListBox.Template>

<ControlTemplate>
<ItemsPresenter />
</ControlTemplate>

</ListBox.Template>

<ListBox.ItemTemplate>

…

The ItemsPanel of ListBox Control affects the layout and appearance of the elements within the control that contain data items.

The ControlTemplate affects the visual structure and behavioral aspects of the control itself.  I think that by resetting the ControlTemplate’s ItemPresenter we cause the control to be redrawn, using a WrapPanel to layout our thumbs, since it does not work without doing this.  [But If this is erroneous a comment setting me straight would be great ]

If we compile and test, we should see our grid of thumbnails.

Categories Menu

The final step for this little demo app is to add the Categories menu that switches the Feedbooks feed.  This involves adding a ComboBox that recalls our WebClient with a different URI.  If you’re interested you can look at this how this is done in the Demo Source Code.

Next Steps

I think a logical next step for this application would be to move from using the Feedbooks RSS feeds to their ATOM feeds or else using their REST-based API for more interesting book queries.

Other possibilites are being worked on as well; stay tuned: we are having a lot of fun playing with Silverlight, .NET, Feedbooks and the UI experiences that accompany them!

-Patrick

Patrick Keating is the Technical director at Seattle-based interactive agency Bluefire Productions.

The new Text Layout Framework for Flash Player 10 is very powerful and feature rich, but there’s a bit of a learning curve because of that (as we discovered while building the World Class Text Tour for the TLF site on Labs).  Here’s a list of some resources for learning more about it.  Or, if you’d rather hire someone to do it for you, just give us a ring at (206) 781-1411.  We plan to post a few tutorials ourselves in the near future.

Resources:

Text Layout Framework on Adobe Labs (Note that each section of the “World Class Text Tour” demo on that page has downloadable FLA files with source code - download button is in upper right.)

Text Layout Framework Team Blog

MAX 2008 TLF session videos

Adobe Evangelist Mihai Corlan’s blog post:  ”How to use Text Layout Framework in Flex 3.2 or AIR 1.5″

Flex 3.2 Language Reference for Flash Text Engine

Richard Dermer’s Pagingation example for Flex builder

If you come across any additional resources, please submit a comment with a URL.

Introduction

This is the first post of a multipart blog tutorial explaining how to create a simple Silverlight 2.0 Web Application that displays a grid of thumbnails from a Feedbooks RSS source.  Under each thumbnail is a button that allows users to download an ePub version of the book to their desktop.

Download Source See also: Tutorial Part 2

Feedbooks RSS Browser

See it in Action

In this first part we are going to step through the process of fetching and parsing an RSS feed with Silverlight and then bind the RSS data to a Silverlight DataGrid control.

In this Article we build the following application:

This Tutorial: Feedbooks RSS DataGrid

See it in ActionDownload Source

Subsequent tutorials in this series will expand upon the concepts below on our way to the final Feedbooks Browser application.

A Little Background

Feedbooks.com is an interesting web resource that allows readers to access free electronic versions of books in the public domain. It is a great site for anyone that enjoys reading.

An epub file refers to an electronic book created according to the IDPF ePub Standard.  Epub files are viewable with such applications as the free Adobe Digital Editions.

Microsoft Silverlight is a cross-platform web application framework similar in many ways to Adobe’s Flash Platform.  Silverlight enables web pages to contain animations, multimedia and Rich Internet Applications.

This article is targeted at developers that are new to the Silverlight framework and that have Visual Studio 2008 SP1 with the Silverlight Toolkit.   This article makes use of C# for its programming examples.

Setup

The first step is to create a new C# Silverlight Application Project for our Feedbooks Browser in Visual Studio.  Creating a new Silverlight Application should create 2 projects in our solution:

• A C# projects with App.xaml, Page.xaml and their respective code-behinds
• And a Web project with our .html files, ClientBin, etc.

The Web project is an important aspect of this example as it allows us to access remote RSS feeds without tripping Silverlight Security Errors when we test and debug.

Now that we have our blank project framework we can look at the steps necessary to fetch the Feedbooks RSS feed.

Fetching the RSS Feed

Start by opening the C# code behind file for the Page.xaml file, called Page.xaml.cs

Page.xaml.cs is a class that extends UserControl so that it can control the UI Elements defined in the default Page object (defined by the  Page.xaml file).  This is similar to creating code behind files for MXML Adobe Flex projects.   Our first edit will be to add a constant string that holds the URI of the Feedbooks RSS Feed.  Our second edit will be to call a method, GetFeedbooksFeed, that will fetch the RSS feed for us from the constructor of the Page object.

private const string rssFeedbooksUri = “http://feedbooks.com/discover/list.rss?order=top&range=week”;

public Page()
{

InitializeComponent();
GetFeedbooksFeed();

}

GetFeedbooksFeed() will use a WebClient to fetch the RSS.  Since this is an asynchronous action we will need to add an event handler to the mix that will be called when the data arrives.  In this case we will use a DownloadStringCompletedEventHandler.

private void GetFeedbooksFeed()

{

//create a WebClient to read feedbooks RSS feed
WebClient rssFeedbookService = new WebClient();

rssFeedbookService.DownloadStringCompleted += new DownloadStringCompletedEventHandler(RssFeedbook_Completed);

rssFeedbookService.DownloadStringAsync(new Uri(rssFeedbooksUri, UriKind.RelativeOrAbsolute));

}

In our DownloadStringCompletedEventHandler event handler we will test the returned event arguments for errors to insure that our action completed successfully.   If there are errors, we want write them to the Output Window using Debug.Writeline().  But before we can call this method we must add a using directive to the top of our class that points to the package in which Debug.Writeline() lives.

…
using System.Windows.Shapes;
using System.Diagnostics;

We can then add our event handler below the GetFeedbooksFeed method

private void RssFeedbook_Completed(object sender, DownloadStringCompletedEventArgs e)

{

if (e.Error == null)\
{

//turn rss feed into UI elements
DisplayFeedBooks(e.Result);

}

else

{

//write any errors to output window
Debug.WriteLine(”ERROR ” + e.Error);

}

}

Now that we have our RSS XML data and have tested for errors, it is time to turn the data into a user interface.

Adding the LINQ Assembly Reference

In order to parse our RSS feed, we will make use of an interesting .NET/Silverlight 2.0 feature called LINQ.  LINQ stands for Language Integrated Query which extends the C# and VisualBasic languages to allow for SQL-type queries to be made on objects in a data set.  When used with XML, LINQ allows us to very easily parse objects from the XML DOM.

The classes that make up LINQ reside in the System.Xml.Linq name space.  But in order to add this namespace to our project we will have to add the Assembly that defines them as a Resource to our project.

This is accomplished by right clicking on the References folder  in the Solution Explorer for our project and choosing Add Reference…

You should then be able to find and add the System.Xml.Linq Assembly from the .NET tab of the Add Reference Dialog.  Once this Assembly is added we can add a using directive to the top of our class for LINQ.

using System.Xml.Linq;

Now that we are able to use the objects in the Linq namespace we are ready to parse our RSS.

Parsing the RSS Feed with LINQ

Before we parse our RSS feed we need to create a class to hold the book objects that are represented in the RSS’ XML data.

public class FeedbooksBook

{

private XElement _BookXml;

//public getter/setter values
public string Title { get; set; }
public string Description { get; set; }
public string Link { get; set; }
public string Guid { get; set; }
public string ThumbUrl { get; set; }

//all public members are set by BookXml setter
public XElement BookXml
{

set

{

//first url decode the book xml
string BookStr = HttpUtility.HtmlDecode(value.ToString());
BookStr = HttpUtility.HtmlDecode(BookStr);

//parse xml
_BookXml = XElement.Parse(BookStr);

//set public string values from book xml
Title = _BookXml.Element(”title”).Value;
Description = _BookXml.Element(”description”).ToString();
Link = _BookXml.Element(”link”).Value;
Guid = _BookXml.Element(”guid”).Value;

//derive the thumb url from the description field
XElement ThumbXml = _BookXml.Element(”description”).Element(”img”);
ThumbUrl = ThumbXml.Attribute(”src”).Value;

}

get { return _BookXml; }

}

}

Note in the above class the new C# shorthand syntax for declaring getter/setters and the fact that all of the other public members are set in the setter for the BookXML property; in this way we can encapsulate all the xml parsing logic into one spot.  Also of note is the fact that we HtmlDecode the xml before parsing it so that special chars in the XML are handled correctly. HtmlDecode is in the Systems.Window.Browser namespace and this requires us to add another using directive to the top of our class.

using System.Windows.Browser;

Getting back to our RSS feed we can now  define the method that uses LINQ to parse the objects from the XML.

void DisplayFeedBooks(string xmlContent)

{

//parse the rss feed as an XDocument
XDocument channel = XDocument.Parse(xmlContent);

//use Linq to create FeedbooksBook Value Objs
IEnumerable<FeedbooksBook> BooksList =

from item in channel.Descendants(”item”)
where item.Element(”title”) != null
select new FeedbooksBook
{

BookXml = item,

};

//set the datagrid to use the books list
dgFeedbooks.ItemsSource = BooksList;

}

This method makes use of a query that creates FeedbooksBooks objects and places them in an enumerated structure called BookList.  BookList can then be bound to a datagrid that is defined in XAML in the Page.xaml file.

Creating a DataGrid UI Control on XAML

The final step in this tutorial is to add the DataGrid UI Control to the Page.xaml file.  The DataGrid control resides in the Assembly System.Windows.Controls.Data.  You will need to add this Assembly as a reference like we did for LINQ earlier.

Once the Assembly Refernce is added to our project we can define the namespace, data, for it in the UserControl tag.

<UserControl x:Class=”FeedbooksBrowser.Page”
xmlns=http://schemas.microsoft.com/winfx/2006/xaml/presentation
xmlns:x=http://schemas.microsoft.com/winfx/2006/xaml
xmlns:data=”clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Data“>

We can then add our DataGrid control to the page XAML:

<Grid x:Name=”LayoutRoot” Background=”White”>

<Grid.RowDefinitions>
<RowDefinition Height=”28″/>
<RowDefinition Height=”*”/>
<RowDefinition Height=”40″/>
</Grid.RowDefinitions>

<!– Top Bar –>
<StackPanel Grid.Row=”0″ Orientation=”Horizontal”  VerticalAlignment=”Center” Height=”28″ Background=”#FF639acf”>

<TextBlock x:Name=”txtHeader” Text=”Feedbooks Browser” FontSize=”12″ Foreground=”#FFffffff” Margin=”10,4,0,0″/>

</StackPanel>

<!– Data Grid–>
<data:DataGrid Grid.Row=”1″ x:Name=”dgFeedbooks” AutoGenerateColumns=”True”/>

<!– Bottom Bar –>
<StackPanel Grid.Row=”2″ Orientation=”Horizontal” VerticalAlignment=”Center” Height=”40″ Background=”#FF639acf”/>

</Grid>

</UserControl>

Since the DataGrid uses AutoGenerateColumns, all the public members of the FeedbooksBook class, which reside in the Enumerated list we bound to the DataGrid’s ItemsSource property, will be added as columns of the DataGrid via their ToString() method.

In our next post we will explore moving our User Interface from a simple Datagrid to a more aesthetically pleasing grid of thumbnails.

-Patrick

Patrick Keating is the Technical director at Seattle-based interactive agency Bluefire Productions.

2. It is a great format for mobile reading and I think that many new mobile devices will support the format by the end of 2009 - Sony Reader Digital Book and iPhone (using Stanza) already do.

3. It is a supported format in Adobe Digital Editions, the best desktop eBook software (OK, we designed it for Adobe so I’m a bit partial)

4. Adobe offers a great new DRM product that is well suited to the needs of Libraries and their patrons.  Adobe Content Server 4 was released by Adobe last fall and it is a quantum leap over ACS3.   A screenshot of the ACS4 admin console can be found in our portfolio here: http://www.bluefire.tv/onlinePortfolio.html

This, among other developments, just reinforces my thinking that 2009 is going to be the dawn of the world’s libraries in your pocket.  We here at Bluefire are commited to furthering that vision in every way we can.

• Adobe Digital Editions 1.5 -  UX design and Flex dev on this update that added content portability and support for the Sony Reader Digital Book.
• Adobe Content Server 4 Admin Console -  UX design and Flex dev of the admin console for Adobe’s new digital publishing and distribution management tool.
• Dexter Widget 1.5 - UX design and Flex dev to update a book preview Flex widget that added customizable styles,  fluid layout to work in a variety of sizes and screens,  and mySpace compatibility.
• World Class Text Tour - Creative and Flex dev on this interactive marketing piece that showcases the world languages and text layout features of Flash Player 10 and the Text Layout Framework.
• Mogreet Widget - Flash dev on this widget for sending fun video messages to mobile devices.
• Sumisho Website - Design and HTML on major update to a site we had done in a previous year.
• Mobile Application - UI designs for an un-announced mobile application: iphone and windows mobile versions.

Another highlight of 2008 was a trip we took to Manhattan in October.  We were there meeting with a bunch of big publishing houses, and pitching them on the promise of rich media eBooks ( EPUB and PDF both support Flash content in Adobe Digital Editions).  After several days of meetings our wives flew in for a 4 day weekend, and we did the tourist thing. Wow, NY really is a great city.  It helped to have our colleague Nick Bogaty from Adobe’s NY office show us around the town.  Thanks again Nick!  Can’t wait for next time.

Goals for 2009

Well, we are still very passionate about the digital publishing space, and we think it is going to see big growth despite the economy, so we’ll be there for sure.  One thing that might surprise some of our colleagues is that we also plan to aggressively go after Silverlight work.  Yup, you heard it.  We still love Flash and all, but with the October release of Silverlight, it is for real now.  We can’t continue to claim to be experts in RIA development if we aren’t intimately familiar with Silverlight, and while we’ve followed Silverlight development closely, you can’t really be an expert if you don’t do real-world projects.  So don’t hold it against us.  It will just make us better.

-Micah

Micah Bowers is the UX director at Seattle-based interactive agency Bluefire Productions.

This is particularly gratifying for me in that Sony and Adobe have long been two of my favorite clients, and so how sweet to be working on a single project that involves both of them.

Anyway, the EPUB demo is big news given the incredible rise of the EPUB format. Along those lines, it is nice to see that the The Association of American Publishers is helping that along with an open letter to the IDPF—supporting ePub.

Other niceties of the 1.5 update are:
- Localized versions in German and French
- Support for Mac OSX 10.5 (Leopard)
- Fixes a bug in which double-byte (e.g. Asian, some European) users could not use Digital Editions
- Improved PDF support, including more complete support for the Adobe transparency model and support for named pages
- Page map support in EPUB so that there is a mapping between the reflowed screens and the paper copy of a book
- Adds support for multiple books per ETD fulfillment
- Improved keyboard controls (hold down arrow keys to continually page, scroll) -Yes!

If you aren’t one of the million folks who have already installed Digital Editions, go check it out today! -and tell us what you think - hey, it is still a 1.x, so be kind

To see how we did this, look at the group xml file here: http://www.bluefire.tv/resources/groups/featuredProjects.xmll

Look at the groupDescription node