Mark Monster

In step 2 I explained about the Architecture of MeXperience I had in mind. This article explains the implementation of the pipes and filters pattern to filter the list of experience objects. I will start to tell that my implementation is based on an article from Oren Eini.

The Filter

In MeXperience there are currently only two types of filters: by tag and by role. But I could think about others like a filter by year of experience.

The idea of the filter in the pipes and filters patterns is to have a simple operation, and a lot of combine simple operation in one pipeline make a complex operation.

My filters are also used as objects to represent an item in the TagCloud. This is my base.

public abstract class CloudItem
{
    public CloudItem()
    {
        Weight = 1;
    }

    public int Weight { get; set; }
    public string Name { get; set; }

    public abstract IEnumerable<Experience> Filter(IEnumerable<Experience> experiences);
}

Yes I know it’s abstract and there’s no filter implementation. First the signature, there’s an enumeration of experiences coming as input, and there’s an enumeration as output. Let’s see one of the implementations, the of CloudItemTag.

public class CloudItemTag : CloudItem
{
    public override IEnumerable<Experience> Filter(IEnumerable<Experience> experiences)
    {
        foreach (Experience experience in experiences)
        {
                if (experience.Tags.Where(t => t.Name == Name).Count() > 0)
                    yield return experience;
        }
    }
}

The Filter implementation is a simple loop through the experiences, and if the experience corresponds to the filter it will yield return this experience.

You can probably figure out how the CloudItemRole would look like. These filters are simple, let’s combine the pipeline of filters.

The Pipeline

Code explains more than words.

private IEnumerable<Experience> ApplyFilter(IEnumerable<CloudItem> filter)
{
    if (filter == null)
        return _experiences;
    IEnumerable<Experience> current = _experiences;
    foreach (CloudItem filterItem in filter)
    {
        current = filterItem.Filter(current);
    }
    IEnumerator<Experience> enumerator = current.GetEnumerator();
    while (enumerator.MoveNext()) ;

    return current;
}

Alright a little bit of explanation. First we start with the list of filters to apply, if the list is null we will not filter, else we will start with chaining all filters together in line 8. After everything is chained together we see all the magic happen in line 11. Until line 11 no filter has been executed, but by iterating through the experiences filter chain we will get a filtered list of experiences.

What’s to come?

There will at least be one more article on the MVVM implementation, but this is how it’s going to look like. Or look at this video.

It’s already more than a year ago since Tim Heuer published his article on Event tracking in Silverlight. Since that time we’ve got Silverlight 3 and Silverlight 4 beta. So it’s time for a different implementation that can even be used by non-coders. This article will make use of Silverlight 4 beta, but in the end almost everything works on Silverlight 3 as well.

The idea

Create an Expression Blend Behavior that does all the tracking for me!

The implementation – Some Javascript

Blend Behaviors are extremely easy to use. Designers can use them without having knowledge on code and besides that they don’t dirty the business flow of the code. Also Behaviors can be used very easily in combination with DataTemplates and BindingExpressions.

Let’s start with the very beginning. On the html-page there needs to be some Javascript from Google Analytics to start the Analytics script.

<script type="text/javascript">
  var gaJsHost = (("https:" == document.location.protocol) ? "https://ssl." : "http://www.");
document.write(unescape("%3Cscript src='" + gaJsHost + "google-analytics.com/ga.js' type='text/javascript'%3E%3C/script%3E"));
</script>
<script type="text/javascript">
  try{
    var pageTracker = _gat._getTracker("UA-xxxxxx-x");
    pageTracker._trackPageview();
  } catch(err) {}
</script>

This is the generic Google Analytics script to start the normal tracking. Please make sure that you replace xxxxxx with your own Tracking Code you received from Google. The documentation around Tracking Events is very good. The important part is that we need to call a Javascript function from Silverlight. I have wrapped the Google Analytics Track Events call in my own Javascript function.

function trackEvent(category, action, label) {
  pageTracker._trackEvent(category, action, label);
}

But this will directly call into Google Analytics, which is very difficult to test because the data will arrive but the stats aren’t real-time. That’s why I created a small test version of this function that shows an alert.

function trackEvent(category, action, label) {
  alert(category + ", " + action + ", " + label);
}

Alright we now have done all the Javascript stuff, for now I will be using the test version of trackEvent because we’re in the development stage. Let’s continue with the implementation of the behavior.

The implementation – Behavior

There are a few different types of behavior that can be created: Behavior<T>, TriggerAction<T>, TargettedTriggerAction<T>. I won’t explain every type of behavior, but for the implementation of our Google Analytics Tracking behavior I chose fore TriggerAction<T>. I did this because of the flexibility in events which a TriggerAction can react on, besides that this specific behavior won’t change anything in the Silverlight application itself, it will just call out to a Javascript function. To start with the behavior you will first have to add a reference to System.Windows.Interactivity.dll. You can find this library in: C:\Program Files (x86)\Microsoft SDKs\Expression\Blend 3\Interactivity\Libraries\Silverlight\.

public class TrackEventAction : TriggerAction<UIElement>
{
    protected override void Invoke(object parameter)
    {
        try
        {
            HtmlPage.Window.Invoke("trackEvent", new object[] {Category, Action, Label});
        }
        catch
        {
        }
    }
}

The implementation is simple, just a call out to the Javascript function trackEvent, and three parameters. I explicitly put everything in a try catch swallow statement, because I don’t want a failure in this tracking behavior to cause problems in the application. Further on I made it of type UIelement because in that case all UI elements can Track Events. You can see that the parameters for the call to the Javascript function are properties: Category, Action and Label. I explicitly didn’t put in the code, because the code is straight forward, they are DependencyProperties. Full Code is collapsed below ;-).

public class TrackEventAction : TriggerAction<UIElement>
{
    public static readonly DependencyProperty CategoryProperty =
        DependencyProperty.Register("Category", typeof (string),
                                    typeof (TrackEventAction),
                                    new PropertyMetadata("Silverlight.Event"));

    public static readonly DependencyProperty ActionProperty =
        DependencyProperty.Register("Action", typeof (string),
                                    typeof (TrackEventAction),
                                    new PropertyMetadata("Unknown Action"));

    public static readonly DependencyProperty LabelProperty =
        DependencyProperty.Register("Label", typeof (string),
                                    typeof (TrackEventAction),
                                    new PropertyMetadata("Unknown Action fired"));

    public string Category
    {
        get { return (string) GetValue(CategoryProperty); }
        set { SetValue(CategoryProperty, value); }
    }

    public string Action
    {
        get { return (string) GetValue(ActionProperty); }
        set { SetValue(ActionProperty, value); }
    }

    public string Label
    {
        get { return (string) GetValue(LabelProperty); }
        set { SetValue(LabelProperty, value); }
    }

    protected override void Invoke(object parameter)
    {
        try
        {
            HtmlPage.Window.Invoke("trackEvent", new object[] {Category, Action, Label});
        }
        catch
        {
        }
    }
}

The implementation - Let’s use it

Like any other TriggerAction we can add the Interaction.Triggers element to some UIElement. The below example combines Binding in a DataTemplate.

<DataTemplate>
    <Button>
        <ContentControl Content="{Binding Name}"/>
        <Interactivity:Interaction.Triggers>
            <Interactivity:EventTrigger EventName="Click">
                <GoogleAnalytics:TrackEventAction Category="MeXperience.CloudFilter" Action="{Binding Name, StringFormat='Filter.Remove[\{0\}]'}" Label="{Binding Name, StringFormat='Remove filter for \{0\}'}" />
            </Interactivity:EventTrigger>
        </Interactivity:Interaction.Triggers>
    </Button>
</DataTemplate>

In this example I used the Click-event but it could have been any other event as well, just use the different event name and you’re done. If you’re making use of Silverlight 3, be aware that the StringFormat part of the Binding Expression doesn’t exist, if you remove it everything else will be working fine.

After some days you will get data in Google Analytics which will look something like this.

Besides the purpose of the application itself, I want to make sure I expand my knowledge on Silverlight. This would be especially on the architecture of Silverlight applications.

Architecture - MVVM

I’ve read quite a lot of articles on MVVM, but there weren’t many article series that were as complete as the series on RIA, MEF and MVVM by Shawn Wildermuth (1,2,3,4). I have no intend to write an article or series on MVVM because it’s not really in my fingers yet. But to know more on MVVM please read the fantastic series by Shawn. But then again my intend is to make use of MVVM for MeXperience. The idea is to introduce two ViewModels (please let me know if you’d advice a different setup for ViewModels).

1. The ExperienceFilterViewModel, which supports showing all experience-tags and the ability to form a filter.

2. The ExperienceViewModel, which has control over all experience-parts that are found in the data store and can interact independent from the filter but can have filters applied as well.

Because I chose to use the articles by Shawn as my knowledge base for MVVM, I will make use of the same components: MEF and MVVM Light Toolkit. If you have suggestions for other libraries, I’m interested, but this will be my start.

Architecture – Pipes and Filters

For the purpose of filtering the experience I want to introduce a Pipes and Filters design pattern. I know it’s not absolutely necessary but it makes sense for this purpose.

Architecture – Experience Data Store

It’s very standard to give an application a database for it’s data store. But to be honest there are many situation where a database isn’t the best choice. So in this occasion I think an xml file containing all the experience information will do. For now MeXperience will only be about the presentation of the experience. Maybe some time in the future there will be an application to edit this xml file.

User Interface Components

I’ve searched around the web (being aware of some licenses I won during Silverlight Control Builder Contest) for some User Interface components that could really help implementing the User Interface that I proposed in my prototype in the first part of my series.

The first piece of User Interface that I want to cover is the TagCloud. But when I search on Google, I first find a component on Codeplex which has tight integration with WCF, second result is an article from my own hand (July 2008), third is the very nice 3D-Tagcloud by Peter Gerritsen. But in the end all that looks like the best suitable component is the Silverlight Tag Cloud by Infragistics (I’m lucky to have the license).

Further on the experience table-tile-view thingy. After some investigation I’m sure, it’s called a Tile View. Both Infragistics and Telerik have such a control. But because I already found a Tag Cloud by Infragistics I will use the Infragistics controls. Hope this will be a good choice.

Every now and then I have some ideas. That’s also the main reason why I created a Windows Mobile application to support at least the storage of my ideas to be sure that those ideas don’t get lost. Some ideas will never be more than just an idea. One of my latest ideas was the below idea. I want to implement this idea, in the time I have (very little).

MYdea: MeXperience

I want application that can show my work experience in an interactive way. I was thinking tag-cloud, tiles, details, photo.

Yes a tag-cloud with the different technologies and roles that have been covered in the experience. If you would click on any item in the tag-cloud, it would be part of the filter. The filter would be applied to the experience.

I wanted to show blocks of experience, to offer a different experience than what people are used to in common curricula vitae. And when you click on a block, the details of the block would be shown.

Maybe more features would be appear in the future, but this is it for now.

Prototype

So what I did was, start with Sketch Flow. Sketch Flow is my favorite tool for prototyping and specially is very easy to use. Please look at below screens for the result.

What do you think about this prototype? Do you have ideas for features that should be included?

Alright, lets hope to find some time for discussing architecture and the basic setup, and probably even more to follow.

A lot of people have a year’s end blog post. This post is similar. Google Analytics is my friend for the stats.

The General Stats.

Everything stated as ‘previous’ are the stats for 2008. I really like the Visits and Pageviews stats, almost 4 times more Visits and Pageviews than last year. Also the average time people stay on my site is 40% higher.

About the content.

I wrote 33 articles in the year 2009, not that many compared to the year 2008 in which I wrote 50 articles. I hope this is not a trend for the year 2010. I hope to write more articles in 2010. But more important, what was the top-content in 2009?

1. Silverlight using WCF with Windows Authentication

2. Silverlight 3 and RIA Services – The basics

3. Silverlight 3 and RIA Services – The advanced things

4. Creating a Silverlight TagCloud UserControl

5. Silverlight 3 – WebClient, WebRequest and WCF calls using Credentials?

I think it’s interesting to see that the number 4 is an article from 2008. What will happen 2010, will we have this article about creating a Tag Cloud still in the top 10? Also in the top 5 we see an two-part series on RIA Services. RIA Services seems to be a popular topic.

Stats on users having support for Silverlight.

Sadly I changed the way I’m tracking the Silverlight support during the year, but I can give the stats for the last two months of visitors on my site.

November 2009:

December 2009:

Yes, these stats are nice, aren’t they? They show us on my site more than 80% of the visitors have support for Silverlight 3 or higher. But then again, this is for my site, which is heavily focused on Silverlight.

Alright the year 2010 has already started. I have a very interesting idea for a series on Silverlight, please wait for it.

I’ve been writing on Credentials in context of Silverlight for some time now. I didn’t like the options that were available to secure services and allow integration with Silverlight. For some history search for “credentials” on my blog.

July 2008 – Silverlight 2 – A series of articles on possible (failed) work-arounds for getting Credentials in Silverlight.

March 2009 – Silverlight 3 – WebClient, WebRequest and WCF calls using Credentials?

July 2009 – Silverlight 3 – Did we get support for Credentials?

In Silverlight 3 we already got the property Credentials on both WebClient and WebRequest. But sadly there still was no implementation available. After the launch of Silverlight 3 Tim Heuer already commented that the feature for credentials was being considered for future versions. Very nice, specially because we finally got it in Silverlight 4 (beta).

Support for Credentials has come to the ClientHttp stack, so you must make sure you register the http prefix to be using ClientHttp stack.

WebRequest.RegisterPrefix("http://", System.Net.Browser.WebRequestCreator.ClientHttp);

Besides that we also need to make sure that we set the property UseDefaultCredentials to false. Depending on whether you make use of a WebRequest or use a WebClient it will look like this.

request.UseDefaultCredentials = false;

WebRequest with Credentials

When you want do a simple webrequest to a url that’s secured using credentials this can look like this.

private void DoWebRequestWithCredentials()
{
    WebRequest.RegisterPrefix("http://", System.Net.Browser.WebRequestCreator.ClientHttp);
    var request = WebRequest.Create(new Uri("http://mark.mymonster.nl")) as HttpWebRequest;
    request.Credentials = new NetworkCredential("username", "password");
    request.UseDefaultCredentials = false;
    request.BeginGetResponse(ResponseCallBack, request);
}

private void ResponseCallBack(IAsyncResult ar)
{
    var request = ar.AsyncState as HttpWebRequest;
    var response = request.EndGetResponse(ar) as HttpWebResponse;
    using(var reader = new StreamReader(response.GetResponseStream()))
    {
        string result = reader.ReadToEnd();
    }
}

WebClient with Credentials

The WebClient has the same properties. Works same as providing credentials to a WebRequest, that’s really nice.

private void DoWebClientDownloadWithCredentials()
{
    WebRequest.RegisterPrefix("http://", System.Net.Browser.WebRequestCreator.ClientHttp);
    var client = new WebClient();
    client.Credentials = new NetworkCredential("username", "password");
    client.UseDefaultCredentials = false;
    client.DownloadStringCompleted += new DownloadStringCompletedEventHandler(client_DownloadStringCompleted);
    client.DownloadStringAsync(new Uri("http://mark.mymonster.nl"));
}

private void client_DownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e)
{
    string result = e.Result;
}

WCF?

Sadly during tryout I didn’t find the credentials property to be part of ClientBase<T>. So for WCF we still have to wait some time to get credentials, or will it be part of final Silverlight 4?

What happens when you provide the wrong credentials?

I tried to make a webrequest with the wrong credentials. I expected an exception similar to “Unauthorized”, but instead I received a WebException with the message “The remote server returned an error: NotFound.”. I hope the team changes this to a more meaning full exception, because this makes debugging very hard.

Today is the day the Dutch Silverlight and Expression Insiders User Group is officially launched.

How did it start?

A few months ago during the Dutch Microsoft DevDays I met Expression MVP Rob Houweling and creator of Silverlight Spy Koen Zwikstra. We’ve had some good talks around Silverlight and the at that time soon to be release version 3.

Rob Houweling contacted me some time after the DevDays where he informed me about his idea to start a Silverlight User Group, along with a few others: Koen Zwikstra, Timmy Kokke, Antoni Dol and Eric van den Hoek. We had our first informal meeting on the 7th of July 2009. We’ve formed our motto and divided some roles.

The Team

Our team consists of 6 professionals in designing and/or development, Rob Houweling will be our chairman.

Antoni Dol: Blog, Silverlight.net Profile

Eric van den Hoek (secretary/treasurer)

Rob Houweling (chairman): Blog, Silverlight.net Profile

Timmy Kokke: Blog, Silverlight.net Profile

Mark Monster (vice chairman): Blog, Silverlight.net Profile

Koen Zwikstra: Blog, Silverlight.net Profile

More details (in dutch) can be found on the About Us page.

What are we going to do?

First of all we want to be a User Group for both Designers and Developers who are enthusiastic about Silverlight and the Expression tools, who want to learn and share knowledge.

- We will maintain a website where we host interesting blogs and news related to Silverlight and Expression.

- We will organize small events

- We will speak on events organized by other User Groups like SDN or dotNed.

For now just bookmark the website of the Silverlight and Expression Insiders User Group.

One of the new features Silverlight 3 introduced is called Local Messaging. This feature supports communication between different Silverlight applications that are running on the same client. This is particular useful in areas like Sharepoint where you offer different parts to be positioned at all places on the screen. It’s possible to even communicate between two Slverlight applications running on different domains. For example one app is running on maindomain.com and the second app is running on maindomain.nl or even more different.

The Local Message API is very easy to use. But let’s first setup the Proof of Concept environment. I created a solution with two Silverlight Applications (SUILeft and SUIRight), a hosting project (Web) and a fourth project which is a Silverlight Class Library, we will come to that soon.

I combined both the “Left” and “Right” applications in one html page, like this (please remind to change the paths according to your setup).

<div id="silverlightControlHost">
    <object data="data:application/x-silverlight-2," type="application/x-silverlight-2"
        width="40%" height="100%">
        <param name="source" value="ClientBin/MM.Silverlight.SUILeft.xap" />
        <param name="onError" value="onSilverlightError" />
        <param name="background" value="white" />
        <param name="minRuntimeVersion" value="3.0.40624.0" />
        <param name="autoUpgrade" value="true" />
        <a href="http://go.microsoft.com/fwlink/?LinkID=149156&v=3.0.40624.0" style="text-decoration: none">
            <img src="http://go.microsoft.com/fwlink/?LinkId=108181" alt="Get Microsoft Silverlight"
                style="border-style: none" />
        </a>
    </object>
    <object data="data:application/x-silverlight-2," type="application/x-silverlight-2"
        width="40%" height="100%">
        <param name="source" value="ClientBin/MM.Silverlight.SUIRight.xap" />
        <param name="onError" value="onSilverlightError" />
        <param name="background" value="white" />
        <param name="minRuntimeVersion" value="3.0.40624.0" />
        <param name="autoUpgrade" value="true" />
        <a href="http://go.microsoft.com/fwlink/?LinkID=149156&v=3.0.40624.0" style="text-decoration: none">
            <img src="http://go.microsoft.com/fwlink/?LinkId=108181" alt="Get Microsoft Silverlight"
                style="border-style: none" />
        </a>
    </object>
</div>
<iframe id="_sl_historyFrame" style="visibility: hidden; height: 0px; width: 0px;
    border: 0px"></iframe>

Coding the Receiver (Sender to Receiver)

I coded the receiver in the “Left” application. In the constructor I created a new LocalMessageReceiver with the name PoC.Messaging. This name is important because also the sending applications need to know this.

private readonly LocalMessageReceiver _receiver;

public MainPage()
{
    InitializeComponent();
    _receiver = new LocalMessageReceiver("PoC.Messaging");
    _receiver.MessageReceived += _receiver_MessageReceived;
    _receiver.Listen();
}

private void _receiver_MessageReceived(object sender, MessageReceivedEventArgs e)
{
    ResultBlock.Text = e.Message;
}

Sending messages (Sender to Receiver)

The sender looks similar, make sure the same name is used. I added a click handler to a button to send the static “Hello World!” messag.

private readonly LocalMessageSender _sender;

public MainPage()
{
    InitializeComponent();
    _sender = new LocalMessageSender("PoC.Messaging");
}

private void Button_Click(object sender, RoutedEventArgs e)
{
    _sender.SendAsync("Hello World!");
}

Respond to messages (Receiver to Sender)

After receiving a message there’s an option to reply by simply setting the response. The enhanced MessageReceived handler now looks like this:

private void _receiver_MessageReceived(object sender, MessageReceivedEventArgs e)
{
    ResultBlock.Text = e.Message;
    e.Response = "Hello to you as well!";
}

Accepting response messages (Receiver to Sender)

To enable the sender to accept response messages, a new handler needs to be added to the SendCompleted event. The complete sender code now looks like this:

private readonly LocalMessageSender _sender;

public MainPage()
{
    InitializeComponent();
    _sender = new LocalMessageSender("PoC.Messaging");
    _sender.SendCompleted += _sender_SendCompleted;
}

private void _sender_SendCompleted(object sender, SendCompletedEventArgs e)
{
    string response = e.Response;
}

private void Button_Click(object sender, RoutedEventArgs e)
{
    _sender.SendAsync("Hello World!");
}

This is all you need to do, nothing more, nothing less. But limited to only send strings from sender to receiver, and sending messages back to the sender. But we want more, we don’t want to be limited to sending strings, do we?

Enhancing Local Messaging

The idea is simple: Serialize complete objects on the sender, deserialize the strings back to objects on the receiver.

It’s not difficult at all, we have the same API available in Silverlight as we are used in the full CLR. Just add a reference to System.Xml.Serialization in both the “Left” and “Right” project. Also this is where the “Messages” project comes in to play, add a reference to this project from “Left” and “Right” as well.

This was just for preparation. The Messages project will contain the structures that are going to be serialized and deserialized, kind of a message contract. So let’s add our first structure: Customer.

public class Customer
{
    public string Name { get; set; }
    public string Country { get; set; }
}

This is still a very simple class, but this idea works with larger objects as well. But it’s important to explain there’s a limit to the size of the message that is send, it’s 40 kilobyte. It’s time for the little bit of sending magic.

private void Button_Click(object sender, RoutedEventArgs e)
{
    var customer = new Customer {Name = "Best Customer", Country = "Silverlight Island"};
    var serializer = new XmlSerializer(typeof(Customer));
    using (var sw = new StringWriter())
    {
        serializer.Serialize(sw, customer);
        _sender.SendAsync(sw.GetStringBuilder().ToString());
    }
}

And on the receiver side we need to deserialize the message, like this:

private void _receiver_MessageReceived(object sender, MessageReceivedEventArgs e)
{
    var serializer = new XmlSerializer(typeof (Customer));
    if (serializer.CanDeserialize(XmlReader.Create(new StringReader(e.Message))))
    {
        var deserializedCustomer =
            serializer.Deserialize(XmlReader.Create(new StringReader(e.Message))) as Customer;

        ResultBlock.Text = string.Format("Name:{0}, Country:{1}", deserializedCustomer.Name,
                                         deserializedCustomer.Country);
    }
}

That’s all. I’m interested to see more Silverlight applications making use of Local Messaging.

 Jeffrey Palermo, Ben Scheirman and Jimmy Bogard, real community leaders, have written the ASP.NET MVC in Action book. I did have the honour to review the MS of the book in very early stages. They were already writing this book when ASP.NET MVC was still in a preview stadium.

Although I followed the development of ASP.NET MVC, I didn’t have time to try every feature. After the final release of ASP.NET MVC this book helped me better understand ASP.NET MVC. Reading this book will give you control over ASP.NET MVC. If you want to learn ASP.NET MVC this book will really help you. It covers best practices and recipes. Besides all the basics, you will really get at speed level if you combine reading sessions with development sessions.

Some time ago I started feeling the need for a tool to quickly capture any ideas. In the past I’ve used pen and paper, but because I’ve always have my phone at my fingertips, why not use a piece of software?

Yes that’s about how it started. Just the idea. I started to work on paper to get a slick UI-experience. It should be simple, finger friendly and also it should be easy to share. Share with others, but more important share with yourself.

Let’s start with a few screen shots.

MYdea supports capturing of ideas by writing, drawing and photography. As long as your device runs on Windows Mobile 5 or later and has touch input support. It runs very fine on my own HTC Touch Diamond. I’m already using the application for a few months, the first version I used was version 0.1 which I released to myself on June 14th 2009. The first version that made it to the web was version 1.0, I released it on August 16th. Today I released the first bug-fix release which also consumes much less memory and storage, version 1.1.

As explained you can capture an idea by writing, drawing and photography. In the next step you will be asked for a name and then you’re done. And MYdea helps you manage your ideas as well, you can view it, and if you want you can e-mail it through the standard e-mail application that’s available on your Windows Mobile phone.

If you are interested you can try MYdea for free, if you have more than two ideas you want to capture you will have to buy it. Please contact me if you have any questions regarding MYdea. Please let me know what you think about this application.

The commercial version of MYdea is available for $ 14,99 or € 12,99.