Presentation Chooser

Example: Simple Lookup (C#)

The simplest example of a Presentation Chooser is one that has a simple lookup capability based solely on the type of domain object. Consider a application that displays information about musical recordings. The recordings are shown in a list, any one can be edited. However the underlying recordings need to edited differently depending on whether they are classical or popular recordings.

Figure 1: A window for picking recordings.

To react to this I have an event handler for clicking the edit button

private void btnEdit_Click(object sender, EventArgs e) {
  edit(Recordings[lstTitles.SelectedIndex]);
}
private void edit(IRecording recording) {
  Chooser.ShowDialog(recording);
}

The crux of this pattern is the edit method which asks a Presentation Chooser to display the dialog for editing the selected recording depending on whether it is a classical or popular recording.

In this case the Presentation Chooser is really just a dictionary lookup. During initialization we load the Presentation Chooser with details of the domain type and corresponding window to use.

class PresentationChooser...

  protected IDictionary presenters = new Hashtable();
  public virtual void RegisterPresenter(Type domainType, Type presentation) {
    presenters[domainType] = presentation;
  }

This initialization just simply stores the domain and presentation types in a dictionary. The lookup process is a little more complex. If I add a subtype of classical recording later on, I want it to be edited by a classical recording unless I've registered a screen for that subtype.

class PresentationChooser...

  public RecordingForm ShowDialog (Object model) {
    Object[] args = {model};
    RecordingForm dialog = (RecordingForm) Activator.CreateInstance(this[model], args);
    dialog.ShowDialog();
    return dialog;
  }
  public virtual Type this [Object obj] {
    get {
      Type result = lookupPresenter(obj.GetType());
      if (result == null) 
        MessageBox.Show("Unable to show form", "Error", MessageBoxButtons.OK,  MessageBoxIcon.Error);
      return result;
    }
  }
  private Type lookupPresenter(Type arg) 
  {
    Type result = (Type)presenters[arg];
    return (null == result) ? lookupPresenter(arg.BaseType) : result;
  }

I've written this to show an error message dialog if it can't find a registered screen. I can avoid needing to show this by providing a screen at the top of the hierarchy when I register the screens.

presentationChooser.RegisterPresenter(typeof(ClassicalRecording), typeof(FrmClassicalRecording));
presentationChooser.RegisterPresenter(typeof(PopularRecording), typeof (FrmPopularRecording));
presentationChooser.RegisterPresenter(typeof(Object), typeof (FrmNullPresentation));

Example: Conditional (C#)

Here I take the simple example above and give it a slightly more sophisticated spin by allowing some more dynamic chooser behavior. In this scenario I want most classical recording to be displayed by the regular classical display form, but to use a special display form for anything composed by Mozart. (I'm not sure why I'd want to do that, but I'm not so good at coming up with convincing examples on a Tuesday.)

Much of the interface to the Presentation Chooser is the same as the simpler version. The code to display a dialog for a recording is still just Chooser.showDialog(aRecording). However the implementation of the Presentation Chooser is a bit more involved.

I'm still using a dictionary indexed by type to store the information. However this time I want to have multiple screens for each domain object. I can capture each choice with a class.

class DynamicPresentationChooser…

  Type _registeredType;
  Type _presentation;
  ConditionDelegate _condition;
  public delegate bool ConditionDelegate(Object recording); 
  public PresentationChoice(Type registeredType, Type presentation, ConditionDelegate condition)  {
    this._registeredType = registeredType;
    this._presentation = presentation;
    this._condition = condition;
  }

Here I'm using the C# delegate to allow the client to pass in a boolean function to evaluate a condition against a domain object. The new lookup capability checks all the choices in the list in sequence returning the first one whose condition delegate evaluates to true with the given domain object.

class PresentationChoice...

  public override Type this[Object obj] {
    get {
      IList list= presenterList(obj.GetType());
      return (null == list) ? typeof(FrmNullPresentation): chooseFromList(list, obj);
    }
  }
  private IList presenterList(Type type) {
    IList result = (IList) presenters[type];
    if (null != result)
      return result;
    else if (typeof (object) != type)
      return presenterList(type.BaseType);
    else
      return new ArrayList();
  }
  private static Type chooseFromList(IList list, object domainObject) {
    foreach (PresentationChoice choice in list) 
      if (choice.Matches(domainObject)) return choice.Presentation; 
    return typeof(FrmNullPresentation);
  }

If nothing matches I return a Null Object.

To register the screens, I decided I wanted to maintain a compatable interface to the simple case above. To do that I allow registration with just the domain and screen types to work just like before with the help of a couple of convenience methods.

class DynamicPresentationChooser...

  public override void RegisterPresenter(Type domainType, Type presentation) {
    presenters[domainType] = new ArrayList();
    presenterList(domainType).Add (new PresentationChoice (domainType, presentation));
  }

class PresentationChoice...

  public PresentationChoice(Type domainType, Type presentation) : 
    this (domainType, presentation, null){
    _condition = new ConditionDelegate(TrueConditionDelegate);
  }
  public static bool TrueConditionDelegate(Object ignored) {return true;}

This way I can use the dynamic chooser in any sitatuion where I'd otherwise use the simple chooser.

I then use an additional registration method to put in dynamic options. I've set this up so I can only do this when I already have a default choice present. This makes the configuration interface a little more awkward than I'd like, but this way any problems show up in configuration so the result fails fast.

class DynamicPresentationChooser...

  public void RegisterAdditionalPresenter(Type domainType, Type presentation, PresentationChoice.ConditionDelegate condition) {
    Debug.Assert(
      null != presenterList(domainType), 
      String.Format("Must register default choice for {0} first", domainType));
    presenterList(domainType).Insert(0, new PresentationChoice(domainType, presentation, condition));
  }

I can then register the classes like this.

presentationChooser.RegisterPresenter(typeof(ClassicalRecording), typeof(FrmClassicalRecording));
presentationChooser.RegisterPresenter(typeof(PopularRecording), typeof (FrmPopularRecording));
chooser.RegisterAdditionalPresenter(
  typeof(ClassicalRecording), 
  typeof(FrmMozartRecording), 
  new PresentationChoice.ConditionDelegate(MozartCondition));