In the previous article I've shown how to improve the design-time experience of your custom workflow blocks by creating a TypeDescriptor class and take advandage of the PropertyGrid control used by AgilePoint Envision to display and edit the properties of workflow blocks. I promised to continue on this topic and elaborate on how to add custom editors for your properties. This article is all about that.

Before we start, let me warn you again that I will be assuming somewhat advanced knowledge of the .NET component model (see the System.ComponentModel namespace) as well as development of AgilePoint (and ADAM Workflow) building blocks. This time, I also expect you to have some System.Windows.Forms awareness.

Setting up the project

For this article, I'm going to continue with the project we created last time. First off, we need to add an extra reference to our project:

When there’s a need to publish information from a web application in a manner that can be consumed by client applications easily, Web Services have long been a logical choice. Historically, there’s been a number of options that can be considered. XML-RPC and SOAP, in their different forms with different levels of complexity and vendor support exist already for a long time now, but they usually meant having to spend a decent amount of effort in order to make them useful, both from the viewpoint of the producer as from the consumer. As a result, in later years different concepts such as REST and JSON have become a more popular option in situations where the consumer is the client-side programming in browsers. But each and every service has their own idea of how to present that information, usually geared towards its own client-side code, with no clear standard for different services to interoperate.

Enter OData. As an open standard sponsored by Microsoft and adopted by giants such as FaceBook and Netflix, OData promises to “provide an easy way to break down data silos and increase the shared value of data.”. It builds upon established standards like ATOM and JSON and provides a way consumers on various platforms to query and update information made accessible from different platforms. Have a look at their website, and read the protocol overview.

In this tutorial, I will explain how one can write a simple OData service in .NET 3.5 SP1 that exposes information stored in ADAM.

In this article I will show you how you can improve the workflow designer experience by leveraging the power of the PropertyGrid control used by AgilePoint Envision to display and edit the properties of workflow activities.

Image 1: Screenshot of the AgilePoint Envision property grid.

Before we start, let me warn you that I will be assuming somewhat advanced knowledge of the .NET component model (see the System.ComponentModel namespace) as well as development of AgilePoint (and ADAM Workflow) building blocks.

ADAM supports indexing video since version 4.3

ADAM supports indexing video since version 4.3. We accomplish this by using the Microsoft Expression Encoder 3 library. There is a free edition available for download here and a fix version here.

Out of the box supported formats

Microsoft Expression Encoder 3 free edition allows you to index MPEG and WMV video files into ADAM. If you want support for other movie file types, you can simply install the necessary DirectShow filters and Expression Encoder will pick up on those. For MOV files you could install QuickTime. But as this MSDN Magazine article states, you could also install some free CODEC packs to allow ADAM to index file types like MOV, MPEG-2, MPEG-4, AVI, ... Basically if you can find a CODEC that works with Windows Media Player, you can use it in Expression Encoder 3 and consequently also in ADAM.

Before you start installing

Before you start downloading and installing Expression Encoder 3, you should keep some things in mind.

When buidling your own Classification-tree-control you need to locate the Classifications on specific levels. This blog will show how to get them easily using SearchExpression.

Finding the root Classifications

Root Classifications are Classification that have no parents. Finding them using the SearchExpression class can be done by this shorthand: "Parent = null".

1
2
3
4
5
6
7
8
9
10
11

 
private ClassificationCollection GetRootClassifications()
{
    Application app = new Application();
    app.LogOn(Settings.Default.Registration, Settings.Default.AdamUserName, Settings.Default.AdamUserPassword, true, null);

    ClassificationCollection rootClassifications = new ClassificationCollection(app);
    rootClassifications.Load(new SearchExpression("Parent = null"), "Label");

    return rootClassifications;
}

An alternative method is the usage of the ClassificationHelper class:

In this post I'd like to show you how you can use the Adam MediaEngine framework in your own custom code.

The scenario I'd like to cover is the need for storing alternate renditions of a file that is ingested in Adam as an additional file. Normally, there would be no need for this as these renditions can be generated on the fly by the Adam ordering framework; this would enable you to store one version of the truth and still provide the flexibility for users to decide what type of rendition they want to get
In this case, we will generate the rendition at ingestion and store it as an additional file. A reason to do this might be the fact that we know that an external CMS will require a 200px RGB JPG rendition for every asset in the database. In that case the export process will be much faster if the renditions are generated upfront.

In order to do this, we'll customize the indexing process by creating an Indexer Engine as described in the Developer Guide (Core > Indexers > Developing a new Indexer Process Engine):

A DVD video folder contains several files

Suppose you would like to index dvd-videos and those videos reside on a server, each video having it’s own folder. You would then get a structure like you see below.

Notice how every DVD folder has a VIDEO_TS folder. In that folder you will always find a file called VIDEO_TS.IFO. The VIDEO_TS.IFO file is a configuration file that defines the disc structure.

InDesign documents consist of spreads, i.e. sets of pages that are located next to each other. Books typically have two pages per spread but leaflets or other kinds of documents can have more. The Pages panel within InDesign contains a thumbnail for each page and shows how the pages are organized into spreads:

It is quite easy to generate a similar, customized document representation using DocMaker 3.0. The API closely mimics the InDesign document structure, so you can enumerate the spreads in the document and the pages in each spread. Thumbnails for pages can be obtained with the GetThumbnailPath() method (use GetPreviewPath() when you need larger previews). Use the SpreadOverviewIndex property to give you the spread column index for each page. The following code shows how everything fits together:

In the last couple of years we've obviously also run into a couple of those extremely annoying hard-to-trace, what-the-hell-is-going-on-here production issues. The great thing about these kind of issues is that you've most of the time learn a great deal trying to find the cause of the issue.

So.... why not help the community a little bit? On November the 30th, we'll be giving a VISUG session about how to deal with issues just like that.

Join us there at http://www.visug.be/Eventdetails/tabid/95/EventId/30/Default.aspx. There aren't that many free places anymore, but if you still want to join, let us know. We know people at the VISUG, I'm sure we can work something out to get you registered as well. :-)

The software that we write, here at ADAM Software NV, has to deal with JavaScript on more than a few occasions. We write web apps that need to produce short snippets that interact with our client side components & controls, but we also produce ActionScript (which is actually just plain JavaScript) to integrate with Adobe products.

Coding C# that produces JavaScript was, until now, an error prone task that primarily included concatenating a bunch of hardcoded strings with converted variables. Throw in a call to String.Format here and use a StringBuilder object there, and everything becomes a pretty unreadable mess. You’d have to make sure the names of variables are identical everywhere. You’d have to keep in mind that strings need to be properly quoted. And you’d have to match up the endless parade of brackets, be it square, curly or round.

No more.