inpwtepydjuf

Prism 4.0 learnings

2011-02-14T00:03:00.001-08:00

I have started to plan to use Prism 4.0 in one of my organisations internal applications. Previously I created a shell application and several modules that implement a standard interface. Having looked at Prism, much of this is already done via the templates that are available.

I'll post some thoughts, problems and examples when I have something concrete.

Extended ListView WPF Custom Control (Part 1)

2011-01-10T00:08:00.000-08:00

I am trying to write a WPF control that can be used in my projects to provide a standardised look and feel for data that is presented via grids. I'll put my thoughts down here, as a aid to my fading memory.

First I'll create the control, descended from ContentControl (as it will contain further content)


namespace Controls
{
    using System;
    using System.Windows.Controls;
    using System.Windows;
    using System.Windows.Input;
    using System.ComponentModel;

    public class ListViewExtended  : ContentControl
    {
        static ListViewExtended()
        {
            DefaultStyleKeyProperty.OverrideMetadata(typeof(ListViewExtended), 
                        new FrameworkPropertyMetadata(typeof(ListViewExtended)));
        }
    }
}

This is really simple, and is a standard setup, next the difficult bit is creating the correct XAML template, this looks (in the initial version anyway), like this:

This can be used as follows:

I'll tidy this up and add a screenshot later, and then extend the example to show it doing what I want it actually to do in the next post

MVVM RelayCommands and BackgroundWorker

2010-12-11T09:45:00.000-08:00

This is largely cribbed from elsewhere, but I wanted to have a system where a RelayCommand starts off an asynchronous update of the Model.

First we have to have a flag to hold the idle status

public bool IsIdle ( get; set; }

The RelayCommand command needs to bind its CanExecute to this property


_getCommandData = new RelayCommand (
 () => GetTimeSheet(),
 () => IsIdle);

This means that the WPF item bound to this command (in this case a button), is disabled when the idle status is set to false.

So in order to use this, and to not bung up the main UI thread, we need to run the command in a BackgroundWorker thread


protected void DoWork(Action work)
{
 idle = false;
 var worker = new BackgroundWorker();
 worker.DoWork += (sender, e) => work();
 worker.RunWorkerCompleted += (sender, e) => Idle = true;
 worker.RunWorkerAsync();
}

public void GetTimeSheet()
{
 DoWork (delegate() {
   _model.GetTimeSheet();
   TimeSheetData = _model.TimeSheetData;
 });
}

TLBs and Delphi

2010-03-06T10:41:00.000-08:00

We register the capabilities of Delphi applications using TLB files. However, from reading MSDN documentation, "Installation package authors are strongly advised against using the TypeLib table. Instead, they should register type libraries by using the Registry table". Does anyone have any advice on how to do this in a 'Delphi' way for Windows 7?

Delphi/Surround/Cruisecontrol.net howto (updated)

2010-02-27T13:37:00.000-08:00

This is a further draft of what I had to do to get CruiseControl.Net and Delphi to play nicely - I will fill out further the details later!

Configured IIS in Windows (see here)
Install CruiseControl.Net 3.5 RC1 (see release notes) - Make sure that the user that the CruiseControl.Net is being run by is able to see and use Delphi (i.e. probably not by default)
Install CCTray
Set the BDS environment setting to point to where Delphi lives (this may have been done when Delphi was installed)
Create a definitions.xml file that has all of the required defaults, for accessing Surround, MSBuild, etc.
Create a project to test. It is difficult to post a real example, as this is code that my company owns, rather than me, but an example could be pulled out and added to this article.
Setup connection to Seapine Surround. I had a real problem with using Delphi and Surround, as by default the code is checked out as readonly, and Delphi needs to write to the working directory (especially when building typelibraries, etc). I have not spent too much time fiddling with it as I have a patch for the CruiseControl.NET source.
Setup the MSBuild section to build the application (in the definitions.xml file)
Setup the configuration to be managed by CruiseControl.NET and Surround, so that the files can be just checked out, modified and then checked in again - this avoids having to access the server machine.
Each developer now gets emailed whenever a build fails, and we can see the running of tests as well, after each build, see below.
Modify the DUnit tests to output XML.

This I did using the code from the link above, and changed the base UnitTest program code to look like this:


var
res : TTestResult;

...

if IsConsole then
  if ParamCount <> 0 then
    if (copy(ParamStr(1), 0, 5) = '/xml=') then
      res := XMLTestRunner.RunRegisteredTests(copy(ParamStr(1), 6, length(ParamStr(1)) -5))
    else
      res := TextTestRunner.RunRegisteredTests
  else
      res := TextTestRunner.RunRegisteredTests
else
  GUITestRunner.RunRegisteredTests;

if (res.ErrorCount <> 0) then
  halt (1);

Other things I have done ...

Modify (legally I'm not sure if I can publish it) the code from Run-Time Systems Cyclomatic Complexity Calculator for Delphi so that it outputs the results as an XML file - it actually does this already internally, but doesn't write the results out.
Create a task to generate developer documentation using doc-o-matic as a task.

MVC Framework in Delphi

2010-01-02T12:07:00.001-08:00

A real world example can be found here on Joanna Carter's pages.

ListViews

2009-09-06T14:26:00.000-07:00

Things I can do with ListViews:

Flat header Vs. 3D header
capture a column resize event in a TListView?
Prevent resizing
Handling Right-Click Events in ListView Column Headers

CI Updated

2009-05-07T15:46:00.000-07:00

I now have all of our projects in CCNET, and am using this to control the port of code to Delphi 2009. I am also moving code around, so this helps. I had to patch a few things, but I have DUnit outputing xml that is then picked up by CCNET and displayed graphically (this is cool).

I have also taken the Cyclometric Complexity tool that I use and created a command-line version (this used the OTA interface before), which also outputs to XML. I'll then plug this into the projects and this will allow us to automatically measure complexity!

Getting testing working

2009-04-16T13:35:00.000-07:00

OK, so I have the source checked out, and then I have built it. I even have a test application, that outputs XML. However, we have a graphical login. So I need to be able to pass in the signon somehow. OK, so I need to think a bit more about this.

Cruisecontrol.net howto (draft)

2009-04-07T00:08:00.000-07:00

This is a draft of what I had to do to get CruiseControl.Net and Delphi to play nicely - I will fill out the details later!

1. Install Apache 2.
2. Install Mod_ASPDotNet.
3. Install CruiseControl.Net.
4. Install CCTray.
5. Create a project to test.
7. Setup connection to Seapine Surround.
8. Setup the MSBuild section to build the application.
9. Modify the DUnit tests to output XML.

This I did using the entry above, and changed the base UnitTest program code to look like this:


var
  res : TTestResult;

...

  if IsConsole then
    if ParamCount <> 0 then
      if (copy(ParamStr(1), 0, 5) = '/xml=') then
        res := XMLTestRunner.RunRegisteredTests(copy(ParamStr(1), 6, length(ParamStr(1)) -5))
      else
        res := TextTestRunner.RunRegisteredTests
    else
        res := TextTestRunner.RunRegisteredTests
  else
    GUITestRunner.RunRegisteredTests;

  if (res.ErrorCount <> 0) then
    halt (1);

More later!

CI Update

2009-04-06T08:02:00.000-07:00

Well, after much messing about I now have CI working for Delphi. It checks out the code from Surround (easy to configure), calls MSBuild (again easy), and this then compiles the Delphi source (tricky and required me to mess about and reinstall CruiseControl.NET). It now checks out 5 projects (3 of which compile, 1 fails due to a missed file, and 1 needs an project to be registered), which is about what I expected.

Hurrah!

Cruisecontrol.net update

2009-04-04T16:25:00.000-07:00

Well, I have CCNet working and trying to build (but failing) Delphi 2009 code, using MSBuild, good news I found out what was wrong, the bad news was I had to hack the CC.NET source to get this to work.

The cause of the problems was that Delphi 2009 uses the brcc32.exe to build its resources, which is obviously fine, but when the code is downloaded from Surround, it is read-only, so it create lots of .tmp files, all of which are read-only and so can't be written to. I downloaded the CC.NET source and changed the command line that is passed to Surround to checkout the code as read-write, and now the code compilation gets passed this.

However, I am now stuck with MSBuild working from the command line, but not when run from CC.NET. Ho hum, I'm sure I can figure this out as well. Nothing is ever easy!

CI with Delphi

2009-04-01T06:32:00.000-07:00

I am trying to get CruiseControl.NET to connect to a Surround SCM system and then check out and build (and then test if possible) projects.

It was simple to install, but it needs as ASP.NET server to work (or so it seems). I've installed Apache and the mod_asp (or whatever it is called), and have got a simple ASP script to work, but can't get the CC.NET dashboard application to run.

More news as it breaks.

Update 1

I now have access to the CC.NET dashboard working. I can't get the command line that CC.NET builds to be correct, the settings seem OK, but I get the following ...

Process command: E:\Program Files\Seapine\Surround SCM\sscm.exe cc * -d20090401153253:20090401153326 -r -bXXXX -p"XXXXXX" -x- -zABCABCDABCDEF:4900 -y"XXX:XXX"

Update 2

Fixed the file locations, and started up the VPN, and now CruiseControl downloads the latest source, and tries to rebuild - the MSBuild process now gives the following error:


E:\Documents\Mark\CCBuildDir\SSCMClone\D2009\XXXX\XXXX\XXXXX.dproj (,): 

errorMSB4057: The target "Rebuild" does not exist in the project.

So we are getting much closer, and this might be working before I go back to work

Continuous Integration and Delphi

2009-04-01T02:56:00.000-07:00

Continuous Integration and Delphi using CruiseControl

Actually implemented

2009-01-11T02:38:00.000-08:00

I have started to build a proof of concept that actually implments code that does stuff, so can't actually post that code here, but basically it follows the same structures, with a command being sent via the Controller, and then being run across the model (and hence the data). The notification of errors is done by the Notify mechanism, with whatever view knowing what to do with the errors statuses returned for each possible input.

Once a change to client, stock, buy/sell, etc has been entered, then at the the moment the Notify mechanism is directly fired, but what should happen is that the whole order should be validated at this point, allowing for cascadimg errors to be flagged.

We will see on monday!

MVC updated

2009-01-06T07:35:00.000-08:00

I have had a small rest over Christmas and have decided that the code below needs to be refactored. I broke down all of the interfaces and implementations of them into different units, and begun to separate out the stuff that is MVC and stuff which used by the model.

Specifically I broke down the command stuff and implemented descendants of TCommand that know what to do to the model - i.e. the model doesn't do anything other than respond to the data changes (or not as is the current state).

This means I have ended up with code like this ..


  TCalculateCommand = class (TCommand)
    procedure Run (model : tObject); override;
  end;
  ..

  { TCalculateCommand }

  procedure TCalculateCommand.Run (model : tObject);
  begin
    (model as TDomainModel).Data.Price := self.Params[0].Value;
    (model as TDomainModel).Data.Consideration := ((model as TDomainModel).Data.Size *
          (model as TDomainModel).Data.Price) + (model as TDomainModel).Data.Charges;
  end;

This is a lot simpler in my view.

However it doesn't solve the problem with how to indicate that a field is invalid?

I might have to register each control with the model, so it knows which fields map to each control. That sounds like a lot to faff, but I don't know how else to do it.

MVC Update

2008-11-07T15:02:00.000-08:00

In the real world, which I obviously can't post here, I have a problem where the result of the validation request does three things;

1) Validates the input values
2) Returns other information based on the inputs (i.e. Other client, stock details)
3) Set whether a specific field input is valid or not.

More MVC!

2008-11-02T04:24:00.000-08:00

A client search from would look like this ..


type
  TForm3 = class(TForm, IObserver)
    Button1: TButton;
    Edit1: TEdit;
    ListBox1: TListBox;
    Button2: TButton;
    Button3: TButton;
    procedure FormCreate(Sender: TObject);
    procedure Button1Click(Sender: TObject);
    procedure Button3Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
    procedure UpdateView (obj : TObject);
  end;

...

procedure TForm3.Button1Click(Sender: TObject);
var
  c : TCommand;
  o : TCommandParam;

begin
  c := TCommand.Create ('SEARCH');

  o := TCommandParam.Create;
  o.Name := edit1.Text;

  c.AddParam(o);

  Controller.DoCommand(c);
end;

procedure TForm3.Button2Click(Sender: TObject);
begin
  ModalResult := mrOK;
end;

procedure TForm3.Button3Click(Sender: TObject);
begin
  ModalResult := mrCancel;
end;

procedure TForm3.FormCreate(Sender: TObject);
begin
  Controller.AddView (self);
end;

procedure TForm3.UpdateView (obj : TObject);
var
  val : String;

begin
  // Update the view here
  if ((obj as TDomainModel).ClientSearchResult <> nil) then
  begin
    for val in (obj as TDomainModel).ClientSearchResult do
    begin
      ListBox1.AddItem(val, nil);
    end;
  end;
end;

I have merge the View classes with the actual form, in order to make the code relationships a little clearer.

I'm really happy with all of the, and I think it will be applicable for the requirements I have at work.

MVC questions

2008-10-31T17:55:00.000-07:00

Having done all of the below, I am still left with a list of questions

Should I be using threads to do this ?
When the command requires interaction (i.e. if I want a form to search of a client or a stock item), should it be owned by the Model, Controller or View ?

To answer 2., the view owns the form, and and is updated by the model in the same way as before.

MVC in Delphi (Part III)

2008-10-31T17:40:00.000-07:00

As an experiment I have changed the DomainModel of my example, to be a more complex object, encapsulating an 'order'. This can be updated, calculated and reset with out the View and the Controller having to change.

The DomainModel now looks like this ..


 TDomainObject = class
 private
   FClient : String;
   FStock : String;
   FBuySell : String;
   FSize : extended;
   FPrice : extended;
   FDate : String;

   FConsideration : extended;
 public
   property Client : String read FCLient write FClient;
   property Stock : String read FStock write FStock;
   property BuySell : String read FBuySell write FBuySell;
   property Size : extended read FSize write FSize;
   property Price : extended read FPrice write FPrice;
   property Date : String read FDate write FDate;
   property Consideration : extended read FConsideration write FConsideration;
 end;

 ///A small implementation of the MVC architecture

 TDomainModel = class (TObservable)
 private
   /// Underlying data object

   FData : TDomainObject;

 public
   ///Property that represents the underlying data

   property Data : TDomainObject read FData write FData;

   ///Executes the given command

   procedure DoCommand (cmd : TCommand); override;

   ///Creates the underlying data

   constructor Create;

   ///Function that is passed to the CommandThread for execution

   ///TCommandThread
   procedure ExecuteCommand (cmd : TCommand);

   function ToString : String;
 end;

In order to do this, some of the plumbing code had to change, but basically just to get the values in the views. I have define 3 views, 2 of which are associated with one form, and a more complex one that is associated with another form, as below;


 TFormView = class (TInterfacedObject, IObserver)
 private
   Ffrm : TForm2;
 public
   { Public declarations }
   procedure UpdateView (obj : TObject);
   constructor Create (frm : TForm2);
 end;

 TListView = class (TInterfacedObject, IObserver)
 private
   Fctrl : TListBox;
 public
   { Public declarations }
   procedure UpdateView (obj : TObject);
   constructor Create (ctrl : TListBox);
 end;

 TTextView = class (TInterfacedObject, IObserver)
 private
   Fctrl : TStaticText;
 public
   { Public declarations }
   procedure UpdateView (obj : TObject);
   constructor Create (ctrl : TStaticText);
 end;

These are created and associated with the Model and Controller as follows;


procedure TForm1.FormCreate(Sender: TObject);
begin
 Controller.AddView (TListView.Create (ListBox1));
 Controller.AddView (TTextView.Create (StaticText1));
end;

...

procedure TTextView.UpdateView (obj : TObject);
begin
 Fctrl.Caption := FloatToStr((obj as TDomainModel).Data.Size);
end;

procedure TListView.UpdateView (obj : TObject);
begin
 Fctrl.AddItem('Order = ' + (obj as TDomainModel).ToString, nil);
end;

...

procedure TForm2.FormCreate(Sender: TObject);
begin
 Controller.AddView (TFormView.Create(Form2));
end;

...

procedure TFormView.UpdateView (obj : TObject);
begin
// Fctrl.AddItem('Order = ' + (obj as TDomainModel).ToString, nil);
 Ffrm.lblStock.caption := (obj as TDomainModel).Data.Stock;
 Ffrm.lblClient.caption := (obj as TDomainModel).Data.Client;
 Ffrm.lblSize.caption := FloatToStr((obj as TDomainModel).Data.Size);
 Ffrm.lblPrice.caption := FloatToStr((obj as TDomainModel).Data.Price);
 Ffrm.lblValue.caption := FloatToStr((obj as TDomainModel).Data.Consideration);
end;

This shows that a new view can be added, which out having to change anything in the Model or Controller.

The first two Views are associated with the main form, and show a single value from the Model, and a list view representing the changes to the order. The third View is the state of the 'whole' order.

MVC in Delphi (Part II)

2008-10-28T10:25:00.000-07:00

The TCommand is clearly a Command, and should be slightly different, but I will sort that out later.

John Wayne!

2008-10-28T02:50:00.000-07:00

The 1975 John Wayne film Brannigan was filmed in London, more specifically there is a car chase that goes down the street I live in. Here is a still from the chase, showing people clearly standing around watching the action.

MVC in Delphi (Part I)

2008-10-27T08:41:00.000-07:00

We have a large Delphi software project at work, that has been in development for the last 10 years and is now basically unmaintainable. It uses threads to create conversations with an iSeries I5 (an AS/400 in old money). These threads are unmanaged, interdependant and duplicated throughout the application.

We have been on the point of refactoring many times, but have not had the time or the will-power to actually do it. So, here goes ...

MVC

Basically the MVC pattern looks closest to what I need. A data domain, and dependant views on it, so it "... isolates business logic from user interface considerations..."

The parts of the pattern are ..

Model

This is basically an Observable ...


  IObservable = interface

      procedure RegisterObserver (obs : IObserver);
      procedure UnregisterObserver (obs : IObserver);

      procedure Notify (const obj : TObject);
      procedure ClearObservers ();

      procedure DoCommand (cmd : TCommand);

  end;

A default implementation of IObservable is the TObservable class, from which more concrete implementations should descend.


  ///This is the default implementation of IObservable

  ///IObservable
  TObservable = class (TInterfacedObject,
                       IObservable)
  private
    FObservers : TClassList;
    FCurrent : TObject;

  public
    constructor Create;
    destructor Destroy; override;

    procedure SetCurrent (obj: TObject);

    procedure RegisterObserver (obs : IObserver);
    procedure UnregisterObserver (obs : IObserver);
    procedure ClearObservers ();
    procedure Notify (const obj : TObject);

    procedure DoCommand (cmd : TCommand); virtual;

    property Current : TObject read FCurrent write FCurrent;

  end;

View

This is basically an Observer ...


  IObserver = interface

      procedure UpdateView (obj : TObject);

  end;

The IObserver and IObservable pattern is a standard pattern from Design Patterns: Elements of Reusable Object-Oriented Software. It is half way there, with the Observable registering all of the Observer objects that are interested in when it changes. However, there is not a way of interacting with the Observer, in order to make it carry out operations, this is where the Controller comes in.

Controller

The controller is used (in my code at least) register all of the Observers with the Observables, and to marshal commands from the View to the Model. My interface for a Controller looks like this;


  IController = interface

    function GetModel : IObservable;

    procedure SetModel (const m : IObservable);

    function GetView (index: integer): IObserver;

    procedure SetView (index: integer; const v : IObserver);

    property Model : IObservable read GetModel write SetModel;

    property Views[index: integer]: IObserver read GetView write SetView;

    procedure DoCommand (cmd : TCommand);

    procedure AddView (v : IObserver);

  end;

This maintains a list of Views (accessed via the Views property), and the Model which they are interested in. The commands are processed via the DoCommand method (this is a bit of a hack I think, and I can't quite think of a way to do this nicely!).

Concrete Example

So the interfaces above describe the basic building blocks of an MVC interface. Lets try and build a concrete example to see how it works.

My example model will be a single extended value, which will be initialised at startup by the Model, and then operations can be carried out on it by the View, via the Controller.

First we define the concrete model ...


  ///A small implementation of the MVC architecture

  TDomainModel = class (TObservable)
  private
    /// Underlying data object

    FData : extended;

  public
    ///Property that represents the underlying data

    property Data : extended read FData write FData;

    ///Executes the given command

    procedure DoCommand (cmd : TCommand); override;

    ///Creates the underlying data

    constructor Create;

    ///Function that is passed to the CommandThread for execution

    ///TCommandThread
    procedure ExecuteCommand (cmd : TCommand);
  end;

As can be seen, we descend from the base class TObservable, which implements all of the IObservable methods, and provides some basic functionality needed by all TObservable objects (see above).

The DoCommand method wraps up the TCommand object (more of that later), and then spawns off a thread to actually do the processing. This hides all of the gubbins of getting data and processing it from the Controller and the View. In the real example this would get stuff from the i5 via the conversation. It would mean that this method of using threads could be changed to use a managed queue, or whatever, without changing the View or the Controller, as they don't need to know HOW the data is fetched, just that it is ready.

In the example below, we just do some very simple maths


procedure TDomainModel.DoCommand (cmd : TCommand);
var
  T : TCommandThread;

begin
  t := TCommandThread.Create(true);

  t.Cmd := cmd;
  t.ParamList := cmd.ParamList;
  t.Operation := ExecuteCommand;

  t.Resume;
end;

procedure TDomainModel.ExecuteCommand (cmd : TCommand);
begin
  if cmd.Command = 'HALF' then
  begin
    FData := FData / 2;
  end;

  if cmd.Command = 'MULTIPLY' then
  begin
    FData := FData * 2;
  end;

  if cmd.Command = 'SET' then
  begin
    assert (cmd.ParamCount <> -1, 'SET requires a parameter value');
    FData := cmd.Params[0].Value;
  end;

  if cmd.Command = 'ADD' then
  begin
    assert (cmd.ParamCount <> -1, 'ADD requires a parameter value');
    FData := FData + cmd.Params[0].Value;
  end;

  if cmd.Command = 'ZERO' then
  begin
    FData := 0.0;
  end;

  Notify(self);
end;

constructor TDomainModel.Create;
begin
  FData := 10.0;
end;

I'll finish off this a bit later, and upload the source for the example

Hi

2008-09-21T06:11:00.000-07:00

In this blog I hope to write about my adventures in Delphi, C# and probably some random stuff about Egyptology and wikipedia.