Typically, you will want to extract the data from distribution (archived) files rather than the actual accounting tables. For example, instead of running the following:

td24 -server 10.10.59.42 -user INPUTT -pass 123456 -file FBNK.STMT.ENTRY -with "BOOKING.DATE EQ '20120109'"

You would use the distribution file instead:

td24 -server 10.10.59.42 -user INPUTT -pass 123456 -file FBNK.STMT.ENTRY.DIST01 -with "BOOKING.DATE EQ '20120109'"

Here is an ONLINE example of extracted data for the FBNK.CATEG.ENTRY table.

Other notable distribution files are the other 2 accounting tables as well as FBNK.FUNDS.TRANSFER$HIS. You would extract from their distribution files in a similar way:

td24 -server 10.10.59.42 -user INPUTT -pass 123456 -file FBNK.CATEG.ENT.DIST01 -with "BOOKING.DATE EQ '20120109'"
td24 -server 10.10.59.42 -user INPUTT -pass 123456 -file FBNK.RE.CON.DIST01 -with "BOOKING.DATE EQ '20120109'"
td24 -server 10.10.59.42 -user INPUTT -pass 123456 -file FBNK.FUNDS.TRANSFER$HIS.PART1 -with "PROCESSING.DATE EQ '20120109'"

To automate the extraction processing, simply create a script and have it run daily after the COB. Here’s an example in Wndows jscript:

var today = new Date();
var y= today.getFullYear();
var m = today.getMonth()+1;
var m1 = (m < 10 ? "0" : "") + m;
var d = today.getDate();
var d1 = (d < 10 ? "0" : "") + d;
var iso_date = (y + m1 + d1);
WScript.Echo("td24 -server 10.10.59.42 -user INPUTT -pass 123456 -file FBNK.STMT.ENTRY.DIST" + m1 + " -with \"BOOKING.DATE EQ '" + iso_date + "'\"");
WScript.Echo("td24 -server 10.10.59.42 -user INPUTT -pass 123456 -file FBNK.CATEG.ENT.DIST" + m1 + " -with \"BOOKING.DATE EQ '" + iso_date + "'\"");
WScript.Echo("td24 -server 10.10.59.42 -user INPUTT -pass 123456 -file FBNK.RE.CON.DIST" + m1 + " -with \"BOOKING.DATE EQ '" + iso_date + "'\"");
WScript.Echo("td24 -server 10.10.59.42 -user INPUTT -pass 123456 -file FBNK.FUNDS.TRANSFER$HIS.PART" + m + " -with \"PROCESSING.DATE EQ '" + iso_date + "'\"");

Simple, not a lot of hassle, and plain productive.

These implementations typically require custom jBC code installed on the jBASE server as well as setting up an application server responsible for connection pooling. There may also be run-time (distribution) fees and onsite consultancy requirements to consider. Costs add up quickly.

If your primary goal is to deliver usable grid data from jBASE to the users, then we have a simple tool that does just that. Here’s an ONLINE EXAMPLE of the data that this tool produces. And unlike the above solutions, we do not have developer licenses and absolutely no distribution fees You only pay for the product one time.

See this tool in action by downloading the TRIAL edition. The trial edition has all the features described in this post, but it can ONLY extract one table, FBNK.CUSTOMER.

You can PURCHASE the retail edition, which has no such limitations.

td24 Version 1.0

Our solution, “td24″, is a command line tool on the client machine. There is no application server setup and nothing to install on the jBASE server. Connections to the jBASE server are done securely via SSH2. After an installation that takes a few seconds, you’re ready to download data. Nothing to configure.

Pass it a “-help” argument and you’ll see all the available options (that’s right, there’s only 4 required arguments!):

td24 [-server] [-port] [-user] [-pass] [-file] [-with]
     [-explode] [-dest] [maxrow] [-xfile]

Required:

        server  IP address of the server where jBASE is installed.
                example: -server 192.168.1.22
        user    A valid user account that has access to jBASE.
                example: -user jschmoe
        pass    A valid password for the above user account.
                example: -pass abc123
        file    The jBASE filename to be extracted.
                example: -file FBNK.ACCOUNT

Optional:

        port    The SSH port number.
                If this argument is not included, the default value is 22.
                example: -port 2222
        with    A valid jQL selection clause.
                If this argument is not included, all fields
                will be extracted
                example: -with "CATEGORY='1234' AND ALL.IN.ONE.PRODUCT NE ''"
        explode Pipe delimited list of field names to explode.
                If this argument is not included, all fields with
                multi and sub values will be exploded.
                example: -explode "CAP.DATE.CR.INT|ACCT.CREDIT.INT"
        dest    The absolute path to the directory where the extracted
                files will be exported.  Do not include a "\" at the end.
                If this argument is not included, a subfolder "done" will
                be created in the application working directory.
                example: -dest "c:\users\jschmoe\my downloaded files"
        maxrow  The maximum number of rows to write to a file.
                After this numbe is reached, a new file will be created.
                If this argument is not included, the default value is 999.
                The maximum value is 999.
                example: -maxrow 300
        xfile   The absolute path to the text file that contains a list of
                multi value fields to be exploded.  This argument and the
                "-explode" argument are mutually exclusive.  This argument
                will be ignored if the "-explode" argument is included
                Each field name should be followed a newline or CRLF.
                example: -xfile "c:\users\jschmoe\my_mv_list.txt"

EXAMPLES

Sampling

To get an idea of table structure and which fields are MultiValue. We can simply pass “SAMPLE 1″ to the “-with” argument.

td24 -server 192.168.1.22 -user INPUTT -pass 123456 -file FBNK.ACCOUNT -with "SAMPLE 1"

This is exported file:

11398^100401^1001^Queen Elizabeth Ii^^Queen Elizabeth Ii^QEIIUSD^TR^USD^1^^1^^^^^^^^^^1^^^^^^^^^^^^^^^^^^^^^^^^^20081231^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^NO^^20081201^^^^^^^1001^^^^^^^^USD^1^USD^1^^^LEGACY^^^^^^^^^NO^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^Y^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^2^28_INPUTTER^0903241641^SY_CUSTOMER^GB0010001^1^

Upon executing the command, td24 will also write 2 files:

FBNK.ACCOUNT.DICT.txt
FBNK.ACCOUNT.DICT.MV.txt

The first file will list all the fields in ordinal position:

0^ACCOUNT.NUMBER
1^CUSTOMER
2^CATEGORY
3^ACCOUNT.TITLE.1
4^ACCOUNT.TITLE.2
5^SHORT.TITLE
6^MNEMONIC
7^POSITION.TYPE
8^CURRENCY
9^CURRENCY.MARKET
10^LIMIT.REF
11^ACCOUNT.OFFICER
12^OTHER.OFFICER
13^POSTING.RESTRICT
14^RECONCILE.ACCT
15^INTEREST.LIQU.ACCT
16^INTEREST.COMP.ACCT
17^INT.NO.BOOKING
18^REFERAL.CODE
19^WAIVE.LEDGER.FEE
20^LOCAL.REF
21^CONDITION.GROUP
22^INACTIV.MARKER
23^OPEN.ACTUAL.BAL
24^OPEN.CLEARED.BAL
25^ONLINE.ACTUAL.BAL
26^ONLINE.CLEARED.BAL
27^WORKING.BALANCE
28^DATE.LAST.CR.CUST
29^AMNT.LAST.CR.CUST
30^TRAN.LAST.CR.CUST
31^DATE.LAST.CR.AUTO
32^AMNT.LAST.CR.AUTO
33^TRAN.LAST.CR.AUTO
34^DATE.LAST.CR.BANK
35^AMNT.LAST.CR.BANK
36^TRAN.LAST.CR.BANK
37^DATE.LAST.DR.CUST
38^AMNT.LAST.DR.CUST
39^TRAN.LAST.DR.CUST
40^DATE.LAST.DR.AUTO
41^AMNT.LAST.DR.AUTO
42^TRAN.LAST.DR.AUTO
43^DATE.LAST.DR.BANK
44^AMNT.LAST.DR.BANK
45^TRAN.LAST.DR.BANK
46^CAP.DATE.CHARGE
47^CAP.DATE.CR.INT
48^CAP.DATE.C2.INT
49^CAP.DATE.DR.INT
50^CAP.DATE.D2.INT
51^CAP.BACK.VALUE
52^ACCR.CHG.CATEG
53^ACCR.CHG.TRANS
54^ACCR.CHG.AMOUNT
55^ACCR.CHG.SUSP
56^ACCR.CR.CATEG
57^ACCR.CR.TRANS
58^ACCR.CR.AMOUNT
59^ACCR.CR.SUSP
60^ACCR.CR2.CATEG
61^ACCR.CR2.TRANS
62^ACCR.CR2.AMOUNT
63^ACCR.CR2.SUSP
64^ACCR.DR.CATEG
65^ACCR.DR.TRANS
66^ACCR.DR.AMOUNT
67^ACCR.DR.SUSP
68^ACCR.DR2.CATEG
69^ACCR.DR2.TRANS
70^ACCR.DR2.AMOUNT
71^ACCR.DR2.SUSP
72^CONSOL.KEY
73^INT.LIQU.TYPE
74^INT.LIQU.ACCT
75^INT.LIQ.CCY
76^PASSBOOK
77^START.YEAR.BAL
78^OPENING.DATE
79^VALUE.DATE
80^CREDIT.MOVEMENT
81^DEBIT.MOVEMENT
82^VALUE.DATED.BAL
83^CONTINGENT.BAL.CR
84^CONTINGENT.BAL.DR
85^OPEN.CATEGORY
86^OPEN.VAL.DATED.BAL
87^ACCT.CREDIT.INT
88^ACCT.DEBIT.INT
89^LINK.TO.LIMIT
90^CLOSURE.DATE
91^RESERVED01
92^CHARGE.ACCOUNT
93^CHARGE.CCY
94^CHARGE.MKT
95^INTEREST.CCY
96^INTEREST.MKT
97^CON.CHARGE.ACCR
98^CON.INTEREST.ACCR
99^ALT.ACCT.TYPE
100^ALT.ACCT.ID
101^PREMIUM.TYPE
102^CAP.DATE.PRM
103^PREMIUM.FREQ
104^APR
105^JOINT.HOLDER
106^RELATION.CODE
107^JOINT.NOTES
108^ALLOW.NETTING
109^LEDG.RECO.WITH
110^STMT.RECO.WITH
111^OUR.EXT.ACCT.NO
112^RECO.TOLERANCE
113^PENDING.ID
114^TOTAL.PENDING
115^STOCK.CONTROL.TYPE
116^SERIAL.NO.FORMAT
117^AUTO.PAY.ACCT
118^ORIG.CCY.PAYMENT
119^AUTO.REC.CCY
120^ORIGINAL.ACCT
121^FROM.DATE
122^LOCKED.AMOUNT
123^DISPO.OFFICER
124^DISPO.EXEMPT
125^TAX.SUSPEND
126^TAX.AT.SETTLE
127^ICA.MAIN.ACCOUNT
128^ICA.DISTRIB.RATIO
129^ICA.MAIN.ACCT.IND
130^ICA.DISTRIB.TYPE
131^ICA.POST.INTEREST
132^ICA.MAIN.RATIO
133^ICA.NEW.MAIN.ACC
134^ICA.START.DATE
135^ICA.ADD.REMOVE
136^ICA.BACK.VALUE
137^ICA.MAIN.ACCT
138^ICA.MAIN.DATE
139^LIQUIDATION.MODE
140^OVERDUE.STATUS
141^RESERVED11
142^SINGLE.LIMIT
143^CONTINGENT.INT
144^ALL.IN.ONE.PRODUCT
145^ER.VALUE.DATE
146^ER.BALANCE
147^EP.BALANCE
148^SB.GROUP.ID
149^OPEN.AVAILABLE.BAL
150^AVAILABLE.DATE
151^AV.AUTH.DB.MVMT
152^AV.NAU.DB.MVMT
153^AV.AUTH.CR.MVMT
154^AV.NAU.CR.MVMT
155^AVAILABLE.BAL
156^FORWARD.MVMTS
157^CREDIT.CHECK
158^AVAILABLE.BAL.UPD
159^CONSOLIDATE.ENT
160^MAX.SUB.ACCOUNT
161^MASTER.ACCOUNT
162^RESERVED2
163^CLOSED.ONLINE
164^NEXT.AF.DATE
165^NEXT.ACCT.CAP
166^NEXT.EXP.DATE
167^DATE.LAST.UPDATE
168^NEXT.STMT.DATE
169^EXPOSURE.DATES
170^PORTFOLIO.NO
171^ENTRY.HOLD
172^FWD.ENTRY.HOLD
173^FIRST.AF.DATE
174^CASH.POOL.GROUP
175^OPEN.ASSET.TYPE
176^LAST.COM.CHG.DATE
177^IC.CHARGE.ID
178^IC.NEXT.CAP.DATE
179^IC.PRODUCT
180^IC.LST.PROD.CAP
181^ARRANGEMENT.ID
182^ACC.DEB.LIMIT
183^MANDATE.APPL
184^MANDATE.REG
185^MANDATE.RECORD
186^DR.ADJ.AMOUNT
187^DR2.ADJ.AMOUNT
188^CR.ADJ.AMOUNT
189^CR2.ADJ.AMOUNT
190^OVERRIDE
191^RECORD.STATUS
192^CURR.NO
193^INPUTTER
194^DATE.TIME
195^AUTHORISER
196^CO.CODE
197^DEPT.CODE

The second file will list only fields that are MultiValue in ordinal position:

12^OTHER.OFFICER
18^REFERAL.CODE
20^LOCAL.REF
46^CAP.DATE.CHARGE
47^CAP.DATE.CR.INT
48^CAP.DATE.C2.INT
49^CAP.DATE.DR.INT
50^CAP.DATE.D2.INT
52^ACCR.CHG.CATEG
53^ACCR.CHG.TRANS
54^ACCR.CHG.AMOUNT
55^ACCR.CHG.SUSP
56^ACCR.CR.CATEG
57^ACCR.CR.TRANS
58^ACCR.CR.AMOUNT
59^ACCR.CR.SUSP
60^ACCR.CR2.CATEG
61^ACCR.CR2.TRANS
62^ACCR.CR2.AMOUNT
63^ACCR.CR2.SUSP
64^ACCR.DR.CATEG
65^ACCR.DR.TRANS
66^ACCR.DR.AMOUNT
67^ACCR.DR.SUSP
68^ACCR.DR2.CATEG
69^ACCR.DR2.TRANS
70^ACCR.DR2.AMOUNT
71^ACCR.DR2.SUSP
73^INT.LIQU.TYPE
74^INT.LIQU.ACCT
75^INT.LIQ.CCY
79^VALUE.DATE
80^CREDIT.MOVEMENT
81^DEBIT.MOVEMENT
82^VALUE.DATED.BAL
87^ACCT.CREDIT.INT
88^ACCT.DEBIT.INT
99^ALT.ACCT.TYPE
100^ALT.ACCT.ID
101^PREMIUM.TYPE
102^CAP.DATE.PRM
103^PREMIUM.FREQ
105^JOINT.HOLDER
106^RELATION.CODE
107^JOINT.NOTES
109^LEDG.RECO.WITH
110^STMT.RECO.WITH
113^PENDING.ID
114^TOTAL.PENDING
119^AUTO.REC.CCY
120^ORIGINAL.ACCT
121^FROM.DATE
122^LOCKED.AMOUNT
137^ICA.MAIN.ACCT
138^ICA.MAIN.DATE
145^ER.VALUE.DATE
146^ER.BALANCE
147^EP.BALANCE
150^AVAILABLE.DATE
151^AV.AUTH.DB.MVMT
152^AV.NAU.DB.MVMT
153^AV.AUTH.CR.MVMT
154^AV.NAU.CR.MVMT
155^AVAILABLE.BAL
156^FORWARD.MVMTS
168^NEXT.STMT.DATE
169^EXPOSURE.DATES
170^PORTFOLIO.NO
171^ENTRY.HOLD
172^FWD.ENTRY.HOLD
179^IC.PRODUCT
180^IC.LST.PROD.CAP
182^ACC.DEB.LIMIT
183^MANDATE.APPL
184^MANDATE.REG
185^MANDATE.RECORD
190^OVERRIDE
193^INPUTTER
194^DATE.TIME

Getting Everything Without Exploding

Suppose we don’t want know what MultiValue fields to explode and just want to see everything. Simple enough:

td24 -server 192.168.1.22 -user INPUTT -pass 123456 -file FBNK.ACCOUNT

Immediately after executing the command, you’re see files raining down. All files are in caret “^” delimited format. A portion of a file is shown below:

28282^111111^4001^Ukwarb Stock Borrow Margin Acct^^Ukwarb Stock Borrow Margin Acct^UKWARBSB^TR^USD^1^^1^^^^^^^^^^99^^^^^^^^^^^^^^^^^^^^^^^^^20081231^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^NO^^20081201^^^^^^^4001^^^^^^^^USD^1^USD^1^^^LEGACY^^^^^^^^^NO^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^111111-955^^^^^^^^^^^^^^^^^^^^^^2^12_INPUTTER^0903211145^SY_UPDATE.INACTIVE.MARKER^GB0010001^1^
GBP149550001^^14955^Suspense Account^^Suspense Account^SUSP^TR^GBP^1^^5^^^^^^^^^^^^947368.42^947368.42^947368.42^947368.42^947368.42^20090107^947368.42^306^^^^20090107^1000000^219^20090102^-1000000.00^307^^^^^^^20081231^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^NO^^20081205^^^^^^^14955^^^^^^^^GBP^1^GBP^1^^^LEGACY^^^^^^^^^NO^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^20090107^^^^^^^^^^^^^^^^^^^^^^^^^1^40_INPUTTER___OFS_OFS.LOAD^0903181430^40_INPUTTER_OFS_OFS.LOAD^GB0010001^1^
10782^100224^6603^Dbl Az Multi Dep1^^Dbl Az Multi Dep1^^TR^USD^1^^5^^^^37044^^^^^^99^^^^^^^^^^^^^^^^^^^^^^^^^20090131^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^NO^^20090107^^^^^^^6603^^^^^^^^USD^^USD^^^^^^^^^^^^^NO^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^37761^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^1^4_BUILDUSER87^0904041853^SY_37761^GB0010001^1^
15393^100592^5001^Hsbc Bank^^Hsbc Bank^HSBCGBP^TR^GBP^1^NOSTRO^27^^^Y^^^^^^^5^^-21231545.25^-21231545.25^-19897484.98^-19897484.98^-19897484.98^20090122^1335000.00^306^^^^20090120^3192.00^674^20090121^-958.90^437^20090121^-64.73^281^20090122^-939.73^701^20081231^20081231^20081231^20081231^20081231^^^^^^^^^^^^^^^^^^^^^^^^^^NO^^20081201^^^^^^^5001^^^^^^^^GBP^1^GBP^1^^^LEGACY^^^^^^^^^NO^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-10395326.71^20090122]20090123]20090124]20090126]20090128]20090129]20090131^-939.73]]-1438.35]]-1004688.764109589041]-939.73]-1438.35^^1335230.14]1342.4657534246574]939.73]4002972.5986301369862]959.86]]2585936.99^^-9061036.3]-9059693.8342465753426]-9060192.4542465753426]-5057219.8556164383564]-6060948.7597260273974]-6061888.4897260273974]-3477389.8497260273974^230.14]1342.4657534246574]-498.62]4002972.5986301369862]-1003728.904109589041]-939.73]2584498.64^^^^^^^^20090204^^^20090122^^^^^^20090122^^^^^^^^^^^^^^^^^^^1^40_BUILDUSER1___OFS_MB.OFS.AUTH^0903181432^40_BUILDUSER1_OFS_MB.OFS.AUTH^GB0010001^1^
USD111050001^^11105^Building - Own Usage^^Building - Own^BUILD11105^TR^USD^1^^1^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^20081231^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^NO^^20081202^^^^^^^11105^^^^^^^^USD^1^USD^1^^^^^^^^^^^^NO^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^1^63_INPUTTER___OFS_MB.OFS.AUTH^0903171747^63_INPUTTER_OFS_MB.OFS.AUTH^GB0010001^1^

It’s probably not a good idea to download everything in sight, but you’ll be surprised that for about 0.5 GB of data for FBNK.ACCOUNT, the extraction only takes 5 minutes.

Generally, it’s best to break up the download with selection clauses (which we’ll see shortly).

Since the MultiValue fields were not exploded, each item has exactly one row. In the example above, record “15393″ has a few MultiValue fields that require exploding.

Selectively Exploding Fields

For the next example, we’re going to explode the fields “AVAILABLE.DATE” and “AVAILABLE.BAL”:

td24 -server 192.168.1.22 -file FBNK.ACCOUNT -explode "AVAILABLE.DATE|AVAILABLE.BAL" -user INPUTT -pass 123456

The result would now look like this:

GBP149550001^^
10782^^
15393^20090122^-9061036.3
15393^20090123^-9059693.8342465753426
15393^20090124^-9060192.4542465753426
15393^20090126^-5057219.8556164383564
15393^20090128^-6060948.7597260273974
15393^20090129^-6061888.4897260273974
15393^20090131^-3477389.8497260273974
USD111050001^^
13838^^

Using a File to List Fields to Explode.

In the above example, we only exploded 2 fields. If we wanted to explode many fields, it may be easier to use the “-xfile” argument to specify a user-defined text file that lists those fields.

Let’s create a file called “my-mv-list.txt” with a list of fields:

CAP.DATE.CHARGE
CAP.DATE.CR.INT
CAP.DATE.C2.INT
CAP.DATE.DR.INT
CAP.DATE.D2.INT
ACCR.CHG.CATEG
ACCR.CHG.TRANS
ACCR.CHG.AMOUNT
ACCR.CHG.SUSP
ACCR.CR.CATEG
ACCR.CR.TRANS
ACCR.CR.AMOUNT
ACCR.CR.SUSP
ACCR.CR2.CATEG
ACCR.CR2.TRANS
ACCR.CR2.AMOUNT
ACCR.CR2.SUSP
ACCR.DR.CATEG
ACCR.DR.TRANS
ACCR.DR.AMOUNT
ACCR.DR.SUSP
ACCR.DR2.CATEG
ACCR.DR2.TRANS
ACCR.DR2.AMOUNT
ACCR.DR2.SUSP

Then execute the following command:

td24 -server 192.168.1.22 -file FBNK.ACCOUNT -xfile "my-mv-list.txt" -user INPUTT -pass 123456

A portion of the results look like this:

35254^20081231^20081231^20081231^20081231^20081231^^^^^^^^^^^^^^^^^^^^
37718^20081231^20090114^^^^^^^^50000^380^1704.24^^^^^^^^^^^^^
37718^20081231^20090107^^^^^^^^50000^380^1704.24^^^^^^^^^^^^^
37718^20081231^20081231^^^^^^^^50000^380^1704.24^^^^^^^^^^^^^
37718^20081231^20081224^^^^^^^^50000^380^1704.24^^^^^^^^^^^^^
37718^20081231^20081217^^^^^^^^50000^380^1704.24^^^^^^^^^^^^^
37718^20081231^20081210^^^^^^^^50000^380^1704.24^^^^^^^^^^^^^
19167^20081231^^^^^^^^^^^^^^^^^^^^^^^^

Selection Clause

We’ve already used a form of a selection clause before with the “SAMPLE” keyword. In the above example, there are many records without a “ACCR.CR.CATEG” value. We can simply filter those records out:

td24 -server 192.168.1.22 -file FBNK.ACCOUNT -xfile "my-mv-list.txt" -with "ACCR.CR.CATEG NE '' OR ACCR.DR.CATEG NE ''" -user INPUTT -pass 123456

A portion of the results now look like this:

10731^20081231^20081231^20081231^20081231^20081231^^^^^^^^^^^^^51000^390^-21595^^^^^
23876^20081231^20081231^20081231^20081231^20081231^^^^^^^^^^^^^51000^390^-278.87^^^^^
37718^20081231^20090114^^^^^^^^50000^380^1704.24^^^^^^^^^^^^^
37718^20081231^20090107^^^^^^^^50000^380^1704.24^^^^^^^^^^^^^
37718^20081231^20081231^^^^^^^^50000^380^1704.24^^^^^^^^^^^^^
37718^20081231^20081224^^^^^^^^50000^380^1704.24^^^^^^^^^^^^^
37718^20081231^20081217^^^^^^^^50000^380^1704.24^^^^^^^^^^^^^
37718^20081231^20081210^^^^^^^^50000^380^1704.24^^^^^^^^^^^^^
36706^20081231^20081231^20081231^20081231^20081231^^^^^^^^^^^^^51000^390^-0.41^^^^^

Concurrency

Where td24 really shines is the ability to download multiple tables concurrently. There is no real limitation on how many connections you can make when using td24. This ultimately depends on how powerful the jBASE server is. On a beefy Solaris box, 40 or more concurrent connections is possible.

The following is a sample script to download 10 tables concurrently:

start "0" /B td24.exe -file FBNK.ACCOUNT -server 192.168.1.22 -port 22 -user INPUTT -pass 123456
start "1" /B td24.exe -file FBNK.LIMIT -server 192.168.1.22 -port 22 -user INPUTT -pass 123456
start "2" /B td24.exe -file FBNK.ACCOUNT.STATEMENT -server 192.168.1.22 -port 22 -user INPUTT -pass 123456
start "3" /B td24.exe -file FBNK.GROUP.ACCOUNT -server 192.168.1.22 -port 22 -user INPUTT -pass 123456
start "4" /B td24.exe -file FBNK.CUSTOMER -server 192.168.1.22 -port 22 -user INPUTT -pass 123456
start "5" /B td24.exe -file FBNK.ACCOUNT.CREDIT.INT -server 192.168.1.22 -port 22 -user INPUTT -pass 123456
start "6" /B td24.exe -file FBNK.ACCOUNT.DEBIT.INT -server 192.168.1.22 -port 22 -user INPUTT -pass 123456
start "7" /B td24.exe -file F.DE.ADDRESS -server 192.168.1.22 -port 22 -user INPUTT -pass 123456
start "8" /B td24.exe -file FBNK.PD.BALANCES.HIST -server 192.168.1.22 -port 22 -user INPUTT -pass 123456
start "9" /B td24.exe -file FBNK.AC.LOCKED.EVENTS -server 192.168.1.22 -port 22 -user INPUTT -pass 123456

Usability

The files are readily usable in Excel. But of course, you can bulk load them to a relational database easily.

There’s plenty of code examples with php/mySql as the backend but I wished they had one with WCF as the application tier. With a little plumbing in WCF and some trial and error testing, I was able to get a small jqGrid application up and running.

If you are thinking about implementing jqGrid in your application with WCF, this post will include some code samples and hopefully help you speed your development process.

Online sample below. . .

You can see the ONLINE sample here.

The version of jqGrid I used was 3.4.4 and you can download it here. The jQuery library (v1.3.1) came with the download.

Setting Up WCF

jqGrid invokes REST-ful style services. In WCF (.NET Framework 3.5), we simply decorate the operation contract with the WebGet() attribute:

[OperationContract]
    [WebGet(
        UriTemplate = "OperationContract?param1={param1}&param2={param2}&param3={param3}",
        ResponseFormat = WebMessageFormat.Json
        )]
    jGridPagedResult GetHeader(
        string param1,
        int param2,
        string param3
        );

But jqGrid is very particular about the Uri parameters you’ll be invoking from javascript. Along with your own parameters to a opearation contract, you’ll have to make room for 6 additional parameters in your Uri string.

Your Uri string will look like this if your operation method requires one parameter (”Param1″):

http://localhost/ServiceName/OperationName?Param1=abc&nd=1246883438361&_search=false&rows=10&page=1&sidx=Uid&sord=asc

Or with no parameters:

http://localhost/ServiceName/OperationName?nd=1246883438361&_search=false&rows=10&page=1&sidx=Uid&sord=asc

The 6 parameters that jqGrid will attach to the Uri are:

nd (a timestamp value to force no caching on the server)
_search
rows
page
sidx (index to sort on)
sord

They are included to aid the development of a “Paging” mechanism in server-side code. To make jqGrid functional, we have to at least pay attention to “rows” and “page”. You may want to implement the other 4 parameters if your application requires sorting and search capabilities.

Although this post will only focus on the minimum, that is, the “rows” and “page” parameters, we still have to include them in the UriTemplate:

[OperationContract]
    [WebGet(
        UriTemplate = "OperationName?Param1={Param1}&Param2={Param2}&nd={nd}&_search={search}&rows={rows}&page={page}&sidx={sidx}&sord={sord}",
        ResponseFormat = WebMessageFormat.Json
        )]
    jGridPagedResult OperationName(
        string Param1,
        int Param2,
        string nd,
        string search,
        int rows,
        int page,
        string sidx,
        string sord
        );

The return type “jGridPagedResult” can be any DataContract that MUST include 4 DataMember’s and MUST have the names of “rows”,”records”,”total”,”page”. (You can actually convert the DataMember’s names to the expected names in javascript (ie. “MyRows” -> “rows”), but we’re going to keep it very straight forward here.)

[DataContract]
    public abstract class BindableObjects
    {
        // dummy abstract class
    }

    [DataContract]
    public class jGridPagedResult where T : BindableObjects
    {
        [DataMember]
        public List rows
        {get; set;}
        [DataMember]
        public int records
        { get; set; }
        [DataMember]
        public int total
        { get; set; }
        [DataMember]
        public int page
        { get; set; }
    }

    [DataContract]
    public class SomeType : BindableObjects
    {
        [DataMember]
        public string Column1{ get; set; }
    }

    [DataContract]
    public class AnotherType : BindableObjects
    {
        [DataMember]
        public int Column1 { get; set; }
        [DataMember]
        public string Column2 { get; set; }
    }

Paging using Linq

The remaining task for the WCF implementation is to populate the response object with an array of data. Typically, we’ll be tapping into some backend database. For this example, I’m just going to use LinqToSql to fetch some data in Sql Server 2005/2008.

Paging is done simply with a combination of Skip() and Take() extension methods. Prior to Linq, we would have to implement some dynamic sql using the “row_number() over (order by…” window function. The response basically returns an array of data, total number of records, total number of pages, and the page number (which is actually the page that was passed in thru the Uri).

jGridPagedResult GetCustomers(
        string nd,
        string search,
        int rows,
        int page,
        string sidx,
        string sord)
    {
        //We're only interested in the "rows" and "page" parameters passed into the method.
        //We'll ignore the "nd", "search", "sidx", "sord" parameters.

        List returnList = new List();
        NorthwindDataContext context = new NorthwindDataContext(new SqlConnection(ConfigurationManager.ConnectionStrings["NorthwindConnectionString"].ConnectionString));
        int total_pages = 0;
        int count = 0;

        count = context.Customers.Count(); 

        if (count > 0)
            total_pages = (int)Math.Ceiling((double)count / rows);
        else
            return null;

        if (page > total_pages) page = total_pages;

        var customers= from c in context.Customers
                      select c;

        if (page > 0)
            customers = customers.Skip((page - 1) * rows).Take(rows);

        foreach(var customer in customers)
        {
            returnList.Add(new Customer
            {
                CustomerID = customer.CustomerID,
                CompanyName = customer.CompanyName
            });
        }

        jGridPagedResult response =
            new jGridPagedResult{
                page = page,
                total = total_pages,
                rows = returnList,
                records = count
            };
        return response;
    }

Setting Up jqGrid

In the HTML page, add links to the jquery.js and jquery.jGrid.js libraries in the head tag. The jquery.jGrid.js actually is responsible for downloading a bunch of .js files. You can choose to download the compact (ie, “*-min.js) versions of the required files by updating “var minver = true;” in the jquery.jGrid.js file.

I noticed that the download list in jquery.jGrid.js does not include the 3 other required files for the grid to work properly: “jqDnR.js”, “jqModal.js”, and “jquery.tablednd.js”. They are in fact there as part of the zip file. Just add them in the “head” tag or include them in the download list of jquery.jGrid.js:

...
    { include: true, incfile: 'jqDnR.js', minfile: 'min/jqDnR-min.js' },
    { include: true, incfile: 'jqModal.js', minfile: 'min/jqModal-min.js' },
    { include: true, incfile: 'jquery.tablednd.js', minfile: 'min/jquery.tablednd-min.js' },
    ...

Next, in the body section, add a table and div element that will actually hold the jqGrid and paging control components.

Lastly, add the javascript that will create the jqGrid and paging controls AFTER the above HTML elements have been added in the body. Hope this post will help speed up your development with jqGrid and WCF!

(One final note is that the grid did not bind the data until I explicitly added the “jsonReader: {…” object in the jqGrid() constructor.)

var service_endpoint = "http://localhost/northwindservice.svc/";
$(document).ready(function() {
    $("#customers").jqGrid({
        url: service_endpoint + "GetCustomers?"
        datatype: "json",
        colNames: ['CustomerID', 'CompanyName'],
        colModel: [
            { name: 'CustomerID', index: 'CustomerID', width: 60, align: "right" },
            { name: 'CompanyName', index: 'CompanyName', width: 120, sortable: false }
        ],
        pager: $('#pager1'),
        rowNum: 10,
        rowList: [10, 20, 30],
        imgpath: 'themes/steel/images',
        sortname: 'ProcessId',
        viewrecords: true,
        sortorder: "asc",
        jsonReader: {
            root: "rows",
            page: "page",
            total: "total",
            records: "records",
            repeatitems: false,
            id: "CustomerID"
        },
        caption: "Northwind Customers"
    }).navGrid('#pager1', { edit: false, add: false, del: false, view: false, refresh: false, search: false });

The above implementaion does not support message level encryption. Since Silverlight 2 only supports BasicHttpBinding, WS-* security features like message encryption and digital signing with X.509 certicates are not available.

However, Silverlight 2 does support symmetric key (”shared secret”) encryption using AES algorithm. Here is a descriptive series of articles on the topic. With a little bit of plumbing on the WCF service side, it is possible to create a custom authentication and message encryption security architecture for Silverlight 2.

Online sample below. . .

You can check out the ONLINE DEMO.

Router Service

At the heart of this project is the router service. It acts as the gatekeeper to any WCF service calls made by the Silverlight client. It’s job is to intercept and decide what to do with the message. An excellent article on how to implement a WCF router can be found here.

An important take-away from the article is that the channel dispatcher allows for one and only one operation to receive ANY message if the “Action” or “Reply” cannot be mapped to any operation contracts at that endpoint. That one operation needs to be assigned a “*” value to the Action and Reply attribute as follows:

[ServiceContract]
    public interface IRouterService
    {
        [OperationContract(Action = "*", ReplyAction = "*")]
        Message ProcessMessage(Message request_message);
    }

The authentication process can be summarized as follows:

1. The Silverlight application calls the Authentication Service VIA the Router.
2. The Router intercepts and forwards the message to the Authentication Sevice.
3. Upon receiving a response, the Router inspects the message to check the logon result. If sucessful, it will create a session id and a symmetric key and store the information in a Cache Backing Store (in memory or database).
4. The session id, symmetric key, and expiration data is injected as additional headers of the response message to the client application if the logon was successful.

The diagram below visualizes the authentication workflow:

Once authenticated, the Silverlight client can retrieve the session id and symmetric key from the message headers in the response. In any subsequent remote calls to any WCF service, the Silverlight client will include the session id in the request message header and will use the symmetric key to encrypt the request.

The message encryption process can be summarized as follows:

1. The Silverlight client adds the session id given to it by the Router to the request header.
2. The client also encrypts the request body with the symmetric key.
3. The client sends the message to the WCF service but again VIA the Router.
4. The Router intercepts the request and extracts the session id from the header. It then queries the Cache Backing Store to see if the session id exists. If the session id is valid, the Router will grab the symmetric key from the Backing Store.
5. The Router decrypts the request body using the symmetric key and forwards the message to the WCF service.
5. Once the Router receives a response from the WCF service, the Router encrypts the response body with the same key and forwards the message back to the Silverlight client.
6. The Silverlight client decrypts the message body with the symmetric key.

The diagram below visualizes the message encryption workflow:

As indicated above, the Router will inspect the action header and decide what to do with the message.

Func<Message, string, Message> ProcessAction;
Message Authenticate(
    Message request_message, 
    string endpoint_configuration) {
. . . }
Message SecureMessage(
    Message request_message, 
    string endpoint_configuration) {
. . . }
Message ForwardMessage(
    Message request_message, 
    string endpoint_configuration) {
. . . }

Depending on the content of the Action header, the Router will choose how the message will be fowarded to the ultimate WCF service.

public Message ProcessMessage(Message request_message)
{
    string operation_contract = 
        request_message.Headers.GetHeader<string>("Action", 
        "http://schemas.microsoft.com/ws/2005/05/addressing/none");
    string endpoint_configuration = "";

    if (operation_contract.ToLower().
    Contains("login"))
    {
        ProcessAction = Authenticate;
        endpoint_configuration = 
        "BasicHttpBinding_AuthenticationService";
    }
    else
    {
        // Message that requires security
        if (operation_contract.ToLower().
        Contains("some_operation_requiring_security"))
        {
            // Check if there is a valid session id in header
            try
            {
                string sessionId = 
                request_message.Headers.GetHeader<string>("SessionId", "");

                symmetric_key = (byte[])cacheManager.GetData(sessionId);
                if (symmetric_key == null)
                    throw new MessageHeaderException("Session Id does not exist or has expired.");
            }
            catch (MessageHeaderException messageHeaderException)
            {
                throw new MessageHeaderException(messageHeaderException.Message);
            }

            ProcessAction = SecureMessage;
            endpoint_configuration = 
            "BasicHttpBinding_IRequireSecurityService";
        };

        // Message that does not require security
        if (operation_contract.ToLower().
        Contains("some_operation_not_requiring_security"))
        {
            ProcessAction = ForwardMessage;
            endpoint_configuration = 
            "BasicHttpBinding_IDoesNotRequireSecurityService";
        };
    }
    return ProcessAction(request_message, endpoint_configuration);
}

Authenticate() Method

Message Authenticate(Message request_message, 
    string endpoint_configuration) 
{

Message response_message = null;

try
{
    using (ChannelFactory<IRouterService> factory = 
    new ChannelFactory<IRouterService>(endpoint_configuration))
    {
        factory.Endpoint.Behaviors.Add(new MustUnderstandBehavior(false));

        IRouterService proxy = factory.CreateChannel();
        using (proxy as IDisposable)
        {
        // Forward the message and intercept the response
        response_message = proxy.ProcessMessage(request_message);

        XElement elements = XElement.Parse(response_message.ToString());
        var body = 
        elements.Element("{http://schemas.xmlsoap.org/soap/envelope/}Body");
        string asp_ns = "{http://asp.net/ApplicationServices/v200}";

        var login_response = 
        from detail in body.Descendants(asp_ns + "LoginResponse")
            select new { LoginResult = detail.Element(asp_ns + "LoginResult") };

        if (login_response == null)
            throw new Exception("No response");

        byte[] session_key = null;
        string session_id = "";
        bool login_result = false;
        MessageHeader header = null;

        //Authenticated: issue a symmetric key 
        if (login_response.FirstOrDefault().
        LoginResult.Value == "true")
        {
            //Issue a new key
            String random_string = AesManagedExtensions.GetRandomString();
            session_key = 
            AesManagedExtensions.GetHashKey(random_string, random_string);
            session_id = Guid.NewGuid().ToString();

            //Cache the key
            CacheObject(session_id, session_key);

            login_result = true;
        }

        //Add the symmetric key, authentication result to the header
        header = MessageHeader.
        CreateHeader("SessionKey", "", session_key, false);
        response_message.Headers.Add(header);
        header = MessageHeader.
        CreateHeader("SessionId", "", session_id, false);
        response_message.Headers.Add(header);
        header = MessageHeader.
        CreateHeader("LoginResult", "", login_result, false);
        response_message.Headers.Add(header);
        header = MessageHeader.
        CreateHeader("CacheExpiration", "", cache_expiration_interval, false);
        response_message.Headers.Add(header);
        }
    }
}
catch (Exception ex)
{
    throw new CommunicationException(ex.Message);
}
    return response_message;
}

SecureMessage() Method

Message SecureMessage(Message request_message, 
    string endpoint_configuration)
{
    Message new_request_message = null;
    Message new_response_message = null;
    XmlWriter writer;
    XmlReader reader;
    MemoryStream memory_stream = new MemoryStream();
    MessageBuffer buffer = null;
    Message tmp_message = null;
    XElement body = null;

    Action DecryptRequest = () =>
    {

    // Make a copy of the message to avoid 
    // "... message has been read error..."
    buffer = request_message.CreateBufferedCopy(Int32.MaxValue);

    //Load old message into XML
    tmp_message = buffer.CreateMessage();
    buffer.Close();

    //Transform the xmldocument
    body = tmp_message.GetBody<XElement>();

    var test = body.Descendants();
    body.Descendants().ToList().ForEach(d =>
    {
        // Decrypt the value for each xelement
        d.SetValue(d.Value.AesDecrypt(symmetric_key));
    });

    writer = XmlWriter.Create(memory_stream);
    body.Save(writer);
    writer.Flush();
    memory_stream.Position = 0;

    reader = XmlReader.Create(memory_stream);

    //create new request message with decrypted message
    new_request_message = Message.
        CreateMessage(request_message.Version, null, reader);
    new_request_message.Headers.
        CopyHeadersFrom(request_message);
    new_request_message.Properties.
        CopyProperties(request_message.Properties);
    };

    Action EncryptResponse = () =>
    {

    try
    {
        using (ChannelFactory<IRouterService> factory = 
            new ChannelFactory<IRouterService>(endpoint_configuration))
        {
            factory.Endpoint.Behaviors.Add(new MustUnderstandBehavior(false));

            IRouterService proxy = factory.CreateChannel();
            using (proxy as IDisposable)
            {
                // Forward decrypted request message and intercept the response
                Message response_message = proxy.ProcessMessage(new_request_message);

                buffer = response_message.CreateBufferedCopy(int.MaxValue);
                tmp_message = buffer.CreateMessage();
                buffer.Close();

                body = tmp_message.GetBody<XElement>();

                var result_element = body.Descendants().
                    FirstOrDefault(r => r.Name.LocalName.ToLower().
                        Contains("result"));
                var encrypted_content = 
                    result_element.ToString().AesEncrypt(symmetric_key);
                result_element.SetValue(encrypted_content);

                // Write to memory response with encrypted results
                memory_stream.SetLength(0);
                writer = XmlWriter.Create(memory_stream);
                body.Save(writer);
                writer.Flush();
                writer.Close();
                memory_stream.Position = 0;

                reader = XmlReader.Create(memory_stream);

                //Create new message from modified XML document
                new_response_message = Message.
                    CreateMessage(response_message.Version, null, reader);
                new_response_message.Headers.
                    CopyHeadersFrom(response_message);
                new_response_message.Properties.
                    CopyProperties(response_message.Properties);
            }
        }
    }
    catch (Exception ex)
    {
        throw new CommunicationException(ex.Message);
    }
    };

    DecryptRequest();
    EncryptResponse();

    return new_response_message;
}

And finally, here is the method that just forwards the message.

Message ForwardMessage(Message request_message, 
    string endpoint_configuration)
{
    try
    {
    using (ChannelFactory<IRouterService> factory = 
    new ChannelFactory<IRouterService>(endpoint_configuration))
    {
        factory.Endpoint.Behaviors.
        Add(new MustUnderstandBehavior(false));

        IRouterService proxy = factory.CreateChannel();
        using (proxy as IDisposable)
        {
            Message response_message = 
            proxy.ProcessMessage(request_message);
            return response_message;
        }
    }
    }
    catch (Exception ex)
    {
        throw new CommunicationException(ex.Message);
    }
}

I took a stab at implementing this component with WCF as the web service provider.

In the implemention, I incorporated paging, editing, and master/detail features of the component by following the samples. After updating the CSS, I was up and running with an AJAX-enabled grid formatted application.

You can see the online demo here.

You can see the online demo here.

You can see the online demo here.

Some Math

Although the object may seem to move along a curve, it is actually performing a lot of small incremental linear TranslateTransform animations. To calculate all the points between a start and end point along a curve, you need to perform what mathematisians call interpolation or “curve fitting.” I came across a great article on doing exactly this for ActionScript and implemented the same calculation method for my project.

void CalculateNextBezierSegmentPoint()
{
    posx = Math.Pow(counter, 3) * (anchor2.X + 3 * (control1.X - control2.X) - anchor1.X)
       + 3 * Math.Pow(counter, 2) * (anchor1.X - 2 * control1.X + control2.X)
       + 3 * counter * (control1.X - anchor1.X) + anchor1.X;

    posy = Math.Pow(counter, 3) * (anchor2.Y + 3 * (control1.Y - control2.Y) - anchor1.Y)
        + 3 * Math.Pow(counter, 2) * (anchor1.Y - 2 * control1.Y + control2.Y)
        + 3 * counter * (control1.Y - anchor1.Y) + anchor1.Y;
}

The variables “anchor1″ and “anchor2″ are the start and end points. The variables “control1″ and “control2″ are the control points of the cubic bezier curve. This resembles the path markup syntax in Silverlight for defining a cubic bezier segment: “C control1, control2, anchor2″. The count variable is a fraction (ie, 0.01, 0.2, etc) and is very important not only in the calculation of the incremental data points but will also serve as the checkpoint as to when to stop calculating once we have reached the end point (anchor2) as we’ll see shortly.

Parsing Path Markup

The 3 irregular ellipses in the above image is made of 6 bezier curve segments as defined below.

const string path_markup = "M 85,135 C 80 ,0 235,0 285,135 C 345,350 750,450 545,175 C365,0 705,0 715,125 C735,250 570,250 515,135 C 425,0 125,0 285,160 C 500,400 110,450 85,135";

There are various ways you can implement a method to parse a path markup. My approach was to use regular expressions and some Linq expressions to arrive at a sequence of data points. For this project, I will only look for a start point “M” and cubic bezier segments “C”. But you can easily change the regular expression to return more matches like “Q” for a quadratic bezier segment or “A” for an ellipse. (Just remember to impement the logic to handle those type of path segments.)

I will perform 2 regular expression searches. The first is for a path segment markup: “C 80,0 235,0 285,135″. If I find matches for a path segment, I perform a second regular expression search for groups of data points within the path segment: “80,0″, “235,0″; “285,135″. Once I have a sequence of data points, I will queue them up.

void QueuePathSegments(string path_markup)
{
    // only parsing for cubic bezier segments for now...
    string get_control_points_expression = @"\s*(-?\d*(\.\d*)?\s*,\s*-?\d*(\.\d*)?\s*)";
    string get_curve_commands_expression = string.Format(@"([MmCc]{0}{{1,3}})", get_control_points_expression);

    var curve_commands_matches = from Match curve_commands in Regex.Matches(path_markup, get_curve_commands_expression)
                                 select curve_commands;

    foreach (Match curve_command in curve_commands_matches)
    {
        var points =
            from control_point in
                (from Match control_points in
                     Regex.Matches(curve_command.Value, get_control_points_expression)
                 select control_points)
            select control_point.Value.Replace(" ", "");

        // Start Point "M"
        if (curve_command.Value.StartsWith("m", StringComparison.InvariantCultureIgnoreCase))
        {
            string[] coordinates = points.FirstOrDefault().Split(',');

            BezierSegment bezier_segment = new BezierSegment();
            bezier_segment.Point3 = new Point() { X = Double.Parse(coordinates[0].Trim()), Y = Double.Parse(coordinates[1].Trim()) };

            path_segments.Enqueue(bezier_segment);
        }

        // Cubic Bezier Point "C"
        if (curve_command.Value.StartsWith("c", StringComparison.InvariantCultureIgnoreCase))
        {
            int point_counter = 0;
            BezierSegment bezier_segment = new BezierSegment();

            points.ToList().ForEach(p =>
            {
                string[] coordinates = p.Split(',');

                switch (point_counter)
                {
                    case 0:
                        bezier_segment.Point1 = new Point() { X = Double.Parse(coordinates[0].Trim()), Y = Double.Parse(coordinates[1].Trim()) };
                        break;
                    case 1:
                        bezier_segment.Point2 = new Point() { X = Double.Parse(coordinates[0].Trim()), Y = Double.Parse(coordinates[1].Trim()) };
                        break;
                    case 2:
                        bezier_segment.Point3 = new Point() { X = Double.Parse(coordinates[0].Trim()), Y = Double.Parse(coordinates[1].Trim()) };
                        break;
                }

                point_counter++;
            });
            path_segments.Enqueue(bezier_segment);
        }
    }
}

Processing the Queue

Once the path segments are queued up, I’ll just create a routine to loop thru the queue and perform an animation for each path segment. For each path segment in the queue, the second anchor point becomes the first anchor point of the path segment. When one path segment has been processed, I’ll signal an event to fetch another path segemnt to process.

The CalculateNextBezierSegmentPoint() function that does the interpolation will now be passed as a variable to an “Animate” method.

void Page_Loaded(object sender, RoutedEventArgs e)
{   
    this.one_animation_completed_event += new EventHandler(delegate { LookForSegmentToAnimate(); });
}

void LookForSegmentToAnimate()
{
    if (path_segments.Count > 0)
    {
        // start one animation
        StartOneAnimation();
    }
    else
    {
        // signal all animations are done
        if (all_animations_completed_events != null)
            all_animations_completed_events(this, new EventArgs());
    }
}

void StartOneAnimation()
{
    // dequeue and set global control points variables
    PathSegment path_segment = path_segments.Dequeue();

    if (path_segment is BezierSegment)
    {
        var bezier_segemnt = path_segment as BezierSegment;
        control1 = bezier_segemnt.Point1;
        control2 = bezier_segemnt.Point2;
        anchor2 = bezier_segemnt.Point3;

        Action calculate_path_segment_point = CalculateNextBezierSegmentPoint;
        Animate(calculate_path_segment_point);
    }   
}

Performing the Animation

As for the “Animate” method, I need to create a routine that creates a bunch (say, about 100) of TranslateTransform animations that move the object in small steps from one anchor point to the next. When the Animate method has processed a pre-determined number of TranslateTransform animations (in this case, 100), it will signal an event that all animations for a given path segment has finished and that event will be handled by the LookForSegmentToAnimate() as described above.

// This UIElement will move along the path
MovablePanel movable_panel = new MovablePanel();

// Variables used as discrete set of points to define a bezier curve for interpolation
Point anchor1 = new Point(0, 0);
Point control1 = new Point(0, 0);
Point control2 = new Point(0,0);
Point anchor2 = new Point(0,0);

// Variables used for interpolation (curve fitting) calculation
const int step_size = 100;
Double counter = 0.0;
Double posx, posy;

void Animate(Action calculate_path_segment_point)
{
    calculate_path_segment_point();

    movable_panel.TranslateToPoint = new Point(posx, posy);
    storyboard = new Storyboard();

    storyboard.Completed += delegate
    {
        //storyboard = null;
        storyboard.Stop();
        storyboard.Children.Clear();
        counter += (1.0 / step_size);
        if (counter > 1)
        {
            // the last point of an animation becomes the first point of the next animation
            anchor1 = new Point(posx, posy);
            // need to reset counter for next animation block
            counter = 0;
            // signal archor2 point has been reached and animation is done
            if (one_animation_completed_event != null)
                one_animation_completed_event(this, new EventArgs());
        }
        else
        {
            Animate(calculate_path_segment_point);
        }
    };

    BuildTranslateTransformStoryboard(storyboard, movable_panel, movable_panel.OffsetPoint, step_size);
    storyboard.Begin();
}

You may notice that I am actually moving something called a “movable_panel”. It derives from ItemsControl so you can add any UIElement to the container and all objects within the container will appear to move along the path. The “TranslateToPoint” property is a DependencyProperty which calculates a relative Point property from a given container like a Grid or ItemsControl which is explained more in detail in my blog on a custom hit test.

Finally, here is the complete code.

MovablePanel.cs

public class MovablePanel : ItemsControl
{
public MovablePanel() 
{
    TransformGroup transformgroup = new TransformGroup();
    transformgroup.Children.Add(new TranslateTransform());
    this.RenderTransform = transformgroup;
}

public Point StartPosition { get; set; }  // sets the initial position of object; will be (0,0) by default if not set
public Point OffsetPoint { get; set; }  // this property is updated by the dependency property TranslateToPoint; translate animation will use this value

#region "Dependency Objects"

public static readonly DependencyProperty TranslateToPointProperty = DependencyProperty.Register("TranslateToPoint", typeof(Point), typeof(MovablePanel), new PropertyMetadata(new PropertyChangedCallback(OnTranslateToPointPropertyChanged)));

public Point TranslateToPoint
{
    get { return (Point)GetValue(TranslateToPointProperty); }
    set { SetValue(TranslateToPointProperty, value); }
}

static void OnTranslateToPointPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
    var ui_element = d as MovablePanel;
    var newPoint = (Point)e.NewValue;

    var offsetX = newPoint.X - ui_element.StartPosition.X;
    var offsetY = newPoint.Y - ui_element.StartPosition.Y;

    ui_element.OffsetPoint = new Point(offsetX, offsetY);
}

#endregion   
}

Page.xaml.cs

Variables

// This UIElement will move along the path
MovablePanel movable_panel = new MovablePanel();

// You can substitute SpinAnimation with any UIElement derived object
SpinAnimation animation_to_move = new SpinAnimation();

// Variables used as discrete set of points to define a bezier curve for interpolation
Point anchor1 = new Point(0, 0);
Point control1 = new Point(0, 0);
Point control2 = new Point(0, 0);
Point anchor2 = new Point(0, 0);

// Variables used for interpolation (curve fitting) calculation
const int step_size = 100;
Double counter = 0.0;
Double posx, posy;

// Variables used in project to animate object along a path
const string path_markup = "M 85,135 C 80 ,0 235,0 285,135 C 345,350 750,450 545,175 C365,0 705,0 715,125 C735,250 570,250 515,135 C 425,0 125,0 285,160 C 500,400 110,450 85,135";
Storyboard storyboard;
Queue<PathSegment> path_segments = new Queue<PathSegment>();
public event EventHandler all_animations_completed_events;
public event EventHandler one_animation_completed_event;

EventHandlers

public Page()
{
    InitializeComponent();
    this.Loaded += new RoutedEventHandler(Page_Loaded);
}

void Page_Loaded(object sender, RoutedEventArgs e)
{
    // Add any UIElement to the moving panel and add the moving panel to the layout
    this.LayoutRoot.Children.Add(movable_panel);
    movable_panel.Items.Add(animation_to_move);

    this.one_animation_completed_event += new EventHandler(delegate { LookForSegmentToAnimate(); });
    this.all_animations_completed_events += new EventHandler(OnAllAnimationsCompletedAlongPath);

    //Parse some path markup syntax and queue it up for animating
    QueuePathSegments(path_markup);

    //Start the animating along the path defined above
    StartOneAnimation();
}

void OnAllAnimationsCompletedAlongPath(object sender, EventArgs e)
{
    // queue up the bezier segments again, and take out first data point "M"       
    QueuePathSegments(path_markup);
    path_segments.Dequeue();
    StartOneAnimation();
}

Parsing Path Markup

void QueuePathSegments(string path_markup)
{
    // only parsing for cubic bezier segments for now...
    string get_control_points_expression = @"\s*(-?\d*(\.\d*)?\s*,\s*-?\d*(\.\d*)?\s*)";
    string get_curve_commands_expression = string.Format(@"([MmCc]{0}{{1,3}})", get_control_points_expression);

    var curve_commands_matches = from Match curve_commands in Regex.Matches(path_markup, get_curve_commands_expression)
                                 select curve_commands;

    foreach (Match curve_command in curve_commands_matches)
    {
        var points =
            from control_point in
                (from Match control_points in
                     Regex.Matches(curve_command.Value, get_control_points_expression)
                 select control_points)
            select control_point.Value.Replace(" ", "");

        // Start Point "M"
        if (curve_command.Value.StartsWith("m", StringComparison.InvariantCultureIgnoreCase))
        {
            string[] coordinates = points.FirstOrDefault().Split(',');

            BezierSegment bezier_segment = new BezierSegment();
            bezier_segment.Point3 = new Point() { X = Double.Parse(coordinates[0].Trim()), Y = Double.Parse(coordinates[1].Trim()) };

            path_segments.Enqueue(bezier_segment);
        }

        // Cubic Bezier Point "C"
        if (curve_command.Value.StartsWith("c", StringComparison.InvariantCultureIgnoreCase))
        {
            int point_counter = 0;
            BezierSegment bezier_segment = new BezierSegment();

            points.ToList().ForEach(p =>
            {
                string[] coordinates = p.Split(',');

                switch (point_counter)
                {
                    case 0:
                        bezier_segment.Point1 = new Point() { X = Double.Parse(coordinates[0].Trim()), Y = Double.Parse(coordinates[1].Trim()) };
                        break;
                    case 1:
                        bezier_segment.Point2 = new Point() { X = Double.Parse(coordinates[0].Trim()), Y = Double.Parse(coordinates[1].Trim()) };
                        break;
                    case 2:
                        bezier_segment.Point3 = new Point() { X = Double.Parse(coordinates[0].Trim()), Y = Double.Parse(coordinates[1].Trim()) };
                        break;
                }

                point_counter++;
            });
            path_segments.Enqueue(bezier_segment);
        }
    }
}

void CalculateNextBezierSegmentPoint()
{
    posx = Math.Pow(counter, 3) * (anchor2.X + 3 * (control1.X - control2.X) - anchor1.X)
       + 3 * Math.Pow(counter, 2) * (anchor1.X - 2 * control1.X + control2.X)
       + 3 * counter * (control1.X - anchor1.X) + anchor1.X;

    posy = Math.Pow(counter, 3) * (anchor2.Y + 3 * (control1.Y - control2.Y) - anchor1.Y)
        + 3 * Math.Pow(counter, 2) * (anchor1.Y - 2 * control1.Y + control2.Y)
        + 3 * counter * (control1.Y - anchor1.Y) + anchor1.Y;
}

Animation

#region "Animation Block"

Action<Storyboard, UIElement, Point, int> BuildTranslateTransformStoryboard = (storyboard, item, offset, step_size) =>
{
    var translationAnimationX = new DoubleAnimation() { SpeedRatio = 0.8, Duration = new Duration(TimeSpan.FromSeconds(1.0 / step_size)), To = offset.X, AutoReverse = false };
    storyboard.Children.Add(translationAnimationX);
    Storyboard.SetTargetProperty(translationAnimationX, new PropertyPath("(UIElement.RenderTransform).(TransformGroup.Children)[0].(TranslateTransform.X)"));

    Storyboard.SetTarget(storyboard, item);

    var translationAnimationY = new DoubleAnimation() { SpeedRatio = 0.8, Duration = new Duration(TimeSpan.FromSeconds(1.0 / step_size)), To = offset.Y, AutoReverse = false };
    storyboard.Children.Add(translationAnimationY);
    Storyboard.SetTargetProperty(translationAnimationY, new PropertyPath("(UIElement.RenderTransform).(TransformGroup.Children)[0].(TranslateTransform.Y)"));

    Storyboard.SetTarget(storyboard, item);
};

void Animate(Action calculate_path_segment_point)
{
    calculate_path_segment_point();

    movable_panel.TranslateToPoint = new Point(posx, posy);
    storyboard = new Storyboard();

    storyboard.Completed += delegate
    {
        storyboard.Stop();
        storyboard.Children.Clear();
        counter += (1.0 / step_size);
        if (counter > 1)
        {
            // the last point of an animation becomes the first point of the next animation
            anchor1 = new Point(posx, posy);
            // need to reset counter for next animation block
            counter = 0;
            // signal archor2 point has been reached and animation is done
            if (one_animation_completed_event != null)
                one_animation_completed_event(this, new EventArgs());
        }
        else
        {
            Animate(calculate_path_segment_point);
        }
    };

    BuildTranslateTransformStoryboard(storyboard, movable_panel, movable_panel.OffsetPoint, step_size);
    storyboard.Begin();
}

#endregion

Processing the Queue

#region "Queue animation block"

void LookForSegmentToAnimate()
{
    if (path_segments.Count > 0)
    {
        // start one animation
        StartOneAnimation();
    }
    else
    {
        // signal all animations are done
        if (all_animations_completed_events != null)
            all_animations_completed_events(this, new EventArgs());
    }
}

void StartOneAnimation()
{
    // dequeue and set global control points variables
    PathSegment path_segment = path_segments.Dequeue();

    if (path_segment is BezierSegment)
    {
        var bezier_segemnt = path_segment as BezierSegment;
        control1 = bezier_segemnt.Point1;
        control2 = bezier_segemnt.Point2;
        anchor2 = bezier_segemnt.Point3;

        Action calculate_path_segment_point = CalculateNextBezierSegmentPoint;
        Animate(calculate_path_segment_point);
    }                
}
#endregion
}

SpinAnimation.xaml

<UserControl x:Class="PathAnimation.SpinAnimation"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
    <Grid x:Name="LayoutRoot" Background="Transparent" Height="100" Width="100" HorizontalAlignment="Left" VerticalAlignment="Top">
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="5"/>
            <ColumnDefinition Width="90"/>
            <ColumnDefinition Width="5"/>
        </Grid.ColumnDefinitions>
        <Grid.RowDefinitions>
            <RowDefinition Height="5"/>
            <RowDefinition Height="90"/>
            <RowDefinition Height="5"/>
        </Grid.RowDefinitions>

        <Grid Grid.Column="1" Grid.Row="1">
            <Ellipse Height="50" Width="50" >
                <Ellipse.Fill>
                    <RadialGradientBrush GradientOrigin="0.75,0.75">
                        <GradientStop Offset="0.25" Color="White"/>
                        <GradientStop x:Name="FinalOffset" Offset="1.0" Color="DarkGoldenrod"/>
                    </RadialGradientBrush>
                </Ellipse.Fill>
            </Ellipse>
            
            <Path x:Name="pathMarkup" StrokeDashArray="53,0.75" StrokeDashOffset="0" 
            StrokeEndLineCap="Flat" StrokeStartLineCap="Flat" StrokeThickness="5"
            HorizontalAlignment="Center" VerticalAlignment="Center"  Stretch="UniformToFill"                   
            Data="M 0,80 A 40,40 0 0 0 80,0 A 40,40 0 0 0 0,80">
                <Path.Stroke>
                    <LinearGradientBrush StartPoint="0.5,0" EndPoint="0.5,1">
                        <GradientStop Color="DarkGoldenrod" Offset="0" />
                        <GradientStop Color="White" Offset="1"/>
                    </LinearGradientBrush>
                </Path.Stroke>
                <Path.RenderTransform>
                        <MatrixTransform>
                            <MatrixTransform.Matrix>
                                <Matrix M11="1" M12="0.5" M21="0" M22="0.5" OffsetX="0" OffsetY="0"/>                                
                            </MatrixTransform.Matrix>
                        </MatrixTransform>                    
                </Path.RenderTransform>
            </Path>
            <TextBlock Text="Loading" HorizontalAlignment="Center" VerticalAlignment="Center" Foreground="Bisque"/>
        </Grid>
    </Grid>
</UserControl>

Page.xaml

<UserControl x:Class="PathAnimation.Page"
     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
    xmlns:local="clr-namespace:PathAnimation;assembly=PathAnimation"
    Width="1000" Height="600">
    
    <Grid x:Name="LayoutRoot" Background="Black" HorizontalAlignment="Center" VerticalAlignment="Center" Width="900" Height="500">
        <Path Stretch="None"  StrokeDashOffset="2000" StrokeEndLineCap="Triangle" StrokeStartLineCap="Round" StrokeThickness="5" HorizontalAlignment="Left" Margin="10,20,0,0" x:Name="path" VerticalAlignment="Top"  
         Data="M 85,135 C 80,0 235,0 285,135 C 345,350 750,450 545,175 C365,0 705,0 715,125 C735,250 570,250 515,135 C 425,0 125,0 285,160 C 500,400 110,450 85,135" 
              Visibility="Visible"
              >
            <Path.Stroke>
                <LinearGradientBrush StartPoint="0.5,0" EndPoint="0.5,1">
                    <GradientStop Color="DarkGoldenrod" Offset="0" />
                    <GradientStop Color="White" Offset="1"/>
                </LinearGradientBrush>
            </Path.Stroke>        
        </Path>
    </Grid>    
</UserControl>

Here’s my interpretation of a sortable list implementation, that is more visually appealing and suitable for a menu component.

You can check out the online demo here.

The implementation basically involves switching the positions of 2 sortable objects. The process of switching positions will be accomplished by creating a Translate animation for each object. Finally, I need a way to check whether the overlapping objects should change positions. For example, if the dragging element has just a hair on an hovered object, that does not qualify as an exchange. So, I’ll have to calculate when a dragging object has more than 50% of its area on top of the hovered object and invoke the animation when it happens.

Let’s define a layout boundary where a dragging element is free to roam. If a page is 900 x 600, the dragging element may only be limited to roam in a 225 x 250 area of that space. I’ll call this the “DroppableRoot” and it’ll derive ItemsControl. Within the 225 x 250 Control, I need to present to the user some visual that “groups” a bunch of sortables. This could be another ItemsControl that is 165 x 200 and differs in background color. And I’ll call this the “DroppablePanel”. The XAML looks like this.

<UserControl x:Class="CustomHitTest.Page"
    xmlns="http://schemas.microsoft.com/client/2007" 
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
    xmlns:local="clr-namespace:CustomHitTest;assembly=CustomHitTest"
    Width="900" Height="600">

    <Grid Background="White">
        
        <local:DroppableRoot x:Name="DroppableRoot" Width="225" Height="250" >
            <Grid Margin="0" HorizontalAlignment="Center">
                <Grid.ColumnDefinitions>
                    <ColumnDefinition Width="192"/>
                </Grid.ColumnDefinitions>

                <Grid.RowDefinitions>
                    <RowDefinition Height="Auto"/>
                    <RowDefinition Height="230"/>
                </Grid.RowDefinitions>

                <TextBlock Text="Try Reordering the Sortables"  FontSize="9" Foreground="DarkSeaGreen" Grid.Column="0" Grid.Row="0" HorizontalAlignment="Center" />
                <local:DroppablePanel Width="165" Height="200" Grid.Column="0" Grid.Row="1">
                </local:DroppablePanel>
            </Grid>
        </local:DroppableRoot>
    </Grid>
</UserControl>

The sortables will derive ContentControl and will require a TranslateTransform object for animating movements. The sortables in this project will be called “DroppableObject”.

public class DroppableObject : ContentControl
{
    TransformGroup transformGroup;
    TranslateTransform translateTransform;

    public DroppableObject()
    {
        if (!(this.RenderTransform is TransformGroup))
        {
            transformGroup = new TransformGroup();
            translateTransform = new TranslateTransform();
            transformGroup.Children.Add(translateTransform);
            this.RenderTransform = transformGroup;
        }
    }
}

Next, I’ll need to make the DroppableObject capable of being dragged and dropped. There are basically 2 ways of implementing dragging and dropping. One is to use absolute positioning using the Canvas.Top and Canvas.Left properties, or in the case of this project, relative positioning using TranslateTransform.

The following properties are added to the DroppableObject and are pretty standard whether your implementation go the absolute or relative positioning path. (There are plenty of articles written on dragging/dropping and I won’t review the topic here. However, the complete code at the end of the article will include the relative-positioning drag/drop implementation for this project.)

The lone property that stands out is the “OffsetPoint” property.

//signals that mouse events are being captured
public bool IsDragging { get; set; }
// indicates whether StartPosition has been established
public bool Initialized { get; set; } 
// where the object has been translated to
public Point CurrentPosition { get; set; }  
// when mouse is moving, this is stored and compared against run-time mouse position to create an offset for the transform property of the dragging object
public Point LastMousePosition { get; set; }
// sets the initial position of object         
public Point StartPosition { get; set; }
// this property is updated by the dependency property TranslateToPoint; translate animation will use this value
public Point OffsetPoint { get; set; }

The OffsetPoint property will tell the Translate animation how far to go from the original starting position. Inituition would suggest that we should just capture the last location of an object and calculate the offset distance to the new location if we wanted to move an object from one point to another. Unfortunately, that plan will fail miserably. Actually, the calculation should be done against the very first location when the UIElement is loaded and updated in the Visual Tree because TranslateTransform object will always work against this fixed position during lifetime of the UIElement.

For example, if an UIElement’s location when first loaded in the Visual Tree was (10,10) and we then used a Translate animation to move it to (0,0), the TranslateTransform X and Y properties would be (-10,-10). Great, that makes sense. Now from (0,0), we will move the UIElement to (20,20), the TranslateTransform X and Y pair should just be (10,10) and NOT (20,20).

I decided to encapsulate the above logic as a Dependency Property of the DroppableObject. Notice that the callback uses the StartPosition property of the DroppableObject for calculating the OffsetPoint property.

public static readonly DependencyProperty TranslateToPointProperty = DependencyProperty.Register("TranslateToPoint", typeof(Point), typeof(UIElement), new PropertyMetadata(new PropertyChangedCallback(OnTranslateToPointPropertyChanged)));

public Point TranslateToPoint
{
    get { return (Point)GetValue(TranslateToPointProperty); }
    set { SetValue(TranslateToPointProperty, value); }
}

static void OnTranslateToPointPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
    if (d is DroppableObject)
    {
        var droppableObject = d as DroppableObject;
        var newPoint = (Point)e.NewValue;

        var offsetX = newPoint.X - droppableObject.StartPosition.X;
        var offsetY = newPoint.Y - droppableObject.StartPosition.Y;

        droppableObject.OffsetPoint = new Point(offsetX, offsetY);
    }
}

So when 2 DroppableObject’s decide to exchange places, the partial code looks like this.
(Note that the CurrentPosition property is the current location of the DroppableObject in the Visual Tree.)

. . .
droppableDragging.TranslateToPoint = droppableOver.CurrentPosition;
storyboard1 = new Storyboard();
BuildTranslateTransformStoryboard(storyboard1, droppableDragging, droppableDragging.OffsetPoint);
. . .
droppableOver.TranslateToPoint = droppableDragging.CurrentPosition;
storyboard2 = new Storyboard();
BuildTranslateTransformStoryboard(storyboard2, droppableOver, droppableOver.OffsetPoint);
. . .

Custom Hit Test
Now that we’ve determined how the sortables will exchange positions within the Visual Tree, we need to implement the logic for when these animations will actually take place. In a drag/drop implementation, we need to handle three types of mouse events: MouseMove, MouseLeftButtonUp, and MouseLeftButtonDown. The MouseMove handler is where all the heavy lifting takes place.

CurDroppableObject.MouseMove += new MouseEventHandler(DroppableObjectMouseEventHandler);
CurDroppableObject.MouseLeftButtonUp += new MouseButtonEventHandler(DroppableObjectMouseLeftButtonUp);
CurDroppableObject.MouseLeftButtonDown += new MouseButtonEventHandler(DroppableObjectMouseLeftButtonDown);

As previously discussed, I want to keep the dragging element within the boundaries of the DroppableRoot element because its only has relevance witin this scope. To prevent the user from dragging an element beyond the DroppableRoot, I’m going to compare the top and left corner of the dragging element relative to the top and left corner of the DroppableRoot. The difference of the 2 coordinates is my offset. Comparing the Top-Left corner of the DroppableRoot and the Top-Left corner of an UIElement is the primary technique for the custom hit test for this project.

void DroppableObjectMouseEventHandler(object sender, MouseEventArgs e)
{
    if (sender == null) return;

    if (!storyboard1Active)
    {
        var item = sender as DroppableObject;

        if (item.IsDragging)
        {
            var transform = DroppableManager.GetTransformation<TranslateTransform>(item) as TranslateTransform;
            Point currentMousePosition = e.GetPosition(CurDroppableRoot);

            double deltaV = currentMousePosition.Y - item.LastMousePosition.Y;
            double deltaH = currentMousePosition.X - item.LastMousePosition.X;

            double newTop = deltaV + transform.Y;
            double newLeft = deltaH + transform.X;

            GeneralTransform gt = item.TransformToVisual(CurDroppableRoot);
            Point offset = gt.Transform(new Point(0, 0));

            if ((offset.Y <= CurDroppableRoot.ActualHeight - item.ActualHeight) && (offset.Y >= 0)
                &&
                (newLeft + item.Width <= CurDroppableRoot.ActualWidth) && (newLeft >= -(offset.X + item.ActualWidth)))
            {
                // the DroppableObject is within the boundaries of the DroppableRoot
                transform.X = newLeft;
                transform.Y = newTop;
                // further processing
                . . .
            }
        }
    }
}

We also want to add the effect of transparency when an object is being hovered or left by the dragging element. This cannot be done with MouseOver or MouseLeave of an element because the visual effect should be initialited by the dragging element and not the moving mouse pointer. So if I were to drag an element by it’s tail and the mouse pointer was pinning the bottom-right hand corner of the element, I would still expect to see the transparency effect if the dragging element’s top-left corner was over another element.

In order to calculate overlapping between 2 elements, I’ll also need the position of the element that’s being hovered relative to the DroppableRoot. The code is very straightforward, if the top-left corner of the dragging element is anywhere within the area of the element, an overlap has occured.

If we don’t take the dragging element’s height and width into consideration when determining the offset, we would be able to drag the element beyond the DroppableRoot’s boundaries.

The Translate animations will be invoked by a custom event which we’ll call “Collision” and the arguments it’ll carry is the element being dragged and the element that is being hovered.

public class CollisonElements
{
    public UIElement Element { get; set; }
    public UIElement CollidedElement { get; set; }
}

public event EventHandlerFor<CollisonElements> Collision;

So, I’ll add the following checkpoints to the DroppableObjectMouseEventHandler method.

if (Collision != null)
{
    UIElement elementCollided = null;
    DroppableObjectList.ForEach(d =>
    {
        var droppableOver = d as DroppableObject;
        if (!item.Equals(droppableOver))
        {
            GeneralTransform droppableOverTransform = droppableOver.TransformToVisual(CurDroppableRoot);
            Point droppableOverCoordinates = droppableOverTransform.Transform(new Point(0, 0));

            if (((offset.Y + (item.ActualHeight)) >= droppableOverCoordinates.Y && (offset.Y) <= droppableOverCoordinates.Y + droppableOver.ActualHeight)
               &&
               ((offset.X + (item.ActualWidth)) >= droppableOverCoordinates.X && (offset.X) <= droppableOverCoordinates.X + droppableOver.ActualWidth))
                {
                    droppableOver.Opacity = 0.3;
                }
                else
                {
                    droppableOver.Opacity = 1.0;
                }

            if (((offset.Y + (item.ActualHeight / 2)) >= droppableOverCoordinates.Y && (offset.Y + (item.ActualHeight / 2)) <= droppableOverCoordinates.Y + droppableOver.ActualHeight)
               &&
               ((offset.X + (item.ActualWidth / 2)) >= droppableOverCoordinates.X && (offset.X + (item.ActualWidth / 2)) <= droppableOverCoordinates.X + droppableOver.ActualWidth))
                {
                    elementCollided = droppableOver as UIElement;
                }
        }                                    
    });
   
    if (elementCollided != null) {
        item.Cursor = Cursors.Wait;
        CollisonElements collidedElements = new CollisonElements() { Element = item, CollidedElement = elementCollided };
        EventArgs<CollisonElements> args = new EventArgs<CollisonElements>(collidedElements);
        Collision(this, args);        
    }
}

Enter the DroppableManager

Wow, there seems to be a lot of stuff going on. There are differing camps on design patterns for Silverlight, but for this project I’ve decided to implement the “Model-View-Presenter” approach. The presenter is called the DroppableManager and it is not an observer but actively engages in all that’s going on.

Recall back when we created the DroppableRoot element in XAML, the class will also instantiate an instance of the DroppableManager class and pass itself to the whim of this class. The DroppableManager is responsible for grabbing the layout of the DroppableRoot and DroppablePanel, dynamically populating the DroppablePanel with DroppableObject’s, and monitoring the DroppableObject collection’s every move.

Finally, here’s the complete code.

DroppableManager.cs

public class DroppableManager 
{
    List<DroppableDataContextItem> droppableDataContextItemList;
    List<DroppableObject> DroppableObjectList = new List<DroppableObject>();
    List<DroppableObject> DroppedObjectList = new List<DroppableObject>();
    
    DroppableObject CurDroppableObject;        
    DroppablePanel CurDroppablePanel;

    public static DroppableRoot CurDroppableRoot;
    
    const String DroppableObjectPrefix = "DroppableObject";

    bool Initialized;
    
    // for animating droppableobjects
    bool storyboard1Active = false;
    bool storyboard2Active = false;       
    Storyboard storyboard1;
    Storyboard storyboard2;

    public event EventHandlerFor<CollisonElements> Collision;

    Action<List<DroppableDataContextItem>> SetDataContextList;
    Func<List<DroppableDataContextItem>, List<DroppableObject>> CreateDroppableObjectFromDataContextList;
    Action<List<DroppableObject>> SetDroppableActualPosition;

    public DroppableManager(FrameworkElement elementToManage)
    {
        //Collided element delegate
        this.Collision += new EventHandlerFor<CollisonElements>(DroppableManager_ElementsCollision);

        CurDroppableRoot = elementToManage as CustomHitTest.DroppableRoot;
        CurDroppableRoot.LayoutUpdated += delegate
        {
            if (CurDroppableRoot.IsInitialized){
                //this is called here because TransformToVisual will not be valid until layout has been actually updated
                SetDroppableActualPosition(DroppableObjectList);
                return;
            }

            // Generate the Visuals that can be dragged around
            SetDataContextList = (list) =>
            {
                list = new List<DroppableDataContextItem>()
                { 
                    new DroppableDataContextItem() { Name = "Customer" },
                    new DroppableDataContextItem() { Name = "Category" }, 
                    new DroppableDataContextItem() { Name = "Year" }
                };

                RecurseCollection(CurDroppableRoot.Items);
                
                CreateDroppableObjectFromDataContextList(list);
            };

            CreateDroppableObjectFromDataContextList = (list) =>
            {
                list.ForEach(a =>
                {
                    CurDroppableObject = new DroppableObject();
                    TextBlock tb = new TextBlock();
                    tb.Text = a.Name;
                    tb.FontSize = 12.0;
                    CurDroppableObject.Content = tb;

                    CurDroppablePanel.Items.Add(CurDroppableObject);
                    
                    CurDroppableObject.MouseMove += new MouseEventHandler(DroppableObjectMouseEventHandler);
                    CurDroppableObject.MouseLeftButtonUp += new MouseButtonEventHandler(DroppableObjectMouseLeftButtonUp);
                    CurDroppableObject.MouseLeftButtonDown += new MouseButtonEventHandler(DroppableObjectMouseLeftButtonDown);

                    DroppableObjectList.Add(CurDroppableObject);
                });

                return DroppableObjectList;
            };

            SetDroppableActualPosition = (droppableObjectList) =>
            {
                // We only need to get the positions of the droppable objects the first time
                if (!Initialized)
                {
                    droppableObjectList.ForEach(d =>
                    {
                        if (d is DroppableObject)
                        {
                            var item = d as DroppableObject;

                            if (item.Initialized) return;

                            GeneralTransform gt = item.TransformToVisual(CurDroppableRoot);
                            Point offset = gt.Transform(new Point(0, 0));

                            item.StartPosition = offset;
                            item.Initialized = true;
                        }
                    });
                    Initialized = true;
                }
            };

            SetDataContextList(droppableDataContextItemList);
            
            CurDroppableRoot.IsInitialized = true;
        };            
    }

    void RecurseCollection<T>(IEnumerable<T> collection)
    {
        foreach (T item in collection)
        {
            if (item is DroppablePanel)
                CurDroppablePanel = (item as DroppablePanel);
            
            if (item is Panel) 
                RecurseCollection((item as Panel).Children); 
        };
    }

    public DroppableManager()
    {   
        //Collided element delegate
        this.Collision += new EventHandlerFor<CollisonElements>(DroppableManager_ElementsCollision);
    }

    Action<Storyboard, UIElement, Point> BuildTranslateTransformStoryboard = (storyboard, item, offset) =>
    {
        var translationAnimationX = new DoubleAnimation() { SpeedRatio = 0.8, Duration = new Duration(TimeSpan.FromSeconds(0.6)), To = offset.X };
        storyboard.Children.Add(translationAnimationX);
        
        Storyboard.SetTargetProperty(translationAnimationX, new PropertyPath("(UIElement.RenderTransform).(TransformGroup.Children)[0].(TranslateTransform.X)"));
        Storyboard.SetTarget(storyboard, item);

        var translationAnimationY = new DoubleAnimation() { SpeedRatio = 0.8, Duration = new Duration(TimeSpan.FromSeconds(0.6)), To = offset.Y };
        storyboard.Children.Add(translationAnimationY);
        
        Storyboard.SetTargetProperty(translationAnimationY, new PropertyPath("(UIElement.RenderTransform).(TransformGroup.Children)[0].(TranslateTransform.Y)"));
        Storyboard.SetTarget(storyboard, item);
    };

    public static  T GetTransformation<T>(UIElement Element) {
        T translate = default(T);
        var renderTransform = Element.RenderTransform;
        if (renderTransform is TransformGroup) {
            TransformGroup transformGroup = (TransformGroup)renderTransform;
            foreach (var transform in transformGroup.Children) {
                if (transform is T)                    
                    translate = (T)(object)transform;                    
            }
        }
        return translate;
    }


    void DroppableObjectMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
    {
        var item = sender as DroppableObject;

        DroppableObjectList.ForEach(d =>
        {
            if (d is DroppableObject)
            {
                var droppable = d as DroppableObject;

                GeneralTransform gt = droppable.TransformToVisual(CurDroppableRoot);
                Point offset = gt.Transform(new Point(0, 0));
                droppable.CurrentPosition = offset;                    
            }
        });

        if (!storyboard1Active)
        {
            item.SetValue(Canvas.ZIndexProperty, 1000);
            item.lastMousePosition = e.GetPosition(CurDroppableRoot);
            item.isDragging = true;
            item.CaptureMouse();
            item.Cursor = Cursors.Hand;                
        }                        
    }  

    void DroppableObjectMouseEventHandler(object sender, MouseEventArgs e){

        if (sender == null) return;

        if (!storyboard1Active) {
            var item = sender as DroppableObject;

            if (item.isDragging) {

                var transform = DroppableManager.GetTransformation<TranslateTransform>(item) as TranslateTransform;
                Point currentMousePosition = e.GetPosition(CurDroppableRoot);
                
                double deltaV = currentMousePosition.Y - item.lastMousePosition.Y;
                double deltaH = currentMousePosition.X - item.lastMousePosition.X;                    
                
                double newTop = deltaV + transform.Y;
                double newLeft = deltaH + transform.X;
               
                GeneralTransform gt = item.TransformToVisual(CurDroppableRoot);
                Point offset = gt.Transform(new Point(0, 0));
                
                if ((offset.Y <= CurDroppableRoot.ActualHeight - item.ActualHeight) && (offset.Y >= 0) && (newLeft + item.Width <= CurDroppableRoot.ActualWidth) && (newLeft >= -(offset.X + item.ActualWidth)))
                {
                    transform.X = newLeft;
                    transform.Y = newTop;

                    if (Collision != null){

                        UIElement elementCollided = null;
                        DroppableObjectList.ForEach(d =>
                        {
                            var droppableOver = d as DroppableObject;
                            if (!item.Equals(droppableOver)){

                                GeneralTransform droppableOverTransform = droppableOver.TransformToVisual(CurDroppableRoot);
                                Point droppableOverCoordinates = droppableOverTransform.Transform(new Point(0, 0));

                                if (((offset.Y + (item.ActualHeight)) >= droppableOverCoordinates.Y && (offset.Y) <= droppableOverCoordinates.Y + droppableOver.ActualHeight)
                                   &&
                                   ((offset.X + (item.ActualWidth)) >= droppableOverCoordinates.X && (offset.X) <= droppableOverCoordinates.X + droppableOver.ActualWidth))
                                    {
                                        droppableOver.Opacity = 0.3;
                                    }
                                    else
                                    {
                                        droppableOver.Opacity = 1.0;
                                    }

                                if (((offset.Y + (item.ActualHeight / 2)) >= droppableOverCoordinates.Y && (offset.Y + (item.ActualHeight / 2)) <= droppableOverCoordinates.Y + droppableOver.ActualHeight)
                                   &&
                                   ((offset.X + (item.ActualWidth / 2)) >= droppableOverCoordinates.X && (offset.X + (item.ActualWidth / 2)) <= droppableOverCoordinates.X + droppableOver.ActualWidth))
                                    {
                                        elementCollided = droppableOver as UIElement;
                                    }
                            }                                    
                        });
                       
                        if (elementCollided != null) {
                            item.Cursor = Cursors.Wait;
                            CollisonElements collidedElements = new CollisonElements() { Element = item, CollidedElement = elementCollided };
                            EventArgs<CollisonElements> args = new EventArgs<CollisonElements>(collidedElements);
                            Collision(this, args);
                            
                        }
                    }
                }

                // Update position global variable
                item.lastMousePosition = currentMousePosition;                    
            }
            else {
                item.Cursor = Cursors.Hand;
            }
        }
    }

    void DroppableManager_ElementsCollision(object sender, EventArgs<CollisonElements> e)
    {
        // droppable hovered over by dragging object
        if (!storyboard2Active){
            
            var droppableOver = e.Data.CollidedElement as DroppableObject;
            var droppableDragging = e.Data.Element as DroppableObject;
            droppableDragging.isDragging = false;

            droppableOver.TranslateToPoint = droppableDragging.CurrentPosition;
            
            storyboard2 = new Storyboard();
            BuildTranslateTransformStoryboard(storyboard2, droppableOver, droppableOver.OffsetPoint);

            storyboard2.Completed += (o, ev) => {
                storyboard2Active = false;
                storyboard2 = null;
            };

            storyboard2.Begin();
            storyboard2Active = true;

            // droppable dragging
            if (!storyboard1Active){

                droppableDragging.TranslateToPoint = droppableOver.CurrentPosition;

                storyboard1 = new Storyboard();
                BuildTranslateTransformStoryboard(storyboard1, droppableDragging, droppableDragging.OffsetPoint);

                storyboard1.Completed += (o, ev) => {
                    storyboard1Active = false;
                    storyboard1 = null;

                    DroppableObjectList.ForEach(d =>{
                        d.Opacity = 1.0;
                        d.Cursor = null;
                    });
                };

                storyboard1.Begin();
                storyboard1Active = true;
            }
        }             
    }

    void DroppableObjectMouseLeftButtonUp(object sender, MouseButtonEventArgs e)
    {
        var item = sender as DroppableObject;

        item.Opacity = 1.0;

        GeneralTransform gt = item.TransformToVisual(CurDroppableRoot);
        Point offset = gt.Transform(new Point(0, 0));

        // compare with the object's current position:

        if ((item.isDragging)
            &&
            ((item.CurrentPosition.X - offset.X) != 0 || (item.CurrentPosition.Y - offset.Y) != 0))
        {
            if (!storyboard1Active){

                item.TranslateToPoint = item.CurrentPosition;

                storyboard1 = new Storyboard();

                BuildTranslateTransformStoryboard(storyboard1, item, item.OffsetPoint);
                storyboard1.Completed += (o, ev) =>
                {
                    storyboard1Active = false;
                    storyboard1 = null;
                };

                storyboard1.Begin();
                storyboard1Active = true;
            }
        }

        item.isDragging = false;
        item.lastMousePosition = new Point(0, 0);
        item.ReleaseMouseCapture();        
    }
    
}

DroppableObject.cs

[TemplateVisualState(Name = "Normal", GroupName = "GroupCommon")]
[TemplateVisualState(Name = "StateMouseOver", GroupName = "GroupCommon")]
public class DroppableObject : ContentControl
{   
    static DroppableRoot droppableRoot;
    
    TransformGroup transformGroup;
    TranslateTransform translateTransform;

    public DroppableObject()
    {
        this.DefaultStyleKey = typeof(DroppableObject);

        this.MouseEnter += new MouseEventHandler(DroppableObject_MouseEnter);
        this.MouseLeave += new MouseEventHandler(DroppableObject_MouseLeave);
        this.LayoutUpdated += new EventHandler(DroppableObject_LayoutUpdated);
        
        if (!(this.RenderTransform is TransformGroup))
        {
            transformGroup = new TransformGroup();
            translateTransform = new TranslateTransform();
            transformGroup.Children.Add(translateTransform);
            this.RenderTransform = transformGroup;
        }

        this.StartPosition = new Point(-1, -1);
    }

    public bool isDragging { get; set; }
    public Point lastMousePosition { get; set; }  // when mouse is moving, this is stored and compared against run-time mouse position to create an offset for the transform property of the dragging object        
    public Point StartPosition { get; set; }  // sets the initial position of object
    public Point CurrentPosition { get; set; }  // where the object has been translated to
    public bool Initialized { get; set; } // indicates whether StartPosition has been established
    public Point OffsetPoint { get; set; }  // this property is updated by the dependency property TranslateToPoint; translate animation will use this value

    string text = "";

    public string Text
    {
        get { return text; }
        set
        {
            if (this.Content == null)
            {
                TextBlock tb = new TextBlock();
                tb.Text = value;
                tb.FontSize = 12;
                this.Content = tb;
            }
        }
    }

    void DroppableObject_LayoutUpdated(object sender, EventArgs e){
        if (droppableRoot == null) droppableRoot = DroppableManager.CurDroppableRoot;
    }

    void DroppableObject_MouseLeave(object sender, MouseEventArgs e)
    {
        VisualStateManager.GoToState(this, "Normal", true);
    }

    void DroppableObject_MouseEnter(object sender, MouseEventArgs e)
    {
        VisualStateManager.GoToState(this, "MouseOver", true);
    }

    public static readonly DependencyProperty TranslateToPointProperty = DependencyProperty.Register("TranslateToPoint", typeof(Point), typeof(UIElement), new PropertyMetadata(new PropertyChangedCallback(OnTranslateToPointPropertyChanged)));

    public Point TranslateToPoint
    {
        get { return (Point)GetValue(TranslateToPointProperty); }
        set { SetValue(TranslateToPointProperty, value); }
    }

    static void OnTranslateToPointPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        if (d is DroppableObject){
            var droppableObject = d as DroppableObject;
            var newPoint = (Point)e.NewValue;

            var offsetX = newPoint.X - droppableObject.StartPosition.X;
            var offsetY = newPoint.Y - droppableObject.StartPosition.Y;

            droppableObject.OffsetPoint = new Point(offsetX, offsetY);
        }
    }
}

DroppableRoot.cs

public class DroppableRoot : ItemsControl
{
    public bool IsInitialized = false;
         
    public DroppableRoot() : base()
    {   
        this.DefaultStyleKey = typeof(DroppableRoot);
        DroppableManager droppableManager = new DroppableManager(this);
    }
}

DroppablePanel.cs

public class DroppablePanel : ItemsControl
{
    public DroppablePanel()
    {
        this.DefaultStyleKey = typeof(DroppablePanel);            
    }   
}

Common.cs

public delegate void EventHandlerFor<T>(object sender, EventArgs<T> args);

public class EventArgs<T> : EventArgs
{
    public T Data { get; private set; }
    public EventArgs(T data)
    {
        Data = data;
    }
}

public class CollisonElements
{
    public UIElement Element { get; set; }
    public UIElement CollidedElement { get; set; }
}

public class DroppableDataContextItem
{
    public string Name { get; set; }
}

Generic.xaml

<ResourceDictionary 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:view="clr-namespace:CustomHitTest;assembly=CustomHitTest"
    xmlns:vsm="clr-namespace:System.Windows;assembly=System.Windows"
    >

    <Style TargetType="view:DroppableRoot">
        <Setter Property="Template">
            <Setter.Value>
                <ControlTemplate TargetType="view:DroppableRoot">
                    <Border x:Name="RootElement" BorderBrush="Crimson" BorderThickness="1" CornerRadius="10" Height="{TemplateBinding Height}" Width="{TemplateBinding Width}" >
                        <Border.Background>
                            <LinearGradientBrush StartPoint="0.5,0" EndPoint="0.5,1">
                                <GradientStop Color="#333333" Offset="0" />
                                <GradientStop Color="WhiteSmoke" Offset="1" x:Name="FinalOffset"/>
                            </LinearGradientBrush>
                        </Border.Background>

                        <vsm:VisualStateManager.VisualStateGroups>
                            <vsm:VisualStateGroup x:Name="CommonStates">
                                <vsm:VisualStateGroup.Transitions>
                                    <vsm:VisualTransition To="Normal"  GeneratedDuration="0:0:1" />
                                    <vsm:VisualTransition To="Disabled" GeneratedDuration="0:0:0.8"/>
                                </vsm:VisualStateGroup.Transitions>
                                <vsm:VisualState x:Name="Normal"/>
                                <vsm:VisualState x:Name="Disabled">
                                    <Storyboard>
                                        <ColorAnimation Storyboard.TargetName="FinalOffset" Storyboard.TargetProperty="(GradientStop.Color)" To="Crimson" Duration="0:0:0.8"/>
                                        <DoubleAnimation Storyboard.TargetName="RootElement" Storyboard.TargetProperty="Opacity" From="1.0" To="0.55" Duration="0:0:0.8"/>
                                    </Storyboard>
                                </vsm:VisualState>
                            </vsm:VisualStateGroup>
                        </vsm:VisualStateManager.VisualStateGroups>

                        <ItemsPresenter Height="{TemplateBinding Height}" Width="{TemplateBinding Width}" x:Name="ItemsPresenter"/>
                    </Border>
                </ControlTemplate>
            </Setter.Value>
        </Setter>
    </Style>

    <Style TargetType="view:DroppablePanel">
        <Setter Property="HorizontalAlignment" Value="Center"/>
        <Setter Property="VerticalAlignment" Value="Center"/>
        <Setter Property="Template">
            <Setter.Value>
                <ControlTemplate TargetType="view:DroppablePanel">
                    <Border x:Name="RootElement" BorderBrush="Crimson" BorderThickness="1" CornerRadius="10" Height="{TemplateBinding Height}" Width="{TemplateBinding Width}">
                        <Border.Background>
                            <SolidColorBrush Color="AliceBlue"  x:Name="ColorOffset"/>
                        </Border.Background>
                        <vsm:VisualStateManager.VisualStateGroups>
                            <vsm:VisualStateGroup x:Name="CommonStates">
                                <vsm:VisualStateGroup.Transitions>
                                    <vsm:VisualTransition To="Normal"  GeneratedDuration="0:0:1" />
                                    <vsm:VisualTransition To="Disabled" GeneratedDuration="0:0:1"/>
                                </vsm:VisualStateGroup.Transitions>
                                <vsm:VisualState x:Name="Normal"/>
                                <vsm:VisualState x:Name="Disabled">
                                    <Storyboard>
                                        <ColorAnimation Storyboard.TargetName="ColorOffset" Storyboard.TargetProperty="Color" To="#333333" Duration="0:0:07"/>
                                    </Storyboard>
                                </vsm:VisualState>
                            </vsm:VisualStateGroup>
                        </vsm:VisualStateManager.VisualStateGroups>

                        <ItemsPresenter>
                        </ItemsPresenter>
                    </Border>
                </ControlTemplate>
            </Setter.Value>
        </Setter>
    </Style>

    <Style TargetType="view:DroppableObject">
        <Setter Property="Width" Value="85"/>
        <Setter Property="Height" Value="35"/>
        <Setter Property="Background" Value="Lavender"/>
        <Setter Property="HorizontalAlignment" Value="Center"/>
        <Setter Property="VerticalAlignment" Value="Center"/>
        <Setter Property="Margin" Value="0,2.5,0,2.5"/>
        <Setter Property="FontSize" Value="12"/>
        <Setter Property="Template">
            <Setter.Value>
                <ControlTemplate TargetType="view:DroppableObject">
                    <Grid x:Name="Root">
                        <vsm:VisualStateManager.VisualStateGroups>
                            <vsm:VisualStateGroup x:Name="CommonStates">
                                <vsm:VisualStateGroup.Transitions>
                                    <vsm:VisualTransition To="Normal"  GeneratedDuration="0:0:0.2" />
                                    <vsm:VisualTransition To="MouseOver" GeneratedDuration="0:0:0.2"/>
                                    <vsm:VisualTransition To="Disabled" GeneratedDuration="0:0:0.2"/>
                                </vsm:VisualStateGroup.Transitions>
                                <vsm:VisualState x:Name="Normal"/>
                                <vsm:VisualState x:Name="MouseOver">
                                    <Storyboard>
                                        <ColorAnimation Storyboard.TargetName="FinalOffset" Storyboard.TargetProperty="(GradientStop.Color)" To="Pink" Duration="0"/>
                                    </Storyboard>
                                </vsm:VisualState>
                                <vsm:VisualState x:Name="Disabled">
                                    <Storyboard>
                                        <DoubleAnimation Storyboard.TargetName="Body" Storyboard.TargetProperty="Opacity" From="1.0" To="0.45" Duration="0:0:0"/>
                                    </Storyboard>
                                </vsm:VisualState>
                            </vsm:VisualStateGroup>
                        </vsm:VisualStateManager.VisualStateGroups>

                        <Rectangle x:Name="Body"
                         Width="{TemplateBinding Width}"
                         Height="{TemplateBinding Height}"
                         Stroke="Purple" RadiusX="5" RadiusY="5"
                                   HorizontalAlignment="Left" VerticalAlignment="Top"
                                   >
                            <Rectangle.Fill>
                                <RadialGradientBrush GradientOrigin="0.25,0.25">
                                    <GradientStop Offset="0.25" Color="White"/>
                                    <GradientStop x:Name="FinalOffset" Offset="1.0" Color="Red"/>
                                </RadialGradientBrush>
                            </Rectangle.Fill>
                            <Rectangle.RenderTransform>
                                <TransformGroup>
                                    <TranslateTransform X="{TemplateBinding X}" Y="{TemplateBinding Y}"/>
                                </TransformGroup>
                            </Rectangle.RenderTransform>
                        </Rectangle>
                        <ContentPresenter Content="{TemplateBinding Content}"
                         HorizontalAlignment="Center"
                         VerticalAlignment="Center"
                         />
                    </Grid>
                </ControlTemplate>
            </Setter.Value>
        </Setter>
    </Style>
</ResourceDictionary>

Page.xaml

<UserControl x:Class="CustomHitTest.Page"
    xmlns="http://schemas.microsoft.com/client/2007" 
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
    xmlns:local="clr-namespace:CustomHitTest;assembly=CustomHitTest"
    Width="900" Height="600">

    <Grid Background="White">
        
        <local:DroppableRoot x:Name="DroppableRoot" Width="225" Height="250" >
            <Grid Margin="0" HorizontalAlignment="Center">
                <Grid.ColumnDefinitions>
                    <ColumnDefinition Width="192"/>
                </Grid.ColumnDefinitions>

                <Grid.RowDefinitions>
                    <RowDefinition Height="Auto"/>
                    <RowDefinition Height="230"/>
                </Grid.RowDefinitions>

                <TextBlock Text="Try Reordering the Sortables"  FontSize="9" Foreground="DarkSeaGreen" Grid.Column="0" Grid.Row="0" HorizontalAlignment="Center" />
                <local:DroppablePanel Width="165" Height="200" Grid.Column="0" Grid.Row="1">
                </local:DroppablePanel>
            </Grid>
        </local:DroppableRoot>
    </Grid>
</UserControl>

The visual looks like this:

To draw the wheel, I’m going to use the Path object and define Data property using the Path mini-language.

<UserControl x:Class="WaitAnimation.Page"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
    <Grid x:Name="LayoutRoot" Background="Black" Height="130" Width="130" >
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="20"/>
            <ColumnDefinition Width="90"/>
            <ColumnDefinition Width="20"/>
        </Grid.ColumnDefinitions>
        <Grid.RowDefinitions>
            <RowDefinition Height="20"/>
            <RowDefinition Height="90"/>
            <RowDefinition Height="20"/>
        </Grid.RowDefinitions>
        
        <Grid Grid.Column="1" Grid.Row="1">
        <Path x:Name="pathMarkup"  Fill="Black" StrokeDashArray="53,0.75" StrokeDashOffset="0" 
            StrokeEndLineCap="Flat" StrokeStartLineCap="Flat" StrokeThickness="5"
            HorizontalAlignment="Center" VerticalAlignment="Center" Stretch="UniformToFill"
            Data="M 0,80 A 40,40 0 0 0 80,0 A 40,40 0 0 0 0,80">            
            <Path.Stroke>
                <LinearGradientBrush StartPoint="0.5,0" EndPoint="0.5,1">
                    <GradientStop Color="DarkGoldenrod" Offset="0" />
                        <GradientStop Color="White" Offset="1"/>
                </LinearGradientBrush>
            </Path.Stroke>            
        </Path>
        <TextBlock Text="Loading" HorizontalAlignment="Center" VerticalAlignment="Center" Foreground="Bisque"/>
        </Grid>
    </Grid>
</UserControl>

Let’s take note on the circumference of the wheel. It is “Pi” (3.14159…) multiplied by the diameter of the circle.

My wheel, as defined in XAML, has a diameter of 80px but also a StrokeThickness of 5px so we’ll tack on an additonal 5px (not 10px as intuition would tell us) to the diameter.
The wheel’s circumference is about 270px (85px * 3.14).

The StrokeDashArray property defines a pattern of dashes and gaps of a Shape object like Path relative to the thickness of the StrokeThickness.

To completely fill a dash around the wheel, we’ll divide 270px by 5, which is 54px. But I want to leave a small gap that is almost equal to the StrokeThickness.

So we set our StrokeDashArray property to “53,0.75″ (dash value, gap value).

Let’s also check out the StrokeDashOffset property. This is actually the property that we will target in our animation that will give the wheel that spinning effect. MSDN defines it as the distance where our dash pattern (defined by StrokeDashArray) begins. We will set it to 0 initially.

Now we’re ready to add animation to the Path object. I want to make the animation flexible, that is, if I wanted to define 2 different types of animations for the same target, I should be allowed to define the animation, and then choose the animation that I want the Storyboard to use.
So I’ll simply declare a delegate that would allow me to add this functionality.

Func<UIElement, Timeline> DefineAnimationForWaitElement 
{ get; set; }

And I’m going to define two animations for my Path object. Note that the targeted PropertyPath is the “(Shape.StrokeDashOffset)” and the final value is “53″. As mentioned above, a value of 53 basically moves the StrokeDashOffset completely around the circumference one time.

Timeline Spin(UIElement item)
{
    var pathDashOffsetAnimation = new DoubleAnimationUsingKeyFrames();
    pathDashOffsetAnimation.KeyFrames.Add(new SplineDoubleKeyFrame() { Value = 0.0, KeyTime = KeyTime.FromTimeSpan(TimeSpan.FromSeconds(0.0)) });
    var keySpline = new KeySpline() { ControlPoint1 = new Point(0.25, 0.75), ControlPoint2 = new Point(0.75, 0.25) };
    pathDashOffsetAnimation.KeyFrames.Add(new SplineDoubleKeyFrame() { Value = 53.0, KeyTime = KeyTime.FromTimeSpan(TimeSpan.FromSeconds(1.35)), KeySpline = keySpline });
    Storyboard.SetTargetProperty(pathDashOffsetAnimation, new PropertyPath("(Shape.StrokeDashOffset)"));
    return pathDashOffsetAnimation;
}

Timeline SpinLinear(UIElement item)
{
    var pathDashOffsetAnimation = new DoubleAnimation() { SpeedRatio = 0.5, Duration = new Duration(TimeSpan.FromSeconds(1.0)), To = 53 };
    Storyboard.SetTargetProperty(pathDashOffsetAnimation, new PropertyPath("(Shape.StrokeDashOffset)"));
    return pathDashOffsetAnimation;
}

To choose between animations, I will assign the animation to the delegate that I had defined earlier and then invoke the delegate.
I like the fact that if I wanted to pass an animation definition from another project, I can just pass the function definition to the delegate, instead of having to access and create a new method in the main code.

UIElement element = this.pathMarkup;
if (DefineAnimationForWaitElement == null)
    DefineAnimationForWaitElement = Spin;

var timeLine = DefineAnimationForWaitElement(element);

The complete code looks like this.

public partial class Page : UserControl
{
    Storyboard WaitAnimationStoryboard = new Storyboard();
    Func<UIElement, Timeline> DefineAnimationForWaitElement { get; set; }

    public Page()
    {
        InitializeComponent();
        CreateWaitAnimation();
    }

    void CreateWaitAnimation()
    {
        UIElement element = this.pathMarkup;
        if (DefineAnimationForWaitElement == null)
            DefineAnimationForWaitElement = Spin;

        var timeLine = DefineAnimationForWaitElement(element);
        CreateStoryboardForWaitAnimation(element, timeLine);
    }

    void CreateStoryboardForWaitAnimation(UIElement item, Timeline animation)
    {
        WaitAnimationStoryboard.Stop();
        WaitAnimationStoryboard.Children.Clear();
        WaitAnimationStoryboard.Children.Add(animation);
        Storyboard.SetTarget(WaitAnimationStoryboard, item);
        WaitAnimationStoryboard.RepeatBehavior = RepeatBehavior.Forever;
        WaitAnimationStoryboard.Begin();
    }

    Timeline Spin(UIElement item)
    {
        var pathDashOffsetAnimation = new DoubleAnimationUsingKeyFrames();
        pathDashOffsetAnimation.KeyFrames.Add(new SplineDoubleKeyFrame() { Value = 0.0, KeyTime = KeyTime.FromTimeSpan(TimeSpan.FromSeconds(0.0)) });
        var keySpline = new KeySpline() { ControlPoint1 = new Point(0.25, 0.75), ControlPoint2 = new Point(0.75, 0.25) };
        pathDashOffsetAnimation.KeyFrames.Add(new SplineDoubleKeyFrame() { Value = 53.0, KeyTime = KeyTime.FromTimeSpan(TimeSpan.FromSeconds(1.35)), KeySpline = keySpline });
        Storyboard.SetTargetProperty(pathDashOffsetAnimation, new PropertyPath("(Shape.StrokeDashOffset)"));
        return pathDashOffsetAnimation;
    }

    Timeline SpinLinear(UIElement item)
    {
        var pathDashOffsetAnimation = new DoubleAnimation() { SpeedRatio = 0.5, Duration = new Duration(TimeSpan.FromSeconds(1.0)), To = 53 };
        Storyboard.SetTargetProperty(pathDashOffsetAnimation, new PropertyPath("(Shape.StrokeDashOffset)"));
        return pathDashOffsetAnimation;
    }
}

First, I’m going to create a class that sets and returns a List of some Type. Since I will instantiate this class in another AppDomain, this class must derive MarshallByRef. To make it easy for the calling program to invoke its methods, this class will also implement an interface. This interface exists in the same namespace of the calling and remote classes and is visible to both.

interface IParser<T> where T : class
{
        void Set_PENDING_PROCESSING_List();
        List<T> Get_PENDING_PROCESSING_List();
}

public class Parser: MarshalByRefObject, IParser<PENDING_PROCESSING> 
{
    List<PENDING_PROCESSING> _pending_processing_list = new List<PENDING_PROCESSING>();

    public Parser(string uploadPath, string file)
    {
            Set_PENDING_PROCESSING_List();
    }

    public void Set_PENDING_PROCESSING_List()
    {
            Thread.Sleep(5000);  //Implement actual code here.
    } 

    public List<PENDING_PROCESSING> Get_PENDING_PROCESSING_List()
    {
            return _pending_processing_list;
    }
}

I’ll need to create a manager class that queues up and assigns jobs to available threads. The assigned job creates an instance of the above class in another AppDomain and invokes one of its methods. The manager class will also be responsible for creatiing the new AppDomain and unloading it once all the jobs have finished processing.

First, let’s create a new AppDomain if it doesn’t exist in the manager class.

void CreateSandBox()
{
        if (AppDomain.CurrentDomain.FriendlyName != "SandBoxAppDomain")
                domain = AppDomain.CreateDomain("SandBoxAppDomain");
}

Next, I’ll nest a class inside of the manager that will be used hold job information. After creating a list of jobs, I’ll queue them up. Once they are queued, I will dequeue one job at a time until I’ve used up my available thread limit. For this application, we’ll just limit the thread count to 5.

class Tracker
{
          public Tracker(string fileName, bool archived) { this.FileName = fileName; this.Archived = archived; }
          public string FileName { get; set; }
          public bool Archived { get; set; }
}


int THREAD_POOL_SIZE = 5;
Queue<string> queue = new Queue<string>();
delegate string AsyncTryDoWork(string file, WorkflowType workflowType);

List<Tracker> TrackerList = new List<Tracker>() 
{ 
            new Tracker("File1.txt",false), 
            new Tracker("File2.txt",false),
            new Tracker("File3.txt",false),
            new Tracker("File4.txt",false),
            new Tracker("File5.txt",false),
            new Tracker("File6.txt",false),
            new Tracker("File7.txt",false),
            new Tracker("File8.txt",false),
            new Tracker("File9.txt",false),
            new Tracker("File10.txt",false),
            new Tracker("File11.txt",false)        
};
readonly object lockItem = new object();

void QueueWork()
{

        foreach (Tracker tracker in TrackerList)
            queue.Enqueue(tracker.FileName);
            
        int NumberToQueue = queue.Count < THREAD_POOL_SIZE ? queue.Count : THREAD_POOL_SIZE;

        lock (lockItem)
        {
                for (int assignment = 0; assignment < NumberToQueue; assignment++)
                {
                   string file = queue.Dequeue();
                   StartOneWork(file, WorkflowType.Upload, new AsyncTryDoWork(TryDoWork));
                }
        }
}

As a job is being dequeued, it will initiate an asynchronous method “TryDoWork”. This is the method that will instantiate the remote object in the new AppDomain that had been previously created. The method will pass the job information to this instance for processing.

void StartOneWork(string file, WorkflowType workflowType, AsyncTryDoWork asyncTryDoWork)
{
        lock (lockItem)
        {
                asyncTryDoWork.BeginInvoke(file, workflowType, new AsyncCallback(CallBackTryDoWork), asyncTryDoWork);                
        }                        
}

string TryDoWork(string file, WorkflowType workflowType)
{
        IParser<PENDING_PROCESSING> parser = 
                (IParser<PENDING_PROCESSING>)domain.CreateInstanceAndUnwrap(
                        "Sandbox.Interface", 
                        "Sandbox.Interface.Parser", 
                        true, 
                        BindingFlags.CreateInstance, 
                        null, 
                        new object[] { "", "" }, 
                        null, 
                        null, 
                        null);
        List<PENDING_PROCESSING> ldr = parser.Get_PENDING_PROCESSING_List();
            
        return file;
}

After the remote object has processed the job and the asynchronous method has called back, we’ll update the job list and mark the job completed and also go and check out the job queue to see if there are any more jobs to dequeue.

void CallBackTryDoWork(IAsyncResult result)
{
        AsyncTryDoWork asyncTryDoWork = (AsyncTryDoWork)result.AsyncState;
        string file = asyncTryDoWork.EndInvoke(result);

        lock (lockItem) 
        {
                TrackerList.ForEach(t => { if (t.FileName == file) { t.Archived = true; } });
        }
            LookForWork();
}

void LookForWork()
{
        lock (lockItem)
        {
                if (queue.Count > 0)
                {
                   uploadResetEventList.Add(new AutoResetEvent(false));
                   string file = queue.Dequeue();
                   StartOneWork(file, WorkflowType.Upload, new AsyncTryDoWork(TryDoWork));
                }
                else 
                {
                   if (!TrackerList.Exists( t => { return t.Archived == false; })) 
                   {
                     WorkIsDoneEventArgs e = new WorkIsDoneEventArgs(true);
                     OnWorkIsDone(e);
                   }
                }
        }  
}

Finally, when all jobs have been dequeued and there are no jobs to process, we’ll signal the main application to unload the new AppDomain.

public class WorkIsDoneEventArgs : EventArgs
{
          private bool _Completed = false;
          public bool Completed { get { return _Completed; } set { _Completed = value; } }
          public WorkIsDoneEventArgs(bool completed) { this.Completed = completed; }
}

public delegate void WorkIsDoneEventHandler(object sender, WorkIsDoneEventArgs e);
public event WorkIsDoneEventHandler workIsDoneEvent;

protected virtual void OnWorkIsDone(WorkIsDoneEventArgs e) 
{
        WorkIsDoneEventHandler handler = workIsDoneEvent;
        if (handler != null)
        {   
            handler(this, e);
            AppDomain.Unload(domain);
        }
}

The completed code looks like this.

interface IParser<T> where T : class 
{
    void Set_PENDING_PROCESSING_List();
    List<T> Get_PENDING_PROCESSING_List();        
}

public class Parser: MarshalByRefObject, IParser<PENDING_PROCESSING> 
{

    List<PENDING_PROCESSING> _pending_processing_list = new List<PENDING_PROCESSING>();

    public Parser(string uploadPath, string file) 
    { 
         Set_PENDING_PROCESSING_List();
    }

    public void Set_PENDING_PROCESSING_List()
    {
        Thread.Sleep(5000);  //TODO: actually implement some work here.
    } 

    public List<PENDING_PROCESSING> Get_PENDING_PROCESSING_List()
    {            
        return _pending_processing_list;
    }
}


public class FileController 
{
        enum WorkflowType 
        {
            Upload,
            Archive
      };

        class Tracker
      {
          public Tracker(string fileName, bool archived) { this.FileName = fileName; this.Archived = archived; }
          public string FileName { get; set; }
          public bool Archived { get; set; }
      }

      public class WorkIsDoneEventArgs : EventArgs
      {
          private bool _Completed = false;
          public bool Completed { get { return _Completed; } set { _Completed = value; } }
          public WorkIsDoneEventArgs(bool completed) { this.Completed = completed; }
      }

      public delegate void WorkIsDoneEventHandler(object sender, WorkIsDoneEventArgs e);
        public event WorkIsDoneEventHandler workIsDoneEvent;
        delegate string AsyncTryDoWork(string file, WorkflowType workflowType);

        int THREAD_POOL_SIZE = 5;
      Queue<string> queue = new Queue<string>();
        List<Tracker> TrackerList = new List<Tracker>() 
      { 
            new Tracker("File1.txt",false), 
            new Tracker("File2.txt",false),
            new Tracker("File3.txt",false),
            new Tracker("File4.txt",false),
            new Tracker("File5.txt",false),
            new Tracker("File6.txt",false),
            new Tracker("File7.txt",false),
            new Tracker("File8.txt",false),
            new Tracker("File9.txt",false),
            new Tracker("File10.txt",false),
            new Tracker("File11.txt",false)        
      };
      readonly object lockItem = new object();
      AppDomain domain = null;

        public FileController() 
        {
            CreateSandBox();
            QueueWork();
      }

        void CreateSandBox()
      {
            if (AppDomain.CurrentDomain.FriendlyName != "SandBoxAppDomain")
                    domain = AppDomain.CreateDomain("SandBoxAppDomain");
            
            domain.ProcessExit += delegate { Console.WriteLine("Process has exited."); };
            domain.DomainUnload += delegate { Console.WriteLine("Domain unloading."); };
      }

        void QueueWork(){

            foreach (Tracker tracker in TrackerList)
                queue.Enqueue(tracker.FileName);
            
            int NumberToQueue = queue.Count < THREAD_POOL_SIZE ? queue.Count : THREAD_POOL_SIZE;

            lock (lockItem)
                {
                        for (int assignment = 0; assignment < NumberToQueue; assignment++)
                        {
                    string file = queue.Dequeue();
                    StartOneWork(file, WorkflowType.Upload, new AsyncTryDoWork(TryDoWork));
                        }
            }
        }

        string TryDoWork(string file, WorkflowType workflowType)
      {
                IParser<PENDING_PROCESSING> parser = 
                        (IParser<PENDING_PROCESSING>)domain.CreateInstanceAndUnwrap(
                                "Sandbox.Interface", 
                                "Sandbox.Interface.Parser", 
                                true, 
                                BindingFlags.CreateInstance, 
                                null, 
                                new object[] { "", "" }, 
                                null, 
                                null, 
                                null);
            List<PENDING_PROCESSING> ldr = parser.Get_PENDING_PROCESSING_List();
            
            return file;
        }

        void StartOneWork(string file, WorkflowType workflowType, AsyncTryDoWork asyncTryDoWork)
        {
            lock (lockItem)
                {
                asyncTryDoWork.BeginInvoke(file, workflowType, new AsyncCallback(CallBackTryDoWork), asyncTryDoWork);                
            }                        
      }

        void CallBackTryDoWork(IAsyncResult result)
        {
            AsyncTryDoWork asyncTryDoWork = (AsyncTryDoWork)result.AsyncState;
            string file = asyncTryDoWork.EndInvoke(result);

        lock (lockItem) 
                {
                TrackerList.ForEach(t => { if (t.FileName == file) { t.Archived = true; } });
            }
            LookForWork();
        }

        void LookForWork()
        {
            lock (lockItem)
                {
                        if (queue.Count > 0)
                        {
                    uploadResetEventList.Add(new AutoResetEvent(false));
                    string file = queue.Dequeue();
                    StartOneWork(file, WorkflowType.Upload, new AsyncTryDoWork(TryDoWork));
                  }
                        else 
                        {
                        if (!TrackerList.Exists(t => { return t.Archived == false; })) 
                                {
                                        WorkIsDoneEventArgs e = new WorkIsDoneEventArgs(true);
                                OnWorkIsDone(e);
                        }
                        }
            }  
        }

        protected virtual void OnWorkIsDone(WorkIsDoneEventArgs e) 
        {
            WorkIsDoneEventHandler handler = workIsDoneEvent;
            if (handler != null)
                {   
                handler(this, e);
                AppDomain.Unload(domain);
            }
        }

}

Now let’s run the application and monitor the results.

3/14/2009 5:39:13 PM - File Controller in MainDomain is Thread Id: 11
3/14/2009 5:39:13 PM - SandboxDomain has been created
3/14/2009 5:39:14 PM - File Controller in MainAppDomain. obtained Thread Id: 7
3/14/2009 5:39:14 PM - Thread 7 created Parser for File1.txt in SandBoxAppDomain.
3/14/2009 5:39:14 PM - File Controller in MainAppDomain. obtained Thread Id: 3
3/14/2009 5:39:14 PM - Thread 3 created Parser for File2.txt in SandBoxAppDomain.
3/14/2009 5:39:15 PM - File Controller in MainAppDomain. obtained Thread Id: 13
3/14/2009 5:39:15 PM - Thread 13 created Parser for File3.txt in SandBoxAppDomain.
3/14/2009 5:39:15 PM - File Controller in MainAppDomain. obtained Thread Id: 14
3/14/2009 5:39:15 PM - Thread 14 created Parser for File4.txt in SandBoxAppDomain.
3/14/2009 5:39:16 PM - File Controller in MainAppDomain. obtained Thread Id: 15
3/14/2009 5:39:16 PM - Thread 15 created Parser for File5.txt in SandBoxAppDomain.
3/14/2009 5:39:19 PM - Thread3 obtained result from Parser for File2.txt in SandBoxAppDomain.
3/14/2009 5:39:19 PM - Thread7 obtained result from Parser for File1.txt in SandBoxAppDomain.
3/14/2009 5:39:19 PM - Thread Id 3 picked up File6.txt from queue.
3/14/2009 5:39:19 PM - File Controller in MainAppDomain. obtained Thread Id: 3
3/14/2009 5:39:19 PM - Thread 3 created Parser for File6.txt in SandBoxAppDomain.
3/14/2009 5:39:19 PM - Thread Id 7 picked up File7.txt from queue.
3/14/2009 5:39:19 PM - File Controller in MainAppDomain. obtained Thread Id: 7
3/14/2009 5:39:19 PM - Thread 7 created Parser for File7.txt in SandBoxAppDomain.
3/14/2009 5:39:20 PM - Thread13 obtained result from Parser for File3.txt in SandBoxAppDomain.
3/14/2009 5:39:20 PM - Thread Id 13 picked up File8.txt from queue.
3/14/2009 5:39:20 PM - File Controller in MainAppDomain. obtained Thread Id: 13
3/14/2009 5:39:20 PM - Thread 13 created Parser for File8.txt in SandBoxAppDomain.
3/14/2009 5:39:20 PM - Thread14 obtained result from Parser for File4.txt in SandBoxAppDomain.
3/14/2009 5:39:20 PM - Thread Id 14 picked up File9.txt from queue.
3/14/2009 5:39:20 PM - File Controller in MainAppDomain. obtained Thread Id: 14
3/14/2009 5:39:20 PM - Thread 14 created Parser for File9.txt in SandBoxAppDomain.
3/14/2009 5:39:21 PM - Thread15 obtained result from Parser for File5.txt in SandBoxAppDomain.
3/14/2009 5:39:21 PM - Thread Id 15 picked up File10.txt from queue.
3/14/2009 5:39:21 PM - File Controller in MainAppDomain. obtained Thread Id: 15
3/14/2009 5:39:21 PM - Thread 15 created Parser for File10.txt in SandBoxAppDomain.
3/14/2009 5:39:24 PM - Thread3 obtained result from Parser for File6.txt in SandBoxAppDomain.
3/14/2009 5:39:24 PM - Thread Id 3 picked up File11.txt from queue.
3/14/2009 5:39:24 PM - Thread7 obtained result from Parser for File7.txt in SandBoxAppDomain.
3/14/2009 5:39:24 PM - File Controller in MainAppDomain. obtained Thread Id: 3
3/14/2009 5:39:24 PM - Thread 3 created Parser for File11.txt in SandBoxAppDomain.
3/14/2009 5:39:25 PM - Thread13 obtained result from Parser for File8.txt in SandBoxAppDomain.
3/14/2009 5:39:25 PM - Thread14 obtained result from Parser for File9.txt in SandBoxAppDomain.
3/14/2009 5:39:26 PM - Thread15 obtained result from Parser for File10.txt in SandBoxAppDomain.
3/14/2009 5:39:29 PM - Thread3 obtained result from Parser for File11.txt in SandBoxAppDomain.
3/14/2009 5:39:29 PM - SandboxDomain has been unloaded.