From 56ceca398b15f4d588aae2fe944442ed38594c54 Mon Sep 17 00:00:00 2001 From: Ichthyostega Date: Mon, 29 Nov 2010 06:06:52 +0100 Subject: [PATCH 01/28] The first substantial step towards a builder backbone Defined the structure of the fixture and the outline of the process leading to creating this data structure. --- doc/devel/draw/Builder.Fixture-1.svg | 4091 +++++++++++++++++ .../draw/Builder.SegmentationSteps-1.svg | 3333 ++++++++++++++ doc/devel/uml/fig129413.png | Bin 15598 -> 15242 bytes uml/lumiera/128901 | 16 +- uml/lumiera/129413.diagram | 66 +- uml/lumiera/5.session | 10 +- uml/lumiera/lumiera.prj | 2 +- wiki/draw/Fixture1.png | Bin 0 -> 82722 bytes wiki/draw/SegmentationSteps1.png | Bin 0 -> 73601 bytes wiki/renderengine.html | 57 +- 10 files changed, 7521 insertions(+), 54 deletions(-) create mode 100644 doc/devel/draw/Builder.Fixture-1.svg create mode 100644 doc/devel/draw/Builder.SegmentationSteps-1.svg create mode 100644 wiki/draw/Fixture1.png create mode 100644 wiki/draw/SegmentationSteps1.png diff --git a/doc/devel/draw/Builder.Fixture-1.svg b/doc/devel/draw/Builder.Fixture-1.svg new file mode 100644 index 000000000..c7bb4e9d2 --- /dev/null +++ b/doc/devel/draw/Builder.Fixture-1.svg @@ -0,0 +1,4091 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + image/svg+xml + + + Structure of the Fixture + + + Ichthyostega + + + Lumiera: how the Fixture data structure is organised + 2010 + + + + + + + + + + + + + + + + List of Model Ports + + + + + exitnodes + + + + + + x + + + + + + + x + + + + + + + x + + + + + + + x + + + + + + + x + + + + + + + x + + + + + + + x + + + + + + + x + + + + + + + x + + + + + + + + + + + x + + + + + + + x + + + + + + + x + + + + + + + x + + + + + + + x + + + + + + + x + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + x + + + + + + + x + + + + + + + x + + + + + + + x + + + + + + + x + + + + + + + x + + + + + + + x + + + + + + + x + + + + + + + x + + + + + + + x + + + + + + + x + + + + + + + x + + + + + + + x + + + + + + + x + + + + + + + x + + + + + + + x + + + + + + + x + + + + + + + x + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Segmentation-1 + Segmtn-2 + Eplicitplacem + diff --git a/doc/devel/draw/Builder.SegmentationSteps-1.svg b/doc/devel/draw/Builder.SegmentationSteps-1.svg new file mode 100644 index 000000000..9694920cf --- /dev/null +++ b/doc/devel/draw/Builder.SegmentationSteps-1.svg @@ -0,0 +1,3333 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + image/svg+xml + + + Steps towards building a Segmentation + + + Ichthyostega + + + explanation of Builder structures: How the Segmentation of the Lumiera low-level-model (render nodes graph) is derived from the high-level-model + 2010 + + + + + + + + + + + + + + + + + + Binding + + + + + + + + + + + Sequence-α + + + + + + Timeline-1 + + + Fixture + + + + + + + + + + + + + + + + + + global Pipes + + + + + + + + + + + + + x + + + + + + + + + + + + + + Clip-A + + + + + + + Meta-Clip + + + + + + + + + + Sequence-β + Segmentation + + + + + + + Clip-B + + + + + + + + Binding + + + Timeline-2 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Clip-A + + + + + + + Clip-B + + + + + + + + + + + + Clip-B + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + x + + + + + + + + + + + + + + + + + x + + + + + + + + + + + + + + + + + x + + + + + + + + + + + + + + + + + x + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Binding + + + + x + + + + x + + + + x + + + + x + + explicit Placement + exit node + ModelPort-1 + + + + + + + + x + + + ModelPort-2 + + + + + + x + + + + + + diff --git a/doc/devel/uml/fig129413.png b/doc/devel/uml/fig129413.png index df8722ad204d59d46078e4734bbade67ba738c37..581c0bf4636c4c6dd513a19a1d087a283f2ff49e 100644 GIT binary patch literal 15242 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%0ATs?pO_vR+0()lp%`4NBeYXNUE^w;YSXo$Y?{$dA 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 diff --git a/uml/lumiera/128901 b/uml/lumiera/128901 index 5a7cdb03b..300f66d4c 100644 --- a/uml/lumiera/128901 +++ b/uml/lumiera/128901 @@ -1,6 +1,6 @@ format 58 "Builder" // ProcessingLayer::MObject::Builder - revision 20 + revision 21 modified_by 5 "hiv" // class settings //class diagram settings @@ -74,7 +74,7 @@ format 58 iterative activityaction 128773 "define segment" opaque_action - pin 128133 "inFixture" explicit_type "" + pin 128133 "inContent" explicit_type "" unordered in end @@ -107,11 +107,11 @@ format 58 end flow 130181 "" - on pin_ref 128133 // inFixture + on pin_ref 128133 // inContent end flow 131717 "" - on pin_ref 128133 // inFixture + on pin_ref 128133 // inContent end end @@ -168,6 +168,14 @@ format 58 activitynode 129157 activity_final "" end + + activityobject 129157 "Timeline contents" + explicit_type "" + unordered + flow 133125 "" + on pin_ref 128133 // inContent + end + end end classdiagram 129285 "Builder Tool (Visitor)" diff --git a/uml/lumiera/129413.diagram b/uml/lumiera/129413.diagram index c8fd505f1..655fa1d29 100644 --- a/uml/lumiera/129413.diagram +++ b/uml/lumiera/129413.diagram @@ -2,76 +2,72 @@ format 58 activitycanvas 130437 activity_ref 128005 // building the Engine show_infonote default drawing_language default show_stereotype_properties default - xyzwh 147 27 2000 581 532 + xyzwh 120 26 2000 468 525 params parametercanvas 130565 parameter_ref 128645 // build Request - xyzwh 541 12 2002 113 31 + xyzwh 401 11 2002 113 31 end end end activityactioncanvas 130693 activityaction_ref 128645 // activity action configure Tools show_infonote default drawing_language default show_stereotype_properties default show_opaque_action_definition default - xyzwh 529 71 2005 136 41 + xyzwh 389 63 2005 136 41 end expansionregioncanvas 130821 expansionregion_ref 128133 // establish partitioning - xyzwh 359 208 2005 205 96 + xyzwh 219 200 2005 205 96 nodes expansionnodecanvas 131077 expansionnode_ref 128005 // segment Tool - xyzwh 458 203 2007 33 11 label_xy 456 183 + xyzwh 318 195 2007 33 11 label_xy 316 175 end expansionnodecanvas 132613 expansionnode_ref 128133 // segments - xyzwh 460 298 2007 33 11 label_xy 459 312 + xyzwh 320 290 2007 33 11 label_xy 319 304 end end end activityactioncanvas 130949 activityaction_ref 128773 // activity action define segment show_infonote default drawing_language default show_stereotype_properties default show_opaque_action_definition default - xyzwh 409 236 2010 135 42 + xyzwh 269 228 2010 135 42 pins - pincanvas 131205 pin_ref 128133 // inFixture - xyzwh 399 249 2012 11 11 label_xy 315 241 + pincanvas 131205 pin_ref 128133 // inContent + xyzwh 259 241 2012 11 11 label_xy 170 250 end end end -activityobjectcanvas 131333 activityobject_ref 128005 // activity object Fixture - show_infonote default drawing_language default show_stereotype_properties default - xyzwh 177 239 2005 49 31 -end activitynodecanvas 133509 activitynode_ref 129029 // fork - horizontal xyz 585 147 2005 + horizontal xyz 445 139 2005 end expansionregioncanvas 133893 expansionregion_ref 128261 // build Processors - xyzwh 359 349 2005 272 152 + xyzwh 219 341 2005 272 152 nodes expansionnodecanvas 134021 expansionnode_ref 128261 // build Tool - xyzwh 581 344 2007 33 11 label_xy 573 324 + xyzwh 441 336 2007 33 11 label_xy 433 316 end expansionnodecanvas 134149 expansionnode_ref 128389 // segments - xyzwh 460 344 2007 33 11 label_xy 460 359 + xyzwh 320 336 2007 33 11 label_xy 320 351 end expansionnodecanvas 136581 expansionnode_ref 128517 // complete Render Engine - xyzwh 460 495 2007 33 11 label_xy 496 500 + xyzwh 320 487 2007 33 11 label_xy 356 492 end end end activityactioncanvas 134277 activityaction_ref 128901 // activity action create ProcNode show_infonote default drawing_language default show_stereotype_properties default show_opaque_action_definition default - xyzwh 419 389 2010 114 42 + xyzwh 279 381 2010 114 42 end activityactioncanvas 134405 activityaction_ref 129029 // activity action connect show_infonote default drawing_language default show_stereotype_properties default show_opaque_action_definition default - xyzwh 420 442 2015 113 42 + xyzwh 280 434 2015 113 42 end activitynodecanvas 134533 activitynode_ref 129157 // activity_final - xyz 543 527 2005 + xyz 403 519 2005 end -simplerelationcanvas 131461 simplerelation_ref 128389 - from ref 131333 z 1999 to point 400 253 - line 131589 z 1999 to ref 130437 +activityobjectcanvas 137093 activityobject_ref 129157 // activity object Timeline contents + show_infonote default drawing_language default show_stereotype_properties default + xyzwh 147 157 2005 99 31 end flowcanvas 132101 flow_ref 130309 // @@ -92,8 +88,8 @@ end flowcanvas 133765 flow_ref 130949 // geometry VHV - from ref 133509 z 2004 to point 595 180 - line 134789 z 2004 to point 472 180 + from ref 133509 z 2004 to point 455 172 + line 134789 z 2004 to point 332 172 line 134917 z 2004 to ref 131077 show_infonote default drawing_language default show_stereotype_properties default write_horizontally default end @@ -105,7 +101,7 @@ end flowcanvas 135429 flow_ref 131205 // geometry HVr - from ref 134021 z 2006 to point 595 407 + from ref 134021 z 2006 to point 455 399 line 135557 z 2006 to ref 134277 show_infonote default drawing_language default show_stereotype_properties default write_horizontally default end @@ -119,11 +115,6 @@ flowcanvas 136197 flow_ref 131461 // from ref 134277 z 2009 to ref 134405 show_infonote default drawing_language default show_stereotype_properties default write_horizontally default end -flowcanvas 136453 flow_ref 131717 // - - from ref 131333 z 2004 to ref 131205 - show_infonote default drawing_language default show_stereotype_properties default write_horizontally default -end flowcanvas 136709 flow_ref 131845 // from ref 134405 z 2006 to ref 136581 @@ -131,9 +122,16 @@ flowcanvas 136709 flow_ref 131845 // end flowcanvas 136837 flow_ref 131973 // - from ref 136581 z 2004 to point 487 524 + from ref 136581 z 2004 to point 347 516 line 136965 z 2004 to ref 134533 show_infonote default drawing_language default show_stereotype_properties default write_horizontally default end -preferred_whz 768 616 1 +flowcanvas 137221 flow_ref 133125 // + geometry VH + + from ref 137093 z 2004 to point 194 244 + line 137349 z 2004 to ref 131205 + show_infonote default drawing_language default show_stereotype_properties default write_horizontally default +end +preferred_whz 627 621 1 end diff --git a/uml/lumiera/5.session b/uml/lumiera/5.session index 87b65616c..5e7b8f6a0 100644 --- a/uml/lumiera/5.session +++ b/uml/lumiera/5.session @@ -1,11 +1,13 @@ -window_sizes 1324 1020 270 1044 872 71 +window_sizes 1615 1020 270 1335 872 71 diagrams classdiagram_ref 136453 // Session backbone 631 352 100 4 0 0 - active objectdiagram_ref 138885 // ModelAssetRelations + objectdiagram_ref 138885 // ModelAssetRelations 730 488 100 4 0 0 classdiagram_ref 128133 // Session structure - 835 697 100 4 0 0 + 835 697 100 4 300 0 + active activitydiagram_ref 129413 // build flow + 627 621 100 4 0 0 end show_stereotypes selected @@ -31,7 +33,7 @@ open class_ref 152453 // PlacementRef classrelation_ref 178437 // class_ref 153733 // QueryFocusStack - classview_ref 128261 // Builder Workings + expansionregion_ref 128133 // establish partitioning usecaseview_ref 128261 // config examples classview_ref 128133 // Engine Workings class_ref 164485 // Request diff --git a/uml/lumiera/lumiera.prj b/uml/lumiera/lumiera.prj index 35bcc31a2..ae9d839be 100644 --- a/uml/lumiera/lumiera.prj +++ b/uml/lumiera/lumiera.prj @@ -1,6 +1,6 @@ format 58 "lumiera" - revision 64 + revision 65 modified_by 5 "hiv" cpp_root_dir "../../src/" diff --git a/wiki/draw/Fixture1.png b/wiki/draw/Fixture1.png new file mode 100644 index 0000000000000000000000000000000000000000..d594217319a1b3fe0adb977054c2e63db723fdb6 GIT binary patch literal 82722 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%0DDe(pQ}`MZ|@ zyfpD=kNkGqF97`Ff>SpGz&HQ>HyZ(L1b}aU|99&FtbaRg^-l57k3adv#k0MKruw>* z4)~wF@7E7K_|+SJSX6KsJ6+8UE!jyX9!O}`zkU524>Bxf~=}=T$>OQu+uXa9tN0H||A-%5n84uR=v}Zn7>=;#!X5A|8ul@3BVow{>Fq@;dla z18^+?3PN1Rr34Nc+h!Xl@#Z|o@*>Aivn`7f0t$#xibwQGOa~rk8+ll?dSyS2&bX;Czl^Qas;POymQgue;Omr+E!k zksZ#MKw^HAc;Nv!ajFHTWnuf~{WyA{9;TtgbsS`HVENMN@G^l&I1I`-KsY4Mh}Z8m zVv(>SoH!GXLqPeM$oXyE`-D^5TU)$o*=f3>NVdc|Cm?jRO15gu%E3K?oQl#N#zRwiS_FC(bTxmkay-s?{G}dtm>z=G#C0 z_s1{k^Lv-^`THOJT5sRTH!qpRp%r&#clU&}%R1mE;kp#Dus!HP2;n9syr)~b&~my3 zeM2Kya`k)=0i^ppP-PBI6Y5D`w`I6jun?j*W(fR=l$9AXcuZ zgFlc8AwV;8(v?HokNLB5Me|hgY;8W3KXX+vr-TyD=-6P#ipBBtb334Og1hg$0Y$m# zU^FpOCrCUe%W-i0#5uh3${}2_dKOHN4**DNFhyxO(Qc$=*hIK40ej8_~Gm8R?nMVc-e2-0*ODwSi~B1Tvs@bEk>eo{PTBygHL?)3RKT3 zgRlh*Es-%18jc_aXH1poH8pTX5sk;7Ov^!Lb}BZm+d+sEvx31uhazh>URQ(i9dM;W zlvmWWoIbTbQc{wuIj$ofery97360>^TUUV+fPuhg8lVISM=c=9mobWTpBIr>9MQOi z#jEF|@l*?5edPecLqidkt2mTRl>s{!v8XlZIIgfAS2TC@;orXZzqsR$>rs^MhwHfT z=n6chj=`Y_oC$53;?)5Fk+_A5>LTP6WMcgb+X3S7-oF7K0E$Y=+FKe= zSOo>?V-@L6H=M)X{U=a4rxNKg3z{Oqt7(uJLo${oUdon(s+wsiD$B#xE&Gs}>Oome zFGugxmkg+%*lomP1tv^0abG=ksggDbsj2Y#xN=z zc3c75c2GUN1d;LrY}m99IT=2bR2HJMwJYZFnj?hr$yYr6GsoSZUh?H1{B+~yslM){ z1OEC=_4lk;TJ}UR-E-Ml911bE8z}&QQ0{OdwG8wPyIx&$x2)eK7A>qHIoatjWErZN zDE}&iz-iMP|JzKbzRU4Mmgu@ zCcg>K(Q`+CMhF9wR4XzZ?YC^lAC1S|)~0rP(`~DuNDP`J!K-VKWsXOl*@oZ0xcj_o zrut3HtSG>TSI$COz(jFr9{Rfb>B#V~<2W(q3j2cOZZQd-7;S0!k&0*|g@a5#d`eEs}oSBW!JP0Pljx>BrOPz}ZymS4S?JofWH zNai#z2Tf=a##S@NSHCVva7pe$PUHiBAT@lpB@_~_@HvhvUf#4Hr(3(Qaz!0fS%Rr4 z@EIy%aTk4q;js;Bi8ExS`4P8mD6u#eubz*y4b9lPX)gx*2P3H|d2xVSlu2VM?umW* zO?h6>?*)L=U{0vz=<#78gx7Y2cyjGF^oGJ%zN`+4#NbV)hDPERde7s@k(K5{+_Ip? zEi7F#52sI_!>%2NNT|O*qNRCk%4BQea{?yU@BbX}#M*<`0XPewaVoDn>3}~x68r1p z4IP_;>7L839{z)&sAkfm;kKezv8;?A*4Voh3nk6&f3V~%;En+)g-c=gNh@5fkDCd$gWi?p8 zv2*?XL-~hyAH&M4=EKw!=!y)#p@VY@oe6(|9D?zbH$J2Vn;4<9?j<}8_!>{AL%Em5xE`+s~MFYh{b-sioB zhT8HxeEiylNb%_?Da%J^YY*w~Ipd}Ua>-PUoEeh@A=F@QLdd!Ds3yEib^1j$Sg@ z+he7t=Yvw}{$+%pKv#EYH4+=ejZ=BuNvBqnl?3ltJiqwz^s~JHlrVUG=@Ahp+crM8 zjm=#;1Aaq;M^m7yiD1trq^OnTXCN5xAQKW5Zby2U}`FSrY^3zd6oC{>9g~~BfW;}zVke9#;C~3E*u!_7~KEr z=7VhBlIif98caNb%?}RTVxXv2Vc{L2I&4{pMTu;Q622k3W3x z3%L8QR$$wK2K?JYYvIu}cnuv3memmlipPpaRo98|sk(PrQJqLA);%1KxSKcbCG(cm zA;r|;QC0X%J*f{E&(?Y3KmP{L|Kxr={vTh!XFj|XTlby7cOPB{udc&u>X^Tzj#!X< zjvZBm>#+CpGkPzvYFYU=0Zh5Y;iLn8|3ElD8nZ{2O)t0O{AoC)F6DZ>tbF$2Sj>uR zvV?%&gwNCyYFj#53Lx>vIW0FGoF~Lrj8U}rB#MrDjYKUQMV6rJ3Z1jK)@*7#QxS^{ zD7HOb4gkPtR>fQL!~~wB2j#M@8G*1BbK3H!<%$$j6Mj>JoK&VxG}_2W^TE*NB;SOZ zwW&Q(KFRAz@b%~#38eU_;Wx5IhI@@@bVy2;SQyQ5fAix4$^K}YDw-!cy>9LYM zBG7w`@lqY5JkwGun&L{F#yO=4&(sNO z+rGgNVsRTqIcZ}h3u18#&u@DTCmTCZQ<8%;pP95~FS40J`MW###N za4=L9kB`W%Bi^^8M@l83>HY{@(UqB#CVaXEuYSJO;YcKoq2WlPTt{*M!5IUg1ZP`& zz!`-%SvJF?YY1ipsA_1LvFM;K-0;*qBPt26KXn8y=}ij;gwIgnGqtg2#3(`kP#Dpe zHD+}<%2NP1+u999mXgb!1Rg^}R#rM?s*)Xz4CuBMof4iObeuZf{b>NRr~0~+Uc*mI zHNP>tHoqI^j}k5?oTp$Vgo=if#|r1IE@7IgSQ6(+0qb~9a!XRd`u$%&4}~-I4Gg2R zcMztb;0w2|z{2U%;J5+=fFv;@F-9~~^SE}5$K!FLsOOK`@fK}AHoCruQ;#fbj;t!C zrYW{0ahDLnMgt?6@N%j@-HOlt(=XsSF3vP}z;;~BtuDgf-+na`Ij9NIjKVo7D9Y7O z>^m6N+;TcnN8|70-7M;&o0=gis+# zM%`% z8&T|dguALEFv(|hKH2kmDvB2Or~54i;V6%{yiCI`tPTCmH=B@!ewP`BV!I-Z-?uj4N8jBA3k!dZU0nXchUhrJ6O=Q|$Vmfn9C&mE!|k2exg&z=>BZn&h9C@_ap)ey z1Z;*xwZr!<7-d4yB(JWi7N=B7-un3i2qCa#>p>jedlZ@^qjxZbk!T#N7gXckzgi00 zibIHmL5a*6P0vg-`da$TKrqG~XKL=>b(l~z)uU>v#TnxyF=iO!+1$|!2p2DH*o(b8 z4ndJ5^bUj&u`FD@Xgcn?X%Xyr(k+!xNSsrDz-PvzVa2v>_Ex$0mjiOL{4Gb0wN1I^ zY0?3|{zS)bU)j-c$I?Zmf7!SN;5asQ9oG>;Bz-;Um_1;4B!aciZo{(qH7KvhLsps( z1OP>1faxNkVjUU?;qgCi!0ftWAzt3|A(vSQ=8e(KPlTA8u+f^{(c{63TwQ>)Dl*Cy;!WA$JM)<}$NTg2Zc zv0y|m#|s&9LadCl2j4uFqk8du`D16f^m{{v zM)oK8iF8`pVG^FH>E&Pq5gaphXMW2GHt7J9-FcVgp>@>7iAIwZR}ow#K6O29WF2KT z6e4ZHH+pj?LnC9289=yalw7ZgPZVT~nmV#MHMJub6BB|!qQ}vK$<+qo7jF#P&ahlp zvhtmb4q{eqiI4eYzcSx^BUrNa!$k$DuHY@AD3g+M*!Rc=w3)n2HL8PX%$JNX!44pa zT7|#BM@#5Evb0GdF&M}XMRkYHQtNjFplzGV$faU%1RYBC7hL~f{kG8-MbZPKxHc_m z#JD3u0@pNP*Y$tf{PpT>4(jc9cm)cv(WbYq4n#ga_vc58$0gb7A@y;`9zI-CV`;Xn z9PdfoR}=TZ*;g1C{b;Bn;W=Pl?782exKfm2Gapna#gJ59+Y)Qh6W1pk%$V3ly(wfU zMfWfuNjZKup74!Ysdv>r!uYp9fu9c^9V8ELuvIo)bg_uU=%Wu#0voB*>P==5^XdX+ zqhuthW)1p=DJ>x`6Ak%RFbE#$RA z4)6I#mAAa+7Rbgz9E-YbXWImNHD1GRUI+o0S2!)vWw9+Bcufdz%cRpkcfYtw`()gG zbhUf=Sud#Hng5r0Azj=R2!5zZmf%_tC66m(q0s#t5GvadJb`rUO%@TEn=T~ka)AIV zcXH~N2$!hVF`j&+#hd85jbEgFwWOAuY4Il~0UdQV5^=Gi`QP8Be)Rr;HBLtF;3miq zIP7*J@k>*`<5P3if<;cc;9kE}cV1xEmkHmzc;2|&f9L7MK|sKy?Tm{2P%Eqab}%um zyfvy-;O(oTr^L*DucVTY)&JG;pm*}}hSSjP8g+e{KA9^Hvt2X>OUJoNFvxP`)+ zURiH47JYyHT9LTawovH#)Aw1Bkd|_W>oEFtNx9viUgk~hd)~!Ku8;w4nxpXDEZWSC zcP+WNtjV}i_wbUBcf*=#p5uhED(5}CN+m9AaEjYud2RBcpf(HIGO}+M_1{iZd*hYc z6B2f%J}GMR@`!ZC5tw42iX3TB<^1UxUI)F3{R$3syTV*A?XKv1WaRmF>MALq)MAdt zQ4F7;Xgw^CiV2g_n4=}Kdd0&^PbmxYPrT2{oDaiY4v<0ZQ%m}%rF5xVRGv0x2& z>JLw_b8hjw3XTgyD$UJ)+xQ3H-dS)SofjEW^Nmmw<1+l77vgqvjfFeWp!PP8u&$@~ zm16BTsqo%h!^KedC7gkz2vX}dI9MH58y7}yrwPZ0ztcT6nA|RPX>Db?qg-@Z7U}Y$ zMlNI(<~4dpt+{4GqulaVER?mB(Z-!^wiG&EPx^xeWokrlDni7ktINM)fD)PTqEIP( zB+xr9O4(>=@F?@w!4;ZJjNmP<(~NYl>!`h-8o7gdDHCb^q>JW?BPv;T%#fO)vGHRe z4^zEv2mHos4T9mn#XnlOFzSXRiB#o6MeAKCJZP%I-oyZfx71fasJ-)vl*_)Oez%_t zjALAWslj^ADA6**Cn$=rvHwopc)b;gAaI%Wf(ON0DYJjRP9uIj<(Aa(IF0;$l0`0h z4l9D;orloIM~jYYEk?rtv&pHoEg|9pjC!ut4iJIdo;0E0Sf{Npf92A|rCY=Pz6}x+ zt z&5*o1go~Y0_*bOk%e}1VV=B<7l-UTe$9TD4z3_f$_{iF;hX~!Rgt8j*4Bm0nR*ulT z+;keaBf2)v)3{luUMImyM7HlB50BHl8N@KSELeF?89d<1yng7(5iL7$iM@U^2~_rq z^HtAEibvuZ>}z1t_dXVNcxajKanW*6sf@?FJL|*k<_14O_oyGaYuoCi~c7UK$2VNInTG zq7c+riOdymMc-0%JwJQOg&*ZgbDhE5b?i1MD!k99t96^DyYAqvV{^1I>C_fb-jcV# zI^VORT{#RQs%3G=^{$VF$CR@^B3CPhDQcP~J?Z$HDQ>P* z3+BkaFQaH?Pluz`BKmHn(?W&*;lp1tZJ&ddo_8?<g^>O zoyZ*wxyW*Ld8s7YPA!#ajAEr{;;i?N!l3&>ddb5(F_srtarS0(8v#iDH9L#mhIAGd zM0!mfO+4VWslk-*+dW$!H@@w_JeU|DD@|U=|4}m(MUc1~VdiQQr11SZo7XOZ+AJNc zmoS`VXL)gTrCgA|5ir9cA~E)OzoAD%{);%mbNS(S$_Tx(gCD4F>Ujk!vU7i4VLlu! zQTXOV0q3|`D;4*7+k}!-l#Ki3b%fgYZ1L}8BT#|{>^a_G3$j9=>{`Q$vauF1j=?SW z!U$=9Y%y{|CHfTG91Y~db?2Oy5iYh3?_w=|?rRn(MjIQ@>W(?7zpM5Oj*UWDTd zfxH7I(7TK|qET#OL_v)xDuL3m1+~C3F8qT}?|Qy5aMMS$iDjSW{EaRZu7i)RXeciu zRXq|~d5W^oY4Et|twTlMR51M_rvX!6nL_^hDU7B606~Z-{mQD)rA~S{IuxO-^e`$) zj9#E>;)V(@rLbu4iZA!G4F|OzVk%qjp~i&ut08B$jK#LR5jt*|n3cJch~{e#b*&1K zbVYSFEyKPMl~xAAKOXNPPjpV_r+cPbITnbloJD-P8o33V>2QePcYBdr`k8tDG^!&M zs4HqH9k~9A_WACfLr{}!Zj4;udj(?@owi2eXc!~`eiRd<0xKb%k{Q>~$?k-Z6H;68 z%7rokaU-^3eYYiUK&VzpCB?*P9ZW_2G-@luhakY2#(n9nzD_2K5021trtp#Hz6?4G zSd$5l>7CHdAv6NxAxS65Y<^7Uxo13Vi<(#kp>I}Vo8_gya|{FlpjgmSDJ?UE8UE3g#LL#@W=xdNIfv1{mlKMcAmufnK)L9AAp5UyeR2Y+@Yq zuS4Q3(q%L(QW+G(8BmEKL5fN#HnxXw?`i@bBtNgZ6KXM_vzI|O)SaP;Hn(Gq^(KFW zD{dXDhc1*1O;QSMC!+`*ZCe;~BJI9b_RFx44^0kT>(#N5hx9-{Tc|dd+I^0ZCGbB8 zUV}5njg~RdK}?N%-SgGKAgF>D2a{(uMjPMj{kD*nx@NP3&x;u}`Jg;E1_)fLk!Apv^loq9DmO~AJ`YifNl<@5EMkt8zG3Po zj0khcl#oJBAMMqbIb&P>W9h)3O#L-7hp%I>}o(ro5vcON6a=fDL zwjxTSeXI2D^RAbK<_bMGC!HoG&6NXOxJbdulk)B!eC{HjrVB)!Y<%6H&&ox*+;-U3 zOxoRnFL(FZjMd9uiM5WCUx}NSinUua`*cQDzhE#%k>%(Z3!QK)AqJ*VE=;G}DFyQw zAne5%vha}b~ybDy)m@NK{ z<%?W<22&d0(>+X>DWmKe7bV2$GusyNIU5ObP!Wao=?SzX1k>-rbuMIww1txUQCz@W zA;<)L9<_Zr{bdWx!lC(AIa~QpyPt^&CqCmR|3|g=*J(=WTP@(5;@c<6SY-*nGej2# zI38wVX?2D|tDn8o%7{Mq##h+u$*KJLpEa=2qg{Jk=tyykT6m3C+dP0;L`^youqZ2% z2G(ol-1#-nrP(h-pAZW#5Z$4N33_Q!&UKNZUlGKMLk7!| z=u`7nxc*SYit0|RplEOj$xUiCx;6$^$_AYOr=lq77um152z8t1l- z_i#UF-ADn`k63gtTKo#iVMs2kI;s9JegRP{Nr4X*_{xQPaKk1Z)n0( z&ijyRpz`mj+YMr%WiyS$9dSgPP-SDMQKt;^qi6rI$G-cxiG5AN9c`P#`b_fDD+SS$ z7Q4599}OenX#$<#?A*lJScy~hwP8WhFN?9PyQ-lTEmOZ%v2^g-z$vw_zwq^Pj7M^Z zW@U~If#Qx=Xc0;Evf@g&FnVj**hWK42C;W5CZR83QSW)Fj6Zv`L|MGuCnI}Wv7cf3 z;A(a%cJ3MmF{v=wU{jU#cHE@~Z^$v-#X~S(AB*-_#e{uVD+RT7^3jb;H+IdW|qzM_O@{+_GE8 zmK2H*3@7=mAarABLAG}yCajllx0O{6UNHMa{$g0ITQ(BffV%&OtcPc^TCQp`Dykkz zPdRH!5mp8tyoZ1CI@ksrNiIC7N*=em3Rj`uO0{F=k{(}_5;>Yojw>r0^XJ@IqA$H^ zk4m*ho;UxB0Qp%GXJIhTcWQMZCW;3t1;a!YjUY@#$nOa@Yt7544Y!fxaZ}3Djh~1& z1cLv>O4%R7tGaNV%Ulqk=g4pfm;s6;%`RtOUBy|?Lh!I`pK9c7E5N9do`Jagh9syc zybb+Yw@5mrHK=erX}XUp)$WMf=I)*QS8aAeD%_DooH;3DEib4pH^)G~ga>AUZi{Az zX@X}x$GJ!7W;wJoEqNoa_7;sR*3<^C9$LeuD4=Agx}$LEeq(ZOuMK%Uz%MI?jYJ7G z+1d4%*VnNs^5!zpp#JS8xb(@v<&vN zPo2MytkYzP@=5Dk@ZqkqjC99|zogb1C0JkG%+mQ$`BLrqup`uV28`HG?&pMt31a}T z%}}H{mdJ?`s>(T?6h=|b%mm}YIo@%~72e7@fzvHs1E@tkD{YLZejR4@CrQD4v*X#3 zJl_$}(CCMO+iCq0Zdx?as*V5-{_dvi{nP#UHmdz~?*(HW3dgeJGZ_p!z-z;Y@eZ$c zLTg^k35dtKG3!|R%~puqZcxq#m*iB8L?Ay{1hC9vTz<&YF$72KwT;%E&#=?J2P@t@ zw2{r`E%AB(g?E&d)~%LAeXAq|Bt@Uy(TGOn23!%O@zoMuRjxRd;rltD0IQs%@yA{W z;5_LzGpV>%H?>EDCrwevIMhSfC)1%y+>A9mSZHFMrMx8#Vv5y>ff&oTAO5LLxzZua zQS2JnNUuqu=3o4h7rCP*W4EV=GEAhcYDSq4ieT$Kj-27GcCd!PMw{sdw%$3sM@M~C zVt)Ym+yjNbkZzwz91x*3Y0h^RWAzc`nxmMCZPYta%ER36fWj3Ltj&Qhy=6g`Y4NMU zH4DF2Au1Hwh@*5RUsGKtCY59Zxk6_2-l%JR^KKJNcfXfxM3t0*Rnk9{(=W8%F`Lg& zHI7z7YC4FpW!ekcOu`E?G!5L*wb^peWTV$$UfH+)npj>wcUtB}-s`H)kUG?q$`v?e z0q48#zgk|d?Rsk2b`ALuCPll(vh!qR*~vH96>odmFu__i4K*{BHf==cVU@=sUyY}a z&YjA+m!mOL$uS=Mw~p!m5#6>Z?Adef;Zl0EpW(*^%}rznO|J3cP>z~jYr@h=o*(gz z^b1`uor>1Z{d;Och_EPD!fi6zOu&vbWsIOS-fD~#o4ndeiUM?Q6J6p1U7xev9JAZ% zrK)fnU1^MnJP9;O4S@>dz?!wpY@%(X2#-=`Lw66PD!3XrdcF-3k|KYH)vUT%PapaR z7J{W#I%$kV85sp`X62k#Ge~qL?EP2HkxW5*Ha`xe#2(0@Mucf1%EN%6gd_gR^Zas) zV#InXpaEy}u#GQr-mqn90?^A)UuN~@Tz7{}{?gp1J*T@b?>>JyHN6R#%61hOF`JWo z7g>nnOP^fHzEV1XlnxKA^E$5lux(MaZf+*xl>=#`im3fOj(v&JcY7VEj{#|TSJ4tE z`uroKDD2sIzM@oElgHt)LB-HX_N`kcN0$x7MQiShD#HG)7>SQt3s=ji;$!qG^uk+(KV;+T;B4q4ZMmCWm8 z-;XgFsCxp)r~6??lqwV2qF9j@wZw$+i_I^`^!4B#p{u`9z+uR$Lrg8pO6q*tQ8fx9 zBO0Iu(WztINYr7n@*hL^c%ZKU_#xaT&-5NKZ`WAa!Dsi~__{2!>oE!W4cn-m&cfXT zPM5#iUf$ATj}#=xKK| zTNo%1E(LAv+y&Uen!bJ(J|SX6Ld|VAgCgr#hT-3-B6jF%gPy=XRqu1Kd{t38&3y7N zdBBW~=3!^x8li~0vj41Zg4{6y{?(8tXp<5b0UOAWa`Izi(jgSo7c*l6{b((~VH@o^ zR!hrT#$;lL8WE#6d4E9=G8#d)*1*S(kwWGRM#zh-Js1#JytqK0E32vq&~ZK_X{OZ? z@n&V@tFCV5t1+V`HL2(B=-<)^$FD&adB>N#moq~5_3jfC1X^r+pmm~LE{pzq&RDVO ztb&TtzWhu6-TjY=S8UM4j*#hzq=>_>@*H7TErgry{rA7?tjryuu6Qo6h$;h3hOtb2 zWRUggeniiO(+GFbL>9;}h*9a!8{^ln*{ESIWo75ao_j$FnI~__kiBk8 zwa8*LOdwZeb>%@WD3H zNu;(S02Ip`aSY6>0_HMWkq+*eNLlZ6h>$)t}{ z)N59XOl%h+8}Xo?zlj@8R+!u7+m-Wm0XJ6FhP>JA!xxHB)kYWSp)L^Hky7^%=E(gR z9#Ww}8cwE%hg~%U%-pztzP|Yl=>dl0o1xt4GGQJm#J9P2K&4a?3>pie;K*nJx(~L# zmMU$pVnp}cvnFz=4gzL8EVa(o#a7xRv^4oeRz$uB6_`W{Ujv6|Ihr z3p{Bm`d)+lcgDN{Fur@D7d;V8g)mAcM^GudBg(6l~#dbN6 zuvBQl87IgVWOw{q*{4tSyi_7f{O8oQsW=UimmwWH`?xHILpr4ioDQ)U$J@hi7G%8r zPg`{i`33DXamQlw9qs7l&6G0gDn4vqlA{>&Sn`L6Q+AyktGvsnrXa~4izCkP8(zgJ zp9H(|TqcW@%Z*lf1BaEhy;$GxpmWIX$|P8!NXse1$bB~1rG6YTp~=tdfXMrW40=r~nB0M0uTBnqV?@595I!8)Gr zcp&{(aU-hWf~zy1G!(>U@Bh^SSu&3??Po+exXN%qoPKOPk&GMeob z0P>k+Sf3uq8EU-|_BCb9|C;l8uxJJ9R9J+jt->m&P(>4N(`!mP1S~FjR|NaB$RDe3 zefXxTUPZLRZV{}-Yd>eJz5QpJ^hki)p*mdlvACEveq59$=ykC5j}}32n6TIfD^rP) zP~1xt>A~J7C_NN=_Jm5pzQ$$daWZMfUlDSXHL=3h>G!XZml7TbxHVKRF$4lBqE`vwYFS_0rl# zdhh&(8pbO)xQm3%DW7tngcFx7XeVd)Npq`CqRZvDgR%YsBgR!m7GFqx9h|VWg>?-W zJ4rI`kb^&e-fF+NnkCVdSI1FF6fEwuA0?ZAwJdi=8^Z3TKch5P;6=x8RCuCa!R{O!%Zlb>pw!Mm+G&q`f z8jr(*IA^^UkOfs}6BCI!$oY0;j?WDyIUitu?MPPKWIa@>)<&Ek1cSE(A)*)10lH9` z{0t&gxmZn3`=foE<0UO|hY{@J=9*LzO1FThr0jkB65&;0VfN$;ToTRYMo;&Y{$)Fw@_qc zkSHp@r(hTSWkF*OpPUr+8tGoj-NM3*Uqruk#ldI-#3_iGvNIuU^0%rO!zgMP75~(f zG-YE`)(1Ihi8Nf&U({;72q~%dvI@A{#+1@&lX#o+g-r28@`%%!ap@u4GS~PlCpPnyP#2(FAVHvVp7%GXI(RtpSR(4^%d_{l#I(|-9_d#X8GV?OD+o^Xx zmt^~=ej+;CgcR;v)trVGECEOVB4%ul#0>e4vZa`ckD z#~6(}#2HYyAQBmATuR~5@-~KYfQ`hXF54XhObQON{NHi?;6%{iqL8nsW5E5fKr5o> z2jN(bu|8;32j67izGLZeejdPCvsqCgkwk zvnC<)nv*LBG!Y%zKs`#=Pgffg_~$FD)A*Qknt(g+0Rh1_TS#U5*SxBq7|k3xZ+SnM zn(^oGnBcpVwGBH7XU+Jln^2lk94T~I7VLzQwxd@M# zkDU&8be%Lsz}3|vdy6WARye;d5g(61lLYaOPNFMyx9AvJm3=!xpxP;v&yL-^WA5#k z%TwO~bD$SL0*8Kk44E$A({!KvIYF-4r@o?lwHt7KKxQV1N|urJm-~}(8u4?RDaF6L zI4_UekKn%wrn|3RO}RnJDs6bPv8@_uTk~m^>Q*yu5Jz2PzGoqGvJ@2-%DiKnrDFnz zBS7jxald&cqndrm?uXYH_yn8%?Hs0;tl$_pr2C-7n3=vCEQ?CMRr=tqV*`LMsvRw8 z2_@m}jv2lxA*66WGQ-_3jg@(s1&T9vC>MtY|L9|;q^VC+M_J2w4$YSCs?=GWI$K`% zf5eUX(e;x;6iUZ41Golf7sYe=ylY=o4S9|$V*kv$m68dUmfK)j?rb;kx*hJ&R`5~I zaiG=>IEOIFb5Kno^mBt@Q-ZMHWGTsPhU=B!Ax1?+NtF}6t;DR8;O@t#$~Dj}(`N_g zw1(=Sy#)mE>Mtppf`B=kFn09VwcB=Ws4OrxJ7H)?O9}^du3_Weo*o{T?>+xiIp0u@ zo&?>-xywXJN=IfcjV#jBOy)xnx(mCCK8Sj5hyMUhp|5439wtPb+4dSX*XbpXs*nq} zP*|8hZ-nB^A@i4l9NXrFK_GB@BR-b> zN*XT{O%c&#a!o~EArt9o%@` zspYF#4!6AIc(p#V0?o);%FVY$e}7pmjq%%c!`>6=sq6SD?6)zoyZXgo#ov`k6A$Dx zS>=Nv_VkLkX@KdmTA~e81SdNb`g8O8(6X18fLmzmhOcaYHen>gx?@963JMn|NuH{G{VD2npzZGbe+g>M4IqT!=K>e-d9I{^2WS z_rt*Pi|YX9*JJTV!2I_N*ci5dz@GIz;$JTSjk<)AnEUGw{H9u(I~60Eb=#^Jn0O1g zpwY??Q@?nE zl!=@4jm@oryBakUypI7Zq(V&w5_9N5NBC=Mb>(Yzgi5}k0M*xkC#{k?!kCXyfbk~# zBa>+#D>Rn9`m}`;IEhD4(MCCQj{cdXVN|4+E2aNB+C$`ZB)QA)fBgGgOSf02*e_l=#^ zmw??Upx(LVV&#KFhWTi?$pQ_>U%cQgM%cy(=I$Ob=UR*9L+9Kwm%z^sL6pWgDt!Y* zlBD!qNp%%+rj#A&gi!F1u_zj&7RegJQ*X`r{eiu|%FIpKsNU4;;jTYF^<|<-h#>pt zD54V$noImgom&~@#kDYI!We*--zPmBAmBSMMwJaX&!&8Vn-onc7C>goG!5nnX#87BE_#3k# zfJ{0DKBwDIHz(RR!_i=eH{Gr}|BbV%dH=M)Sg9Eytkv=N>l`s>mrcOnWwfbD@1=`M z@=vgcB-i;cHE9JqO}wq8<62Pb;{cZZuOHX%b?(M&i$!>7Ka@EyhM4EOg&PLQjc7_H z*73Xw*p#k9v2$XaX09=flVVQbI#i7!-QZ<0JZd{9hl_tSf)f5EV?uCi?X z@6xqNG?ggy0u~x-KhRR{Fa%q9$6J8I!;s)%HIbHow052e5}E~0MYPn^S{Aj{rgxpJ zZekLXEUDme5oa{ApL_n)e)7C=&n*kw7$%xi&Xs62ADgFBz(-O6!ZKTe;YbKcU@qm+ zX!7tzD_@I0Jre~HF^Yo~uD-4!`Z-x}lBCbea3Xk&15V!D$Zwd&ed;Sq+bkDoQjJ7B zH!ef+r}ZWAkW|)%Que&U;f(Py0Jtr~Qg>-}nV_VqVnvVJ_L3>J`3E5CXpz%D_sJh? z{?0gx-8`*!ozc_JZBEq`2{d1q7RXs3b3E^VWl$JscI}Y%d_ea>QvXdjaQESOqpU#g znmTjasg$~TZhwMx!r6%u`aAbCI`Ta{LU6G0*M7z1f>CBF58n$Pb3QS)4=P((VpR-U zCtvdRPMNUR91>$75?l2ovbZZ50*!@o-+z}d_!`c?%qB!XIZ{z>If?jjG{ZF2GRkf7 zvUvp>!r`BKpV!~D=n*IT?`&C8y0+Cn5L(%$k!W0q?mYz!Za|Gm0e@a#^YV;ovRplt z`IrXKUpaNI7ptZbidQY79IC%cL@jm=LKbJI$jg6i!94*&AP^z2RF&&AEDI#d#DxzOzwWQ-Ko^tw;j=pS|ax#>Hq zA`lmJrY2lOO>_ou8PxZ{Gv-3W4D0L=kQHgdjrM#D?)A!o4eKz97XjDlu*#qr3kM(V zNJ5QCs23~}wXD4`&IDXjVGWq$Br*#%Y^(6}IvJLKd(u}im0@xR&mC5Xl6*p`go!i1 zBl992u*CW^eKh1p$(KM}p?gFI-z~B&h>`#eTt(9gq%pkqs5yy)2*6tp$h&u-hZWpV zmVEXT8$E5^KG+zon^N;F+rMZm&JcfD)l_*P0QKvQGYUw!P%dTX9H4K|RnHnWPwQ*1 z@ttx`R;1mm9{Zhg1*PX4d~Q$62Jn8B6|PS&f5)P`ySsUqW>tII+lmtzD1k9Z7>m<* zX7iD^`9+G@sq{{#k#B&?$zSs-gT&Cm8;O%O5lZMa6VHi6wA)QMF@hHXzv``09U7i% zmH&M>%F7z`z&pNk+u=DP>N-B)7w>Q+p)ZN-#0O>PX(=$tD{{X1lbrR)iVUInSI?K* zeLPq&Q(-70dkbk#4#mRb8uWMYU+X4!2wzk!Z)~i;SFZ0 z`862D<3dp-l>1mzC`>9(ZDL2mU@jG;R1ZM0XlutGsR4*7vPrN|jpe%ulLY6ED(F1` zdFYn82I`h26CTl31pS9J|-0l8~WHk<*~J6{ZIpj(~lNi51=59 zW`H757X#X4YKr;g`t*ui9zZh?gSxq{s=)5Y;(v%^OcnW!yn?#VyaNIYA$ph#lfatS zf-C6YXchpxjB4+D;>VZbix=!c|4ns!zq|Vi1=Pf>#&kTrA?VRPS1I$(Kp1$CyF#AM zsM03<7|7w9Xjp0JoI?q6So{dg=8PaiV$^rU;a8!7u&4idDV5`C>D9WMji%4k7wXF& zP%g?Fznyf69W7CQ1pXwy7-@JN7^bd#1i+eb3V7O_xy(I-D;AISiqi|fyS zta(2-e%9w*S`18d@#jTBg!c2@R00!Xk>~FUNZK6wTvg-$W5OJJ)vY7Q@t-GJ1Sr_uNq+vT zM|J_Ir^5f=m_U-HCT&jSDdfz0`y|5+Il9G8z-%jC^mai9_>`rnYV_wlXvgD_sk85< zxcyYuW&GB%pP%R-hq;wvX)-S${wN2{^OX-ATDLx047LnU-v1u#5b$}B3h39RT>JoR z>vQlK{hweK8hh5zg>VKq*YD@RJLA(fHyZ=A}$g3x>UEn(^^?#dSe!CKA`}ttO z3b4L8G8zcymdFB{9h%{Q7fT5xDRu8L1O@z;t8qv!tX-w=N=rZ!#K!yIPTaE4puC|7 z2r;pCPP+`{jDD=En~pX7pGXO2PYZ+ifE9^tOy-K*Z~Q9YwuzAjsFGPaw4Ky-!<94w z(x$xRP7!~kr0TlT;?&!M-5&R!Jlf>=n?Q5n{78D3MBD*()w8+IZ)x$0sH*(i2vb zTWC+I4RXY`A?iQo{-u5ug!-;VPrxR1;`Bv#hn01_kk#+MSuP6S$4xGOU;77Yab!mX zHeOEx%e98G{x=$MSx>Y^6HgqW(C(%L%hH~k+Q|YZkktGi*WbsG6X4o8dkv}lL+Q6h zU3XW!jtjN^w*nm}**lWAnE$1(ew}LwtZJ(IRJQ~IDCcDjS9Lbd!3_c2u}O_D+J9-a zb3Fc=AHu7PllxD?6P|;IltI^^lIBmqVGW3$yjwUVQT<$dvHjncrK&SNpTd#00tp)q zMWk)R^Z$1c3j=8rgYg`kZ_8&6-=zB86Tm2r`9lDLEX6iv_Thg0e^c#{tK;cRwm*Jq63F`C6Sg)z{csRd zeKgVZe=AYgNf?Hf<4sx})B^qwpKOI8C-N%j{_*4wZao!PX*dqEzgGZTNY}QIb$K3ZNp^*78M4|g} zPt0@tVPedN@&Eopf5ZN?bkk>Y+#Hvz_;s-~vjJy~yYjBlJ)7fyy!^#y#vPsq_hFhK zz(n%CV@dq&msv>hKjmaO8$0d$pFpfO0Hst~pZ=VuNTj4%$o_AWgwz(CsDc7wHK44@ zJY5~GlL{F&ivNUOiHqh}LTLQ%HiC_&c$HYR|jQ0#fy<^QBBv+AS=0aUb5nc1Kyml#T;FWz23^!umuzc)oM z{d~+T7O?h>fdDe?P~1^aI8^<=jbVVCRv{YuHjV*9R0as;-8WmQr<#O$&0Vz*qYgkn z!th_`UdJxLDqcN!`GfBRSoZiMrptQ zNPZa3EDm&?S$xVx4QmvN(oHAJVcwBskLYk1u?V9OaIExEBfKm4qKo-u=rquI&J&od zRksJ`qnwMRl-aJts+^w6XSW-p6_wWVwx*{;D{D0UD@W?iEfS;qMV@XD0=@cS3Po{% z-S{DjBYIe)x7kP?^~nMHwuc+ma!$#P+RwQ9qSTJ-!6JHz0A}_Tu9zx4-gA-6CJlD9 z@O%vX#%Y-Tq>uiGhaa;Y3l?^>Rn>m-xGfoy?C@OO_xtunFM~I^MrDVV!|pLm0ah2Y zWdp&+mt``Q4TO7jzcs8NwFH$of*LlkAHlVrNf#r*m%gZ0h9=LoYF1 z!8P3luIust9%jZaCPr~x}*B)w|_VZ^lS)4to)@|RdqX&attNGvc*EA zdu>nkl&kprBa!pr%mtLgsMYdC6~BR+3DGoUHVx@wq`MtZc*zLCL-{h58o3vDmu_>V zl9h~eO1E>PtR64l_ge2^x-vdz?E;)n=LM`Uim=#P=gK?aflZl8!s@Motj}xbBlK}= z%D*?gs`k%w*Un)wl@ZhicLODsO7g$o3@JV-^V$mPE@((UYX|sxo?iy_O9bV@vgO04u{hAwu%lzMB?e3?8WQ;RF7suu!&uA^r`WI z*njI>qSIMbgNLazDP^vp>*L4o0mhThZKtp6YFH)9x6Yv_erH`j1AV9J*iPq8^e*Gp zp1dI|2_@o;>Z}4wH;Au70X6Z|r=#2ck9=U@Kk_C*O%I;HD!y=XJ}u!Wjeb!6o$OcPmcAXQh1%n^D z$!wtes(G`P71yrS0tDpT*n?EyZ!v+$rsLp?*c7<+G8q71st~@xuhW1m>4;4)MT02& z(I2|e-=R3cyc_rtTCm=+NU~z}tig@RPmREHy|7hMf#MNb#Ly~BL2o9ebuno1=X@yM zY3i3VNwO{i6n_E~Q$S}%GOVcUTUIvN@HHE3l>;Dd{01hF7v4MJAXd)88Q_0$!2iUt z-lFKR+5JwAAo*Id< zi&LF)fdjjx7(8r3sX!U{4K0HsKPR()YR0G0@T=P)1WnX8IG{{r{TL9?;xI@7>_<%y zI(|bDg4aG52g#Anjc(Q4azTRJH*On#=v^PS|q|Ofoi5^^2|rC0duE9M)0|bH-Bv^2Fhd1B7b^pWb zDyleBQ{8)7wyd=}N=-!;1C`ty$ z*(V~z06+=IOG|w8&N<5U@&7pYXE!$(4t=r%y~)vY zpjiLE6~7a=6QT*hN!`3lQWp}uVQ~Lz$*(d>2==D`wYSI_sEY&tHFIpv zH}z5fwV#y6%*OxwqD0@vKKlP@ANxtDV9uDZvLra7LfGNc}=Gb1l{^}R|$`C zaS>UIkWcCW3q$&wGCuQ#CPgB${rHg=q_N>~k5l#NfHYnl2Mk~qYuYc3hoKkiJQ7(( zywESxrhQR3iK`wNsbjzBt?DRJMs!;=d8qW8obQ4tARpT-7LsUNjQcjQjD4Hvyztgz ztAp;r-~I(AH1@I4#prPJeqv*yS380;_I0vcBqa107b1GUSCr5bUKAS0WK8`)1XTcp zV-A3K$2#V6=AMX=QwnoG~O2w_2)Tu{=6W`tvu8~d0 z_=siYn@XwhJmb(ji^}+x3|+70{yXNq_(MgS{9*_U5RzDidJ(Plqqk2v^K_R#VGi)% z9q)DIQE=3Po5mRql8b0e2bwU%IrL6CJFZc9KC<=a9l2e~>mnzi8A;KGwSPgKbq?e& zG9b+}@uhQ0u5P@omx@nGnk4oV(`0B-2ZCn;Y!ywC?57f)SH}6rg7fdaE#uwo5(Ep# zB{k*2EZ!<%-t(+aBP1H6@$8BsMrd z?0wzb>0Efb&)%K4qKYT}_wnX7z;{{9L#3|nReWEr7th(s-M}c7ah%YPLwzyD%YBTS zOWw*{H;_i1uy1TNRM|(iq02p#%&>M(^m2C+{N6&*@fX+U>xBe(=wJ+i6aRL=^S{gt zblRVe`8$*O`DP=+)}xOPKS|KznGx(=X~SIxAg}TU2C7=b`?PBVwB(kLv*M-)j4@{Z z@?1kE0hMDB`DU>VG_hqPI7T>6Jo%v}1}lL`5zA$X>WVwG#rK#{Q)=Qd!bdde z$B#17FSI}N(bpfbk7tAcRh%h;sC*&Ga4ya&)6`VO;)@Fm`;(Qm#?8%E!phHC+>^y@ z&CN}FO*3k_USv@%Q80VDqL#4@m6gm|nwnvBifM8Q;)a7e6KpsaFtf8c@_H?^(@Aux zJXRB=gukdH2%7?H&HeFUz*WHG3EhCpw;G#Tty9QSnn7LCHp&; zY(^Gv#81yI*%%IPDILXAC z&zUizhe}aFfdmH!M_FERqAfUWq9xfkKM}v8M6^==99n~)lIeyk7!ZKGaS!a_;2gq> zB*S!&=E>n|L4u}6UUc|0m0g%EuW%0VQBy#-qO3Ivt>Si<4^P}CMR!-eSxqvrryoiJ zWuF_q;!hben7+1q?;OpwTeNTNSTck~7o3WFe^CgQ=mt$NYBWcovUDd^4YaT*xtiB= zdUNmJGxM#nksULlpZlZc>c-{0k%xf(slMAUEWXy3mJe>@gGrIT682R! zbW0B{dIK6T)iF0`gl0v6KjOL@b=FTpKcEkj`hm^t2wo~s45|*K;iwzLb`@ZEuOb3t z9S7K)LwR9~6Yj83K7j5gp@FPl*rfPtSHS7t?gdM8bN#}@2QFL&l~|y!!{g9=Xfge} z@m@0#x22e<{i1a*>vEGEyf0&uhPI|=j20CBbfU7da*-xM4?3jP|8iDuz@>4YU5p;e2e!3=V*abI0mO)0 zz#ShnA65sJYY-lY0G?3$>;OZ~+EaMW>ANSyKCQ@rAsXN*DN>C4-zS(S!ai1j1rSk| zMv9%O z&9y)feAu3Nmv!iINl4KF-vpYoB}7Ii_2y2u26XaHlP$|Dm}Jg8RiK+ zf(g)dDJYITw#WAp>%q%P=L9dT- zsOe)bOTYNn>;+$+F5#rYF)^Z|$TpnKer53hAF2x4-C%_iU|!$9(R4fb zAU)&#ukSOTvZmdpX7I-`ey;sD-PZXpu9(`a#!#-^7izF(ZI61Z0oA&D6wl}sxi z6Nd~q)YLppD{`bB9$-CfTsY~UXE-*?Hl@wW4M;%d?J*wxBg<{$wDk3>!Hyu2YR%RV zzq^e!^yW_uM-1Zk^7E}d*EL@&Kk>+$s+W;-;)m#7KU~{dZ1ewg^fK`JYq9pUs1Ug) zMBR9VWtWAIf*6wMaX4=?md>$|-2KG=8$E?(6qmA8##EG+42kRbl4?LM4Y-3@L1<7H zAt)^KK^ho3)Zfa?hS7(gBIzbJO@5>uT5P~RWP)E81%^G7C_a}9ydo78a|8YnT%ID( z*D%6ge~}AT(5U9sJ4`Fj{p;qnI-vjU<=(r&{w;G|!+^EdXQP7Qt*BT+E=d|{8OkVR z97qF%CVtAXXTS6;|K&>QWx|2PNblzFv^<2!Q!^|VNmH+O&@^@1RMEtwK%}ZNn!Dc( z1JKfKm;Th@z8}`!uIu#ta@(t2*R~n02EKwxjhKiC*H@~PNgTKtwI=P@c|0F|o7VHR zwA5@D{)u*#{9jgX`LDFpIqU0AecS&!wbRm^O;)Si&dw-K+Q&ZDsFsRIrb^jxjeMw; z6sXU{tfUJ=069N|tqXarmsYH|JW2}1+ ztcj5;mD!Ojpb|p(RVmoI2oJc#wTR?u!S1^cA77)79RAPQC98^MHrvdUsuii0!#nl`Yk* zI_mn>AGM|OcHFTLo&-$d^;G>D@wKyc^bk^OKo;Rm5v3_hDF zme`%Ku2$OC>f>qen$JZCyv~A%&iqkj=LRmmfyak{?jSt;bn5$o!CxIP4%BDe1CM!ALMN#A@Q9%LHwnS z$N$cGl~6~a)AKk@oO{~Z&MvvoX1sfc_}Q!1ukq}1Qv1d3HlD0qL8o=>?NR-*1N-}i zC3`-PJLi#^(qE~n!pA&$%=h6qDu)V|u2(-og$Gz8bsN~YT2;acw*yfN1bBf~oT)Nw zhX{&359y{MWIJp{eJhDr!@5vHT7R^{8bX)?>i}%B+svW0Dyk)Mpe;92EL5!?y^jyz zmuOPfphP4wq!9_{YDwj4$>-7?q|gIr9m7u0ld>k$D^JIEnOyGtI=I*#t42V$e~_gJ zC=NW^h^Wjsq1MtD3H|H$8eqNgTa~}|)gL)>IYYA<66S!9RxO>0|5YbbPh)_fqyb0e zK8AZpAGmk-)AUOj%2aB=gPy(_y%~?XrQma9U_znyJ(+?>okyhAZ3Oj;9hx& z>Iaw?>dJ&4?wFMd0+J-)Zw(2ReP96L7O#R!z zUtn5%F7fZ97y^?Mv$Lz5R+{8}E-K1$ezCFP0En;?LWfGn;UtbDciw}IJ{{G%Kay-y z>9RFbNwt)}>AijXRV7=i8t`FCc49R7Ns5wP9La@Eb{4KOlSu>IMOh1DvP>+*`6b7m z1;w7}M7GewPKh=k*cPluoJnArs5Ft*1_PqEb~gbeH%*c z7_QdH2J~>wL)T!=43NEAHE@X{-wx@_fd>GLoU91W8-lwzxS!R%V2od10;cW21LU`p zX+`?qxf`lA==^tZJs0i$>FAyB`e&ry^Gp72dLvGAyuW_X>1blI{J}#r%fw$c?0vXd z9_ukuSKnY}Vv2g{QCdI=?9B(A4_xgV7VS@gH{bFt_Om7q4iA<+K7`Liy^q1K$gWy= zkxt|db9bcDYzP&sHpkLE@+^N>^Fc!+xh41Nv-ds|_93l$P>DL4Gy~Mq>`@&81t7=V z#7p{-Kh}(|)VQfoKha35USdPd&<_W2spe&G-Z4(D#&V$z;JH*4TtyIH6pCe(N#eb5 zP%_6MnlR}A8$s7^seSw8_(=*k^+yTa-VUKs&ASC-i&Yh2{_uO>boM&=sxLaXJzCDl z!LhKEE{pidlb=cR{+m&QpP0dt~jW7a)Pg#0Gj0L*iEZ-|AD9Eq|9G}kM>3)#g zO{<5uQ=6_~XEV03V^M2uZDIZ|$!VUk8h376bu^U}i3AK57F~wP2p-N8f^wd(G*ktH zoUgH#S{zpCTYKUAz;d$g(Dz@`v0m#ov#T_f^0#+e_^Zr%gc@v~enlOD&y99g;~5)D zE&iHeS^1|L^eQ4FyW^Q=%qGbnIS~qL?s$AZbEUy?^=mot963hD2gI2CJc9i#DGejF zFGv;3?PtMEbD_@*|Gt`hu}sNhO>gr`r*-Y!fZY@zMUNm1j(5az~VyJ#u2B-r+?~*&ewc(?;fP z5)bJ_oqNr0yvjwwk~LqDScUTAOui2_>3t5H`W1FNB^?QOy^&lI#mmGLLNbJTXd#9vqyHZ#TYf zY{qcx$o%2*&6k8E5c4XGd3Iipk1GY34i0b*+K0p(97IqA>IkZ7`=!^~4|42-FoD& z2M`Icz#qUnU*=jURPcE-p!HLUR1Ek^DhVTt#Z%6?SxZ$2K+|K-^spV~aIt58X;3c3 zZDTKIzooSNEkk_K3U`b@+m4Nx2Z?M^Mm+P2ENLU4Vl5QDgo~W&g6ArEK|-c!WM2p( zVEZ&+*nLpRRau!Q;&bs26AqA1!bS~SY;jl?*cZAvU7Lja3~c34IEKb9c@L9$$vM>g za?2(msn(wn3}HU(sJ4!-W;J>l^3W(#X%@~^5vry@K|nxQI$7_gUOlDodK2 z$whe)R4q8&*lx!($TVf|v7=qYpgu$0$})E{G*4lW7Zd<{3X2l&NHqLt4DhC0>N})t z;i%!OT}9xs&2#F4L#GR5gPsy@>{6y&VF2V2YE9f*|F(RjdWOFc1njmAeVUr0Hk%Fu z7dHo|TZIb_$o?fG-g|4f@FNT@8_ZMmUys46WvAYxKmM%jOKNIKzRM8No%h@*mr!~} zt!x{$ojz(J`ktGLz(y#I=i5blzK4UVx_|#g;G4;GL!rgRS=#4oj-ZAFa?vH{5%;#r ze7}=+2y_T4VG5-^%=*G1(ej5?KatiZVM?rcnNgr5uO5I#g7qFpZtXFYQ!CQdaJ)MJ zn21L?J;oD*FVLZgN?sx23K|~mrQEsa99VMXAq}pNesROPxDa0*+(!xDrUGo1%GHa^ zBW=zwQ_|9Gox0A$AGRo7+fup0Q(3eti`Y9^J7i`yn%Ud`;T(3~igK##`sdXO>3+*w9<8Yk%kZQ)+P5M06|Md=V;HdR)Na!!V%Xl@ zZFQoHz2@b$on<_3?R_@r?>z0P%5xnZ|J~*D#-XxOrd6`RGo217Rmrt|bl$FnEgoG zVqZByuE}>o=@KRXn@(9>M=pex|7`_jO8?T5YP&MUwCl#hp`@qh{P@bs%0&9I>=zK! z&`=a0wJcDJTy-6*sqxGf&D%8D8j4G2jTVuB`RW$+vvB~RhxsB|u)Y@@9DK8D`WSJ4 zf4`&}G=*t?DCC+356C%;b&KOdWFkaQCAvu1 z^P!jOsjRHdKRw;c+gG4890HWh$a8d^1wVJ+{?)|T zCYhw5CE<4@{l+*dt(>00xvAA~+Gm(OXc{Fv!tJkZy7#+a=|`CO*eK}#+wxlr3xk8& z1IEs*b!G&TX>uwyu-!UWyGJjlLMxz15Q7Dli;IgTHn^=ppR?~s+$X)SFR|7cOIzfI z5ORLUYI2ka8JmuI2^m@(%S1WaF-P(0HnZXQDe<7|Dx-Gtz&jJG-NS}h3Zn^&%yhdf zxveuV+4}}ssXzfzzSP<%`Dn^QrIA0Q;pTb=_uL%~^T%rh)@(x1+@dUjb5b z44^~ZYa!tL=NY&Fp+c62^EIw+Zrpku?iIW*B*^s2S>_H7Hso~w4maOapPQBvFy#mH z?Ptl+epob7=D{=@ibaX&PYhKUIrhYbkWFELVZ3|Hv6Z13_-_0qj!c+OUtd3`9!bb? zMZjQz*F>ENmJ&v<)zSTreaq~KHqIbOW9@VFzFgOF>$7W1lJybxgIU2dE`wGRg^Y_g zwsS^-RKy2Hym47Z`&onVkZX^A5DjE1LMuT9EG#S%6KP~+cE&StJ-A6*YelqbNU+~;B#HEd%wDzTXv%zho?K;Jw6wG~ z3F>vqo0@pudK}E&pyJmdg7`!*?B{n#Wmm$U_DrLr3L?)l6!*YaMpT3^DQ-MUFJqkJ z2;)R4?8t~AnD6BcRnsHQfiD6KWYE(0_R)oMoS0pE2^--v`?Sh4Z?TL}sF(ct27+kW z_R?W3W1nNVESb;6rW1xf3sp5t?Api(lp*hrC-pJc^G7Kr&7KEHL2ET6v-@90ccYbR ze5)@E{-Q9a$=i$4CDKF`u7bX!j+ve|eUy zI#L{tk61hWeyaRe&s>a~qDH$;`Tp|WKYrP5q^!WSvzvncHZyjB&kN=dEJ_Lj2IW&K&vy3%J$Om%ywR~kixFbdR1CvZBqrv!l@SDKiS1fRvYQ6{Fe#D+cWF4KkZFZoS{ zCJ0-sS~1L@`-n+M%01V5zT&7Ka^#78^9*wM6=t_k+wJ>37@_Jp@D;XhL61A*o=^^x zAQ0c{iizmWyEMAs+T=6gB&fF^DvmT3Nx~kso&Bm-y4a`{V4jJK7B1g-_p?Df`Ad4b z=bLfbfOBsVDKH0zYj1C#vHF$OT=wgSXJEa9gO8Sqr)4Qkh+C8kHDVkxZ!@p2+3NQY zf*kJ`Utw)m@yDYXBUYVy%FWxyy8p;mL}3ml%JYBPIhej!R%5<+Y=thSNr>;&nFvK9 z9k5?SX5u6?`aoa2Wy6|j2wzO~sMh-peXWcELLOz=wABJ61qHNp2i;xf zFQm&oF8dZW0`BJjrv=D{`wV>m({{0L&@f(bGuVRXBE+Yt4#IT8ep#2&p zx4cG~Wf<`*I6Be7fBfvja~sjHW$kjk$+RCu4SKH2MMX11zW;PyS)T8~Gy)pF(&gjx z+PQD{=kFskQ}5g#81P{K>EzeQ%WUF6Y~IPf$#1%%WltnDE9?Dl8aB?oX|sRb?0un< zQppn!dg-jJv`y%KN_VMT_E3r+v~*iKiXPip$9g?>x~nwIx!A2=;&S=NxSzt5Y~y+l zzq@lRJk)dZa?xjDmD_oEvkb!X7h@a=`VFRoNaP8-|Lsxn5#1yHbC&f)IPHVL!0Pbb|&)NEGes~Hm_JWp`fvDZppt+4!)tG|IGR%w_JH5~inSX)1eWm1sDuEqYx499EC zcH7EDhI&!;A=VLbr`a&O6(#n1y1whr8$q`n()vI4EF$EpQ^vb)#&RW7=7jICA-Ys_ zgtT^c{<81(`=HG0dQRQf51X5txc})MCh^`+!K~Mv_Hwz%ovW28H#6&EGNjXm8*_#Z z&1>bT8OGx>q-+J_#t*--$`5N5zlX;$V;#%<&Qhu}5oj~0N0XhE^#%|CX$`MDw+TTE zt*Yzy3B#90^|y7|ZwcVPl5Lm@`4s!UWn=DT8{E&xAk?XuH%g!o|NESK>TjiSwM3F% zM`)B{WbIY1Mb~ec-bPz6w<}e(mhjVp#zo16t2Cay|0r3dukzp;Kz5AK$m4VH-HBmI zk9V}U|KM&g981J)3&IND25p;rcFw(f5XEvjz`f^^t>o^V$y$M$WOr_PTS*n(w?7DF zS|@RA+u(`l-)KMSI9zH)w9XoW{Uo56n6X*EBxr@MpQPreHa<veo{* zqZa!(F%Oo2`yBjHKfYZA$pGO+d*KSGTC-eSyecUPECsW4T|r{ zl*6J@73UW9SrNS%2@3$?nb^aB&`JM*u)f-3$Y2torn-&f^lv-Mne@%AtW-+hwoYbn znXNIEhdIcv93=KsA+D<%p7}`SuAr>qAqTokKo5_NBLat)M#lo zuez7DIQAmwyOu|fI#iC*MoE~W^IjK1d#_#|@8&K!)<^wL2md|@t=zA&P;xfrb}myNS5X5c>ce%Z~{b;wsFPXke`3{LiU z#&?CA4QLXry1Q%a*xQOq1?!cKC{Z> z#5j7S683{1iPyH8!R3igs)e>=0&cvMwLj$1VO?{Y@wFrK2tk5tF8tV;2L zV6;>HuOM8-jG!U)3)l{yyu5UCqnp5LRgLBH*EEVS2}5XWzi<^`)xz7|CUQs)uP=o& z{vv2qIae6oFCia8PHwEGtJ}VRK1^YRZamtz-DowyJYMT=RT$8hM4LDu=n|%`?Sf8Z zuo~khdSf7v9_c2dq*X3h{yqHJfX;0;`2qq)e{~Dp9r0lumX2a7Zk)49(wO>D(F%e28rl!vG*G$L zWXFJLiuw=>aQR%Ek=N>YPNl8(ZH ztMBg5_Curxj@~!rhsRYJ8CU2-i$2@i+s%!v6jR}NyF1}eH4ZP4wNnvx3mZMVc?b{_ zRRgl{H~7?rkRG?m0G*y4v?;zs>ul-A;zaV;yId73Y4sEu+wc2j`8^Ak-wZ@K+m&D& zit-oj4EhAiCgSTmPHVh4jNW>BpGC@u0k%i#(Kd3UZ|YYadtD!{_K`MMzx}Z%p3&74 zz$x?)_Uzksez$<)cW_fw{1sTXvpwHo$Tzk&6r=9I%tg*BhfM{@ z(l<$;7MGTM<(Awr~=Z1E%o?TCSmcFc-PKp1ihx9%z8%-Tx zt^Z088}d567n~5i5%_0mK~;Dti9!;6w>6jFq%ZJ1TLbbZE)2o~yB|M(bjR+yO0ncj zz4AqPe~f*Q81<1trd&T685xGGrg}^9Ai`f)T~2eZsl}B?&=<^MV?l<{f zmthc)c^$NjkKY~R0x2mevv2}b7DS}x9}G>*Sfit3VrCixMeHT)e1IO zM0{r>EhGA;N(9y9<>i6Cy%Y=QuL7pXEB%f0%MNn65q}Is$Rw-3CCrXGA%2+5 zZTIY4U7J(Z)Vu}-Frp(_aGhl-ai~GJE0^w^#&U+_;0`w3xUCyX-OZsvuXpb@K&e~n z5ES6E+Y8_5k7x!H=wDOWF@xt!c`{{u$uSj(r_5=nQkA#G7<}F>OqhQDc{lCjP>gg~*0|Eov?pzfONSdu zXgZwo)p4yd{o>6Bxn{;DaecV#Hd|)XWb+UIT-$N-%+fP6iFyu>6!}G7PJ2JeVsQ|; zoUqH8eGY zW*mqbgC5Lf|Lo2Qi%kWDy}_mb(2Q}c^8m4fAC73;bx#%M9~5$rYIUCrA2+lVo&p4P+XsUn$l!RQOrHf9!dfXASW z%+G7z&+AA?z|DNHW1m4;Q0HR`MWj_Wj-sb$i)z|7jf}KWh*{+= z5j@NYwhTTc7m52J zORUNM_1?;G>7%~>Keu-M#5~q1>nwVccYH@z!R8s&;lN2s6b>m;j$F5A#Muu9+~g=) z@iOczfc3PhO@eL?)!Rr)N^0fhH<~h1_>0M5Rx+%Ea(p8djn|4kkG+OKbwhP^_3v2} zT+A>@7;@Awx*^&Rn(rq^Mk3A4+kSXbq6B833CCdF9`)6SVjna_D)!k=d{%SMy zz;tT*+`3D0j7vR+GiYF@lI5?Wq=lTdXH`;_81_?L*#R6m;pwejO{F2Y2+o}b1xZN- z4xgc~Rcef^KO3bhD-S$7xi?(}siO;T7Vm$7u+!0o^If@h{$^&nyQ7`X@L@_hIZ~%! z4Ao!TlyiB3J~96rbzn-}SxSn2yJTN?qe82%`PZ*s@r!80eJ3m5d>&*w`BaQQh3b-J zI(T8^pFsdd)Ut6U?ZxfU$jDbrj1KnsXd<%|YaX%$sR&G6$%5Y##oLzk0;U*k6z=S$ zQ9Ql`HVR2f@XF)PUU^1xN&fF}wc>|@d^(7AGf3xVTbh~{{fIN&RKREfMy*e?y>2OD zEvgCvq<`nCA`qhl6#J@U=#1r(l$7Gt_+@lt?M-5B4K4Mf;;>sQtS@1bC?Y>a7E@LH z4R`;2dfR%-$qQZWGFy$JIMv}#w1LRzm!768-#ceiH|bF;B$*2&e~EMp!+Q^jr}Ncq zgZWxoDuYljDyS<@B)?Kd3cE|}qDxOlN{{hr+Ar*wWTRba)#t}Sy1y>Ht`?JVb5j3? z!r0#$Fv=|)I$S+IA4jxb!OJI^E|vG^_cW>c-5fQ*EY3PeC&!0|CRP+Ontv;~RWD)E z>@%!OCp61CbE5oyNjg;2@8%zjPAclXEbnJby?-C1 zu=h4pwt66dG`MTB6SK5DK=BGBVsiKKQnpHa*GsGC4V@X^tI^MlxeA5Wjt(J$J}VIB3j4IVM@W#09=_wvpR$tHy_BE~hQFJs?8URlim=5$zo`at ze%pt#_|`Ctwl*|OeK0a|5_evQisD3_fs}<&ASixiU>IIY)vnQL0SCCA(>8kFWq5k{ zb95|7IM+@Q8^*-7hPDiAK{pV9sprG^QXPpG|NFB3)=qsxDW1K{(CH3DfnEk z{J`PV+eGFUZ1Drw(I*7MEZBsYl_%_)%OH}o%$g_)#Y9?P!Q|2Ak65u1j3Sih{&G8E z`KdbUBQ4ygcr0fwceI1Ef z+te3p9<<*kh(ek({hpoq^Y@=~J|a^9A4;K@hc~2F8XwuREk+{z*(9d_JPva7h=o2E z!*a4BdKg$Krn9p>-fbl?fNClPRl)6)zP+g;JDhg)Cy<_-1!cefSGcMoTx%;L zai;Q5E(?jUXR09C0sy$Pw`<#SY$md zY+d^{gJ^`w$rdQ;8vYNCf&-I180gN9<#kEAVOFEp>ECHw6@l;kUMDN`t;@N;dG$C6 zQ$X3&H&Bqt=e9px(xb@UZoVA}p~)(|&G*0f83i6(gt~>!OfFA+XbI3qxQw>`5vYT` zV}W*d%58EXuX^J{mjRJKYflUj{i(V$0u@^A5&hwR`z=(^ai|!pyK)2tKOz{LFykn4 zG1+Zep8OSXjO@M6l4`ur>-}{WEAkQU&a9Rg=3Joo`U3?Vpewc@QUwY zjmO%{O)FL$i0&-pVr_wEAQTj&1P_5<_s#R}Y~xRY$i>JYNJ0)-13Dm`GZp=Y<>>P} zO5cf{KfowV7uLE0um*6V_rVM;CdW4Pat@s!07Huy;J>b; z#8$*MgvB<{4P9=1IGec+4XvuvkN;9V8tN!wa$Vx-JRv{BgAd=Qv)SMi^bhImnzNBp z9*f-PU*c_m*cu!N(F;LLKz%FCe~)5hV+j)jK<@WQ__%4NL$e1kZqT`^&?sw}$QSQ* z1dG+Bwbz&1Z!cG6;$&rqLVnw++VOutbwH0Xr*}H!SsGd6^$|cva7L8w{FeWp^i8Xu z@Da+D_LK0D!R&|eA970(3+x z-|oMAK{I&B+K{z~vn>O-ukd{WfH?da4AhBxC>RJtTz3G%fG6yt^<tr^^m1XGbde(?GT!@e7HZ53`^7xT40SutcvqLA*5< z)Qfg7b8x7(AGa*u=+(@NIh8W8uw1Tz`{hO3D1i6&1l&T^pbo^15?erg=)wmzlpso& za;a<;`&)$t5Dw>!*B1wn!-CgJwm=!T^A|@1PK-ijU(CK{pbJo-S}LKS$(+wP&w-)K z_>KzS5rtQ?BKr`m!kF)-f(LIdUl1u--zrot8@H;iFfH5HFnSxdZ}l2z6!=qt%v3gG z;gC)~Y5wl{e`yM(k zO6jXVr*klCsi2TmcZ@>=*) zMAhW?w?}YPks+U+&fp^1gUU{^1u9V6zFi#qzm{e@KGZHB*LFSMEE|CVLbua#wc|%e zM@MW=>B981sX=dGfP|i&-i)TU!F2-Y9@W3;uuj4PX5*N~=m0-dgVNJ3T@r5|6=0$C z{The;*j@(X4Qr}Uj%S)8OeFbPHH`5L3DCz}Hv~GP_Kc0z0x0EH5%<)haj`E_zk&eW z%*QTzxF0pGe|;CYhDkL%kDC|RNrc?@Izf7Re6`!pE6v4PvaX`8&I=UwwSdL90|AKq z9TFJ%pF6%+H>|C${ukRo8u_Pfj4F*IT}nwR2yyDfA8|_T7~u?IV0w{)YU!)`&@*bJ zr!A^<=M5874`v13m<&Sqi$XOA#+IPxtJDwFEW6q4fIiW4gjK<6L`_%#bh0fD($l41 zJ2iUvSDgEK%4T%8&%MP`XrsWQyw$?W>J&8X_6meTH^CT>zvW#U`b!AXP+CgA{PO%r zR-neH|KUTU2n)+0CGa0yxO{WG%)bv_hv_EkGX;WzGb(kFrZhwlKtx;wnhyMvVw_n3 zp7074n@LPjeOaJ&vEIW{gf6L4j2;Y7q{r)!>u~ZcZs&=pNEA5wueYd;3|ga9&}D(2 z0WMO1(C#DRSP#?8jUn`@AsntGi8S{)A( z*Q?&G%g2*oJ^)G}+Jrd@;X@?u|I1$<9(+6JY*+amSK7AmW9R^YA=mxGufN@XW0a*y zbqLOHFk4kABp40J-f@Knd%$=jNj3zcPl=I1_XtFjd`om2<~CpnhObJ?Nw`Ml$>R`1wZ zU}?d>M$66^6k$*_H8%?$9vqC?+Sx@YCJlh#n3|^M2Te`0San9cB&h;ykacpU#Qs8t zDeK_qctRj3DEKH`c3njAY`wbbwf5Y9f4M7udhILh^geo*;9+g(HWlT>f%l>T$8>(Z z4hURbJx${A^(T~aPsl-kukLqR)gECdf((m{V0tYqrP_hqomhwTo4LaJfI2!#zOn7) z;gAjF5;s5yJpj)y_A9NtuZ@k(HArLe%`GgXgS5YuIVT~jmL_j?rR{)e!(I|C6(PC; zr~^R?k$9g(8)Rv@6AyxtxnL)ekUjq1`(HKSf{0rD?efte2k#GB39Y`&-o>*!%t?-S z!MqbGlhlhnodlpD-t{@sq1h&9jzedh z5LR+85TO6@8=Xb62{#_i@~a!pP4R?WrWjD(&+q#FE-hsdp(7sG)YK4354?GA)4Y7_ z08Seln82efo4;4T`Y*k`MC0hHCp7)VXM;V3@-ro!SzrPAXLi5=bV#r{+o%B^DUe>G z#})-*$KO~k>FdbDDY&GLw>`8!Q+5jK+M?~61_T#S(a^l`@$pY+sln`>3>+G)hV46Q z71`6roEmhV__Ax1)3zPiN?2G}_(2JdMgokSt)HZHD}#n%K61gcbK%Ff;2r%!N}v;` zl=G=vUV<1-9=r*unsN%N)y!iCU9~MNwq->VZJIv?XjL^EEt!Gv=Of7W#^HkZaoy_{ zvfl>Hz{zlU%_0CJLl1IwGxB(R$gpbWnZF%0X1wnCbW7!8T$t%9{W8Bq$xpWJWZ4}# zw)&k65*R%Ns%~-*jX1WpE*;;93HK3-`npT0t4~FOm!DpazzdZe$5lDAzt_Y(2qkOa z0ovXW_V?yVOp;=pI;{A?gOU!syzjCcGxxqhv{X|#fZ2tGeBW`dVV(h@F+$`CvBx6= zaQ(ABD{)&4a8D)3mKkL<7?R5_hByFFf#}}}HvxU`RMCPswySI(NWemQwY<{zrp;yR zrm9ltYeY*<;KROOjn*L+(%WC3p>8V3;gk`{!U$v~QnA#HQB$$`aJ6k(NQ8x82FovbV`_pSql#}pua zczJo5z4I%Z{~lC)KKg&1QDqj*3C4t}M}*mXw`f}McLJLsi<%yY^6o>K6FCDZiEKQsWp1t4wZHcMVDfUZSJckJKSpTem&{DT z;;t@#x=@dE=v(uVFTVMcUaSKXu}usu_i~y@S#ByxtjQ-c*!6l*2uwAq%*Uy)Cp8z{ z`=!~9pq>Xrg70kW|b)L^<}hKXFu5Ms|?klxEnc zv~2Q5%TYCt`^}kp@Z@gD*fuP5{JUHbD8niMy+iyD^%Cf#wuoSQq)TQKGN3k1>W_?W z0z*kVh8KD8e_DVDWNS%FOW)dOnf-G-cc)YiK$<#HvTP=k*lmRz3;<+l7Cwu{CE~xO zC-<+new#3G$*W4yPk5k897m+o9>&tjf1!QHA5XNErq$`!}@ zIce&!#E}U)Y`w((7@itdPEABy0_zy<^`Gzrk4yp#)5lE8$7-)U&zzU4-; zI70(QCMIr5;$TmHnxKSwvM_a?V*kd)SgGnKL?J${3U`*?!)OFh76yRG+)a;2HadtOvKFZA*;PV28JA(+<*-eqVraeP zTY@Vryaw;77J5b6F7KINK^-S~?m4Krxp6`0AtWu(%&dqQ9265A^b4ypQ7+Xbow_9} zRp{^4%=3L|Rs8b@dudG_9q&F6lg)zte{{WdP?c*JH@xXhgMuK^9TF-X(v5UThk}HZ zbazPE;Gt8x1Ox%;5~M-8Rk}k!;#>Rq=KbrPcjn9-M|a%!wb!+-wSKYgveHt$Xxmkb zybL2N#S8@>f=K#4(okYe3{Hl(R7^<2L}i8u$~+tU$8VY6(!UwwS)fKwVWw-COZf7o zRZP`$qRiBjQRVQS34y}94(s@*wAsImrSIT9^aY%Xo^6!`O(~=BLOpk^!+ohOLNxdo zPC<|S`)Os9H4X;SaFoZiDv2Fa8_vt{&B}4&F<`NUBMsIVX$%vZZ_O^?maKg=cXND8gA< zE%sJ1KA4$Xl=wY!9L*m@+9h`--0h|DD;nmYq#b6ztE_og(m^@ucmILgdS23b6ycpR zmV@xT&H4gHODRv65o<;lTZuP8-&v9{qloF|UGLS7KB+H@U6947<3ytlFHd{-@Lf*) zy(e9Zbl0a*+$2bs;&D+6Y#eZ!-?>469du7~y|aDYT@c4Nv%jqQD$?m2-da78vK7sj z)E7JgSYfSBL8Hx=+s-%*RZ7mbwic;}?L4x^#)uT`mIT-`)ik*I{w)7V!kDfevV(#|{M68JN40F4)16r_%9m>zddp}=jN|QVq;x)y;HJeyv(dsw_u*~DG)-arG(VX_j9;*YU zkbp|j5F*)cvgLZV2c}*uwzTs6ZU)=O2DFN49(~+Gs~5Z1^S=X^B38HGC|#`G5qzGh z$$o*gn)=j`K{X-5Xxp=hgHvVG(^Bfs$wlDxpycUdm}S%Tv)#s(D)s}(tN$D|G@NrO zROsosl@#SLf6K}BzO)e02ok)T>XqM3{zPKnCO$j5{t+2ks|>j`Qpq`sS<2Rqnc>?* z$BenN%Qxc08ZtL-C>>ya^fLQ59q`G2wc*|B)ZoC@R@~I=A8sea<1fz*y<$5L{1t=v zc#$%J^75T5*-vX{DxZG8acS&)*}XefsAHC|o^}Au`SmGkqbM}Y1uBDD$VvujV04Hb zOc-e|^<;bq+?cu`Da3B513_WW>{qu(bU}@ie=p9cM`6tx!AoQwD0zAGt}M%5Ebu~@ z6!Tu%s$TCQI=Swf1nT>r+nx&w*;tb!lCYv7>?cx;cC;-fnvG6<7nX}k|&PABo8&>5QwAjBFyjKW+hv3j^W_T~-{)Wa$?+~^! z;6*DeyOH^yJ{6*cgiIl%?wslS`uR1VgWLPqmG~ck;cfg>{R@L>ViSwuTwDfa1V7i^ zUnRbOk3{U9ZS8s7yP(y00z=52hEeUMLWxVCroB#ZEM3oo2!d6jHiZ9 zqYldx=0S6?ycRJp_q7>E-#c z4(hUxV_8(yZpG%QOXPj}#3|U||AR>C50-tEGCwD0hg0p0>Dz&juK zZ(HNw@X(9Lw4T4Iv{x9Mw~IeZjWK%r`tob^ZkHVRom&jpL0rL)kycBfKF%rak2As}~CFC55As zh#XUTALL7jmW}b^oNZ6B!9(#&AZezqVf%N%8tJN~i=TZ`e#d&8`Y^!PA9$BK|Faj( zl~1}ogEk8DL2k=g2X+`1?;juURla(7Zfm=8t<_c2i-LzMv$K~+p}|@h)3;`3V~YZ+ zVA6??GTpiOzLAQd&shRUxMDRda4Woa&GzA<^Rn4xw8$<1*S~<@SR~WNaYq^hXBjTs zqf8nOoys#D?2O-7A#L^{S@kv|y3!;E4rMG92If=W{A&MP{o6G_Waj3+ziV3m9!7QW zqXnlp(-zz!Cx5w9`a)07bx8*8<>n3Z);KLvrVGrRGqbWx#oT#Uf7?!6ef#m_ z2OBZ1xUD&$*u|30BECnqEvP`wsjolx0yFr*BsvLqh-Tn5K*$?El3X{&I0Aq5ydgu} zy@l_y^K~@>@L2VNqN3Y4t}|=H`~m`c?tL-_rAF5K!~`lUJ`tjFI3T6aEw0gY-o-OA zHNA9GP{1xVh~$G1BuCu8fB!qs20V=?)0^UmJ@Ho{BfZV0p6YVhqN~>l`B!hA+uJgdeW9t20}?ggCdfcP92T@!Gm|=`yDqgHp|Ve76cf}yRH}rXz%|* z7fuLWUCS^#@8jMSdR{kUUu8#3EzI|Pbs#MbZ3t2>%N6KtWw|&x;~<`zcm)Im)ZQ}t zf!TBiSha6{FhC`cgM&ls-^upo#ROO*P9V)-b#!&rV>?4oOly$I*Hlz!($UbERyr>< z(aRw9%S>(q{&{<)_XAfuutAdD>KP9&KLIs*de^9${Q`KaS4t`>G5jh0CWeN$?@)QB z9f0n)`NNwxuHGO`4=`$AX>?ub>Jf1G84lV~Khcq%XQj1&|AIgM?T6_*_L}rULI%;X zu{oG6^WXlR!U^&nC?R?9_n-w2q=~Hnc2l+~>**Zcad!Y~n$pr9axl$jaN8|LAxaeEq|8>tbP zr~iO7)gBPRI|tvTztQx5TjdHXtp~d}`O}c;Z7QR@(*Ft?S9{*5648q4Itr$kdc6nz zRBE|%fAJK+SSHV(rwVX!;oG?N2gEivOLB9*ApFwumc{&r*=xZlML9jvwnC$H19|+s z?4l77x79KwW#!7c8JIi7*3=|mstO;$%)>K~o|g6~%?|ddCMYcGH?M$RQ}XscU24g+ z!0&d|{Uu!Q{5SndqTWlA@6XAMR}m+RXM^d{@iDjPi(fsDZnCOPz5p~Z50I1qPz9kR z;tArgJpY~=-g*cp5{wqIW>w)pG8_S^5i-}{#fu&cF}MMq%Hx>q*Pwa$bM>1yNV&?W z6rBN6d~nn}=+dLPwzf7kIobY&Ff~8{Cc1j$+3eb|hCa}yn3*8vXvFL>Um;lE zDRaX@kV!o^DM`-A;9Yk&8aPYg;o=H=_3G6o>oTg^ZvXXL%z%WSNM)NdLSCTYgS~Bm z-faor=~}3?IC<}utVa~nj4s{y1zB@+A#f&ZcQpSM7cjd7O-)Ulnuo%hH4|o4Ub_$W zXl$9ugHo|fXsTY(dY1m(dfjNP;C{c(yZ|ipxCa=2s~Go-cBk2`)b02X9FY%enB4f zZ@&|bPhnm6V6hF*7NIm`=H%=hw@*LLm;4^mYFVzMqN}o9bXW8}Vz}tEu*k^7M6I2l zDy3*hNbvb20zrm}BqY?k|KI^G0?0unmizZ*4x<#Wq>j&%Cm04(MP#j>JRyIbjAjXp zV7>U!&q{oe^!!kE4yt$sQcSZC%8WS4z6mQW_@SK0(4uksV)&k!OQ;n-z09`YzI*qG zn3#A_kSd-W_H+QMbgG1#lQc9j*#aFq)g@3-3F=Bp!fpUUe~gZfMo(WIhnagGig5t#k zFHRF{7XtqczzdtxQ#^}l2OKoPJz42m-o?CYMK}8t)~q_Fv&?KJb1ZB$N~x8CgW%(oGliV?VU+i^1T$ z{FsdaOX*L`56ltT*|#VRMq0+k9Q6Isf;H@|kW(?U54_M?-VfCYl$!2=RNb@Ou-%(sy@u7K)}N6xp{dVc>j`5CBme2RonU z@n2%ipJk>xI+5(z2IXe_jEte^kaKCzK!okO5HMQO*y46LACw{K|7(qysr$kyr31fc zxWIL9UbIuuK^q+-j4VgLxqphtL7#OIxw6w%x9&kLakTd-FZBo*+m{+d` zoBz)HX%rR}H9{lY9pLXjc5v__tGfEVAIyjtaHZ~s^T3V(JB*u!rE}1NPx#{Ua{KzU zTT=ZRQtEd=>Q@HRC5koF)JkIF<7=SerrN1nNjR7=^DAw6dLK zG%$~wucQ4%l7y6WXYQ-pvphwaP?*$c^+-kr{rLFUW2(HMfZpxTk0mIm9@Eg$N>{mk zj)0(-xy|o?l%ZzUWK+a&A1B3B$JB9Roj&Qq8M}Gsx^BI7p8!`|ZlRFJr=5j55=0_f zf=@Pgnl}t6@m+VX??y5_2?z)%1u6YF#DOPFOsis#QBhWY*;H5eI0cM)kdOA6!gD|N z{~28EPpPfvzO+|GGBCr862u}5IMEXC=9qyWRWA@q@{@OLqi5X4f#VWzF53J1H=+lp zih9IAy%bFcmd|nS+Sz5{#AMD#>HN4$T4~pO{=aD0d1)4=^!30bH=W@; zRf-a`Z$^i+ZiD}^sU_blRGrw-6a8j}d(V678#;^PYv|N-ewb-be})BA)lE7#74Ex8*~-x z*qW^|Pe6=ct3nmOkvGms^{oIXt>q~=90!1x=}zLg{Il5<@Gn{Gfh&Q5^Pstn1G`3A zV`XJ!Ew~1&@&TkfyReyb=yh^CxQDjmeSy=W8ZZA4Sf?hV(i1Z+viw7FI&u;c&7GB% zC&Wmk3oBEm6Pmw#dmM@jlh%{`foIYODYWIjR$zweXU{jaTqww zkYHE2AzCUO_^FPe3?J6h)kVUhRy@8d?0duxVyAMS>43k6#YIJ@uvzgw==~YoNk3X# zO_hBk5@tK9XIOe`-l}S5`y?Z1Kr1v9ZyX5kw;r2Qo zeq==j-wkr|h>HvV-2D6}y<>$RWU-0$wY7;B%Du+EC-hXfb^>%iA>LX4xPH!uSq~Eqc?}6WHC0r+&VSEHPv3IS zr}zEFfUB!JK#Iw1>E0u>w{Knt)h0AONV}{(U#=9Z$t2X^CHRt`kx zdk!w)Fw3+$&+Tc~P3%aSx34kkJrrLOPFV3tZ~qWGZ;f?|C&bz^LHr1>LJT#O%PeQuU5hO5=HOwL_@Kj6 z!vU<B#{lL&VlD-6A_DXD$?-8Zu@@XAR{dbP(+BT$IET(B zRF(`J{bV{1&5LQk?zg|5X%c>4(pIrpxVU1UK6{4S+S;lDF81tU+X`6E{tPqk){z>& z3`rtNe#Unz^8Zy8-yh@>jPG)i?RP&)$jxQ`pgnDgU2Td>qaN(coN9gr_{eLJo#KNs z1D}VhZ-EbN=C7g27x6vWux2Xwuk0;}40Ioz(Jl9iaiLn>RN%v~|dEra)A9 z^qno^0ICGBgNB7iem~1~D#m~1>D3sO-dJ8K4v&x*hBl*sVKUkx3@w}_orH06+jIE2 zpenGmyE~E>754iuppIb%q>i??+X;O$`=V&cWrf zIivuv>6Q;`hDn#lWMi5wzwB}Cc;x>d;=y!`4ZceNl76U5|Ekf3{wehEspY%2L_Ier zO8)(NIKJd90hPfW319xN9%JlAdWQ0X&hv6$uZ@G{s0z}YJgl9&cTewabXbzS;qakn z>+>@jz5h5gw%aifRLs#97YlDDUk{d;IX0~en2#3uLWf5-i!0$w$IXeWHf zm~Usky5;Y;goFhRt$WZ~?0Z~RT7s6N2rm6r4#jrk3S zjxTI={-(y+*uN)biyG-a##!0QcUM;_G~NHsy&J?Bub2ra>}S={i=ZOO)M?CVB;8)Y zpv$oB=s0Zyg^IVI-vp^*@i^z?wj6ypl1Q=UX$@y+(KJ5=51AdxU>^=xh{3FDcUoR} z0X2hB0*Ol~y^ClXYzT&Z@g<*^V@STiafh?}Xg1X>26tQLMu`1gKRaAU8Bfp*F3vM0 zB_?*kh)MO-DU+_7G9ohUQ7>Akp65`-CTgpUiPvcUj*V0C5Ez@@Bz9Dz#+7;tQ*p*8 z*?IpipJ_%^=@}gQmL|Ubku0)T(kfVlu&I`F@ND)=VB1Z1&&qXoV>{&%gNxa*`vKj!yN9z~= zhJ&O7X0r$|Cp7lk+~lVsbgrF|H%#<_(Rw1tB|Ujk@)SmwR8DqJMiN3{8Du^we~lGB zBN81ac*VhX=;24mAdy@*EYNNL+M9Sf4C> zp5IMc+8tC>R1{*3^AK#9<579r@n8REWH3_)qY+K`#Jaoq;-aG5 zZS3U4QwyT-Gz0zJEy=TPt@wL7$XRTo;_KOVyZIbotG0^U}*ty)IuW$}zRb(!9Qq$XDve zNn=X8d>BuCX+Rm55M3}?j~+arH8(!mR4s5^E>Jo}GyA%9v$EkU!=zO)G+(Y*(L{dc z2$H9Yyc+-7>I5y(e^~HQ8X)pVY!Qokim6eimL@qSdK5=6k;)IvyZ(c}rMsqg`l@gO z)6N}++`x|yhI|OpS4}O;2>MUAXcdsI8ttSqi|J)%f(E{Sl@Q@8!rBd9WxZ_zi8xYe zgM@hu;VuO}x_WH$+&@0dOQfw{#m4;%M=XA!ph1(-Ztd~ zTlj12+E2@~qrwJScIwkVKO1CBlO}nb9Iqt5yMD30G25k% z$MxKh8+hQbFd0S5$-dio|89zVD!&hcGEgx*|^PAlNuwMv)NMC)Em>9`z z{KaCdK+B?>?;d5G1F7K?_LG|(udO<@w(ZO*Cs-YMT0jN|kSm=9Kh?dUD}Mq?J_OJ? zlRy-x`v2Wsc(vQ~k4V3m9Mu5;ZNJ(JsPDoP;Gv@9;^a(BsAFPc_5dnbL3OiGuBLlu z+hlzLj|PK)0C~{)XhzGSIGno)&dry%A|fI_J`50zB)E+(g9IiiYNh)Xlc3-&V2Y(+ zSUB7h0cE@bLJH96#Jh%}fW|T0zkdU$5_VvjV2Vls zl9CRXmKqipM<9MQBn#+lNH#lskMErc!LU|a-Xi~tYYLqgOM}ls8JqX3dE*@32~sS= zjHjN@1YxZRX_6LK>Kiw1nCub(Wr~2i;Vy7CC(64^467_^XW;LFY!hOS3597bOHKcF!uoA65TI4MYYyqC}tThs^{3fB;Y`#6X6ztuX@g1=}RtFab7(e#v9B z*iQ6@IigbiSinaJQv@ADYiosorHX_pfEU}&L18dp4=4;*V0rza{PhNweSb_xLt0O- z5dcXgb#(o0gw#dAeo-7FS<>jAO^E4 znP$il$dbDsB({lHrgQs^TZ~F?0pQyToK!q2@E|ZBS6H9{;9BW0!Sk`-M%TdL3CtEl zfP_m^Uq2E;3>iwl2!d=GDJg{S(HdI9%23ra4Qeq@f?Kgz7&t_jh*V)$bl3(EX%Bvu z7>32f;AyJt18#^>;Is3?l^SB4sA?(>SPiIMZ$n!XI_IPag%~Q1KvF3Fch;>AZVwH? zq?pi=F5w554qi%sBuKhRrTTTF;er9)AP0lfO&4k$J-vH?Jb*Xbq9dBL4sd7`@ArJJ zp4@BRhb=oNX9jiWkTD5|dBQ3H1*Y}ex+i`z`Q)R7pI{=7Y0R%*Pf?c(9~y>D7^+aAqi)SLP*8U>+`C7LsIcn9gH{3+C=Fh_k?b*R z3(Y}kXlADM?yZ1}LIAtMBtV$WK_iA;JRSqwYQup@=fro^zg0d)Ets5~TwNO=J(m1b zmiPZdjLq6YHHi91Dt;uQBH*9rn!6~fA$8P5W&GBZZsVRHbDz~ zT7~P1!rHMf!R`B)pd{wzCIsLJsFWzzs|%kCV4pq;I#K~mgafb-p2N?QRuJI6dHWXK z+1dGMV;mo_q(xz()xnHz@K;1YW7a-1b4O^-{pM4{u1}9rP+?DD=8Xm*$K&Qe3DhVy z5Iw{W+48T=H3%UrfW*suZv{9L3O5#XoDK&tfJs=G5|Se7HRHt;a$4cp?A|9+&n!VZ z0@W1|zqegoUASdu))U@TRmv!uOy*HgIx%ws94Y zk7nVs{E>|+#=OpDsSVKf?mIV=V9TQ7=e6~1@j+QFGFyHsz@n*vQk4M)wCfcean%%o z3{qDwf*vXCxkag8ZWbSOu|oISdaC9|d{PnxSargnU0s2;GO~RsxP1wMpd`TFnyDrB zY@mVAlY_00_QB3`Yck~fJGPw0Mrs^l+Hm%mkK#V}6KEx3Kp`ZXKf3f~#z_{QWzm-e zGa7MV7I!CXjhNI_YJ>nrCvdEQ$V(E?h*l4rrHi;>!?c8u4n#e$U6x=HM5Pzlm8e$&s)I6FhV!pc0kzPd!^IW^XsKqDtW{F}dMf*&5} zklQHA2jUM9L5ZI4-=#f0PXxG{P%&)ulPJ^<;pc7}1PmfVX! zx!(;hS#VoKD%P?72?b_mZ6psLo)ocUX8^w&yqkR5k!P)#ft3{-JgFzucTj(6QB5@= zhyM{3PH~%r|99Q+>LCVLMCA1K6WL5H_%URZ!i;rXckF}{96X_BS&eg6o-Tgm_O%*5 zYbikyOBl${v$KfT)e0K*t#t(9Brf5>F8w#@6IP^xlaJ~?zH;C+mzW{^R9dr1rkAiX zyUa^2G4Nj$B7AJlE!^SrMPxv0XFLYdHl8>9=X6-#t9o)I-m$>MPhK*`fMsJ|ms|*=gfue-hfDL|-VQti>c89D^(U&Cr_<*!^ z$aj4C?aRO@Nr?y4!$vXPSdiy zPfx=#g}I7A8^)t5Yqb*i{}-KZ%f?h)aAn8qBjVyJjz#!|(pxQN zC%tupIr8YkrSv%1^A=Oxu&ZvlM&*=ZeUa$3b(Vyf%;6AcY;L?*!@vID`=(8U@%vQv+&0WUqGOOy z(c!#VWl+Aso~Oy)c{ZX=t!fq}=0p`fv`Dh%ZuC=r4y{g`VH0U*TpZW;+mVwF!hS5@ z6zkOXCkHimkBrMx%<52NJiScuu+*Z%tV;pWM|WS$GaQS{@0WFj>^Fq|ZV`q_57y^N z{1``$$DjTOyM;%w0oTRQ8cX|NFiS^?Jadd?LBi5tcTd$%5 zg@|zH{1%7av_}&VD5$v;$i1lvm3ZVPmoH-J_}{M4{!93@=|{mr)H7k~OO`_p)q4WI z(!YFuQBXjp_)y+V6wl1C*@pGQ|F3CBMAVa~&4FuE#S}kjr$eGHFzA&7OSq=nO$wE2 z6aqC8N2$(GQTTA1v1K)u2cba7EFJu+6$y*8NBtr;hGc6MKd0;y7WF6x<`Np3a9Uc# zJ)s2xx*XipBqFQ`ti6+yQ1+PZC7v8oBS!VRsc>bTj|DDNjsl3J{rB-aY z8G0BI5lw^}(&NTwT&kol68COu%G-NZc#k?ne}rC?5pThHJ~(96Pdb0JGBy>5KAgYa zln2_PLyEe*ir3vM2onr_l+{6VFtp(Flw8`G5 zb<<}EpW-qi85WUf-K4+BZqeswlB`^v-|&B=aI`y3xI2*g@}X%%TUOB`G9+mj^FKBc zOf;j?MAHuOmfx6#l@(nbWi{>7oQ|sPRI#wp;v(x(5kZ9Xd6hkjZ;Sqktv_m)4e+ND zkmBg1MZOj$V(bnf2}aNt*r8o}Ob2}Ax1wZ6L}kn9>-NN;ujZ+eU{Zcli;js2EidQ2 zL%5AL8T+wq-%?p0{WgR2hL^P79E#XPw>CCc5rY1Qj7JI3kh>pq|bKT&z7EPtM z9hm=1>Jx;}m4%Zq%XKiaapB);AoS_%WG^g`vXMq>j8`Cg|KZ8-h5%*iYt&t8IS78x zW-p5Q;r8DeH7!=W!sySk`>3lJcB(#Ox0OLQK4Qgm5q+=!KF15r%Am6sYy4C_L^!nm zmxLV=k;|>FUNZW61)LGu4c4iH(jR|eIXm+rL!VJNiMstEh>2Ad-w4aM-HEnb?Gnj2 zeiwPdT{V7jf2PYxXBC+_aP`6mzNTbNjEOtb(Ky|6Asst&Z_+-y=mIl-0L4YARCEvMf~i^L_NA_aXPtrpNY@&AX>hpN3MzFP?Q7FTdBG*gtk} zWy!VqC2E)0Gaf^VSe||tD@b*dP1|72Cn>riZv~08@3>XKRnO@t#ccY}-1mXYOWv9< zcg~9?Vy6ia_Iq2cYl8wX$i45eLD~?uqd@y3jLyq@b7xBgd536M!F`pTU~}#c z>o;2QB`Gur6BV?m>_s&j?1KRtE0c^?*i$=v4=j9q&ZLVE>zNyE3_D{7%WxSyI!=wc zIZAjciwI?zmei$x&qk0RkK7Qtr0Sw*_p=&bN=cF zcbUGH;l(2LXMd!@ymeQ&i8W#MYiwJTZ(F=?wt@NU;qc)4hZE#S3M<2}E3ySIJG~8( zr*+&vLH!gLX*+>aOcjrfh89RU9z+6iMJ*$(gm;P>Sw>%46&*TSDjuJ9oCDu2Rle)Z zMX!7#MBQ&Ve=G-QD96tLO5mw5GgCS;3W^oUYaje4PR%spiY;#9NJR%Z%DP;=b)MdV zCu0<&*b$@KrgPZOO~|yg4Kz*9HdZ70<~yIP2E44&n=`BFvEVCXnGSgRjvl#pa36A6 z%fbTjFe#~~9-bB%eGEFLG$y#1mOQfGc&}9pa9gNwFuw%4l@dH~E0%+00iaivF2vKT zkqyR7DE{vt;K`nktr6Q;0Et#Z(Xf?{2gDw-yt(QkIQQi5>uy74~dlyYRQsR~J|6 zRVtECMVtt9c`b{oDL^{B)0=Gu@|d!VIH3skPA@NAh!v99;kMA&+Kj4^`-sZ(45Hx( zb1oO^sL+EO)C1xXoKrD}Mq)8{u})o%YxhRhUQddk-OC~!+B`1%DUovq{kLHv9Fw|w zrK1NP6fj94{7B_+Y*oeR2h>4bk%e*(vff+${qG6;3VC>Bq>Q5QX_N>0peuCrMDndg z?;Vj3Z8|!#a!5%QiIv~-I2dS={rdHbUR<0yCVLThHqa=^dw2){z>@sK*w7I7-S;u0 z{54m5g?FQ(DQ=;$=iC;5SGY*0e#SM-ia>f(kahnttWHCq!a;QF89ExPoT5Uj>a*b5 z0fhNGA^%77dn31(oDURU4eT#ssGZu*-T(FH&)4*4f+%q~CLJA}oT4HVfI2XP^AIR^deR^KkSGiM_^z1zDJomH8MX8; zuC_Ojq>vE9S2hwVP^0(}k>xmwx?P-4* z>06px?f7Aw#7h|7iU(iX0o?8$2uYXW;WJ7~N>Zo}EB;Q@>8Up?dRS{P=smLl2|)yZ z{(S!eL`pC?vjzHlcqoWhwbzI0+sB>5XBQKfAF4meRS2vYx9jVmO4F{$nqc1csmAB; zwZ+tYnHmXMKe}ThsiWZdrSv=OKRx-tT;jVzI6Ga-d#l6*H{E6Lflt`s@RPw|GSF{g zE2;r!zY5q|2Z#_*jnI!YF^a;%!aDHf!NWFq9+&E;iu>FE6+hJXx8{Sc1MZsCk-%kk za+Not1EK%~IwMQo@bBbuWuA#p$AQ$oM>U?j6U*ObrHcD-9WUKbd%X)v$UYbLfBYA+ z=oTXzmLuy7F4V$AJ=~ma677-FB>~UAD!TLc78hw6n#R*hN_NP}G5+4WN1#-PE1I_R zcAekaFjBu53qf}4R-1hdBXsB>U<}S?hrSgu2nazJDqWUjAkZuTT#A1AvNZ$)2kd_% zqodF=&wNv##`6mCa6S|KiCz{ot83yWUoCL>0D?=W;+D%zcvy!06kf=R#n^i5n`A6R zOkb~Ml66Oc+zF$UZe{w(UXL!dD?380#KkV>H1Jeb?j%)rEi0dhgwg0wF= zfetk+rSpHPBRA=U*vhh2A}?%U)&4;2J+er$eoT%dXBMnK0;CW_564{uf;r#{ODE#iv})(AH==!AT~tN(v%Nu2%MTPJqhjz z5};5%KmuL<&UrlntQI8t=%Ha@Xb1>WIp|hVO(;aA`|do={QUg3nUG_I&hxZgy$L$3 z?O!jr2NOpS*=?1>02C}2k+Kd&TCD6xsCAF~a@pcvEchYufm!^1j^cEcs& zbZq6d8gseo1u!eVjqvS5i`O55>v9v~d$RwQCf+0s(Z%OylB@)Dkz1ko(M0Q*Dj{2; zGLz(3SyyNU<<&kSUnkQOqjI8%zIZExNkR_Hgvcl&8vA~ojS2v}f=SSo-_j#xw#A41 z!v=%X_*vciX(DFd4);1*zC*Ppd}vPS2`luWQQ1XG${O9Z(2-wMSoYLw2Cu0zxD;@{ zZF(H~Cg7jda`ciWN9NBm+`D4b?A+{;IUSM9%Z#(p6N`V4uiR)|5?1zxWQnD7hU?@e zP5sOD?@HVrfToDB6&4UvI=DPnu_lkoM?Rur`Z+rfucD_kn$yPYZS(8TxKV?to#ud3 z5q*%!;sg{%g`?>1IPx!k$KdPd$0J3#M!yaB9g{PW)HyXN`#MzObv&TFob$Vhj za1v-0D0KMh6%@YCAAkE<$XgdrBShx))qe;5_rvq4Z~wlESPM*)bJe&CoS{0phibvR zVeB!{uM*^~Yi<`l8?>_6OPkz$9HwYJJm zP#s59U+sVB5Mr@7PNI7r|6=+8f6tV={U7yICX)$?VqcO*znM{p(SCJBpfS{xn7 zxIg6=PN3%!!`J)$A@i1)g4gb=mf+y&sq(Ub{Zb9%==c8~#rzBAVl{(B_Kn1Kc>oxo z!jpcg=D$Q#5gQx!WJw>GBz_AcmxfApm@k$^+im$GqhCZYmT z>j6W!RPngfTTEb$8R+RrOs#UHk*id~9fyR?<-Vn(>F7Vg;gP7b>=2Kv-3fWwb#;@Y zPTt|?7)KolSD=k{_s`u)tYM z^jS3?lR8A{JjL7G!)mT=_4e$MNkmcd*=K3Z1~!iqOaa&a%BhRGFTFE84*F#hCK(~; z#->z8Z$D@GdVYE$fkx1EOnh_EMh3aKy-gUle{Oi1`L(VCslH!GDBHj0{LH^UYFfO2 z&<(GmfhIrt>#DrzaKpzdtErvr)gQ5<`z|k^n9kTvewpb7UV9K7_7Gz(i@a|q=9zR3VY=|3fBeywH$idpRP@n60Wxt5vPl-0p7cFU%C0l zG-oQzLb-aqe8jj%?@gG>;rEq(ch5@}u^VAV=`KA!t-8}f{j^EU+QJRy;UPO`HMFv3 zw(v!Nb=LHNliMgqM!NfMJ)Adms4Voq5-N&*?1F!)>Ir;z1bnxPdXjg}@N0z7>VK>` z*6cCpRa0BZ5|7B_f0FlGm~_K0f+nPPr;ua+LUP1TfM#-mcqPADz| zJ|b#^yME?;tOj~D zi;B#s1N!0JT$6gAv1Zq}E!diA=b}=38Fk(7)3b8ojT;f&(a6uVy4I)k!EN3YBe+NU z2D%%yXk$bk+2^~miKt5jx8C**fb?W1$171EvWTD8dCKBQchMe7dUNvjz4s_AgDHk@ zooQ)}413D5yEn|3)Qyv51^ZPvNbBXao)49c+hZ|c!VwF7C6EycD<8_!Qq$7nTUw-m zhuK&gxNavb%i5{~WsNT_JA z=)x#2)XWO_j4M66dHkC_?)-dyP5A7yTjsm!HPQtd>$fpKs}%|-cLYO zUV2VrtD0)nhh2A%QV3fu*f_Wf|6E}P$#Ci#be}QjN#=y@lEYD`a(Va86UF_$d5JZ$ zMX2&f9Xy|Rm;7Cbs%;IAUR3Y7Pq6|I=dCa*O&a?R7Ngf08L!|8AoE@yEdGxc03Lfm z2_xVT449xUlLm5;l!___Mf0H0a@V~@Y1FaX9z`7W>J>4o+DD+k5eOgzJ_@@s`krjP z1OnyaY%oXxWY0iqf%D`ZJZ&fLjt~*Z)Zdvu z;c0HzUqLA*Bvip!ANWaxLucF2-Q$tn-v#jm&*f;>o8BiC&K=HYY(f}|H6;>R8@(e)h0y0i1@`4$ZHBm6x z_z4i$!T>3tqoX4b;HOj2*1iF;h$+h`x^8JMyB1RPCeP*7#$_wOnie#ZMX#$ zAdIAHfw}q>cB8B)Mv{`>mV}xJ2UdA;clQ-6B?g!z@knTB;$fV>rpj=0P!I~-_nLLZ zftQiVqjkGN=-mZlP9?~Q2X&v~TVRxx-EI`$MyyQ3!GvE&+K>qr)*@>$bX=S_6sEhm zx89SrXR${U;Dt)(w011D@BPKe$5^E2Dsp&~*;B!nDw-1CbgaO5y=i_Onvp>VY;|T4 zXVb-js#-EXF4$hU0x$LzmEMM zRD*|bnK1SGI?~2kAgdp%6AEa25^6XoXr^ybMIL1Pvz#;Wtzc?{uA+p>VR zg|OH!QH*mShupoW5J3DfXRK!9^*bo<5G_nz@v@moxG^dq#(O#uy_)=iphWOaqx-q) zh9iu) zQA&X*E(XPv!WcDoYqo`iI>}|1lWIQFoyTf(&8|0sYY}@0T2nynzDAi^nY8~e?_1%2 zT=8BLCbchZd3d%^%jfk+?J2oQaK?8`-Za`2V%o0Cs%QI?b1TwICdseR$x!^+09*dz zs-9%XiZ~N12;N(OrWV&091SBGd$Hyk1M7;YxWHBdTU_zxbal^8H`l7#PYQ%j&IDHjzD^a`x2K4Nt zmXXgs)(1U722Y@gV=e|EK5=VMzgsmdr<}n5-@d=?n%Q&h*5D6RC(jZK!=u%_A=nSwXgVWMQNXry z`J+%4o4oy_5?)j(-cS1DCwsTVz*o#HW@X?$N#x()R^Su{42a>kJV$UKu;Dt~TB^+M zl?i=B2;GFn3RurOAO*M!i`r}Mx;DpnAJ$;#9SVz$>+b#@)LX%pNhFT8B zO=LE)gktZ4WX-RYQpLQ8Lh0+UT}++agsIticoe`JQ0(y2mLF1Mc6~h+u<%7iZGCuNL``d%?y3<75qpgdljm2 zn`Epl{mejdLnQ!}8m0 z`HGC8_f@DfDk0={SPL}K(~AHxK#Nr+{lkZ}FlZ{Wxw*OT)w$LCckjaB1VSCaq@<)k zn@ch)+v^)1JHoTPYPP@Xm{-r?Sc+h!yma};2dH@KR#-8cI+}@ z9-;ch01P=O#p&wFzj$#U9<1TIn&!pG!&7EB_{nBexTmgj;@&5P)PVu6%`8^N-_7+erzn|= zgJ>H2z8knT3$qHAz(yk19C*p+y|<`3VmiR)1%y02*;@-%6$UEQ)#u&m9esmYSLw~# zNgCZbjK#CxFP{+kPV;ufV>qBaNRFr9&SPK3t9v|}wocgF_TIYg>!bSk-+P~hK^YPdHJ$HRQ;W4oFPC`oXh7$5$ z6MJlMa6vGm{clfM)!nOU``9n@Ud}Z&wJ=k~xp{#n+Og)SsrZY%sV2T|X+bn&amnZ1 za0CNx`15y;HUnpu_a3++4Y8H(Gn|PB{8;(nk+^B{jNmYRvjj|V51r>Djqu=!KV4u+ zX#>fQH_R@ngOM4oUrpk97DzFKM|?W+j16AIBxz7fq1EQCHhMW24R8-Ty<78T4(`Mn z<|mA5*IHf=~E#TgEBKr2%Tf7lIWfts0$A7(?dLvG#f!bCDF%~GmMM2}^ z?C#~HNN6$qg~;H;;d14-UwQ^FRE-3Ma*x`Isso0dlGc*zf6A9;kF)0$jCv&asR;Xp zB>jLPkSI|TOk;E#P}VQC8_JXhF<3C1c(uxx%Lgxh8u!t?+WA!}aYxCm&c~)lZ#FeK zUhlg>W;E^D=1mI6=5<-0Ug2NgDsIY8lp1#f(+woLT}~pFT8bdytL}EdfTrCgvR4kM zu$?KW|FqI%=sY&==fz1_xtb4Cu9!A9dmJt3`Mn_%bQ665V;SXeXNTc6e-gN;>377i z`1kS&^H0k70gTit{JKw{BB2yJ1UXR($b?um#O<9X9CI6j&|o?Z3JH^W@#4T|VpUN5 zu2-Ucbm8l#;^@Ue4Wc7X$FvvTBpUmWPUYx|v#NOS|MQ>R&5;LXT60B%YgG zUSxSP`lU{HGHBf9{j_@iRQN6p;NlOv=iQy+-C{fYBiYKthp0>o>f%^-^mk9EAKctQ}S;wn=Q}zE*_TKSW|9{`Gy=4`$B_y-5XHk@l zjO;CYgzUXXLPlh-knFv8sDyOb^N>w8*<7#Vcb?ZD=k>Vn`+D4eef#Fn@%g;xYdpuS zj)8=)|KM|idQp*du?MH*uWO!Eu9o@BP1Soyr^yWjQd0GAA05`Bh0bN(_Eivb-Q6bwid7#H6DKLi$tB~l6~A-%mhZpO zNSEvg{L3spbVYz~=s5A7p}Zc;+`;Y3GkvTk4WJb{!6jPWRH8fb5$vocLC;v6SeQKO zFmlv|&pl13tuam);q>uC9BZ#fx0xJZBYNfPo1?)H{(n9VT-s`#l2*%-Ig^TyzHNpB4_kkJY)^^9Fc9%Yi~Q}* zR_QV7`MdbuS(cnZU`z=rA2&)4Bfq5=7R`@P;9~T8G@0!<%*B4yT@)@`^@an4wNOd^ zQ5jd1r2*Jg_Vx9ZKuEsX$_a(PabSziZH+NSejB0jO-vX4QHgY%H6*5!;}sd;6upOU z}N=L4z^9-A!&L-#3;&lS+i zGVthDeE2NxXx>H*$jNu~8;(P9@oJY@$v8J1zxzc8P`dGw(2F`RK?1cfnQKQ3cBWHM z0@S%4TDW z2%aaGlTVs{3=H_LfiC+%^RFdP*sOsn>$tb%9JZl+H9#(dK{edA@z>JhjUs{bX5T+d zb8{ymX0xKc0+w`hTLR(2BH!hmA2|_eRTqK2jo&f2&`-a7@d63)ev!Rx#^j`q9mqdC z1I+>jAY41A<`<%pn*zjvyLignw%nLYE|6+(K;UnL}bZcyA zdes3#-1GwUVE(inwQTz=9-WP#rCJ@EQ=*evZYPNG#^{Cx$z zP4i>Yfyrg-MU`r0&)^{4i--GzKO|O?8&C=a+qGI;YA7OfP^j@LoH2v5pos>RX+%+3 z{hzlf<+u}Jbu8yTJ`)><)*!l54Mu(wPW=L7*8z@LTU=VIbOp%UnK$qoaQ^T82n67t z8_H#F8bpobfG~B8@`nR8=1M3%AD1<*f2s0c-ak3mhNL3|SoMyrdp|e}0ZsT!+NiwZleP>cV*o z7=>x5hhBt?-x{S^qpd&2ThCK8Vr}4eaaaT3x-VXUaPxv<`JH@V%M#zb|7!mO2+3gl z0`%XEBF7WR@cMxgjl#q&c>qWj)^nQ2Ij+=k2Q{>;%1TN`Bp3#_oW*;dUT5w>%rm5BP*42Qy9n2+6ok+*dH-|VMb%b~+h+lfhZWLA5Ay(Xmj{vO z91Q%=FOm3j4xoYB4CG1c_4V~XaBcsD+RYZR;#94jZe`c}j&(}t-1Znb5a9qVod!lc zWeN8|L<<4N^+mhz46K@(n!2dlbk@3t2DtDBWn)D|UF}OwHvt+aiB|5s_In(fEXR`Y zJMp2$e4wkrGxvZmKzT525rU1Xe}6fA-#TYK!mjeOlT?S7z@0Hl1v6lr-xMZYo*0thJ8dtLr(9~bP)CO%Daf33=k&zLrd-v{1Dk6RYiIuCUwpIh-GE+UZ3EcNs7oc)yfTRMa zf8Wx57>Z$(slqG&p+1@}(_6JqsY*=Y#^B5|{zmbKkkc2dWnoz$Cx9>(ZHT^(8Kjd1kK%-GK%3{{I~<%!LZgY1KK*GTRVZzqGOeUOvt~F- z3$8ZjE=zc9r)YKAoNs9qj7Mpj9(xoZ`L4Krnm$yxwg2EOo}(#6tjQK>Sxq~X{Oy@m zjy_yscS=8hUhRQEe7mnFABriOUweDE?<=Z-UO*(M!zgp{^45Xc-UM+M(4i^IMyyLf z)TjmohnMW@nnK^mG-s&31=hsHPs6Lzu?P^HI+e4r@1=d+tWpjYv^dzC)Jg?vLr*Tb zliLdll=qG(a2-}fuVNph4OJFthe!TqZRLO5y9)x_J~rS!kF8NOl9fE0rTRnR>C-#P zPoI8978%%Cw&ha_mQFC3d3t*4Lt!}6=b!dAKz|u+(o6iu$F)%UfHhc`#4c|Q?4JKq z&sfScJ-bs}@~8Gd^5<%7$n00*7r~_5@t6WRGa$0113^TuQu6&Jb+1x4Sb%0g-Jl-L z*!ZjP)~4uWCVTVTc8<+yW|xabG=f&u^Vud^!_1aiFRtTgl zs6zpLJWWYOHTFj>_3^`+IgneRpU*7Vqoz*%c16!`5Dfv?Thz5D0!kn*pcf%Y8|4CW zOy%Yv{*jC*P=BWv;J7hfNxH4gYKUbAp+rdzp@Q}YZ0w}oBzQxY2fJ9q2O zH^8c622#x>B}wjaHOEA%{UcR%UG83w5KB`C!X&hV1{dv)ULOFTp{#eovF^x|m+DE) z$ob~6uiyvDdo5ndzQ11+RV2Fl*jAD1N5e*>dinC@Y2K{$p6YE@))R3CW$9s>Uyoj% z`84Z01RoLXQ{P7Y^mv#(pc$kykBR)IE^J|3hl-;9F$P zMp0)z{47CL$I`cK%my@k9HAOTP5vdZC)4#)g6hY7kAd<+589iCh8pr52!8yRFLZS` zJb{VR8&=CPEEt$10N$kPn&WE8)#XPk{SEsh&pU z(JOhA-~IP46SqIR9;~Vmb%o0xeJL%y7TFzWOnot#bD7^+P{H?`pZkvoOCjfP51H+l zV;lFn#$eU1K4;DQ6lwTc39|b7`b9M*4R&_N4Iy(;$`IJG>OT5pm}UW?^Y z`&+V9@}PHonPX}Fm|;3$xav~)wVZVUseTAndHt)wL|NCMLZbe~$V!vqYq$*>R1uzM z>5Cv0BCVh>CSI!z8@;UBKjyje(A>>l<*Lv)(57k9mUi|)1)U-ZJ$~#x@%)ulWs6WVz z`R1(BWkW+Yih9U3%DNK{`I|!adQD|QlSGJD8YVPq3u==tNo}M#X0Q%tphXe{Vv`V+ zR!nVf*3N>`K_mROpY#jO`#iO@OuZT*tKp5aLaNt+!Ge;XKoK$=&Nl1zq2m7r1ote3 ziuzGS>z`>N@z9Xjje6}J1hLPl6+jG-P<*u;`{xZb1t@Rl>yL53&W>eppylM?Fow+x zU=EWS9Tj<0*&42m9#BN5-dwI}1U|t&NXz3DjmTSD--QF@CU5f&2Jrrc(LmK_8Pu6j zhX{~^YCXLEZOugXE#2baDC{3&4JM_M#;A{yfcqFF&;h5;J`jCkKYsiMl?%B{NguS& zB_&`bVqgq(vUhYMabjEbL4XTD1HS?7X7_s@9v*t&FAOZ4cfhzGDl?R#U3 zg88|yaK5hXf*XJ*MnL636)(K^6*Wq9p1_I%T~ihTfg0ads5w;nUHO7UE2{3&0G6}s zQ)h#Im+?0^HNdVI)$f6Ni5v$I(K%7NkWiWVnJJYCv6x_E3+fd$iar2GN>y9?yT02D zN?dNEfHM!oIK{!T<{FTClvB58K)>-1NNys*SHil=1&{e_cO06%DG=^^&8uQ#V*^Sz z>h*X~XeTC8(kk}>sHlbP=@@+u$WX33g{7s-urN$O ze8auP07SR6TfIeK736;T@)o4=$}NX(K{>Z47@uOi+KK|0cNS1D@jh8fD%Pq9gtiC} zYX@HY?$atD7GZVldrUO~`t|7yzSkIqEAkNF^3z`~GNfp8SmXr6&AAR5&0mqKanvr0>&wX4h_D;RHd z;e-^EOSkqNDA;5iO@M%95cE>RL5j-0aV=j%86a%oqD&Vxi)1aDK_H|WeeUwlF=~Yvf074cv z$UT0lt)=YZ<0A@+q7~W;lR6Iog(^rUpxs_bvIP3EA&_ODHW3I>JqP<7NH8Go7&+pP zjEr;?O-IS$)aZaYE1<|i;mh`c|K$XIfVkx3@9@73klH4Ty4;0I3u=eJ{4F#u)WL)a z2&P8CxdM}X4EexY#M_N%1cku9)z?5Zju)WX5mhVfo2a?2weu55`rx4UP9FFQf zd;WX@3d1laBzf0U^6%M>^Xc(Wfqpp95R*W;jiQSWg5|@OCD4wkfK7|qGFb_od_>Ts z2Td^YfUqjohYIY+@u1H%)fv+#i)Z3fQ<$m?V{3^4*`dbZoHB!Od%x-5VZ znQKLZx}$(}#w;O0-!?Z0@>QsV^x_mdfCwp&cRRrL<|aHH z9NpY-zKL1r9&JwbqOM$M^rI$l$R!>A?J+}DmuzoIM!2B?jT-mm%Uy8>5)fw=rn?4P z7BXMh)Ug>Ev&LI{!$X;&&J80RqG|t~K0QS<{PYx~z6M2=vz@Gtfa`TM%uKEdN>kuP zM&`Q{#E6=($4w$Cjty8-OR5E{4!8Yvlm7;`5}`I#p87?Vgj-DQ%j*I zaPtuU#%z7MIe|%;6xNq#;n6V6AxZ}a@%;v}Fj8qeGHmj8X*}k~*Po&hG6$2YFtHnh zlac`g)VYT2LoKoAd-+nm&<};ABVNruU4QF5`_FbNWSB});=Jm5PE|ZwGWQBO>=w(uV4257`r7e90u)6PLSI%@vZ>f^EtBgvpg8v=arg=3)_bLPm4-O25 zCI(tbUWF47rapX;)7f=X-67+2H%%-(G=MfuQ!OClQ-0y8iuxMs|grT%eXSH+;o%xz+e)dKGS3l3PMuVlyS4-p_{^VLsno z^GP-C{^BI|TWfTkt#5xWhfu$GG3Js$Kt!7=#V;vT$14*`1hVWiOwKAR&1EEpG=x%F z5scXUL_=@Zt&3;Ne2w_eA30r$4*Kvu*1U~QXXct3iWm|Z44K+pV#6U??X#RqkMMQ$Kb(hx0|dA6_cP|Q}fymxu%Lz*d6I$z#k#lP2z`j50T zJv_R3g{2l(IqI|vtg{cUk}<8&UezA!IAvdrH>WbwTV{1_CNFERucPahXdsJr?A*B>OuLrzYYv-h zp2CY*Ok%e@xMFHjVq^y^bUI2-*T@@TGtndDctn}=EIsp|*zQG)wP}4H54=>MbHT2t zxTolgnJNmFZ_O?S&=1 zsn_ZWli7b;DSil9{c_tsx47zWAWz913%T8Uzf}>AVrgHSOhuf}g|ANj-qMS1cNvJN zsCc&}tI5XcJ z4d^#v?w}8PIaaYs!>*jk#>x>(ZIOkWmYyg-Xg?$T(eK?xX>**r8&PQAkMDu;aNYiK zYFOX!24%``KYo}%WO64D#mKVl`3NDRdCTeZ6shDG}pd+);^2Z{9HbW6fKrRi2I8eDs*%*)G0t zv7jxb4RT9K-Z7{C<7{D}mP^!^6dK8y+H{|jlb@Lag!*d2wysW|X8YZ(>5H!{7Mw*l z+TOJo@J1s`H&FSiwKXaifiiE$_7PZnLh_1|BM`qj-=~xEO#_5dB#_6ULvjMXqTisz z-v`Zv+>@c|FQF~7Pd(d-`|K`SE1c98f>+mJ!QFAtD0&1@R6agsWOTPlLovn#zv2(; zyAcuFp(7^5!2tx*d28;DWWAAZlMi=tZ};@@H5&T)))}F*oE~;rP+Q8AZA8z1TER0Y zJ4*8eJ;~nZye*GGI`$4P?+OGsUpEf_9Gyi(MzR3Xv~27-B#e;eK?D&W7uN|YhTkD2 zb3Yi8`hNG7Ev#;MECOuo9CX(e8#iB(AN}R}z`~1NR<5YGuLG)Ut zgpRxrcHz8Gt6I%Wj_O+~ZkztZ@<1_OCo_pUuY6Tho~(X_H-KTM%Wbw}j7|9~mbWiv z*fg7ttBm;kK>RB#GKT*eQBc_sX=doN9sm_r8V)K5$bYRp@touSCE z`EBK>$`(;DEW&lWz|F!k=62dO+{S#OG{#}*d$=l1gWz+}wml@djW<@H z%m@#feYyu4sKgK9v_YlJbEl(qC{(6MA86dafq<-Lo>ETpxa+2lDCVhZU+iCb`w}C{ z98Sod*cEPuyL8pkE$?!J~j#KI9TO(4A zJI9W{8(nfM8)+a2qaQQq4bGOK7PZE@8sEX+FKvijd__z7yjNUJhod_@?XtOYUgnRU zJ;6ZQyn=^_1t(`jOhoqQ>UUDySL_S8Bt0uaJE?5GUF~?++-&Cpd~4IXUXCPxEVz0+PRM8O<+`5cgTVR92km%neZB=QEwP<&F z&L1~3Qu`jfZVo`$_ipSvZmYFrDSL_@4WvYjK@LOVx8t(tE-6wmbJOk2*~EnBN=!q5 zGMKnm;IK8%F(u!)LJJ;lCD_581 znH#cF?3X~u{E?dTKQ0j~D=imdif~8K&!4|^ZXA-YL}zObW)xrUQ2cyr4F{2!Em|tu z*U`Hgeig|c4@ylB{L$&Y4YK#FeR@5Zp$AC~rGD=Q$$>X<*QeqyaU~mq_nURuJUrxh zH)eVH{UTndHGN2(WStp5*wM5+dUMQbtH?dY_l@^(M8`!yGX_;ubfDcoBfh&~{j@^M zVIu8t>|2KT8=NlwXVH;)#g%c~xc~P5cwL!HBRia9VtQ?;>*?QsFUR#0UsRo%Yk z%oh+~J6#@<#(a@1>@DnQFVskIUcYmC@sZ8lNAen-$j<;?w|hKAQuw>OhsysN()2AK zb~Fs`MDaJ%Hl4_JRb}ZCH0F z9Ucs$-O8o$V#?5!<-K2R{bmlX*Y1SKB4uyfi*R(_m`yj(PNqM7#pMqHKSHXG(ZGebA3i0+L->$`e{I;QdE<~wFsK;pI?UHW0 zDy<#a{dR0)p@`5;l&5J%sm}hH0<8qNC=m=KCRM!dMMsUUbB~jmr{HeO0-VwvYt9D$ zn$l?-e~~tR{6%o+y5wF+nj{6;cj9&0u(~fW{DsA(%NH&-C#UZ=L^QOXy6W5w#h6yWKkPvcotf-%{hpcurJvqYoqgF{GGQG8U)pLbl z_WkGwyBev?8*|e{VJU$jCC;t;3;ke)+T&{Hx9_{g?Xzf96 z2x)rIf&bLU?i|F-&F6W&UCDd*2NIIvHD5gRHD=Z%qHe$PINZLTl<3smj($vpX{d!q zm6XBU@dp;sV;46&xE}#y(7AmiS3*p$?-f#+&w-qt&l@SszOG25TaZq*pDPny`Vi`` zYmEb+0&?BW`rB4h5wr;YlOtr;A4B(T2@`!DU;ft&JOvbGWcBQogM5Yio)c9*>_Sm# zxvnqOX<=eu`)(S&A5s_EJ5W+IwX|m>pSEwlZ12J&LVOzCSlTDvxH;!V`u+Pe`aju3jos2tb=8(a zxm^U#lQe|QMn>2&|C(Pco;&hul^XjP9{SS~UYd_mX)vx-XUB@t96U{(EbXZ)d_+IL z&p%`yVS>sB>M$d_rR_C%?-qU0YBOc;k|SF9@hHeaOy5!-yOU~%)>kPhq1*$(R=O?` zJUu%>l18peY(Dph_wHk$NVCUIIUwx|%!s1QrbBYQRG=Rr=# zwP|O$*?F#h0@3Am%(kM&$(+nwjcoWxS14lGyYUszq1}&DJ9h7t{kOrUQILM{&RHR= z9C^JpMYPx;zClxg<=#DprWuv15NbR500i^OUx9*(hlC_eZ{~!^T?0B#0{R=!!>r9G zUbMsx4}FXA?^zcXT9nyOYw|Jd_p+y7@nbLy+17Ny8xnw5rBFmbwgHUM<*y3e3x$BA z4K;m&y_(W9aud^0IIUh!$;4!uehcSD09qo0!yB4VlP*W92ZKw7jE9hVgph=+-W46K z^QHoB^V6s0Q1S^IT!H-I#*2=PSKRdfXteXx3z{5dZEQAQ*u*sI6iLJmumm5!#d5fg zwYBs-%;&3-8c%^uY;Lwdmq48H>P23#i5xA#&8q7xGW>gA zIy@h`cHwvOKH*LW65^LcrjJs()E%AP&I-YMk48xr&)~4nBe=+8re`xeM7hB8Duq=4 z16FzX#{>V=F|9ixZEeGA-2GmKeRXcSDYOveGNE(bVv|5F>p!)8ve#O(VKeAr@UvOk zS%AF#)-5NZdNX1f*55l;)I-S2bu|Iw|`rbr=8~m{u z7hW6-IW6aTrE=k=vKU&A6+GKxLC&&anD1}+p`n7V0>aj5M%q~xp2_4lX7qGkn)|Ru zpX*{{$SSJ&8Og8MwXlnVHdqSfb*aifIVaeB_KSZrFv%v;gSM7q(vBjh2u6n+Dnh6f zfI5_HGvC>gSmsmS5tUd;!^tiEQi&y%$X^T2v|dh2@^9X$2Kc7WhLG93B|o zyS;$++>6#QWFHm|u!)3jlObn)sqH+gNf8?ARy@p_LtFqA~>#_~+5O7xGoW!t^2o+T`lbLNsnz5;x~#J4W$;Qx%iVaorg zSfO*lUq23j*Z6-ZXZ_C~IpQ5H5fkVmWX$S8&efmG{N42zB{-+KmN<&{> zvr~yVT5f!M!In6GibYG=bc5&vFNcg7RrUY<3;vH{+W-9a|Nde1Ny(iLsz(@O{M0Sv z$5iFS?o<5z+X7Y1^whYv{EAhL{WN#sjjD71)l(g)Jv=I}BuL!%zui98xi^RFi~bYW zz$)k;KD@_fsUoHp#|;_e^2k#Ah;jU0z`gdc_Q4OTa~P*+S9U4+nj9`He1ux)-ngH! zm+$6TA#vU+hFYPdW55X@XUsw=e+_78bPaB{nUl`O*j**>8<~@S(1}}Jh5$WWIcGo{F zpvgb4-4c0;?88+@k3mz$87slVI;m4Yco%L8LMtrT(m*#e*o75|bBdXXUKAh{i10-J z(9Vn@G46!XGA4wNwdIbqZ^ukPi+FhdmstIDfRThI*2)Bd0yAmlRDcRr;6-o8QUSUq z_QqvQ?YI_dajM$QU}nfO?Ifc21}$6`CamKK`^V>7rL;fG8@`Xx6j2mlqkxz$NuW{8 z!o5hgO39NigvZ71SYjgmA&_rH$(e_PX5lXepD9T2jBY3Kr^c99E|>Uj*F1w-YE_e> z{$Zr6C6cdF%pX~PQe79t=%|;}V!;2&O4=&mePeV1k51XuP@UcS{9;ea1@z|60rK$o!M|C}Z{f>YQf2~MP|EvH>wLY8y^JBEb`GqtU{JNl{R$@x43ocn9!~iLhV=_=EqG+eATkj!& zA)xxq9fMAS{>R@mN}&nfTNM}oAW*+u97+3-j8B(igv9;E4!LlIHD-B4d&Qqryfo(z zILG){JJc9W1yTgMgRk)q{M&H<;wzmo7~MkcCl%eTz*+orG_9#`)p7x?Se`{!*nfo- z-`wz5UB|&-H=>6>x2b-S;=|ub&i7E~aA9@ebs!&ql$CUj9$*t`CKZ+e0Z*#5xEi~` z&b_e|7dJcm$(Reb@UYCbfMO9Nl{+o9pf}^c->{Fd!W#3fbSSRWZ@F5{SSU8dwbwK; z&!8u$KAAVmqHgE!PcS-Bclh`v;eOW-iNLN-oTbpikRMhZ8v!yF+6CBQ>@tU8Wy%~b zv!|H-_hpveA-#LM`r0Fm&eVbsU1M&ur-}%ok~Rwm_vS|;QtEyVXUbT8YaORDOK(O= zUg3mgQ%qF`PBGpUD!xiPOwCUwGr;l0P8uZq5VRph^F_+rr(GMfP4cvfRz#Ja(tjDrF@hAh%=JCvYjK!I!>y}bgLd^vN6vE1ZVmC6StOTGic5v@B1T&e^>-A zB^Zeu_{7O0KMlNSzzrB=Z=Nofj7J{P8m3>@q1F%-K00Ib_Tes(V$tHk&OjT~m$Tert=g#_L3W&c9TuC}ylrt;)E_FI3`F%@w5&Vib zLt||#v=o4pVpXBV-!{icRb0ka->f_4^4HZX-IzMXD&?B~*oS`eeZW263^hi$=yT+O z)vW-6KlQYPrb0sk=Nx)F)3`fe1S-jE#_{}Q@2;C5tj=~H`N9;ysJ7f$>MON9fhy;@ zep27k*>`2%O04pWc@n>m+s>jF|A9X87=e(A5a^L_UZz4RjH3M%TJ-(3&@+cd+bH@! z=t3%iKix7gVQVo*p}DF6;NZZ!T|-@cc+8~YGnh>x{7aw( zE;HuR4=x~Rx{zJvz;RhLvW{z;ZzYl6(s6!O2b5BTOh^}VWuwMTJYW%TP@s{pkqCus+$^|c!QvSIea zXFl{rtpm#)xQu^IQ}TCV7#XZQ>v5xVZl)g!R}Mi%F&R(s&$i#$oL|Sr=O@ zEmD1;#@55$y&^mleUS2HeecKbN{RwPrS0d=nZAQ7Q!g9sXLf1uO_+o0jR5iFUHUPi zf}%9_0Ku6boslug!ZB+;lHQoF{g9(={zy|@-9zeZY(4#noZC5%NJm}6=Q~Bt`^!=; zpB_9B`?OPqza$q)s-J;XE{$KI0S z0yVNBy{5Jk>2O%Po$j{ z^>6u4ojL}mhpPIN7@mz@9nEPfP>b?0_avuLQ!MPAo}X@#T#<#%ye+k=Pj{8QwwgC5 z<`pPuHu-Y&)7N0KmiXat--}8|(aoq)8)_Wr+XGq)vu#cpx`@y!%>_!*@bIu~68?X| z8)~|jYnuRp3)I(uOK2Hy!-5zEqHwhER)kKl%fo zwssxuQ%7<(`v~>sT33fW7R~=54<-m0E@x=D&YWqFX5DXe$&nbJotFGeOP0~mxeNYv zX`=tv9t+#lJ_@M-CbQ*Wzz71PL-|v)3@FZZzLjg+T&6L#Y+=7SC!>hdC)|hsd9v>< zSu9!Vyt-S+G+LANf5E}jNeJ^AOG^FRtorMDOzgR08j(uYb?&E!@@8|f7|x1hE3UDz zsa=hSVxJ2|j?fi=cem6ucfo@)_5$SDQnc8X5iq+zW9B0;C+{0~VgYsMA@BiFP3f~E zKbNW;Xk4H$LeN+SgwE^n>ApnOAJ!@6B#I!DnFKgxm+e`7uRjs&Je#f$r16H(Vf2_d zEr#pUE|X{UU5gM)<+?74GGhWt*Aw5T&?&#`yT)ca>9cTnYwdqy0TKkJuJIW^HgwkS zGOzi?!WzNSOHf!;#M(@81lTH&SL=qYhHAF}2jVqK83;gFrZBrOv*pm^w{KXYL_yVA93N#~(nS(L; z*Igq+bTXgm>(7X|0PGoHBxv2;-Kb{*Vh8Z`g66h+Hx5nerab;u^rD2w0WvF$lGp-B zlI?8sO+XWXSnXiZk&{J=`6}B=imH6k=g;qVZb&=JlecrfkS{EH?S4l^?MKdrybLzO zSa!m#D|LLg0lHp4?+efC$itH$UKR)KDAm=*&WH0yv{+l54Bz4bqOl8}$j~+;fi_|T z@XmKVTL6a#F!OJNgYZCcsi~2GQUar4IAI;&$c~SX?*dfew@R}q`b{k z-5BCmj6Nh_Zp6Yz;w4BJkcXa|l9_{GP$=m4yw?L97Id zbJwAzdXG9(#g1AQd@S?Y04@z!k@ADLP&$mpav+3z6*y2Ce(u}zxj{JQ?AOzHT=H-C z#=70#d8$(MazTjKr+qb`X(3p z2PlrprDR@Hd5(8zeo9IMDqVbUZ3T6c$2Ja0kDJdy@ILqik$K5Ksdz&=Tmzcq=xuY` zBDHQuhSwO^jv@m@*0$;-CtrDN@AIn2??&}rNjo*C8ea9%yZiVOb$#6y+5vfyl8+kkd@E0G%I5$R)-RdbEal|oJ!%0UYp5P3?3#DC z{aMPPFWmSn-n{kd1UFN;!R~TwdGVEVq?mj0w?NfJ^FyQ4@s4^rLGNrdK_a*zTFsu% z&iyTtyli?f@-ht8q%}sEz!RBJV^UgLn+#ExAE>cJ$-zJ1}?F^eUQ1nF?4=UdqH z+0Y5nn%O#@6+XMN{PC{H;u_5~JM+M1rM8Pcp~Tbnukb!UO-~BG%=)YZ31G|BUP!An z+QCV2L&g5mOa?;}?-5l4RW;TQHlTUFbgjH87`r);+=4^YRA6E5x!j)JfbY0#zf`jS z#%M5ho#KRD`R~PEpPTLVR_hc2c7U)ht$oSP!Dv&s{%-Wm8!yZ371q>zjwX!YtjoD@ zNq}y)eE$3m(41B1-;9&|kw6G7_sVb+RY+Oe#PM|@v#qh-vH%c*YE4RAY zZh#a-$|5^{G1jTB-!S5HxbBYS&geeO-!GJ6Fh;!*jQ>4CzHqCt^yp4W`8(HM_9b;q zbxL8oj6>I^wufUE-FbO=tf1t-Cx}?KYQK?hb-Auu*OsdyU+62dosv8$=JHC<)|)XE zF`C=6AfoGe`ZuC72Qg)mRv^W}C9duYEWs4Zx|iXWt5a^X^@~4)3nL`RJ)2Bt)@lT5 zKHOlnARM@Uogv)qC9g}9%@2SfsjxnpZg3e#(~zIR)x-71v&G!P$iVT%Z^qTbyp8c1 zQwb@8yduLJX7|6snr`1{zd|!a)5IK1&Ogagy^C`PGZ7=+KgM6ozoFxh4daTi7=r;@ z7M&4IEa2=By|S{hu9lY8!GpYVXrv*-jgN6*vp;B;V;bHFv}?tEiW}!Ig*BB*aQ>UW zf39|~mr5Y{!oq^+roj4l$1%Nog7;?WEf6kYkPdb6@7xS+J04DM9F)?kn*SS-epOal zYJC+=pQ(vD?nHG#CP%Z?XM(77oTa#7rrLP`+N(uPh62r9mZqs2)nbNYO1pX8!5@v6Whzg?9y`3o zhjA?M0^9r?px8d`LU_Sv)X2x>(TwQv_`$+hzIfim!rhvg9&8S1!d|b*`&!?*== zd`J1cIM)U@=~v3To9M0;bXiwub5UZ$t?<)5sVmcSkhn@xKbhZm=B=A#bX3&bOEtBZ zPgVz5b5wlW7@KBVPoRf>ZUUCW%fM|hzLUq(#G6)HY>_E;dNFlTcjC3?_C#C23!aa}^6b^5!0Xw>^8D@<;BEw$ z3q#)UR68Yx!~(P$)%;_zJPQSp1rLcFus-6xB3u1%vtute--<_F{(>r?-4$!&8~%Ws zvO^0Ax)d8}y+l_nJ8S(<2`tYxvyMYg;m&sfa9Sz(cp{nxMP+(b@c zVwx7VPgrwx-fsg(6B_x#wDm#O>|~3OQu#o=@s|fZ_D$@Z6VIik#VI2hmbh2P;Ue{b z`@4=o())N45G!MnfQ+66*zIY8s#EjM{j7xF_RVJznFa!82k(QaEu5s^O_^1#CZ;m# z1do_>OLQHKq9~?dk8%{Y8`W;Km@Y2@Jat103hcA#@VqihG5@UTJ3%A4yPkQi&E%m{;8gN2Zpl%* zn${ZQ4N(brT)b=o2t4x!k}Z3>w`85C|l@c%xhxQwi&pLU(H1*CRpX(nwaSgdUSOEQpX2A4D)h=~Y8NLEMG(aUF2<{m4{Z}Qs(v*gx zCjkCqN5wNppaKYG!h7LV(x!}@d5?}$bk ze-yvCn4%t%ij1q2XYl&RJ*(Xi^4iaiz_g5}zem~oXNC_Z%1g&~MN-)tVD9ICsM?UA zn+5F15A$7N`#(6#-p9wwK)gao#baB|-3F{Q4*;bDqIVh$Va}1bQkF3>S&DX3wNVhw z^p{xa=qM;CG+3qFc&I3Mbu^^HD0j?P9^7ufFam|ernok_EH^9Mf9Q-9c#E0=ZUNox z+X20J2Z=|dcwMaR=g9lnS7bH;JEmosWWpNWj1IzDD{neZW5~y!Twnw&^v&S^b-l#U zddd_|h0c!um)wt`KC^voJuILfD;jeQofn-Kw{GcYp7&GwCmN&NKA};Jq9Q%^k;=|Z z=^Bv(SA&2Y=v7JcI~Qy6x)^S9jvF!i@MfD>jeg4Lixt~JA|q+}6LO|u(zy3bbkg{w z7$0w6r{xhiT6d5sbltY8>U)}})fumeAG&QM8 z8|50L;Z2-*?vonO0j2USA*FXO6p_ zEF6tEK0BLF0x4uG0skqSO;3XpZua0bY@-|ggdBO8Jz_!}ZJ4ubSI)tfk<7Gu#M28Q zU0caQmirEztAjWfR|_g%TlG&`9-a7T;A7fq_?BtS*g-|NRq!##xkj zaF@ zV}tVsK%SYHn9z>q{G?E125{{}0wEKuPt|q+0z99frqluO=dkc_JUxdFY`kmNWPN=l zMMXtlXlq9R=INHCq`?v$4FeuCU9TgXe4&2s(18;jI~d7qwFh9@djE=vh!A06kz^I@ z`HZ0XiPI9g5dKHGnF5_nBBv8${s!w`p3)wwCV7X;HAKf7tiW~_uG@G^0xk}s`h2PV zVY4xyN<#-EqILjOWer*G02TfgSXZrN`bomsiwS&JIuzY$Ky-tvShwyPs79cygaQKt zU#P2NWvl?`A0>4Qa+n|9SdNnlM?Z+j83zINfi-6WV`F2w^YL#8L)~_{5Y@&I)fB#` zC->E%>MYHI@qj;gwT33@As)IMo^W(fNdv_RYmJs`pU(8oujhA4t-nsr=|zjgtF=4s zd7zuKOg7Q&xciEm7J(QNl$Y@E@X(lOwSl?J0@fg)1_&TzFk%8~7YI6c1IGfj#zCJT zx3!g_NTZ|^*gD`dMdDN4gNB8s%(29gCqB6U({S$&(_Ik{Uv=k?Dn(@cQq7E&QjSfC zD6=~8=;yv?M77>kj74R7fkgx9eybNCi@2lOzTjx;zzf!b0>Dmy@dEL-#-=6}P>u#x zE?W82CMfN9f{b$Zi1qGXA1}*;2Nd96C77nfjsmT{GB=M-9_8KXO0#}M>Mo6E!AJcR z^yWnzkp6S6EWQ&M=I?l_b@cJ(g&!eBqDe8jZ`@x`72BCAO8V3Jz``G6$McE1c;(sQK$AINz7Rn4Bx7jEh{ycPy2jGVD&WrB`o*~C zzkdG?1SldQq@1Yy)GSFq6i61=Z`_zqdo!T&z$TRbSzI_%`Iu`p_$(48&653ad`v2w z5kE(afiaPJ{I*+dx4ob9p)f|7+&|W>-M2eWZ#~4r>I@*qDAVjjx-bHsK01uS6E8{6 z37>$Fu)=vw^@aSrgD@!tMG#ar4*vc70}CFUd)#4vgIG8K&ECRkkX2qz3Mlk?0N0Q7 zrOk)EkdFWZjbg%>Fo!h1x_c9;KdJA2sw-$BQxAOnkR)M>l%4^rMF}&kFDUqB5zqnfp=43XRZ@bQFc2vGkF{Lf za~>5|Wm!Cei9Kyd#?^C&UgQp~j&0+rwZCIV%>GhccJ_E&*2^hzGRa>5uQ>#dzi&Z) z_g?m~Xd9iMk0ZtG&!!u3j~}t#^?P+Eq@)(Vb~4EQa74+nW-{|@3(OMQLlqUWeC15g zvQ&L6E1LsUoRzdU*Wf@1Jw5dlKl@A4wFy)p9Hui$87&W|m3bThqUzP*2_5Kb&-p)5si+Bx)VGNjM< zh)Yn)js2bIX0}_9DnZgz)Q{gL&AYN<2c9!AcMAiVj9^8h`9t{-OpJ50v(d!|bDNrI zLH6P?*yRE}QbkYCd$lp(sB6vH1jT4nL7>wkm?Hl0OV#0Q^W{#8!n zKr$OuET3$S2bST5ixY}(o_-N-tL8o*_V@3p<-TKXilA-p^s~a9 zx3|7NYK?oM(mC+j)y1dnB3+p-`jUspnwoI~oWrj{sMWFDuPZAUur9+~#?BNP7RJaF zTliA9O**aRP-({4_`*#)Q;`9lTc^D`;`AE!^85I&HJMtz2Ba` z3wTr%qM5)XzxV##Z58jU8OfET%-1J>;``|j<8ITtSWR`|U%S=;ceQ}Y+8zrI<@9?l z%D!u6@)mVNmeogxhaS`RbqDABgJ+v(^L5WvqH(xJ#U(|}F_O~a9+VPyir(FNaO4rV zRlka=%6m=Cmh0nw5eYINjL{6fBM+Cg(dKL3u!+xLDneIAZ z_QoH56ocU|9rNRM;VZOB$6PfQiMA~SN!?(B$x__OgUWb?rJDZci7dIv;5%uOVzd~8 z9l6KP6K~_sv|KxqqZN8BL_=35ES~K$%z#Aq&+v`PFCdYA9KQJ5>dC(j^sJ==^`Zwa zhMs>~7gb5k09MU}!8R~lh24eI=L^&|U%Rog@yuS1ByKVqx-Kkna+75T>T`Ib?xl&FtmZ?$2feIvAkT&frBtG#{I&Lrz*X7L zuWfj8@-DYQvz8|WzZbKa!Zy(2jTBI(qD?ARRQTacfA+T`s%T$AUro_hX%;Ie^qrEdUoHe7Zwo2-R|}}scur%_FS)grgmQ% z^POzE(s6{8WMVf{0F?Oy5 zvT%(E-0`%EJ$i(nSK3RPERQEE2w_dyT$v{5{V%rOGAgd7X&2suy9EnD10+b0;O_43 z5&{Hw_X!eQg9Q&xg1ZkAJVArITX6Sp=f2Le1D>A{Px0mf&=*k8rN6)V1AZIQMa=KYpl7jyaH>$g*pFsZz}lHJdIQBqTQsaIqWPd8J zCg;&yX3+&AD9t{7I9Z#aRIQa(!%H2VF8X4Hf)V9$IX{0+GU9>sxkPo8WUiR2h@EGT zqhap!77XO|6mAvjIVe6Ja zhD&T1*u?0@KID9!2grGN0kybndHg=!YAL*Q-rytP~xASoqbOz=@30vje%GQ4MjqRBKxRfQAHT7U8*sSed2|qcHtB2&Rw+E#va>) zqo?#4?{M1E_7!XHwm)Kbcjw4!bv1UC+B*LrI$B9c0S!idetCF!X&K2`(WjLBlbR!dP{tfbzwj*Q`*+2O`FSeaR;T%rI^de$M{^VZhWEc$>b5jKj_PRK)?YW_$U3vAmUvlmF0A@GAlVy)3hy2&C z@iAM4%@P2C^-wntl_#|NsLx4^Ued+IE~9UKDX;!bH=@t6ICQQd0p_;A}rP2Y%op@?o>a0C$>KfCO05x$QDpo1- zL8G|hMWIhN`kFRM*#|JHpJ#ncjUp22F}jz z(Vg$o_D&k*=jKUVIVX|xCY4&|KH_vq_Pye=u4^867xjv#67Ajz5j>;1yJHyxmIyWd zmJ;eFiVeA4C$cn{0GYIU(wGi`u3uNK#2tT#5@}EUDY}$8lmANJaQ02Z{DqrMq#b1B ztnx=u^!`m{e0=ibWqogB@IXLp*`h~Z<53y~tz#m{loJ(0&5Rv)UIyEcroIDQYmN@` zdzG9Of=C0lC2{b+reHd6J3<@sRURdltKrz6ZMmkeT#-X1yuFP2-CGQeIXS1KxVbb! zN-~kHL%~}Fv}|hUtibl)bz-r2pr^+{)$1c)TUr)JCnj(yWz{ZZw`;Sz@Q+7V@DT;d zPdp7WhOD?jQMUjHD1je-*p!r5eYTD&gnGuTgNC+!d3!tf1C;zqe0znkDF>pbSRggO zmr><6CiL~j6}kcmJF5H4=CpCwhM^{pHwyfG8BP@fpHPs&DkS25no-mHC7P!+I^QQ- z{G675*UC!jm6e#I_cR84^lqLvl^oN@1O!+lb}o=YSq^PjQ`?+Q=xIr! z?NNcyq0JdRb#=D7nwp+`_pD+9lvNzE&nmAhYa=_3J$TSStI^9zOxWs8ds8vpW=i+v z&j>4`00&RR$zsTcGcQ8QkV!4UmOB9SIjKsizl*Inq#z(zCcq<^?L6yxuWw?XGGw)E zpy~9^9V|_{q|J8yV(e`=nN*PO3t=z2>bYuGe?qR{3w8}n^3)Y)-u-RrN*eu3lG^JQL^ZJHyZ|9NQRt2>h} zi%U)P5}~$KGC|Vy$7Ju~lXGmz6qA;AX{Ph;v)v~Gm&)Q}{PD)&ZV>AbWbx!79q)gw zgKyEttt&33;pgEK?lx|>A%r$Yjb*G2OPj8?EWC|(_$fngnF-=}DQ5_X@uxbR?hWe9 zO-Ko*;Dpc!%tLsMV)>V~Quj6VljDO0@4t3NZxdEdSWSB_D18PyF&v1+F&gEWjFT*4 z4?{)W<>w?h00+pbFMsD2GGX;pf88-WAwYiBXltHdsK`8FS*NvC+UfB8O3+do%`mfU ztG&IPST>>eXToRcAo`WBo$67`B(`m3FJNdi|qV};cBguD)4rB0T@vgAVko!)m_}Z$p6~BNGo+Op0o6YKVAOI9EHh33xj~Q3N zR?^ichgmoSX@%-^9aydYN(G^Nd1ZzppCZ&-U$S;$Yy@0<c$-82vlqbT0m!ziTlN~%7z(|HT4=wlgol0S|TJO0S={xvq;simFuO7{Kg z%1_GRAD=?|+`luWQ(9WSSKBHI%xQYxA+B=J&cAeYw0}ZA12c`8JH6pUKn&r9gBNGy zjp2vK2zYNWA4f_)D1W7R?z!Lwl3Mun!yn6!Ap76irzGqj9Q=%I9uTcdZ2qU zXv2lzY{a8%ULVlpxkFkZ^WRGdQr*54l%JVfXB2G_wM~*}PFk|bsZep_lk2k&udwkxvwc@6%;Ae!FDIR`VElPND0!53Q6GU$^5Pry zWa3DQ!q1GyGD;M5rm0q^&mV-%!2!5AwX&Ha)`qNyz7nqAu42Ql52JjqsIXxxI8X2V z0=_+;1ml!ZS{BcpJ{a_W;kZJNmP)}D-aX-kuLiA2Uvliu($H>~pp5C_tM$-MBq(ak z*s#0Q^=spgUtg^^qc_)@9hp^3t2;3MEF=BYN}9xqC_obib>hG*DQa1yi!fSTT^s@4 zdu3hm!G+HP>pSY^1sQai5Q0AMSVJh&Bzag{Ea4UuI7l zx4NBf?^}W15_Y79d3sm3dgde=tIWCT;(+b%>Z=G|t1QWEfx2GsKart9AbH9_1 zJOe@CeEux`8maFD8-q)tnqVs#bY5N$$(=eJ?jNvyV=7`1d#^UdFEFzF6Qf!q2)=il z*m0m!uqZsY(XJ!*+B4*@-Ie!3@9vt5)a8VQeTAuLG>f=n(k5-zo{jIr!HHiwk~Vxe z_6L`nk96L~Z$>Jgc3~|M4Oq z*>_pmA>R5uwsHj{G0r@^418Z_i{LQfb$M%yS3Mu)Kws7C_^~;VGrbLjJMfGpiabjX>92^bpbX(^SqRK(6*R<2U|LAmaEDiX#{(g6N=kq~b zF5q+=wBEq?5T+8Q^>DC~-9~t<@*Pp%3Fzq95$BY@`{f-wZ`kN@b-DjL*(G0G?pvJ> zPA%vxJ1nh^q`b|IVtj!IiU5oP~Wq}xin2cSfCu)}c+?#g@CXp~<*kDGD-a*9?759&dx*WV4l* z=E!3mexVOvBGflId^F7#6e8xv4hUY^reE|;6p)#)tj)8&zdDZl!g;2j zsl?Kwtmk7H9|PG#(|YRJt+lz_3~zN7;M<5HpsYseu!`9X_I{Ml-^W4JERxHoM}GdcB9;+RviXGW`@_64Ah z-yCzOF)Z309VyNjA0Ob=ZITYeB?<1s$53zUm3mc$ZbM8Zh`9|%B_)@$sb$BLPd4_i zJpTdHx5CjmWo1;sa(FT04;W%HF}#$;Q`63v+$3eg>8XhqJbg~F`lVi-L9w%FF0^t5 z^WHu!9|*{1npBvcOOuG^5r}ucH=+vmkpQg>b^Sg4VEOPA;1e){C%4OPJ+$T!brUMw zg+jc}IrHiETTkNnRctaO@g)DF}>Rjzd%ajH&d-Wp~5!3mF&!V9R!;p+VXgQb6|Vo`ivLUAYgFt zsKl9Ob9p<>_z;mPLO`-f#By*s^v0&0qw#m275P<6zaT-O@*wyB2|kshp*Oj-i!VpWmm6 zS*c5LKjGj(-f=^90DAxr>IEb~-e{`UuAA^fRe(Oz%?EsFBqRfFg}yQMn-~cKK?3E8d5!^Ll2YTW-*QSmD)Br#QmH^fl9ic!w z;w1lYI?#usi+-7KsZ3R zLG@7!I00UX*z=|zcmHt5tv>a}?zoF1cm*_4DyN`oTsBcDQ-lYVMxg@|3|EwZHC+LH zaNHe4AZH;(%)ZPWPDZtyf;blkxCd+aWS3@013XE!W!nCb4wMe09Q)B5SwINL30Z&_ zf!qhFrOBhvs~lQrj7vj&rRWWv#h!z8zlifNxR3-+TLE2@MSwCJr}{Gvn>_F3n~kZ1 zePBFsSp^t^v?A$#F~Zc1=b}HcMP?nAw8!4yZ5W8#URDzPO8U1xr7FsPAUT*|GxAKV9sby-e?9Lr zU`rEBBcdfk4t!4p`k6XF;MCzQIEMiuC{A#d;#$rPB8P`f1P zCU^SvC2s%|NQR&w9San=eor85z>_A~kdt~=a84x_CN;avpC|xs`9+NZ>K#H*H9cSj zPqK4TREzD5s)6ecVoT!MjL<}D1AzHQ9E7%krKH~}8JYQ^EJ-$akQw>{{=@^~O;3&u z``uRnKk{NXe3Q>SkQ1%Ox01)M7hV*N!}c5s?|j7x2q1W2+&=3sTb54ThlL6-zrjkd z`1bP1V=w^DYk?#<&b7bHgWF7;i5(iiIBhO|81cBZeF~PCWbK7hfW%S;$1TJ0U{+Hl zlR0zOlAn4WT*VQPBCkB}mvfGtCLM9b4A=`IUZH@uHw`#`I_hHhRm;`&v8(nrMLIJ|zsVZpd)n3h<%#0(YVjz+(n z;76SIAq$esB8PK_2*)pg?5UN`X#x>>CS^ zX+`3Pcw1DARho%v$W&(3P(~_!bogpE|8TWiG^!1s{>2XEb>!{>WhxJPWZ+t+=>v&b z!Tn;6-7{zfUBN+c918(&JF#o5FoW|>5>J3@X7vN+M%7LkP%p}L-z*m%8ftqzDM{~! zCuW3H33R|H8SlyB`g}bg#h(nCbl`MvS|GNcO8a4f3(iYr3umt8=}b#t8O>gSpJ?6) zRKclKj7eT`NoEizH(h~Y(C|R;LNkYW)~8z3>gr#g7TkPZZIsA(_oFr8cd$TwCFsj& zgApK&_#McJ zJgzSf79wD`M+&$Az8I8fA_N8J{F~%fa(wAjvFJsra>kl5R*5zikQq7p2aQ=_Y-otu ztakDEfgoZ>0DXaJZyzfNousIR&<7l`{yHEl)D}UKl5zMVaoqSD1My#Q{}ioS0G$}m z`kj=txW(Px0>)t3H|Tl0Bj$~snIFyh@g^Bm1)~@S3f-c+%yhBD`fXNHL#}7QMObKD z6ns5KZz2#(E~@c+55A1>kAFPL^8bX<nW7)AdPnk~a+PU3kBwx{@LdKgoJ@lD}`Q`$U<0 z$1akrxF(B2mBV}XG>bT@xcJ-6W0CuNY@aL-qwqQ@Osiw|EZg5qOzb)u*6yU*$jOL? zB#5jMIG7gGU-b0wYls&;`=M0d)xaww#E)hr3h7Ln_wyFHqG+`B<)5W;0?>8+n)*H|~*A`v}2)f9P+rf-$cqr*qpjzT0VZOHC zI7vr@+?95kr_r_UEgrH0;2RAzO`Z#hpErg?oC;1uy_GKH-g5vbq{|4ov&jj32ed|c z7vGquP5w6x{nFXGOMTZnEr2JRZftMEJO}9?MX5iGBChrqPny$Dn*0?b7xQPkA3Mq;$s@iZ(n1M&b=4*ZAvwbva7c;4CnxIZ5Q z0V+|jTt>v1P}t^G5ia+Vh5?r$JXlRNCMW`Y5AdH!Mk#ptRpWNdiF7WxU&PYtnz^dX zX~a2*-umfWo!q;kpx_~v+kltbR!xgI3MmlWne<#>hT`nh>d`33h$(#_p1NPYuWYqw ze=xNh$a>wH<)7(`9iOMMme|NE*CYPqWJ$3}mxNOMLsf>fAkh<-Ys~5>ie_Ut67r`o zQS178jP)KRXqesay&g@)^fO1&(V3Z8#tQj92m2YskJ~55pFfW+EJSAfadb?4>GK}n zVSb4d@l?PYY5nze0URMMJr&;|20%x@+fi$!%4+z%$6~12@l2dBICMWgdl^Fv#Z`|y zcPEN6`2L8--W=LGI3dd$&5bmoV>XSPmOeDS7voniEVjXG8LR@QBH2Jb_uA?0?(icL z_69-qP7VOnHkc1_#L_cYf!FWhQkhW-$%Wyugpt0Eub?{R3USVWs@x<8HEg$8~;Se3Mnb$qSP#eczVF9IgpDZHWvlNGA=BEH8ZB*bi56rLzQ z+|AR+U=@Xn;iIn77mYQcuF~~cNpzhgQn&s%AqjU3{Nbb*zm70?0)BEPu5;kA?9jwa z$XzIAR*4yV_!-Y%UO_U%QFI|I=5kisVZtPzoy9=Zx7O%gDo1wI~T<&vr3n|m-t7y-)N45+P7ak+8LegEWXRnkn;6=vfw*#f} zDhd8U*Lv z22IJP50yfO%6Q)FvPsaMINN=OLzbU!R=_waJ@_x>21DLUqRV*fy?7nGRy9=v492=ZZ~DthFJa;(JX zqr0`E`kcFkmMyFoK<)BsAZ|RwdgVS_(dD$-C? z^DE~Cug{iYwl;SAUdLuf1*JpxZ2redL&xktA)N&TlXjOMu^dHl97hCU-3v`;tO1X{ z3ociND_%xIy7pc(;67&oH7#~Q?H9G%R4Jl~alMCSs~h7ddYAmeo@0ugdgRtzx`(sb z6!&v^d=zx{l}_OiG1pSuH}T$j3R>g0J&1*L>_aZ+mEWkA)-0-OejH6xuPn+60X-id zS>r`HcFQ04E5VDq0B!!nJ5{-Kh^>af)7$%~#vkXW5#PAhoaJ+JWE6)w#?39(yCRu8 zZ-@+n3x19*GY{No6`_qo5q!dS)5)jZqqjJ&9q+fKTJ%#quz?j{@;*!{*Q zFDwksFXihtDTeRwA8e8_q%$y{I#~LkkesiS9v-b1RTB;dZ709j35$A$zmQwVDWXaG zsk5MAb2Kgc!ivkj&pWC29L@_9$AEMCj!KpNOsqUNvHV30&-3n}PseyvX;)7-r!kQM zE<*xLBWF6SPxy|cfLL6-5|u2JPF3JxO^Jv$?TRy4csIE(ob9Ugb^Ar5kB9HW36nfy zBzI~NQ|r^isLc08?JJ9GtY&}k@^^=W((UO3Pw$E3HG*yCA&j~YQg~u0Sjlzc7f0kf zww8Nd4f3u_Y>87xtBx5W%7RzIM=2XH9GKSw?{tBFg|{&MS#I)bMD|xK|L@>5%a4Zx zpR;F;_&;Rcn`iqQ`6Knk?;_Ay9aV#I@~cpSmVjx&jH|pvLR_(^;JBp3am?=L+@_YE zcUNs^mo1n?MMc4~+mA1U^6*!XN(})SyvmyzwcTG=5ozP&+YgJ=r&hI)@il@9- z>Duj~P%RV^^{X!P5&JE~pb-W*jOCm+em-{h`E^s@(uNCOeco~fYGKO{RXGDlebWH%X}Bv!K0}1OVgN?WUQ@#txDrwQkU-H@qJKEvQ0pRA!usRQP(t(6BRyWU z;QH$`%b(WAJmtZ{Y?$r)cS;{Kt6W?_-+^bWGab@6G?&A|N zRMJUj8J#jiP48RA3v5aVSQHl@ygmXjNgT%mzEkp73ezKE0Ey!xs8sT(RFU)r^PvgM zy`w6LN5*W020q%CQR&}+Qf9_q*{3t?%h^g{79@}rrxq-&KTjT8)$+#rW%aG_`DVs* zi3xtY&27el8Fl6lP1=35nU7wVKaI6Zn26T%8<9KgfO2>oGl z%2GO3Kp>C`5h%B90e&KmBIE?)oaU=VmLeS!Y|L4*LA?QFR4NuAHG*Q{I+H_gh(8L4 z&8FDttx^mHI z&{vcJBSaO%mA8NZ)Ex`}ln@t+Dbf3(cSwlI3_Jel+T;@vg;V?MM9t~kiR zr8LmM5gR~3Q~|>ih2+i$HN+h>o7}`5Sp7_Eb#eN`;`R`15qdww4mfj#v{iT|jT<Z4!J+rZB^v5 zX@eI;QM`iG=6EukV!2~BN3K@dx7U^b5^naVRLE$Qo8Zt>V3N-#+PH-}D#m#985wM4 zGU1+Rt-+S(=-a5w{?hXz0fU@+gDC0*G!XD*s#DIVgY~EJPr1M0 zb;tus@Q#=ppTw}C%6?Rie@&u5xxH{}2-|_DqHtreJY*>Q=_k>Zc?J*2@CxJ=Fj4?U zKWTJ#%XO7e29Q+b=?^rUgC-!Z5X-NLLf?q3!xP8V#QHxcjyL1R9iaj++F$|UjK~w% zLk0a2VyH#C*^y1HlA+^~@LIy~4qyDfM}YrR{zqQw~C?+ zKo<}n=0*FkFm8`jd(Ed*cdV=F3QK?46w0;srL46Z(5|DLKg+=KPgtPW9eQ!el z+(ZX>cjA=!vKik1<_y=pMB5By#3@e?=<#x-)@5I#k!?iinH=pN~w#X-l z1g|IiDp;P9XuO^}o!|s72_8Fts#6T4&>Xc_2sPiF&sAd+DWu({V^f=2T>OR3Q6J$H zoKv6v!3#vWUHQSP!tPs-E{D!Pbdjp1UhNRo1yTjf^` z>lwy_GTN&Ux}Egmq&=!<(YgHNZoHIza`tz90Ap4$}fgy@oDnx~L$x+Ddl5$t;+f6L&pLuRvkU{uH0wLiOJ zp#S4K3J)9<2dXB6-#>sMe#jIVc$Rf@8T(NbUD?ylK99FIZxWH2s{Y(8pOY|B_jxLTlnx|S)z#+^)#{)kT5@J=5PP(&FBZFTphfQCXA zFuc6gkf4ab2OP2T!o+0wu#dL$<7g|&!EpiVa`S%ltx6Oxv;09FCh)z|nM=N4EdP~t zv)`axTNM44?fNtB6n_7D15&@-6hhOhl8*w1K7vpisuzZcqFe_@)WHfg!NH8^4zBNs zF)L#b3Vx%m$O27?-T_=s43SGZG9_k(8W=#aRBo=)cl0;83B>rsX{T>c==xC0D1*^R zOixZVvmZG*#;sWvuf`GNX#IRoSq^D4MkQ%0WD{CV)VH7fG5hvy$vuqul74i6@Y0g$ zD8}7q(@Zn)LbSvzUt?T8VVX6;%Q2Vd&c_WdR{YVIHwLiIE@*d8G6=^!uQ-23+RKBfsjB(8$% zVNX@owQuj7${fg<2=&h$L;53==DB)Coeuw6%Fs{pgSGPys(^L@=?)hJxF>PqnLZ~G zEj|3bJw~O$?$M~8*gsA!-p;mlAx@IW?pa!{@3yU&e!1axXBNi45;C{y`$E+AARI)W zJE3)QLUshJc071TyD)A*^cE~msYeOMqhGvtievg}3|*LaXWoz!d1WR(Di866*Bxj_ zn1$9x;W(2(9jH7+Sqc)r&E1N=}e@=0R{a(xDBo2FTj*Yy#R-}))XlegxM$c#Emdfdb>!4 zc5`jho@T@khG*R2&$l1U7MzE_c+EGo`Sj>X8=onZF;_<6ERo^z?=OX=?)GRRFSn}| zVV7{EnOa9ds_ZT_vkf>LGwE5|g>qmw%SfjAeeWWCSxg7rUNA%$IW$~x{ltj<;`Fq@ zPVr>5`1`zq`tw=TXU#m+`8RV{%AB07d@r%f&kW0(HmeM(Ec{`{ss@O30+UM zHCIBEo>KNaPIx)<=76yOtV20$FamyJyik~Q==0JAx`jTE7&JHGmBq;;TBsC}v$6Hu zhUz3|CeKONx5unoZ9e@gmf7aj)_wIt!Ro&CJzpMO-xY?Z_!-Hz7z*R#5(=$SD-v+mf z2P2OFJ+p<3A@Qyn(oOTb!kW`feo(gqFy9@kS!0XYmMLO7hsPAY!$FyW^9j6|XF029_J9ZZT zIl)t2onDQ_qMgNcc70MA{@{1X7kf{KRaH3tv8+cl>U=Dfab%x9m1 z*Ab2yc)^8qb2iD){!By^A}2yX0Xq+ce|<30P;J{+W+IxFbR~2y?-JO9kr@L&0?9=P zD*MX4@d&f^YXuv8+NhmXCgbONqNEWR`bs=(Tk&Sz$wnsb`nt`A8HI##_XQ#c{58>r zW`zj-Lkx~HGE@>Mhc2v@tW!O(Ah9xOzC>Bm2p)vcqP4a+4~ zTlAc1e@&?@Px>ys8iv=5Lw@1So@vSNKoF_98U0YXv*bJOW$!=xcXkU>0gnVdV=6TVSMD^sq)-}_wa&j_Q zP1ZopKULKO6<)S5UfNBdY5J~v=pv;egM(eB#dV5@ zU>>C#*HEVy2otKL>EA!}^~@jVQ^QcorUZ|FCg!%@Qw|Pc|3Vmv>JT1Ti z)6<@v=z4GkhazS^Z5R(@rlk^w<%p1jdncJOL82pM-$bQ?t+bL;4${l(TiajJy7ev# z&-hmEw#CZRfFTnsgbLT4r@rjLN8it%EiyoBOx|h^8^!rd)%pIDlsJ~I?$BV$=jc{^ z#{EWO_Ltp?pT^8|oIP(D7>7;{`5o5MD_|o2kM^x6w*jh}nnKnSeJVs+?Z3MnnscQ2 zoiR`03ht1=!h3;z>qwBC$=$fPIL~6FroAmpYaf zt}+#S1Pcf}#F2!!2-6wLTFGO(x+z!n?g%eUy^D^DpdgSx zC(9CouEp?Az3Yi608p0vuKa#aPEyG2Tgp?28|vJsVT0MHAG>Yh2nY&h8lB*CUs9W} zeNizm2-eg#2uVylrZkGE{Jh|xnj55l4CXi@-DI@V@ zrPmwytlpa(N)3z*?0fg`gC3qX4i6Y=qCut135|*6!cxvQstDEkjyQ70nywf$F39&k z`~Z_jO;(Oc@~8JZ(T#+{e$B0@o{R`YGVTnkAPqB`aj{o4Bj(J6ala(E;CrY@FI`P z55vu5Q(h2EYJ1h6Lqe03pZ%MXzMvGTL`CaZ?hVV%r(fSS%rty${(>q92{fGaI0*=0 za#_lksZh=$&%IWniiuo z8t-*RRet*Tm!{l=4@GnXoDxPjSd*07!I_KvXJ{2SJF7*Z=Pb`}baUkkN zgt8C+t{rHZ=M#8Q-hOZZ7L(5|g|@-VrRG+ZU~4}v&oBNeJH({VbHrNLQT|t7kinB2 z3Ur+Peba(&qH$V7rjPgF(P#t&5pStNfvcoRN(f+YVWFirOyGd!(K=vNlg+>~e|7LJ zom+tPxjmZ#sGX=A!#`LZ) zmh6GBsAeApUx8llTjIU0!IUEtG|yDkDH+2l(0e&KsYhZ2G!A@@&-+tLUVO;9?Ux;K zA!CdRhD?E5Z|U|*GKQCbWPTiA|Mz52aGw(_^RbRJ_-bEO7dEqKt!DTb#>`CJD%41943AdRwo9R@ z{|NjY1*^lrvw7M*OfX8?=jR^_(xFq)7W+S(ydb_p>m)i36kX%_>eBZbrkh{?#+pqH zN$0cnho!N{~iMVj!Q0h;1~PdB4W-m89(iE)S0VBu5xvd?AKlW zk7Npj6d-pvnL^ihhcO8SVCpYYw;hyo%I3&a@E?mE5`Kp^6DrX=eA}^pIHIbL#Yt=r zUs`44L$Uv_tvy1(EEcoVd!Nfdxw+-P z9{c~%B9A@zVCUeQUT!^U`-eu1%3kjSzyFcV4G~CYYS@e}g-_chN8RQzZMW6`A`=FZ z*|+htxedTK7(2AU1F6u)NcrDX{N=bQN1rE;(oUtOy-{iXoA&qr*Dw@6DJs!+6jqJH zjp)B#cf?EplmZ-u$4~Pu%QIZVcUUX1?HGXsJf;Xd`tX=v{Z$k`n%Cl|=!nm;zpN9N&=RFcWIwoqjEEn~k^$#ok)qxGNC-f$7>c{cFosyQQ3 zapZ?fE^eDsN)Oid%*Wh!OK zw2zqz$@(*Ihw?JwHw<4#57$9SF~;{pyAPQ#S3I);tUdW?=VANff$xI_?EE5n9cIKB zTd{WoCEAi_rhA8N_=V3Sx2bbk`1n+tdO*+w4S{2vGq+mSt;U5hx(I36=V9=7)9M46 zpZJ2!Vz}}d8H{oHGY5Y|!gZh ze{6GPf|S1INPUD#fuCe|Bs*naS)}#Sq8>{I;*Ab3?6vD|8e=`u|0PI??p-YYREiSz z{ol?2J?7mfISwJjZdG#9 zwzaqen%`*JPkhn5?e$nP8hC^M$-H$=q3)*M`TlI#&tkT0eX-D6XeHz(;aPd`=GVVU zqW+nhLh$Nfbpqt}xuCVodmLuUu>;LG35U3BD{@%W?(zC*!`e50Q(l2wfgh{T8#9;w6Hst}W z4(~U9iN5qMx$6(NX=Pme!hiN~4O_b9!X5kCXM8EANagxAuDJC$nZ99V?H!eMi-Q6t@W-(I7~rYgpEuw8bhdGk9pgym;S zi%JJ48tosNvc~$f%a%J%o{}tVPm}hAK)7-fIuncQdpCCN-hc$x{WF(;ZJ-JHwaFw; zlG4v+B9_zVANwx~{&@1^8amy&OvC-#rH@Jno(QUT5%Yq(-N9#tme1KW$;JQn8kCYl z`!OZYqx|g>r=gCqy~nA`6yE>;lql-aPgCTlHK~%u!awB6|1fMw&=XaU&6C&rZtuk< zVVHvX$ePB#b3#UZ^R+BdgG=z)2vZ?9i{$Hx3TzkZ?84`f?CM8culZvZT`eYCHU0s- zLlKDlo93Xf_#Txy3(b)^p_5U0`adY2WZu8{}_MGMe zQtm%m=ZuV|^WGyxqw)khmXrJX4%tYET=o!EoiZoB95+evTY9Fxl>q1U(!O@#Fy_(G z&WkmpJ1w3sEGp9iZPmVQnPK_Y5VMy5p`$}qCt;q)$;$gQh(faaR(r|wVz$3?7%75d z2OrHEAH@><{9RS?af#&CIlo|FCmV#{O`|I<-XsTYap&91xnJ&|P_k71Y~4^clav&c*^AQqsX-f*1mUf!j>+KHD)T|0540}aCk#Ey)9?WSVi zXWB>&|Dz@!;j~2T-)8O!rLw|7qJxX^6EAmbBn%str#VE$Q20Q*;~J(+{^)X3yY?E^ zV&a+I!T4<(-YAu&=qr?fDokcNEVy!ciH;##dH&6-JO8^_+l>D0v*}+357!56a^UwX&VQ*emzll_s$WfL%rN#|8^WRIL^5)(txfkjwB^+UUr-uc>)MY5mNI&kIP zFcj_^eNw*Lb+9SjX4Innue687A&j|sHQQZXWnIVI%J;73?)GkHvnD0Z>BFVtf3c0X zMuj+e(^|*F`DOMVQIhsQa^=O=?o#W&9l!AiaC;0Yf^m7+v=tPL1@KIMKruNA|4{wi zD|_tk0{zcF5y>HOKV zHlm`_5`R^%fB91b@~1H`gDb#FR3QFm@3VoL1sj*Z&;J_2K1|~>_w-*WSeRhzIA1Zm zPU6Y@N4Za1zPKYNYkmHo$%;YbF*aNLT3*I7`2APk31T;g3i_uma>g1)|A5!#8~n;( zm3IE3TglCT-H~DNQKZd%gh>{LihuPI4Nd1Iov}sne~5HZ=|~W{;p;<@D%5N*Zv7V; zc{>}XJ@oo#c1W4&pb(N@(=d)=gnCKi-FrB~P`fJvH~X z{A>IfAK@-Ly6&Sr)oXEi=C|B+9o548}3jB}@u=sEVcO`aL(kVw?)YO))Pv zA8e?SZiC&8h#Mm7abFfsA1&o2C;cl)UC>3`aNhm>+0U+1M1-1(0a25lUh$b(+GU?^ z@`FOv>m-!N`-dhC`F$gL|Llr4H}%cZ4>}ghaVh)G5&w4KH3NSch9lAZVHqv=S1yQP zcLjR?-xRgJ->%o69d&;DRohn;oA=iP!%_dR&}w+WeuH^qL{dpjQr+I1Tj!Z{F-sNY z=|-=CNy7=SdKX2}wN;915+kFbyLQ?&`E$7zv^ZIKpIpvw^pZ=#G`1bkk`*K_Vo^@89 z|L^7Lr=SoMTFrm={UgP#9+2E32W$oYX?$@~p66fE&WJT4AvYHR8(D1;TDRZNUgoO* z@57l*=jClrf|{yNYj(z1T`gVkbzb!qY5TperPFh{9c@>-7)hwy~QmHb%(k@!!p8ms`EnDaLul{KJDhm|hSASW`Z8{WrL9S}e=KPGT zPmkQs|NZ(wTX*BH0Dmn(k(BqHdQZYW+tq)0^6wmQaYecF+GpKIg%&3Z&-}W{bK(E} z?!NqY7N1K=oA;?|t@XysHFsXKS>AYFvEujpc44j?$y5KUe@_SHQv3RPJ=YZeAC2pj zFTMF`=b`&7JM-@By)`erfTg$UEnwZ~GuiBa{HDxX_kG^oTWoisRAu(bGX=Vp(Pgvx z%daYMU;Y2L;E?wPpQxzsX}fpLx43=v?~%xvemichiaH&By84PAy!PbbZ;iUYcpbE% zAzQ&IB`39Ym-|~0c*XG{VC7NUEOlstZ)Iw05AuF}Z;j6NTlY92ii|g~^DrTcugG7mnM!`MJ<) z#{70^t{qnP+9KD=#kpSl-r+7hX{q$<17rRF#FZg$BBM^Nn)N?f>DNu>fBzEC^Itvq z$L2{(YUG`41_p+T7YY0l3=9p7TtkUG_@D9ji;_D2%iXO&KQMT@`njxgN@xNA;(p91 literal 0 HcmV?d00001 diff --git a/wiki/renderengine.html b/wiki/renderengine.html index 2ab329a32..f2dd7e790 100644 --- a/wiki/renderengine.html +++ b/wiki/renderengine.html @@ -1077,6 +1077,26 @@ Please note the shortcomings and logical contradictions in the solution currentl * The current design rather places the implementation according to the roles of the involved entities, which causes some ping-pong on the implementation level. Especially the ScopeLocator singleton can be accessed multiple times. This is the usual clarity vs. performance tradeoff. Scope resolution is assumed rather to be //not performance critical.// +
+
//Building the fixture is actually at the core of the [[builder's operation|Builder]]//
+{{red{WIP as of 11/10}}} &rarr; see also the [[planning page|PlanningBuildFixture]]
+
+;Resolving the DAG[>img[Steps towards creating a Segmentation|draw/SegmentationSteps1.png]]
+Because of the possibility of binding a Sequence multiple times, and maybe even nested as virtual clip, the [[high-level model|HighLevelModel]] actually constitutes a DAG, not a tree. This leds to quite some tricky problems, which we try to resolve by //rectifying the DAG into N virtual trees.// (&rarr; BindingScopeProblem)
+
+Relying on this transformation, each Timeline spans a sub-tree virtually separated from all other timelines; the BuildProcess is driven by [[visiting|VisitorUse]] all the //tangible// objects within this subtree. In the example shown to the right, Sequence-β is both bound as VirtualClip into Sequence-α, as well as bound independently as top-level sequence into Timeline-2. Thus it will be visited twice, but the QueryFocus mechanism ensures that each visitation »sees« the proper context.
+
+;Explicit Placements
+Each tangible object placement (relevant for rendering), which is encountered during that visitation, gets //resolved// into an [[explicit placement|ExplicitPlacement]]. If we see [[Placement]] as a positioning within a multi dimensional configuration space, then the resolution into an explicit placement is like the creation of an ''orthogonal base'': Within the explicit placement, each LocatingPin corresponds exactly to one degree of freedom and can be considered independently from all other locating pins. This resolution step removes any fancy dynamic behaviour and all scoping and indirect references. Indeed, an explicit placement is a mere //value object;// it isn't part of the session core (PlacementIndex), isn't typed and can't be referred indirectly.
+
+;Segmentation of Time axis
+This simple and explicit positioning thus allows to arrange all objects as time intervals on a single axis. Any change and especially any overlap is likely to create a different wiring configuration. Thus, for each such configuration change, we fork off a new //segment// and //copy over// all partially touched placements. The resulting seamless sequence of non-overlapping time intervals provides the backbone of the datastructure called [[Fixture]].
+
+;Building the Network
+From this backbone, the actual [[building mechanism|BuilderMechanics]] proceeds as a ongoing visitation and resolution, resulting in the gowth of a network of [[render nodes|ProcNode]] starting out from the source reading nodes and proceeding up through the local pipes, the transitions and the global pipes. When this build process is exhausted, besides the actual network, the result is a //residuum of nodes not connected any further.// Any of these [[exit nodes|ExitNode]] can be associated to a ~Pipe-ID in the high-level model. Within each segment, there should be one exit node per pipe-ID at max. These are the [[model ports|ModelPort]] resulting from the build process, keyed by their corresponding ~Pipe-ID.
+&rarr; see [[Structure of the Fixture|Fixture]]
+
+
All decisions on //how // the RenderProcess has to be carried out are concentrated in this rather complicated Builder Subsystem. The benefit of this approach is, besides decoupling of subsystems, to keep the actual performance-intensive video processing code as simple and transparent as possible. The price, in terms of increased complexity &mdash; to pay in the Builder &mdash; can be handled by making the Build Process generic to a large degree. Using a Design By Contract approach we can decompose the various decisions into small decision modules without having to trace the actual workings of the Build Process as a whole.
 
@@ -1708,8 +1728,8 @@ To make the intended use of the classes more clear, consider the following two e
 
a special ProcNode which is used to pull the finished output of one Render Pipeline (Tree or Graph). This term is already used in the Cinelerra2 codebase. I am unsure at the moment if it is a distinct subclass or rahter a specially configured ProcNode (a general design rule tells us to err in favour of the latter if in doubt).
-
-
A special kind (subclass) of [[Placement]]. As such it is always linked to a //Subject//, i.e. a MObject. In addition to the properties of a (unspecific) Placement, the ExplicitPlacement specifies a absolute time and track position for locating the Subject
+

+
A special kind (subclass) of [[Placement]]. As such it is always linked to a //Subject//, i.e. a MObject. But contrary to the (standard) placements, which may exhibit all kinds of fancy dynamic and scope dependent behaviour, within an explicit placement all properties are resolved and materialised. While the (standard) placement may contain an arbitrary list of LocatingPin objects, the resolution into an explicit placement performs a kind of »orthogonalisation«: each remaining LocatingPin defines exactly one degree of freedom independent of all others. Most notably, the explicit placement always specifies a absolute time and [[output designation|OutputDesignation]] for for locating the Subject.
 

 

 

@@ -1766,19 +1786,34 @@ Some further details
 * a special case of this factory use is the [[Singleton]] factory, which is used a lot within the Proy-Layer code
-
-
a specially configured sequence list
+

+
a specially configured view -- joining together high-level and low-level model
 * all MObjects have their position, length and configuration set up ready for rendering.
 * any nested sequences (or other kinds of indirections) have been resolved.
-* every MObject is associated with an ExplicitPlacement, which declares a fixed position (Time, [[Pipe-ID|OutputDesignation]])
-* these ~ExplicitPlacements are contained in a ordered List, sometimes denoted as the //effective timeline.//
+* every MObject is attached by an ExplicitPlacement, which declares a fixed position (Time, [[Pipe|OutputDesignation]])
+* these ~ExplicitPlacements are contained immediately within the Fixture, ordered by time
 * besides, there is a collection of all effective, possibly externally visible [[model ports|ModelPort]]
 
-As the builder and thus render engine //only consults the fixture,// while all editing operations finally propagate to the fixture as well, we get an isolation layer between the high level part of the Proc layer (editing, object manipulation) and the render engine. Creating the Fixture can be seen as a preprocessing step to simplify the build process. For this reason, the process of [[(re)building the fixture|PlanningBuildFixture]] has been designed together with the [[Builder]]
+As the builder and thus render engine //only consults the fixture,// while all editing operations finally propagate to the fixture as well, we get an isolation layer between the high level part of the Proc layer (editing, object manipulation) and the render engine. [[Creating the Fixture|BuildFixture]] is an important sideeffect of running the [[Builder]] when createing the [[render engine network|LowLevelModel]].
 
 !{{red{WIP}}} Structure of the fixture
-The fixture is like a grid, where one dimension is given by the [[model ports|ModelPort]], and the other dimension extends in time. The time axis is grouped in segments of constant structure.
-A problem yet to be solved is how the fixture relates to the mulitude of top-level timelines, without generating a too fine grained segmentation.
+[<img[Structure of the Fixture|draw/Fixture1.png]]
+
+The fixture is like a grid, where one dimension is given by the [[model ports|ModelPort]], and the other dimension extends in time. Within the time dimension there is a grouping into [[segments|Segmentation]] of constant structure.
+
+;Model Ports
+:The model ports share a single uniform and global name space: actually they're keyed by ~Pipe-ID
+:Model ports are derived as a result of the build process, as the //residuum// of all nodes not connected any further
+:Each port belongs to a specific Timeline and is associated with the [[Segmentation]] of that timeline.
+
+;Segmentation
+:The segmentation partitiones the time axis of a single timeline into segments of constant (wiring) configuration
+:Together, the segments form a seamless sequence of time intervals. They contain a copy of each (explicit) placement of a visible object touching that time interval. Besides that, segments are the top level grouping device of the render engine node graph; they are always built and discarded at once.
+:Segments may be //hot swapped// into an ongoing render.
+
+;Exit Nodes
+:Each segment holds an ExitNode for each relevant ModelPort of the corresponding timeline.
+:Thus the exit nodes are keyed by ~Pipe-ID as well (and consequently have a distinct [[stream type|StreamType]]) -- each model port coresponds to {{{<number_of_segments>}}} separate exit nodes, but of course an exit node may be //mute.//
 

 

 

@@ -2784,8 +2819,8 @@ These are used as token for dealing with other objects and have no identity of t
-
-
Any point where output possibly might be produced. Model port entities are located within the [[Fixture]] &mdash; model port as a concept spans the high-level and low-level view. A model port can be associated both to a pipe in the HighLevelModel and denote a specific ExitNode in the render nodes network.
+

+
Any point where output possibly might be produced. Model port entities are located within the [[Fixture]] &mdash; model port as a concept spans the high-level and low-level view. A model port can be associated both to a pipe in the HighLevelModel but at the same time denote a set of corresponding [[exit nodes|ExitNode]] within the [[segments|Segmentation]] of the render nodes network.
 
 A model port is rather derived than configured; it emerges when a pipe [[claims|WiringClaim]] an output desitnation and some other entity actually uses this designation as a target, either directly or indirecly. This match of provision and usage is detected during the build process and produces an entry in the fixture's model port table. These model ports in the fixture are keyed by ~Pipe-ID, thus each model port has an associated StreamType.
 

From d1c64dd1c05c39d88350eec93fc7aed63cccac0e Mon Sep 17 00:00:00 2001
From: Ichthyostega 
Date: Fri, 3 Dec 2010 02:28:29 +0100
Subject: [PATCH 02/28] small cleanup, replace try-catch by VERIFY_ERROR macro

---
 tests/lib/scoped-holder-test.cpp | 75 +++++++++++---------------------
 1 file changed, 26 insertions(+), 49 deletions(-)

diff --git a/tests/lib/scoped-holder-test.cpp b/tests/lib/scoped-holder-test.cpp
index 918e7416b..baa350562 100644
--- a/tests/lib/scoped-holder-test.cpp
+++ b/tests/lib/scoped-holder-test.cpp
@@ -23,7 +23,9 @@
 
 
 #include "lib/test/run.hpp"
+#include "lib/test/test-helper.hpp"
 #include "lib/util.hpp"
+#include "lib/error.hpp"
 
 #include "lib/scoped-holder.hpp"
 #include "testdummy.hpp"
@@ -38,6 +40,7 @@ namespace test{
   
   using ::Test;
   using util::isnil;
+  using lumiera::error::LUMIERA_ERROR_LOGIC;
   
   using std::map;
   using std::cout;
@@ -105,8 +108,8 @@ namespace test{
             
             TRACE (test, "holder at %p", &holder);
             TRACE (test, "object at %p", holder.get() );
-            TRACE (test, "size(object) = %u", sizeof(*holder));
-            TRACE (test, "size(holder) = %u", sizeof(holder));
+            TRACE (test, "size(object) = %lu", sizeof(*holder));
+            TRACE (test, "size(holder) = %lu", sizeof(holder));
           }
           ASSERT (0==checksum);
         }
@@ -157,60 +160,34 @@ namespace test{
             ASSERT (holder);
             long currSum = checksum;
             void* adr = holder.get();
-            try
-              {
-                holder2 = holder;
-                NOTREACHED ();
-              }
-            catch (lumiera::error::Logic&)
-              {
-                ASSERT (holder);
-                ASSERT (!holder2);
-                ASSERT (holder.get()==adr);
-                ASSERT (checksum==currSum);
-              }
             
-            try
-              {
-                holder = holder2;
-                NOTREACHED ();
-              }
-            catch (lumiera::error::Logic&)
-              {
-                ASSERT (holder);
-                ASSERT (!holder2);
-                ASSERT (holder.get()==adr);
-                ASSERT (checksum==currSum);
-              }
+            VERIFY_ERROR(LOGIC, holder2 = holder );
+            ASSERT (holder);
+            ASSERT (!holder2);
+            ASSERT (holder.get()==adr);
+            ASSERT (checksum==currSum);
+            
+            VERIFY_ERROR(LOGIC, holder = holder2 );
+            ASSERT (holder);
+            ASSERT (!holder2);
+            ASSERT (holder.get()==adr);
+            ASSERT (checksum==currSum);
             
             create_contained_object (holder2);
             ASSERT (holder2);
             ASSERT (checksum != currSum);
             currSum = checksum;
-            try
-              {
-                holder = holder2;
-                NOTREACHED ();
-              }
-            catch (lumiera::error::Logic&)
-              {
-                ASSERT (holder);
-                ASSERT (holder2);
-                ASSERT (holder.get()==adr);
-                ASSERT (checksum==currSum);
-              }
+
+            VERIFY_ERROR(LOGIC, holder = holder2 );
+            ASSERT (holder);
+            ASSERT (holder2);
+            ASSERT (holder.get()==adr);
+            ASSERT (checksum==currSum);
             
-            try
-              {
-                HO holder3 (holder2);
-                NOTREACHED ();
-              }
-            catch (lumiera::error::Logic&)
-              {
-                ASSERT (holder);
-                ASSERT (holder2);
-                ASSERT (checksum==currSum);
-              }
+            VERIFY_ERROR(LOGIC, HO holder3 (holder2) );
+            ASSERT (holder);
+            ASSERT (holder2);
+            ASSERT (checksum==currSum);
           }
           ASSERT (0==checksum);
         }

From 145ad6c3a51d918ebe6a101d673d7e00591d8941 Mon Sep 17 00:00:00 2001
From: Ichthyostega 
Date: Fri, 3 Dec 2010 03:13:57 +0100
Subject: [PATCH 03/28] more (trivial) cleanup and renaming

---
 src/lib/allocationcluster.hpp                              | 2 +-
 ...scopedholdertransfer.hpp => scoped-holder-transfer.hpp} | 6 +++---
 src/lib/scoped-holder.hpp                                  | 2 +-
 src/lib/scoped-ptrvect.hpp                                 | 2 +-
 tests/lib/Makefile.am                                      | 4 ++--
 ...dertransfertest.cpp => scoped-holder-transfer-test.cpp} | 5 ++---
 tests/lib/testdummy.hpp                                    | 7 +++++++
 .../{vectortransfertest.cpp => vector-transfer-test.cpp}   | 2 +-
 8 files changed, 18 insertions(+), 12 deletions(-)
 rename src/lib/{scopedholdertransfer.hpp => scoped-holder-transfer.hpp} (97%)
 rename tests/lib/{scopedholdertransfertest.cpp => scoped-holder-transfer-test.cpp} (98%)
 rename tests/lib/{vectortransfertest.cpp => vector-transfer-test.cpp} (99%)

diff --git a/src/lib/allocationcluster.hpp b/src/lib/allocationcluster.hpp
index 304405d58..1b51e9d5c 100644
--- a/src/lib/allocationcluster.hpp
+++ b/src/lib/allocationcluster.hpp
@@ -54,7 +54,7 @@
 #include "lib/error.hpp"
 #include "lib/sync-classlock.hpp"
 #include "lib/scoped-holder.hpp"
-#include "lib/scopedholdertransfer.hpp"
+#include "lib/scoped-holder-transfer.hpp"
 
 
 
diff --git a/src/lib/scopedholdertransfer.hpp b/src/lib/scoped-holder-transfer.hpp
similarity index 97%
rename from src/lib/scopedholdertransfer.hpp
rename to src/lib/scoped-holder-transfer.hpp
index 3d600e61a..e7e78c945 100644
--- a/src/lib/scopedholdertransfer.hpp
+++ b/src/lib/scoped-holder-transfer.hpp
@@ -1,5 +1,5 @@
 /*
-  SCOPEDHOLDERVECTOR.hpp  -  using ScopedHolder within a STL vector 
+  SCOPED-HOLDER-TRANSFER.hpp  -  using ScopedHolder within a STL vector 
  
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler 
@@ -22,8 +22,8 @@
 
 
 
-#ifndef LIB_SCOPEDHOLDERVECTOR_H
-#define LIB_SCOPEDHOLDERVECTOR_H
+#ifndef LIB_SCOPEDHOLDER_TRANSFER_H
+#define LIB_SCOPEDHOLDER_TRANSFER_H
 
 #include "lib/error.hpp"
 #include 
diff --git a/src/lib/scoped-holder.hpp b/src/lib/scoped-holder.hpp
index 4e2c82627..83191970f 100644
--- a/src/lib/scoped-holder.hpp
+++ b/src/lib/scoped-holder.hpp
@@ -47,7 +47,7 @@
  ** friend function.  
  ** 
  ** @see scoped-holder-test.cpp
- ** @see scopedholdertransfer.hpp use in std::vector
+ ** @see scoped-holder-transfer.hpp use in std::vector
  ** @see AllocationCluster usage example
  ** @see scoped-ptrvect.hpp simple pointer-holding collection
  */
diff --git a/src/lib/scoped-ptrvect.hpp b/src/lib/scoped-ptrvect.hpp
index d21e2333a..fa7515c6b 100644
--- a/src/lib/scoped-ptrvect.hpp
+++ b/src/lib/scoped-ptrvect.hpp
@@ -171,7 +171,7 @@ namespace lib {
       
       
     private:
-      /** @internal element access, including null check */
+      /** @internal element access, including range and null check */
       T*
       get (size_type i)
         {
diff --git a/tests/lib/Makefile.am b/tests/lib/Makefile.am
index f8661006b..f6930f20b 100644
--- a/tests/lib/Makefile.am
+++ b/tests/lib/Makefile.am
@@ -84,7 +84,7 @@ test_lib_SOURCES =							\
 	$(testlib_srcdir)/sanitised-identifier-test.cpp			\
 	$(testlib_srcdir)/scoped-holder-test.cpp			\
 	$(testlib_srcdir)/scoped-ptrvect-test.cpp			\
-	$(testlib_srcdir)/scopedholdertransfertest.cpp			\
+	$(testlib_srcdir)/scoped-holder-transfer-test.cpp		\
 	$(testlib_srcdir)/singleton-subclass-test.cpp			\
 	$(testlib_srcdir)/singleton-test.cpp				\
 	$(testlib_srcdir)/singletontestmocktest.cpp			\
@@ -106,7 +106,7 @@ test_lib_SOURCES =							\
 	$(testlib_srcdir)/typed-allocation-manager-test.cpp		\
 	$(testlib_srcdir)/typed-counter-test.cpp			\
 	$(testlib_srcdir)/util-foreach-test.cpp				\
-	$(testlib_srcdir)/vectortransfertest.cpp			\
+	$(testlib_srcdir)/vector-transfer-test.cpp			\
 	$(testlib_srcdir)/visitingtoolconcept.cpp			\
 	$(testlib_srcdir)/visitingtoolextendedtest.cpp			\
 	$(testlib_srcdir)/visitingtooltest.cpp
diff --git a/tests/lib/scopedholdertransfertest.cpp b/tests/lib/scoped-holder-transfer-test.cpp
similarity index 98%
rename from tests/lib/scopedholdertransfertest.cpp
rename to tests/lib/scoped-holder-transfer-test.cpp
index c47cd2a76..ace319736 100644
--- a/tests/lib/scopedholdertransfertest.cpp
+++ b/tests/lib/scoped-holder-transfer-test.cpp
@@ -26,7 +26,7 @@
 #include "lib/util.hpp"
 
 #include "lib/scoped-holder.hpp"
-#include "lib/scopedholdertransfer.hpp"
+#include "lib/scoped-holder-transfer.hpp"
 #include "testdummy.hpp"
 
 #include 
@@ -68,8 +68,7 @@ namespace lib {
             if (throw_in_transfer)
               throw to.getVal();
             
-            to.setVal (from.getVal());
-            from.setVal(0);
+            swap (from,to);
           }
           
         };
diff --git a/tests/lib/testdummy.hpp b/tests/lib/testdummy.hpp
index afa810f79..605a92fc7 100644
--- a/tests/lib/testdummy.hpp
+++ b/tests/lib/testdummy.hpp
@@ -23,6 +23,7 @@
 
 
 #include 
+#include 
 
 
 namespace lib {
@@ -63,6 +64,12 @@ namespace test{
             val_ = newVal;
           }
         
+        friend void
+        swap (Dummy& dum1, Dummy& dum2)  ///< checksum neutral
+        {
+          std::swap(dum1.val_, dum2.val_);
+        }
+        
       private:
         void
         init()
diff --git a/tests/lib/vectortransfertest.cpp b/tests/lib/vector-transfer-test.cpp
similarity index 99%
rename from tests/lib/vectortransfertest.cpp
rename to tests/lib/vector-transfer-test.cpp
index f165f2ece..c011f56c4 100644
--- a/tests/lib/vectortransfertest.cpp
+++ b/tests/lib/vector-transfer-test.cpp
@@ -24,7 +24,7 @@
 
 #include "lib/test/run.hpp"
 
-#include "lib/scopedholdertransfer.hpp"
+#include "lib/scoped-holder-transfer.hpp"
 #include "testdummy.hpp"
 
 #include 

From ee56ab36a068889803da8f647c9acb8ec24404b7 Mon Sep 17 00:00:00 2001
From: Ichthyostega 
Date: Fri, 3 Dec 2010 05:13:52 +0100
Subject: [PATCH 04/28] Definition of ModelPort, model port reference and
 -table (#718)

---
 src/proc/mobject/model-port.cpp | 69 +++++++++++++++++++++++++
 src/proc/mobject/model-port.hpp | 91 +++++++++++++++++++++++++++++++++
 wiki/renderengine.html          | 37 ++++++++++++--
 3 files changed, 192 insertions(+), 5 deletions(-)
 create mode 100644 src/proc/mobject/model-port.cpp
 create mode 100644 src/proc/mobject/model-port.hpp

diff --git a/src/proc/mobject/model-port.cpp b/src/proc/mobject/model-port.cpp
new file mode 100644
index 000000000..332fe9d31
--- /dev/null
+++ b/src/proc/mobject/model-port.cpp
@@ -0,0 +1,69 @@
+/*
+  ModelPort  -  point to pull output data from the model
+ 
+  Copyright (C)         Lumiera.org
+    2010,               Hermann Vosseler 
+ 
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License as
+  published by the Free Software Foundation; either version 2 of the
+  License, or (at your option) any later version.
+ 
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+ 
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ 
+* *****************************************************/
+
+
+/** @file model-port.cpp 
+ ** Implementation details of model port descriptors and references.
+ ** Especially, the handling of the ModelPortTable datastructure is
+ ** kept an opaque implementation detail and confined entirely within
+ ** this translation unit.
+ ** 
+ ** TODO: comment necessary?
+ ** 
+ ** @see OutputDesignation
+ ** @see OutputMapping
+ ** @see Timeline
+ **
+ */
+
+
+#include "lib/error.hpp"
+//#include "lib/symbol.hpp"//
+#include "proc/mobject/model-port.hpp"
+
+//#include 
+//#include 
+#include 
+
+//using lumiera::query::QueryHandler;
+//using lumiera::query::removeTerm;
+//using lumiera::query::extractID;
+//using lumiera::ConfigRules;
+
+//using lumiera::Symbol;
+
+namespace mobject {
+  
+  
+  /**
+   * TODO type comment
+   */
+  class ModelPortTable
+    : boost::noncopyable
+    {
+      
+    public:
+    };
+  
+  
+  
+} // namespace mobject
diff --git a/src/proc/mobject/model-port.hpp b/src/proc/mobject/model-port.hpp
new file mode 100644
index 000000000..634d1e0dc
--- /dev/null
+++ b/src/proc/mobject/model-port.hpp
@@ -0,0 +1,91 @@
+/*
+  MODEL-PORT.hpp  -  point to pull output data from the model
+ 
+  Copyright (C)         Lumiera.org
+    2010,               Hermann Vosseler 
+ 
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License as
+  published by the Free Software Foundation; either version 2 of the
+  License, or (at your option) any later version.
+ 
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+ 
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ 
+*/
+
+/** @file model-port.hpp
+ ** Organising the output data calculation possibilities.
+ ** Model ports are conceptual entities, denoting the points where output might
+ ** possibly be produced. There is an actual representation, a collection of small
+ ** descriptor objects managed by the Fixture and organised within the ModelPortTable
+ ** datastructure. Thus, while the actual ModelPort descriptor entities are located
+ ** within and managed by the Fixture -- model port as a concept spans the high-level
+ ** and low-level view. A model port can be associated both to a pipe within a timeline
+ ** in the HighLevelModel, as well as to denote a set of corresponding exit nodes within
+ ** the segments of the render nodes network. Model ports are keyed by Pipe-ID and thus
+ ** are unique within the application.
+ ** 
+ ** A model port is rather derived than configured; it emerges during the build process
+ ** when a pipe claims an OutputDesignation and some other entity actually uses this
+ ** designation as a target, either directly or indirectly. This match of provision
+ ** and usage is detected by the Builder and produces an entry in the fixture's
+ ** ModelPortTable. Because of the 1:1 association with a pipe, each model port
+ ** has an associated StreamType.
+ ** 
+ ** Because model ports are discovered this way, dynamically during the build process,
+ ** at some point there is a transactional switch to promote the new configuration
+ ** to be come the valid current model port configuration. After that switch, model ports
+ ** are immutable.
+ ** 
+ ** Model ports are to be accessed, enumerated and grouped in various ways, because each
+ ** port belongs to a specific timeline and is used for producing data of a single
+ ** StreamType solely. But all those referrals, searching and grouping happens only
+ ** after the build process has discovered all model ports currently available.
+ ** Thus we provide a MPortRef smart-pointer to ease handling of those access
+ ** operations. The actual model port descriptors are owned and managed by
+ ** the fixture; they are bulk allocated in a similar manner than the
+ ** ProcNode and WiringDescriptor objects.
+ ** 
+ ** TODO fill in more details?
+ ** TODO where to put the ModelPortTable
+ ** 
+ ** @see OutputDesignation
+ ** @see OutputMapping
+ ** @see Timeline
+ */
+
+
+#ifndef PROC_MOBJECT_MODEL_PORT_H
+#define PROC_MOBJECT_MODEL_PORT_H
+
+#include "proc/asset/pipe.hpp"
+//#include "lib/opaque-holder.hpp"
+//#include "lib/meta/typelist-util.hpp"
+
+//extern "C" {
+//#include "lib/luid.h"
+//}
+
+namespace mobject {
+  
+  /**
+   * TODO type comment
+   */
+  class ModelPort
+    : boost::noncopyable
+    {
+      
+    public:
+    };
+  
+  
+  
+} // namespace mobject
+#endif
diff --git a/wiki/renderengine.html b/wiki/renderengine.html
index f2dd7e790..9a0da012c 100644
--- a/wiki/renderengine.html
+++ b/wiki/renderengine.html
@@ -1786,7 +1786,7 @@ Some further details
 * a special case of this factory use is the [[Singleton]] factory, which is used a lot within the Proy-Layer code
 

 

-

+

 
a specially configured view -- joining together high-level and low-level model
 * all MObjects have their position, length and configuration set up ready for rendering.
 * any nested sequences (or other kinds of indirections) have been resolved.
@@ -1799,7 +1799,7 @@ As the builder and thus render engine //only consults the fixture,// while all e
 !{{red{WIP}}} Structure of the fixture
 [<img[Structure of the Fixture|draw/Fixture1.png]]
 
-The fixture is like a grid, where one dimension is given by the [[model ports|ModelPort]], and the other dimension extends in time. Within the time dimension there is a grouping into [[segments|Segmentation]] of constant structure.
+The fixture is like a grid, where one dimension is given by the [[model ports|ModelPortTable]], and the other dimension extends in time. Within the time dimension there is a grouping into [[segments|Segmentation]] of constant structure.
 
 ;Model Ports
 :The model ports share a single uniform and global name space: actually they're keyed by ~Pipe-ID
@@ -2819,12 +2819,39 @@ These are used as token for dealing with other objects and have no identity of t
 
 

 

-

+

 
Any point where output possibly might be produced. Model port entities are located within the [[Fixture]] &mdash; model port as a concept spans the high-level and low-level view. A model port can be associated both to a pipe in the HighLevelModel but at the same time denote a set of corresponding [[exit nodes|ExitNode]] within the [[segments|Segmentation]] of the render nodes network.
 
-A model port is rather derived than configured; it emerges when a pipe [[claims|WiringClaim]] an output desitnation and some other entity actually uses this designation as a target, either directly or indirecly. This match of provision and usage is detected during the build process and produces an entry in the fixture's model port table. These model ports in the fixture are keyed by ~Pipe-ID, thus each model port has an associated StreamType.
+A model port is rather derived than configured; it emerges when a pipe [[claims|WiringClaim]] an output destination and some other entity actually uses this designation as a target, either directly or indirectly. This match of provision and usage is detected during the build process and produces an entry in the fixture's model port table. These model ports in the fixture are keyed by ~Pipe-ID, thus each model port has an associated StreamType.
 
-Model ports are the effective, resulting ouputs of each timeline; additional ports result from [[connecting a viewer|ViewerPlayConnection]]. Any render or display process happens at a model port.
+Model ports are the effective, resulting outputs of each timeline; additional ports result from [[connecting a viewer|ViewerPlayConnection]]. Any render or display process happens at a model port.
+
+!formal specification
+Model port is a //conceptual entity,// denoting the possibility to pull generated data of a distinct (stream)type from a specific bus within the model -- any possible output produced or provided by Lumiera is bound to appear at a model port. The namespace of model ports is global, each being denoted by a ~Pipe-ID.
+
+Model ports are represented by small non-copyable descriptor objects with distinct identity, which are owned and managed by the [[Fixture]]. Clients are bound to resolve a model port on each usage, as configuration changes within the model might cause ports to appear and decease. Each model port belongs to a specific Timeline and is aware of this association, as is the timeline, allowing to get the collection of all ports of a given timeline. Besides, within the Fixture each model port refers to a specific [[segmentation of the time axis|Segmentation]] (relevant for this special timeline actually). Thus, with the help of this segmentation, a model port can yield an ExitNode to pull frames for a given time.
+
+

+

+

+
Model ports are conceptual entities, denoting the points where output might possibly be produced &rarr; see [[definition|ModelPort]].
+But there is an actual representation, a collection of small descriptor objects managed by the Fixture and organised within the model port table datastructure. Because model ports are discovered during the build process, we need the ability to (re)build this table dynamically, finally swapping in the modified configuration with a transactional switch. Only the builder is allowed to perform such mutations, while for client code model ports are immutable.
+
+!supported operations
+* get the model port by ~Pipe-ID
+* a collection of model ports per timeline
+* sub-grouping by media kind, possibly even by StreamType
+* possibility to enumerate model ports in distinct //order,// defined within the timeline
+* with the additional possibility to filter by media kind or suitable stream type.
+* a way to express the fact of //not having a model port.//
+
+!!!mutating and rebuilding
+Model ports are added once and never changed. The corresponding timeline and pipe is known at setup time, but the overall number of model ports is determined only as a result of completing the build process. At that point, the newly built configuration is swapped in transactionally to become the current configuration.
+
+!Implementation considerations
+The transactional switch creates a clear partitioning in the lifespan of the model port table. //Before// that point, entries are just added, but not accessed in any way. //After// that point, no further mutation occurs, but lookup is frequent and happens in a variety of different configurations and transient orderings.
+
+This observation leads to the idea of using //model port references// to provide all kinds of access, searching and reordering. These encapsulate the actual access by silently assuming reference to "the" global current model port configuration. Thus, the actual model port descriptors could be bulk allocated in a similar manner as the processing nodes and wiring descriptors. Access to stale model ports could be detected by the port references, allowing also for a {{{bool}}} checkable "has no port" information.
 

 

 


From 41e675016349be528236281f344d25708365c39e Mon Sep 17 00:00:00 2001
From: Stefan Kangas 
Date: Mon, 6 Dec 2010 16:18:54 +0100
Subject: [PATCH 05/28] Move time conversion logic from lumitime.cpp to time.c

---
 src/lib/lumitime.cpp | 20 ++++++++++++--------
 src/lib/lumitime.hpp |  4 ++--
 src/lib/time.c       | 35 ++++++++++++++++++++++++++++++-----
 src/lib/time.h       | 21 ++++++++++++++++++++-
 4 files changed, 64 insertions(+), 16 deletions(-)

diff --git a/src/lib/lumitime.cpp b/src/lib/lumitime.cpp
index fb798d476..bc9812aed 100644
--- a/src/lib/lumitime.cpp
+++ b/src/lib/lumitime.cpp
@@ -47,41 +47,45 @@ namespace lumiera {
              )
     : t_(lumiera_build_time (millis,secs,mins,hours))
   { }
-  
-  
+
   int
   Time::getMillis() const
   {
-    return (t_ / (GAVL_TIME_SCALE / 1000)) % 1000; 
+    return lumiera_time_millis(t_);
   }
   
   
   int
   Time::getSecs()   const
   {
-    return (t_ / (GAVL_TIME_SCALE / 1  )) % 60; 
+    return lumiera_time_seconds(t_);
   }
   
   
   int
   Time::getMins()   const
   {
-    return (t_ / (60 * GAVL_TIME_SCALE)) % 60; 
+    return lumiera_time_minutes(t_);
   }
   
   
   int
   Time::getHours()  const
   {
-    return (t_ / (gavl_time_t(60) * 60 * GAVL_TIME_SCALE)); 
+    return lumiera_time_hours(t_);
   }
   
+  int
+  Time::getFrames()  const
+  {
+    // TODO
+    return 0;
+  }
+
   
   Time::operator string()  const
   {
     return string (lumiera_tmpbuf_print_time (t_));
   }
   
-  
-  
 } // namespace lumiera
diff --git a/src/lib/lumitime.hpp b/src/lib/lumitime.hpp
index 9f13d48f8..4f2ab8834 100644
--- a/src/lib/lumitime.hpp
+++ b/src/lib/lumitime.hpp
@@ -85,8 +85,8 @@ namespace lumiera {
       int getSecs   () const; 
       int getMins   () const; 
       int getHours  () const; 
-      
-      
+      int getFrames () const;
+
       operator std::string ()  const;
       operator gavl_time_t ()  const { return t_; }
       
diff --git a/src/lib/time.c b/src/lib/time.c
index 9fcc15b4f..c5f497f9d 100644
--- a/src/lib/time.c
+++ b/src/lib/time.c
@@ -23,12 +23,16 @@
 #include "lib/time.h"
 #include "lib/tmpbuf.h"
 
+/* GAVL_TIME_SCALE is the correct factor or dividend when using gavl_time_t for
+ * units of whole seconds from gavl_time_t.  Since we want to use milliseconds,
+ * we need to multiply or divide by 1000 to get correct results. */
+#define GAVL_TIME_SCALE_MS (GAVL_TIME_SCALE / 1000)
+
 char*
 lumiera_tmpbuf_print_time (gavl_time_t time)
 {
   int milliseconds, seconds, minutes, hours;
   int negative;
-
   
   if(time < 0)
     {
@@ -37,7 +41,7 @@ lumiera_tmpbuf_print_time (gavl_time_t time)
     }
   else negative = 0;
   
-  time /= GAVL_TIME_SCALE / 1000;
+  time /= GAVL_TIME_SCALE_MS;
   milliseconds = time % 1000;
   time /= 1000;
   seconds = time % 60;
@@ -53,16 +57,37 @@ lumiera_tmpbuf_print_time (gavl_time_t time)
   return buffer;
 }
 
-
 gavl_time_t
-lumiera_build_time (long millis, uint secs, uint mins, uint hours)
+lumiera_build_time(long millis, uint secs, uint mins, uint hours)
 {
   gavl_time_t time = millis
                    + 1000 * secs
                    + 1000 * 60 * mins
                    + 1000 * 60 * 60 * hours;
-  time *= GAVL_TIME_SCALE / 1000;
+  time *= GAVL_TIME_SCALE_MS;
   return time;
 }
 
+int
+lumiera_time_hours(gavl_time_t time)
+{
+  return time / GAVL_TIME_SCALE_MS / 1000 / 60 / 60;
+}
 
+int
+lumiera_time_minutes(gavl_time_t time)
+{
+  return (time / GAVL_TIME_SCALE_MS / 1000 / 60) % 60;
+}
+
+int
+lumiera_time_seconds(gavl_time_t time)
+{
+  return (time / GAVL_TIME_SCALE_MS / 1000) % 60;
+}
+
+int
+lumiera_time_millis(gavl_time_t time)
+{
+  return (time / GAVL_TIME_SCALE_MS) % 1000;
+}
diff --git a/src/lib/time.h b/src/lib/time.h
index 5a6034a20..688eb91ad 100644
--- a/src/lib/time.h
+++ b/src/lib/time.h
@@ -34,12 +34,31 @@
 char*
 lumiera_tmpbuf_print_time (gavl_time_t time);
 
-
 /**
  * Builds a time value by summing up the given components.
  */
 gavl_time_t
 lumiera_build_time (long millis, uint secs, uint mins, uint hours);
 
+/**
+ * Get the hour part of given time.
+ */
+int lumiera_time_hours(gavl_time_t time);
+
+/**
+ * Get the minute part of given time.
+ */
+int lumiera_time_minutes(gavl_time_t time);
+
+/**
+ * Get the seconds part of given time.
+ */
+int lumiera_time_seconds(gavl_time_t time);
+
+/**
+ * Get the milliseconds part of given time.
+ */
+int lumiera_time_millis(gavl_time_t time);
+
 #endif
 

From 26bff0daa33204cc5b6edf5106e2ae155b545e7f Mon Sep 17 00:00:00 2001
From: Stefan Kangas 
Date: Mon, 6 Dec 2010 16:19:17 +0100
Subject: [PATCH 06/28] Add unit tests for time.c

---
 tests/15time.tests        | 10 +++++++
 tests/Makefile.am         |  5 ++++
 tests/library/test-time.c | 56 +++++++++++++++++++++++++++++++++++++++
 3 files changed, 71 insertions(+)
 create mode 100644 tests/15time.tests
 create mode 100644 tests/library/test-time.c

diff --git a/tests/15time.tests b/tests/15time.tests
new file mode 100644
index 000000000..8ee10499b
--- /dev/null
+++ b/tests/15time.tests
@@ -0,0 +1,10 @@
+TESTING "Time conversion" ./test-time
+
+TEST "basic functionality" basic <
+ *
+ *  This program is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public License as
+ *  published by the Free Software Foundation; either version 2 of the
+ *  License, or (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+typedef unsigned int uint;
+
+#include "lib/time.h"
+#include "tests/test.h"
+
+#include 
+
+TESTS_BEGIN
+
+const int MILLIS = 700;
+const int SECONDS = 20;
+const int MINUTES = 55;
+const int HOURS = 3;
+
+/*
+ * 1. Basic functionality
+ */
+
+TEST (basic) {
+	// Zero
+	gavl_time_t t = lumiera_build_time(0,0,0,0);
+	ECHO ("%d", (int) t);
+
+	// Non-zero
+	t = lumiera_build_time(MILLIS, SECONDS, MINUTES, HOURS);
+
+	ECHO("%d", lumiera_time_millis(t) == MILLIS);
+	ECHO("%d", lumiera_time_seconds(t) != SECONDS);
+	ECHO("%d", lumiera_time_minutes(t) == MINUTES);
+	ECHO("%d", lumiera_time_hours(t) != HOURS);
+
+	ECHO("%s", lumiera_tmpbuf_print_time(t));
+}
+
+TESTS_END

From 620a22b2a8c172ed03185e656a82a1187789caa9 Mon Sep 17 00:00:00 2001
From: Simon Larcher 
Date: Wed, 8 Dec 2010 01:10:38 +0100
Subject: [PATCH 07/28] Added anchors to the glossary. Fine tuned the wording
 in design/index.html

The arrows "->" before each item in the glossary give direct links.
Use the #anchor of the link to refer to it.
Everything from the item name is kept with rules : Two Words = #TwoWords | Two/Words = #Two_Words
---
 doc/design/index.txt             | 25 +++++------
 doc/user/outerSpace/Glossary.txt | 75 +++++++++++++++-----------------
 2 files changed, 48 insertions(+), 52 deletions(-)

diff --git a/doc/design/index.txt b/doc/design/index.txt
index 7d35ac233..a78d59ac8 100644
--- a/doc/design/index.txt
+++ b/doc/design/index.txt
@@ -5,8 +5,12 @@ The vision of the development team defines a modern design for the core of a Non
 One of the key aspect of Lumiera is the strong separation between the user interface and the processing core.
 Lumiera as a software will come along with a GTK GUI but that does not make this exclusive, any other GUI could be written as well as scripts to drive the core.
 This is made possible by the above-mentioned quality of Lumiera being considered as two strictly separate parts.
-Lumiera as a processing core will be able to do anything possibly conceivable and thus enabling it to be used to do any task on video (and audio?), even unrelated to video editing.
+Lumiera as a processing core will be able to do anything possibly conceivable, therefore it may be used to do any task on video (and audio?), even unrelated to video editing.
 
+.Workflow
+****
+The word Workflow is used to name the way tasks can be achieved in an application. Any operation in Lumiera must be possible in the most suitable and stringent fashion. The Workflow is closely related to how flexible the GUI is but also the concern of deeper and more technical parts of the application.
+****
 === Overview
 
 The internal structure of Lumiera is divided in numerous subsystems.
@@ -16,7 +20,7 @@ They can be categorized into three main categories plus extra components :
 ==== link:gui/index.html[Graphical User Interface]
 
 User interfaces are basically handled like plugins, consequently it is possible to interface with Lumiera through scripts. It is also possible to create specialized GUIs.
-The interface is the closest component to the user, it is purely visual. There the user manipulates, organizes, loads, configures all sorts of datas that are called Assets. These Assets are grouped in a structure called the Session.
+The interface is the closest component to the user, it is purely visual. There the user manipulates, organizes, loads, configures all sorts of datas, especially MObjects (media objects) and Assets. These elements are contained within a structure called the Session.
 
 ==== The Processing Layer
 
@@ -27,26 +31,21 @@ The Processing layer (or proc) is where the elements from the Session are assemb
 
 ==== link:backend/index.html[The Backend]
 
-The backend uses the Low-level model. It does the rendering process and makes a heavy use of the Input/Output System to the screen or to external monitors.
- +
- +
+The backend uses the Low-level model. It allows the rendering and makes a heavy use of the Input/Output System to the screen or to external monitors.
+//link:workflow/index.html[The Workflow]
 
-''''
-
-link:workflow/index.html[The Workflow]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-The word Workflow is used to name the way tasks can be achieved in an application. Any operation in Lumiera must be possible in the most suitable and stringent fashion. The Workflow is closely related to how flexible the GUI is but also the concern of deeper and more technical parts of the application.
+Extra components
+----------------
 
 link:application/index.html[The Application]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-Apart from all things that deal with the internal gear, Lumiera contains several elements related to external elements.
+The application controls the initialization and shutdown procedures as well as loading external elements like plugins that are widely used.
 
 link:plugins/index.html[Plugins]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-They are key elements in Lumiera since the application relies heavily on this concept of modules.
+They are key elements in Lumiera since the application relies heavily on this concept of modules. For example, the GUI of Lumiera is a plugin.
 
 
 
diff --git a/doc/user/outerSpace/Glossary.txt b/doc/user/outerSpace/Glossary.txt
index 1408fcdf4..9f5f7c2ea 100644
--- a/doc/user/outerSpace/Glossary.txt
+++ b/doc/user/outerSpace/Glossary.txt
@@ -2,31 +2,30 @@ Glossary
 ========
 
 
-
 'NOTE Draft, please help rephrase/review and sort this terms, shorten
 explanations, the long explanation is the topic of the document above..'
 
 
- Project::
+ anchor:Project[] link:#Project[->]Project::
         the top-level context in which all edit work is done over an extended
         period of time. The Project can be saved and re-opened. It is
         comprised of the collection of all things the user is working on, it
         contains all informations, assets, state and objects to be edited.
 
- Session::
+ anchor:Session[] link:#Session[->]Session::
         the current in-memory representation of the Project when opened within
         an instance of Lumiera. This is an implementation-internal term. For
         the GUI and the users POV we should always prefer the term "Project"
         for the general concept.
 
- Timeline View::
+ anchor:TimelineView[] link:#TimelineView[->]Timeline View::
         A view in the GUI featuring a given Timeline. There might be multiple
         views of the same timeline, all sharing the same PlayController. A
         proposed extension is the ability to 'focus' a timeline view to a
         sub-Sequence contained within the top-level sequence of the underlying
         Timeline. (Intended for editing meta-clips)
 
- Track-head/patchbay::
+ anchor:Track-head_patchbay[] link:#Track-head_patchbay[->]Track-head/patchbay::
         the box in front of a track allowing to control properties of the
         elements contained within this track, unfold nested tracks and so on.
         To a large extent, it corresponds to the placement of this track and
@@ -39,7 +38,7 @@ explanations, the long explanation is the topic of the document above..'
           patchbay, that is not the main purpose and they can do things beyond
           that..
 
- Timeline::
+ anchor:Timeline[] link:#Timeline[->]Timeline::
         the top level element(s) within the Project. It is visible within a
         'timeline view' in the GUI and represents the effective (resulting)
         arrangement of media objects, resolved to a finite time axis, to be
@@ -54,7 +53,7 @@ explanations, the long explanation is the topic of the document above..'
          * global pipes, i.e. global busses like in a mixing desk
          * exactly one top level Sequence
 
- Time Axis::
+ anchor:TimeAxis[] link:#TimeAxis[->]Time Axis::
         An entity defining the temporal properties of a timeline. A time axis
         defines the time base, kind of timecode and absolute anchor point.
         Besides, it manages a set of frame quantisation grids, corresponding
@@ -62,14 +61,13 @@ explanations, the long explanation is the topic of the document above..'
         busses). The GUI representation is a time ruler with configurable time
         ticks showed on top of the timeline view
 
-
- Busses::
+ anchor:Busses[] link:#Busses[->]Busses::
         A list of 'global Pipes' representing the possible outputs (master
         busses) similar to audio mixing desk. A bus defines the properties of
         the rendered output (Framerate, Resolution, Colorformat and so on).
         Busses are part of a Timeline.
 
- Sequence::
+ anchor:Sequence[] link:#Sequence[->]Sequence::
         A collection of *Media Objects* (clips, effects, transitions, labels,
         automation) placed onto a tree of tracks. By means of this placement,
         the objects could be anchored relative to each other, relative to
@@ -80,7 +78,7 @@ explanations, the long explanation is the topic of the document above..'
         contains just a single root track and sends directly to the master bus
         of the timeline.
 
- Placement::
+ anchor:Placement[] link:#Placement[->]Placement::
         A Placement represents a relation: it is always linked to a Subject
         (this being a Media Object) and has the meaning to place this Subject
         in some manner, either relatively to other Media Objects, by some
@@ -89,7 +87,7 @@ explanations, the long explanation is the topic of the document above..'
         thus are organised hierarchically and need to be _resolved_ to obtain
         a specific value (time point, output routing, layering, fade,...)
 
- Pipe::
+ anchor:Pipe[] link:#Pipe[->]Pipe::
         Conceptual building block of the high-level model. It can be thought
         off as simple linear processing chain. A stream can be 'sent to' a
         pipe, in which case it will be mixed in at the input, and you can
@@ -98,15 +96,15 @@ explanations, the long explanation is the topic of the document above..'
         (busses) in each Timeline, each clip automatically creates N pipes
         (one for each distinct content stream. Typically N=2, for video and
         audio)
- 
- MediaStream::
+
+ anchor:MediaStream[] link:#MediaStream[->]MediaStream::
         Media data is supposed to appear structured as stream(s) over time.
         While there may be an inherent internal structuring, at a given
         perspective any stream is a unit and homogeneous. In the context of
         digital media data processing, streams are always quantized, which means
         they appear as a temporal sequence of data chunks called frames.
 
- StreamType::
+ anchor:StreamType[] link:#StreamType[->]StreamType::
         Classification of a media stream. StreamType is a descriptor record.
         While external media processing libraries usually do provide some kind
         of classification already, within lumiera we rely on an uniform yet
@@ -119,42 +117,42 @@ explanations, the long explanation is the topic of the document above..'
           film quality, TV, youtube).
         - implementation type (e.g. 96kHz 24bit PCM, 2 channels muxed)
         - intention tag (Source, Raw, Intermediary and Target)
-
- OutputDesignation::
+        
+ anchor:OutputDesignation[] link:#OutputDesignation[->]OutputDesignation::
         A specification denoting where to connect the output of a pipe.
         It might either be given _absoulutely_, i.e as Pipe-ID,
         or by an _relative_ or _indirect_ specification
-
- OutputMapping::
+        
+ anchor:OutputMapping[] link:#OutputMapping[->]OutputMapping::
         translates one output designation into another one, e.g. when hooking
         up a sequence as virtual clip within another sequence
 
- OutputSlot::
+ anchor:OutputSlot[] link:#OutputSlot[->]OutputSlot::
         opaque descriptor for an output facility, ready to dispose frames
         of data to be output.
 
- OutputManager::
+ anchor:OutputManager[] link:#OutputManager[->]OutputManager::
         manages all external outputs of the application and provides output
-        slots targetting these
+        slots targetting these.
 
- PlayController::
+ anchor:PlayController[] link:#PlayController[->]PlayController::
         coordinating playback, cueing and rewinding of a playback position,
         visible as 'Playhead' cursor in the GUI. When in play state, a
         PlayController requests and directs a render process to deliver the
         media data needed for playback.
 
- RenderTask::
+ anchor:RenderTask[] link:#RenderTask[->]RenderTask::
         basically a PlayController, but collecting output directly, without
         moving a PlayheadCursor (maybe a progress indicator) and not operating
         in a timed fashion, but freewheeling or in background mode
 
- Controller Gui::
+ anchor:ControllerGui[] link:#ControllerGui[->]Controller Gui::
         This can be either a full Software implementation for a Transport
         control (Widgets for Start/Stop/Rev/Ffw etc) or some Gui managing an
         Input Device. They share some feature to attach them to controllable
         gui-entities (Viewers, Timeline Views)
 
- Viewer::
+ anchor:Viewer[] link:#Viewer[->]Viewer::
         the display destination showing video frame and possibly some effect
         overlays (masking etc.). When attached to a timeline, a viewer
         reflects the state of the timeline's associated PlayController, and it
@@ -166,21 +164,21 @@ explanations, the long explanation is the topic of the document above..'
         mere control for sending video to a dedicated monitor (separate X
         display or firewire)
 
- High Level Model::
+ anchor:HighLevelModel[] link:#HighLevelModel[->]High Level Model::
         All the session content to be edited and manipulated by the user
         through the GUI. The high-level-model will be translated by the
         Builder into the Low Level Model for rendering.
 
- Low Level Model::
+ anchor:LowLevelModel[] link:#LowLevelModel[->]Low Level Model::
         The generated Processing Graph, to be ``performed'' within the engine
         to yield rendered output
 
- Builder::
+ anchor:Builder[] link:#Builder[->]Builder::
         A kind of compiler which creates Low Level/Processing Graphs, by
         traversing and evaluating the relevant parts of the high-level-model
         and using the Rules System.
 
- Timeline Segment::
+ anchor:TimelineSegment[] link:#TimelineSegment[->]Timeline Segment::
         A range in the timeline which yields in one Processing graph, commonly
         the range between cut points (which require a reconfiguration of the
         graph).
@@ -188,23 +186,23 @@ explanations, the long explanation is the topic of the document above..'
 // Note by Ichthyo: "Extent" sounds somewhat cool, just it didn't occur to me as a term.
 // We may well agree on it, if "extent" communicates the meaning better. Up to now, I called it "segment"
 
- Assets View::
+ anchor:AssetsView[] link:#AssetsView[->]Assets View::
         The windows showing and managing the available things to work with.
         This are the ingested footage, already composed Clips, available
         Sub-Projects, Effects, Transitions and internal artefacts.
 
- Rules System::
+ anchor:RulesSystem[] link:#RulesSystem[->]Rules System::
         Translating the Timeline to the underlying Processing Graphs involves
         some logic and knowledge about handling/converting data. This may be
         configued with this Rules System. Typically Lumiera will provide sane
         defaults for most purposes but may extended/refined for site specific
-        things.
+        things.  
 
- Processing Graph::
+ anchor:ProcessingGraph[] link:#ProcessingGraph[->]Processing Graph::
         Rendering is expressed as detailed network of Nodes, each defining a
         processing step.
 
- Config System/Preferences::
+ anchor:ConfigSystem_Preferences[] link:#ConfigSystem_Preferences[->]Config System/Preferences::
         TODO: agree on one term here
         Provides defaults for all kinds of application configurations. These
         include machine specific configurations for performance
@@ -213,13 +211,12 @@ explanations, the long explanation is the topic of the document above..'
         data. Many settings will then be stored within the project and the
         Config/Preferences becomes overridden by that.
 
- Input Device::
+ anchor:InputDevice[] link:#InputDevice[->]Input Device::
         some hardware controler, like a extra Keyboard, Midi Mixer, Jog, ..
         TODO: decide if the main keyboard as special (global) state.
 
- Focus::
+ anchor:Focus[] link:#Focus[->]Focus::
         TBD
 
- Cursor::
+ anchor:Cursor[] link:#Cursor[->]Cursor::
         playback- or edit position
-

From 7960ab53643c4dfa8d8d8e73d67b668b640b2de0 Mon Sep 17 00:00:00 2001
From: Ichthyostega 
Date: Wed, 8 Dec 2010 12:31:51 +0100
Subject: [PATCH 08/28] Start a RfC regarding requirements of Website
 Navigation

---
 doc/devel/rfc_pending/WebsiteNavigation.txt | 156 ++++++++++++++++++++
 1 file changed, 156 insertions(+)
 create mode 100644 doc/devel/rfc_pending/WebsiteNavigation.txt

diff --git a/doc/devel/rfc_pending/WebsiteNavigation.txt b/doc/devel/rfc_pending/WebsiteNavigation.txt
new file mode 100644
index 000000000..965897144
--- /dev/null
+++ b/doc/devel/rfc_pending/WebsiteNavigation.txt
@@ -0,0 +1,156 @@
+WebsiteNavigation
+=================
+
+// please don't remove the //word: comments
+
+[grid="all"]
+`------------`-----------------------
+*State*         _Idea_
+*Date*          _Mi 08 Dez 2010 11:32:32 CET_
+*Proposed by*   Ichthyostega 
+-------------------------------------
+
+[abstract]
+********************************************************************************
+The Lumiera website is assumed to accumulate a lot of content. Thus we need
+to care about making that content accessible, to help finding the relevant
+topics and to keep the overall structure intact. This RfC is to collect,
+discuss and agree upon the guidelines and requirements.
+********************************************************************************
+
+Description
+-----------
+//description: add a detailed description:
+
+Issues to care
+~~~~~~~~~~~~~~
+
+Navigation::
+  The page hierarchy becomes at least 5 levels deep, likely even deeper.
+  When reading a page, the current subtree leading down to this page should
+  be right at hand; especially access to the siblings and the parent's siblings
+  is important. For re-accessing content, it is necessary to be able to drill
+  down to an known location (``within the design docs, detailing the application,
+  I need the configuration section'') +
+  -> we need an *auto generated navigation* and an embedded *menu tree widget* in the web pages.
+
+Tagging::
+  There should be an easy way to categorise individual pages *by keyword(s)*
+  and an automatically generated indexing by tags, possibly with an per tag
+  overview page.
+
+Search::
+  The usual *site search*. It should include the contents of the issue tracker.
+  Even today such a scoped search is valuable and even necessary for working
+  with the informations collected within the Lumiera project
+
+Sanity::
+  Each relevant page needs to be reachable. There are some additional pages and
+  especially subdirectories which should not be linked into the website navigation.
+  Moreover, all (internal) links on the pages should be valid. +
+  -> this could be addressed by a **sanity checker script**
+
+Usage situations
+~~~~~~~~~~~~~~~~
+
+(a) working on content
+^^^^^^^^^^^^^^^^^^^^^^
+Working on content should be readily accessible for _everyone_. One time contributions
+are especially encouraged. This leads to the following usage scenario:
+
+A contributor has some informations to share or wants to do some additions or modifications.
+(S)he locates somehow the place where relevant informations are stored, adds some text,
+possibly adds a new page or splits another page in two.
+
+_Note_: no awareness of the issues of navigation can be assumed. The occasional contributor
+won't notice any concern which isn't right at hand.
+
+(b) maintaining a subsystem
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Some person(s) will be responsible for a subsystem or some segment of the informations
+on the website. This responsibility is content centric. It might include frequent rearranging,
+regrouping and reordering of pages to accommodate the increasing scope of informations.
+
+_Note_: while here some awareness of website organisational issues can be assumed,
+any requirement to care for external organisational issues is a burden and distracts
+from the actual work to be done -- thus it is likely to be short circuited or postponed
+``for later''. Note especially, reorganising content in a subsection *must not* incur
+the burden of re-doing the same reorganisation steps mirrored in some central navigation
+configuration or table of contents. (this is a knock out criterion)
+
+(c) maintaining the website
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+The website maintainer is responsible for the overall sanity of the website, without
+being familiar with all details of ongoing work in some part or section of the information.
+Another concern here is the outward perception of the website, which might incur changes
+on the top level navigation or some rewording of overview pages.
+
+_Note_: this kind of work is rather unrewarding. There is the danger of collisions with the
+work of the subsystem maintainer
+
+
+Conclusion: Requirements for any navigation solution
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ * ability to to pick up a nested page structure
+ * ability to cope with any additions and changes in the lower levels automatically, without help by the user
+ * ability to override:
+ 
+   - not including some subdirectories
+   - including links-to-external at arbitrary positions
+
+optional/additional features
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+The following features would be handy, but can be considered optional
+
+ * ability to change the displayed title of a page in the navigation
+ * ability to control the ordering of pages in the navigation
+ * complete manual override of the visible content of a specific subdirectory
+
+
+
+Tasks
+~~~~~
+// List what would need to be done to implement this Proposal in a few words:
+// * item ...
+
+
+Pros
+^^^^
+// add just a fact list/enumeration which make this suitable:
+//  * foo
+//  * bar ...
+
+
+
+Cons
+^^^^
+// fact list of the known/considered bad implications:
+
+
+
+Alternatives
+------------
+//alternatives: explain alternatives and tell why they are not viable:
+
+
+
+Rationale
+---------
+//rationale: Describe why it should be done *this* way:
+
+
+
+//Conclusion
+//----------
+//conclusion: When approbate (this proposal becomes a Final)
+//            write some conclusions about its process:
+
+
+
+
+Comments
+--------
+//comments: append below
+
+
+//endof_comments:

From 8802beb753a7b2191dd9f8cc9f0055dc3e037208 Mon Sep 17 00:00:00 2001
From: Ichthyostega 
Date: Thu, 9 Dec 2010 22:43:32 +0100
Subject: [PATCH 09/28] rereading (and rewrapping) the builder/engine code...

started this a long time ago, then got sidelined....
---
 src/proc/engine/renderengine.cpp         | 10 +++++-----
 src/proc/engine/renderengine.hpp         | 21 ++++++++++++++-------
 src/proc/engine/rendergraph.cpp          | 12 ++++++------
 src/proc/engine/rendergraph.hpp          | 22 ++++++++++++----------
 src/proc/mobject/builder/buildertool.hpp | 22 +++++++++++++++-------
 src/proc/mobject/builderfacade.cpp       | 10 +++++-----
 src/proc/mobject/builderfacade.hpp       | 12 +++++++-----
 7 files changed, 64 insertions(+), 45 deletions(-)

diff --git a/src/proc/engine/renderengine.cpp b/src/proc/engine/renderengine.cpp
index 25eb6257d..73af98a72 100644
--- a/src/proc/engine/renderengine.cpp
+++ b/src/proc/engine/renderengine.cpp
@@ -24,10 +24,10 @@
 #include "proc/engine/renderengine.hpp"
 
 namespace engine {
-
-
+  
+  
   /** */
-
-
-
+  
+  
+  
 } // namespace engine
diff --git a/src/proc/engine/renderengine.hpp b/src/proc/engine/renderengine.hpp
index 1c361c739..b64530ed4 100644
--- a/src/proc/engine/renderengine.hpp
+++ b/src/proc/engine/renderengine.hpp
@@ -32,19 +32,26 @@
 using std::list;
 
 
-namespace engine
-  {
-
-
+namespace engine {
+  
+  
+  /**
+   * @todo this is planned to become the frontend
+   * to the render node network, which can be considered
+   * at the lower end of the middle layer; the actual 
+   * render operations are mostly implemented by the backend
+   * ////////TODO WIP as of 12/2010
+   */
   class RenderEngine : public RenderGraph
     {
     public:
        ///// TODO: find out about the public operations
-       // note: the play controller lives in the backend
-
+       // note: the play controller lives in the proc-layer,
+       //       but is a subsystem separate of the sesison.
+      
     private:
       list renderSegments;
-
+      
     };
 
 } // namespace engine
diff --git a/src/proc/engine/rendergraph.cpp b/src/proc/engine/rendergraph.cpp
index c2ab6e332..0900dde06 100644
--- a/src/proc/engine/rendergraph.cpp
+++ b/src/proc/engine/rendergraph.cpp
@@ -26,17 +26,17 @@
 #include "proc/state.hpp"
 
 namespace lumiera {
-
+  
   /** storage for the unique node-ID counter */
   ulong NodeID::currID (0);
 }
 
 
 namespace engine {
-
+  
   /** */
-
-
-
-
+  
+  
+  
+  
 } // namespace engine
diff --git a/src/proc/engine/rendergraph.hpp b/src/proc/engine/rendergraph.hpp
index 6fdb28217..c994737f5 100644
--- a/src/proc/engine/rendergraph.hpp
+++ b/src/proc/engine/rendergraph.hpp
@@ -29,25 +29,27 @@
 
 
 
-namespace engine
-  {
-
+namespace engine {
+  
   class ExitNode;
-
+  
+  /**
+   * @todo likely to be reworked into the engine backbone  /////////////TODO WIP as of 12/2010
+   */
   class RenderGraph
     {
     protected:
       ExitNode * output;
-
+      
       /** begin of the timerange covered by this RenderGraph */
       lumiera::Time start;
-
+      
       /**end (exclusive) of the timerange  */
       lumiera::Time end;
-
+      
     };
-
-
-
+  
+  
+  
 } // namespace engine
 #endif
diff --git a/src/proc/mobject/builder/buildertool.hpp b/src/proc/mobject/builder/buildertool.hpp
index 93086ac4c..2d919a70a 100644
--- a/src/proc/mobject/builder/buildertool.hpp
+++ b/src/proc/mobject/builder/buildertool.hpp
@@ -62,7 +62,7 @@
 
 
 namespace mobject {
-
+  
   class Buildable;
   
   namespace builder {
@@ -105,7 +105,7 @@ namespace mobject {
      *       as we simply store a pointer within the BuilderTool instance.
      */
     class BuilderTool
-      : public lumiera::visitor::Tool 
+      : public lumiera::visitor::Tool
       {
         lumiera::WrapperPtr currentWrapper_;
         
@@ -172,7 +172,9 @@ namespace mobject {
       
     using lumiera::typelist::Types;  // convenience for the users of "Applicable"
   
-  } // namespace mobject::builder
+  }// namespace mobject::builder
+  
+  
   
   
   
@@ -185,8 +187,15 @@ namespace mobject {
   
   
   
-  namespace builder { // to be found by ADL
+  namespace builder {
     
+    /** to be picked up by ADL: redirect tool invocation for double dispatch.
+     *  The purpose of this function is to apply a visitor, while the actual target
+     *  is managed by a generic wrapper (smart-ptr). This template function serves
+     *  to generate forwarding functions, which pass on the \c apply() call to the
+     *  actual embedded target, while passing on the fully wrapped object for later
+     *  referral and usage too.
+     */
     template
     inline Buildable::ReturnType
     apply (BuilderTool& tool, WRA& wrappedTargetObj)
@@ -195,8 +204,7 @@ namespace mobject {
       wrappedTargetObj->apply (tool);   // dispatch to suitable treat() function
       tool.forgetWrapper();
     }
-    
-  } // namespace mobject::builder
   
-} // namespace mobject
+  
+}} // namespace mobject::builder
 #endif
diff --git a/src/proc/mobject/builderfacade.cpp b/src/proc/mobject/builderfacade.cpp
index 175aa2b24..99eb87ed9 100644
--- a/src/proc/mobject/builderfacade.cpp
+++ b/src/proc/mobject/builderfacade.cpp
@@ -30,8 +30,8 @@ namespace mobject {
     using ::NOBUG_FLAG(memory);
     NOBUG_CPP_DEFINE_FLAG_PARENT(buildermem, memory);
   }
-
-
+  
+  
   /**
    * Main Operation of the Builder: 
    * create a render engine for a given part of the timeline
@@ -41,7 +41,7 @@ namespace mobject {
   {
     //////////////////////TODO
   }
-
-
-
+  
+  
+  
 } // namespace mobject
diff --git a/src/proc/mobject/builderfacade.hpp b/src/proc/mobject/builderfacade.hpp
index 98197ec13..86520d483 100644
--- a/src/proc/mobject/builderfacade.hpp
+++ b/src/proc/mobject/builderfacade.hpp
@@ -30,8 +30,8 @@
 
 
 namespace mobject {
-
-
+  
+  
   /**
    * Provides unified access to the builder functionality.
    * While individual components of the builder subsystem may be called
@@ -44,12 +44,14 @@ namespace mobject {
       /**
        * Main Operation of the Builder:
        * create a render engine for a given part of the timeline
+       * @deprecated thats a placeholder! the real invocation is now
+       *             in the course of being worked out ////////////TODO 12/2010
        */
       engine::RenderEngine & buildEngine () ;
       // TODO: allocation, GC??????
     };
-
-
-
+  
+  
+  
 } // namespace mobject
 #endif

From 28279613858fbdd4287567e79765978980b11804 Mon Sep 17 00:00:00 2001
From: Ichthyostega 
Date: Fri, 10 Dec 2010 01:27:17 +0100
Subject: [PATCH 10/28] WIP: test driven brainstorming about model port
 registry

---
 .../model-port-registry.cpp}                  |   8 +-
 .../mobject/builder/model-port-registry.hpp   |  72 ++++++
 .../builder/model-port-registry-test.cpp      | 212 ++++++++++++++++++
 wiki/renderengine.html                        |  14 +-
 4 files changed, 297 insertions(+), 9 deletions(-)
 rename src/proc/mobject/{model-port.cpp => builder/model-port-registry.cpp} (89%)
 create mode 100644 src/proc/mobject/builder/model-port-registry.hpp
 create mode 100644 tests/components/proc/mobject/builder/model-port-registry-test.cpp

diff --git a/src/proc/mobject/model-port.cpp b/src/proc/mobject/builder/model-port-registry.cpp
similarity index 89%
rename from src/proc/mobject/model-port.cpp
rename to src/proc/mobject/builder/model-port-registry.cpp
index 332fe9d31..87a26492e 100644
--- a/src/proc/mobject/model-port.cpp
+++ b/src/proc/mobject/builder/model-port-registry.cpp
@@ -1,5 +1,5 @@
 /*
-  ModelPort  -  point to pull output data from the model
+  ModelPortRegistry  -  creating and organising and accessing model ports
  
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler 
@@ -21,7 +21,7 @@
 * *****************************************************/
 
 
-/** @file model-port.cpp 
+/** @file model-port-registry.cpp 
  ** Implementation details of model port descriptors and references.
  ** Especially, the handling of the ModelPortTable datastructure is
  ** kept an opaque implementation detail and confined entirely within
@@ -39,6 +39,7 @@
 #include "lib/error.hpp"
 //#include "lib/symbol.hpp"//
 #include "proc/mobject/model-port.hpp"
+#include "proc/mobject/builder/model-port-registry.hpp"
 
 //#include 
 //#include 
@@ -52,6 +53,7 @@
 //using lumiera::Symbol;
 
 namespace mobject {
+namespace builder {
   
   
   /**
@@ -66,4 +68,4 @@ namespace mobject {
   
   
   
-} // namespace mobject
+}} // namespace mobject
diff --git a/src/proc/mobject/builder/model-port-registry.hpp b/src/proc/mobject/builder/model-port-registry.hpp
new file mode 100644
index 000000000..2ef87f126
--- /dev/null
+++ b/src/proc/mobject/builder/model-port-registry.hpp
@@ -0,0 +1,72 @@
+/*
+    MODEL-PORT-REGISTRY.hpp  -  creating and organising and accessing model ports
+ 
+  Copyright (C)         Lumiera.org
+    2010,               Hermann Vosseler 
+ 
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License as
+  published by the Free Software Foundation; either version 2 of the
+  License, or (at your option) any later version.
+ 
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+ 
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ 
+*/
+
+/** @file model-port-registry.hpp
+ ** Mutation and management facility for model ports within the builder.
+ ** Model ports denote the points where output might possibly be produced.
+ ** While client code accesses model ports only as immutable descriptors handled
+ ** through an (opaque) reference, the builder is in charge of detecting and organising
+ ** any (new) model ports arising as the result of the build process. Changes to the set
+ ** of current model ports are to be activated with an atomic transactional switch.
+ ** 
+ ** builder::ModelPortRegistry thus acts as management interface and factory for model ports.
+ ** A given instance of this registry can be promoted to be "the" model port registry reflecting
+ ** the current active model ports. Within the Lumiera application, the builder subsystem cares
+ ** for setting up such a registry, while all other parts of the system just access the current
+ ** model ports through the mobject::ModelPort frontend.
+ ** 
+ ** TODO fill in more details?
+ ** 
+ ** @see ModelPort
+ ** @see OutputDesignation
+ ** @see ModelPortRegistry_test
+ */
+
+
+#ifndef PROC_MOBJECT_BUILDER_MODEL_PORT_REGISTRY_H
+#define PROC_MOBJECT_BUILDER_MODEL_PORT_REGISTRY_H
+
+#include "proc/asset/pipe.hpp"
+//#include "lib/opaque-holder.hpp"
+//#include "lib/meta/typelist-util.hpp"
+
+//extern "C" {
+//#include "lib/luid.h"
+//}
+
+namespace mobject {
+namespace builder {
+  
+  /**
+   * TODO type comment
+   */
+  class ModelPortRegistry
+    : boost::noncopyable
+    {
+      
+    public:
+    };
+  
+  
+  
+}} // namespace mobject::builder
+#endif
diff --git a/tests/components/proc/mobject/builder/model-port-registry-test.cpp b/tests/components/proc/mobject/builder/model-port-registry-test.cpp
new file mode 100644
index 000000000..47f425476
--- /dev/null
+++ b/tests/components/proc/mobject/builder/model-port-registry-test.cpp
@@ -0,0 +1,212 @@
+/*
+  ModelPortRegistry(Test)  -  verify handling of model ports
+ 
+  Copyright (C)         Lumiera.org
+    2010,               Hermann Vosseler 
+ 
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License as
+  published by the Free Software Foundation; either version 2 of the
+  License, or (at your option) any later version.
+ 
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+ 
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ 
+* *****************************************************/
+
+
+#include "lib/test/run.hpp"
+#include "lib/test/test-helper.hpp"
+#include "proc/mobject/builder/model-port-registry.hpp"
+#include "proc/asset/pipe.hpp"
+#include "lib/util.hpp"
+
+//#include 
+//#include 
+#include 
+
+//using boost::format;
+//using boost::scoped_ptr;
+using util::isSameObject;
+using util::isnil;
+using std::string;
+
+
+namespace mobject {
+namespace builder {
+namespace test  {
+  
+  using asset::Pipe;
+  using asset::PPipe;
+  
+  //typedef asset::ID PID;
+  namespace { // test environment
+    
+    struct TestContext
+      {
+        ModelPortRegistry registry_;
+        ModelPortRegistry& previous_;
+        
+        /** setup */
+        TestContext()
+          : registry_()
+          , previous_(ModelPortRegistry::setActiveInstance (registry_))
+          { }
+        
+        /** tear-down */
+       ~TestContext()
+          {
+            ModelPortRegistry::setActiveInstance (previous_);
+          }
+      };
+    
+  }
+  
+  
+  /*********************************************************************************
+   * @test create a standalone model port registry to verify the behaviour of
+   *       model ports, accessed through reference handles. This test provides
+   *       an example setup detached from the real usage situation within the builder.
+   *       The ModelPortRegistry management interface is used to create and track a
+   *       set of model ports, to be made visible by an atomic, transactional switch.
+   *       The access for client code through the ModelPort frontend is then verified.
+   *       
+   * @see  mobject::ModelPort
+   * @see  mobject::builder::ModelPortRegistry
+   */
+  class ModelPortRegistry_test : public Test
+    {
+      
+      virtual void
+      run (Arg) 
+        {
+          TestContext ctx;
+          
+          fabricating_ModelPorts (ctx);
+          accessing_ModelPorts();
+          transactionalSwitch (ctx);
+        }
+      
+      
+      void
+      fabricating_ModelPorts (ModelPortRegistry& registry)
+        {
+          ModelPortDescriptor& p1 = registry.definePort (pipeA, someTimeline);
+          ModelPortDescriptor& p2 = registry.definePort (pipeB, someTimeline);
+          
+          CHECK (p1);
+          CHECK (p2);
+          
+          VERIFY_ERROR (DUPLICATE_MODEL_PORT, registry.definePort(pipeB, someTimeline) );
+          CHECK (p2);
+          
+          CHECK (p1.getID() == pipeA);
+          CHECK (p2.getID() == pipeB);
+          CHECK (p1.getPipe() == pipeA);
+          CHECK (p2.getPipe() == pipeB);
+          CHECK (p1.getTimeline() == someTimeline);
+          CHECK (p2.getTimeline() == someTimeline);
+          
+          registry.commit();
+        }
+      
+      
+      void
+      accessing_ModelPorts ()
+        {
+          ModelPort mp1(pipeA);
+          ModelPort mp2(pipeB);
+          
+          VERIFY_ERROR (INVALID_MODEL_PORT, ModelPort(pipeWC));
+          
+          ModelPort mp1x(pipeA);
+          ModelPort mpNull;
+          
+          CHECK (mp1);
+          CHECK (mp2);
+          CHECK (mp1x);
+          CHECK (!mpNull);
+          
+          CHECK ( ModelPort::exists (pipeA));
+          CHECK ( ModelPort::exists (pipeB));
+          CHECK (!ModelPort::exists (pipeWC));
+          
+          CHECK (mp1 == mp1x);
+          CHECK (!isSameObject (mp1, mp1x));
+          CHECK (mp1 != mp2);
+          CHECK (mp2 != mp1);
+          CHECK (mp1 != mpNull);
+          CHECK (mp2 != mpNull);
+          
+          CHECK (mp1.pipe() == pipeA);
+          CHECK (mp2.pipe() == pipeB);
+          CHECK (mp1x.pipe() == pipeA);
+          VERIFY_ERROR (UNCONNECTED_MODEL_PORT, mpNull.pipe());
+          
+          CHECK (mp1.streamType() == pipeA.getStreamType());
+        }
+      
+      
+      void
+      transactionalSwitch (ModelPortRegistry& registry)
+        {
+          CHECK ( ModelPort::exists (pipeB));
+          CHECK (!ModelPort::exists (pipeWC));
+          
+          CHECK (ModelPort::exists (pipeA));
+          CHECK (registry.contains (pipeA));
+          registry.remove (pipeA);
+          CHECK (ModelPort::exists (pipeA));
+          CHECK (!registry.contains (pipeA));
+    
+          ModelPortDescriptor& p1 = registry.definePort (pipeA, anotherTimeline);
+          CHECK (registry.contains (pipeA));
+          CHECK (p1.getTimeline() == anotherTimeline);
+          CHECK (ModelPort(pipeA).timeline() != anotherTimeline);
+          
+          registry.remove (pipeB);
+          registry.definePort (pipeWC,anotherTimeline);
+          CHECK (!registry.contains (pipeB));
+          CHECK ( registry.contains (pipeWC));
+          CHECK ( ModelPort::exists (pipeB));
+          CHECK (!ModelPort::exists (pipeWC));
+
+          ModelPort portA(pipeA);
+          ModelPort portB(pipeB);
+          VERIFY_ERROR (INVALID_MODEL_PORT, ModelPort(pipeWC));
+          CHECK (portA);
+          CHECK (portB);
+          CHECK (portA.pipe() == pipeA);
+          CHECK (portB.pipe() == pipeB);
+          CHECK (portA.timeline() != anotherTimeline);
+          
+          registry.commit();
+          CHECK ( ModelPort::exists (pipeA));
+          CHECK (!ModelPort::exists (pipeB));
+          CHECK ( ModelPort::exists (pipeWC));
+          CHECK ( portA);
+          CHECK (!portB);
+          CHECK (portA.timeline() == anotherTimeline);
+          CHECK (portA.pipe() == pipeA);
+          VERIFY_ERROR (UNCONNECTED_MODEL_PORT, portB.pipe());
+          
+          ModelPort pwc(pipeWC);
+          CHECK (pwc);
+          CHECK (pwc.pipe() == pipeWC);
+          CHECK (pwc.timeline() == anotherTimeline);
+        }
+    };
+  
+  
+  /** Register this test class... */
+  LAUNCHER (ModelPortRegistry_test, "unit session builder");
+  
+  
+  
+}}} // namespace mobject::builder::test
diff --git a/wiki/renderengine.html b/wiki/renderengine.html
index 9a0da012c..09e2a5006 100644
--- a/wiki/renderengine.html
+++ b/wiki/renderengine.html
@@ -1786,20 +1786,20 @@ Some further details
 * a special case of this factory use is the [[Singleton]] factory, which is used a lot within the Proy-Layer code
-
+
a specially configured view -- joining together high-level and low-level model
 * all MObjects have their position, length and configuration set up ready for rendering.
 * any nested sequences (or other kinds of indirections) have been resolved.
 * every MObject is attached by an ExplicitPlacement, which declares a fixed position (Time, [[Pipe|OutputDesignation]])
 * these ~ExplicitPlacements are contained immediately within the Fixture, ordered by time
-* besides, there is a collection of all effective, possibly externally visible [[model ports|ModelPort]]
+* besides, there is a collection of all effective, possibly externally visible [[model ports|ModelPortRegistry]]
 
 As the builder and thus render engine //only consults the fixture,// while all editing operations finally propagate to the fixture as well, we get an isolation layer between the high level part of the Proc layer (editing, object manipulation) and the render engine. [[Creating the Fixture|BuildFixture]] is an important sideeffect of running the [[Builder]] when createing the [[render engine network|LowLevelModel]].
 
 !{{red{WIP}}} Structure of the fixture
 [<img[Structure of the Fixture|draw/Fixture1.png]]
 
-The fixture is like a grid, where one dimension is given by the [[model ports|ModelPortTable]], and the other dimension extends in time. Within the time dimension there is a grouping into [[segments|Segmentation]] of constant structure.
+The fixture is like a grid, where one dimension is given by the [[model ports|ModelPortRegistry]], and the other dimension extends in time. Within the time dimension there is a grouping into [[segments|Segmentation]] of constant structure.
 
 ;Model Ports
 :The model ports share a single uniform and global name space: actually they're keyed by ~Pipe-ID
@@ -2819,8 +2819,8 @@ These are used as token for dealing with other objects and have no identity of t
-
-
Any point where output possibly might be produced. Model port entities are located within the [[Fixture]] &mdash; model port as a concept spans the high-level and low-level view. A model port can be associated both to a pipe in the HighLevelModel but at the same time denote a set of corresponding [[exit nodes|ExitNode]] within the [[segments|Segmentation]] of the render nodes network.
+

+
Any point where output possibly might be produced. Model port entities are located within the [[Fixture]] &mdash; model port as a concept spans the high-level and low-level view. A model port can be associated both to a pipe in the HighLevelModel but at the same time denotes a set of corresponding [[exit nodes|ExitNode]] within the [[segments|Segmentation]] of the render nodes network.
 
 A model port is rather derived than configured; it emerges when a pipe [[claims|WiringClaim]] an output destination and some other entity actually uses this designation as a target, either directly or indirectly. This match of provision and usage is detected during the build process and produces an entry in the fixture's model port table. These model ports in the fixture are keyed by ~Pipe-ID, thus each model port has an associated StreamType.
 
@@ -2833,7 +2833,7 @@ Model ports are represented by small non-copyable descriptor objects with distin
 
 

 

-

+

 
Model ports are conceptual entities, denoting the points where output might possibly be produced &rarr; see [[definition|ModelPort]].
 But there is an actual representation, a collection of small descriptor objects managed by the Fixture and organised within the model port table datastructure. Because model ports are discovered during the build process, we need the ability to (re)build this table dynamically, finally swapping in the modified configuration with a transactional switch. Only the builder is allowed to perform such mutations, while for client code model ports are immutable.
 
@@ -2852,6 +2852,8 @@ Model ports are added once and never changed. The corresponding timeline and pip
 The transactional switch creates a clear partitioning in the lifespan of the model port table. //Before// that point, entries are just added, but not accessed in any way. //After// that point, no further mutation occurs, but lookup is frequent and happens in a variety of different configurations and transient orderings.
 
 This observation leads to the idea of using //model port references// to provide all kinds of access, searching and reordering. These encapsulate the actual access by silently assuming reference to "the" global current model port configuration. Thus, the actual model port descriptors could be bulk allocated in a similar manner as the processing nodes and wiring descriptors. Access to stale model ports could be detected by the port references, allowing also for a {{{bool}}} checkable "has no port" information.
+
+A model port registry, maintained by the builder, is responsible for storing the discovered model ports within a model port table, which is then swapped in after completing the build process. The {{{builder::ModelPortRegistry}}} acts as management interface, while client code accesses just the {{{ModelPort}}} frontend. A link to the actual registry instance is hooked into that frontend when bringing up the builder subsystem.
 

 

 


From 16aed07977bd96b07731e6b741f5817a192ac6d3 Mon Sep 17 00:00:00 2001
From: Stefan Kangas 
Date: Fri, 10 Dec 2010 04:13:23 +0100
Subject: [PATCH 11/28] Use CHECK instead of ECHO for several tests of time.c

---
 tests/15time.tests        |  5 -----
 tests/library/test-time.c | 12 ++++++------
 2 files changed, 6 insertions(+), 11 deletions(-)

diff --git a/tests/15time.tests b/tests/15time.tests
index 8ee10499b..4722d9ea1 100644
--- a/tests/15time.tests
+++ b/tests/15time.tests
@@ -1,10 +1,5 @@
 TESTING "Time conversion" ./test-time
 
 TEST "basic functionality" basic <
Date: Fri, 10 Dec 2010 12:47:21 +0100
Subject: [PATCH 12/28] Add more unit tests for the time conversion library.

---
 tests/15time.tests        |  1 +
 tests/library/test-time.c | 27 +++++++++++++++++----------
 2 files changed, 18 insertions(+), 10 deletions(-)

diff --git a/tests/15time.tests b/tests/15time.tests
index 4722d9ea1..0cb57ddcc 100644
--- a/tests/15time.tests
+++ b/tests/15time.tests
@@ -1,5 +1,6 @@
 TESTING "Time conversion" ./test-time
 
 TEST "basic functionality" basic <
Date: Fri, 10 Dec 2010 15:29:43 +0100
Subject: [PATCH 13/28] augment asset ID: automatic conversion, typed NIL ID
 constants

---
 src/proc/asset.hpp      | 102 ++++++++++++++++++++++------------------
 src/proc/asset/pipe.hpp |  14 ++++--
 2 files changed, 66 insertions(+), 50 deletions(-)

diff --git a/src/proc/asset.hpp b/src/proc/asset.hpp
index def4a02ee..80e5f2aa7 100644
--- a/src/proc/asset.hpp
+++ b/src/proc/asset.hpp
@@ -108,6 +108,8 @@ namespace asset {
       ID (HashVal id)        : hash(id)         {}
       ID (const KIND& asset) : hash(asset.getID()) {}
       operator HashVal() const { return hash; }
+      
+      static ID INVALID;
     };
     
   class DB;
@@ -303,53 +305,59 @@ namespace asset {
     
     
     
-    /* ====== ordering of Assets and Asset-Pointers ====== */
-    
-    /** ordering of Assets is based on the ordering
-     *  of Ident tuples, which are supposed to be unique.
-     *  By using our customised lumiera::P as smart ptr,
-     *  comparison on P ptrs will be automatically
-     *  forwarded to the Asset comparison operators.
-     *  @note version info is irrelevant */
-    inline int 
-    Asset::Ident::compare (Asset::Ident const& oi)  const
-    { 
-      int res;
-      if (0 != (res=category.compare (oi.category)))  return res;
-      if (0 != (res=org.compare (oi.org)))            return res;
-      return name.compare (oi.name);
-    }
-    
-    
-    /** promote subtype-ptr to PAsset, e.g. for comparing */
-    template
-    inline const PcAsset
-    pAsset (shared_ptr const& subPtr)
-    {
-      return static_pointer_cast (subPtr);
-    }
-    
-    
-    /** type trait for detecting a shared-ptr-to-asset */
-    template 
-    struct is_pAsset : boost::false_type {};
-    
-    template 
-    struct is_pAsset >
-      : boost::is_base_of      {}; 
-    
-    
-    /** convenient for debugging */
-    inline string str (PcAsset const& a) 
-    {
-      if (a)
-        return string (*a.get());
-      else
-        return "Asset(NULL)";
-    }
-    
-    
-
+  /* ====== ordering of Assets and Asset-Pointers ====== */
+  
+  /** ordering of Assets is based on the ordering
+   *  of Ident tuples, which are supposed to be unique.
+   *  By using our customised lumiera::P as smart ptr,
+   *  comparison on P ptrs will be automatically
+   *  forwarded to the Asset comparison operators.
+   *  @note version info is irrelevant */
+  inline int 
+  Asset::Ident::compare (Asset::Ident const& oi)  const
+  { 
+    int res;
+    if (0 != (res=category.compare (oi.category)))  return res;
+    if (0 != (res=org.compare (oi.org)))            return res;
+    return name.compare (oi.name);
+  }
+  
+  
+  /** promote subtype-ptr to PAsset, e.g. for comparing */
+  template
+  inline const PcAsset
+  pAsset (shared_ptr const& subPtr)
+  {
+    return static_pointer_cast (subPtr);
+  }
+  
+  
+  /** type trait for detecting a shared-ptr-to-asset */
+  template 
+  struct is_pAsset : boost::false_type {};
+  
+  template 
+  struct is_pAsset >
+    : boost::is_base_of      {};
+  
+  
+  /** marker constant denoting a NIL asset */
+  template
+  ID ID::INVALID = ID(0);
+  
+  
+  /** convenient for debugging */
+  inline string str (PcAsset const& a) 
+  {
+    if (a)
+      return string (*a.get());
+    else
+      return "Asset(NULL)";
+  }
+  
+  
+  
+  
 } // namespace asset
 
 
diff --git a/src/proc/asset/pipe.hpp b/src/proc/asset/pipe.hpp
index 922dec444..35c64664d 100644
--- a/src/proc/asset/pipe.hpp
+++ b/src/proc/asset/pipe.hpp
@@ -45,7 +45,13 @@ namespace asset {
     {
     public:
       ID (HashVal id);
-      ID (const Pipe&);
+      ID (Pipe const&);
+      ID (PPipe const&);
+      
+      /** allows a Pipe-ID to stand in for a full Pipe Asset
+       *  @throw error::Invalid when there is no corresponding Pipe
+       */
+      operator PPipe()  const;
     };
   
   
@@ -95,8 +101,10 @@ namespace asset {
     
    // catch up with postponed definition of ID ctors...
   //
-  inline ID::ID(HashVal id)       : ID (id)           {};
-  inline ID::ID(Pipe const& pipe) : ID (pipe.getID()) {};
+  inline ID::ID(HashVal id)        : ID (id)            {};
+  inline ID::ID(Pipe const& pipe)  : ID (pipe.getID())  {};
+  inline ID::ID(PPipe const& pipe) : ID (pipe->getID()) {};
+  inline ID::operator PPipe() const { return Pipe::lookup(*this); }
   
   
   

From 7043db90eeffaf7b4bc602ca1c97d58996d08219 Mon Sep 17 00:00:00 2001
From: Ichthyostega 
Date: Fri, 10 Dec 2010 17:39:39 +0100
Subject: [PATCH 14/28] introduce an explicit StreamType::ID

---
 src/lib/query.hpp                             |  4 +--
 src/lib/streamtype.hpp                        |  9 ++++---
 src/proc/asset/entry-id.hpp                   |  2 +-
 src/proc/asset/pipe.cpp                       |  2 +-
 src/proc/asset/pipe.hpp                       | 25 +++++++++++++++----
 src/proc/asset/struct.cpp                     |  2 +-
 src/proc/control/stypemanager.cpp             |  8 ++++++
 src/proc/control/stypemanager.hpp             |  2 ++
 tests/components/proc/asset/basicpipetest.cpp | 12 ++++-----
 .../proc/mobject/output-mapping-test.cpp      |  2 +-
 .../mobject/session/defsmanagerimpltest.cpp   |  7 ++++--
 .../proc/mobject/session/defsmanagertest.cpp  |  6 +++--
 12 files changed, 57 insertions(+), 24 deletions(-)

diff --git a/src/lib/query.hpp b/src/lib/query.hpp
index 283292b24..2e3186cc6 100644
--- a/src/lib/query.hpp
+++ b/src/lib/query.hpp
@@ -28,7 +28,7 @@
 #include 
 #include 
 
-#include 
+#include                       /////////////////////////////////////////TICKET #166  Oh RLY ... need to do away with this 
 
 #include "lib/symbol.hpp"
 
@@ -64,7 +64,7 @@ namespace lumiera {
     {
     public:
       explicit Query (string const& predicate="") : string(predicate) {}
-      explicit Query (format& pattern)            : string(str(pattern)) {}
+//    explicit Query (format& pattern)            : string(str(pattern)) {} //////////////TICKET #166  outch... that needs to disappear
       
       const string asKey()  const
         {
diff --git a/src/lib/streamtype.hpp b/src/lib/streamtype.hpp
index 6dc5747fc..cf45ad59c 100644
--- a/src/lib/streamtype.hpp
+++ b/src/lib/streamtype.hpp
@@ -37,6 +37,7 @@
 
 #include "lib/symbol.hpp"
 #include "lib/query.hpp"
+#include "proc/asset/entry-id.hpp"
 
 #include 
 
@@ -47,7 +48,7 @@ namespace lumiera {
   
   
   /**
-   * 
+   * TODO write type comment
    */
   struct StreamType : boost::noncopyable
     {
@@ -72,6 +73,8 @@ namespace lumiera {
       class ImplFacade;
       class ImplConstraint;
       
+      typedef asset::EntryID ID;
+      
       
       Prototype const& prototype;
       ImplFacade * implType;       /////////////TODO: really by ptr???
@@ -149,9 +152,9 @@ namespace lumiera {
        *  and use it to create a new framebuffer */
       virtual DataBuffer* createFrame ()  const =0;
       
-      /** similarily create a impl type which complies to this constraint
+      /** Similarly create a impl type which complies to this constraint
        *  as well as to the additional constraints (e.g. frame size).
-       *  Create a new framebuffer of the resutling type */
+       *  Create a new frame buffer of the resulting type */
       virtual DataBuffer* createFrame (ImplConstraint const& furtherConstraints)  const =0;
       
       //TODO: do we need functions to represent and describe this constraint?
diff --git a/src/proc/asset/entry-id.hpp b/src/proc/asset/entry-id.hpp
index 3f736892e..b16739a02 100644
--- a/src/proc/asset/entry-id.hpp
+++ b/src/proc/asset/entry-id.hpp
@@ -241,7 +241,7 @@ namespace asset {
         }
       
       friend ostream& operator<<   (ostream& os, EntryID const& id) { return os << string(id); }
-      friend bool operator<  (EntryID const& i1, EntryID const& i2) { return i1.getSym()  <  i2.getSym(); }
+      friend bool operator<  (EntryID const& i1, EntryID const& i2) { return i1.getSym()  < i2.getSym(); }
     };
     
   
diff --git a/src/proc/asset/pipe.cpp b/src/proc/asset/pipe.cpp
index 2188a8138..8e823313a 100644
--- a/src/proc/asset/pipe.cpp
+++ b/src/proc/asset/pipe.cpp
@@ -38,7 +38,7 @@ namespace asset {
    *  default wiring.
    */
   Pipe::Pipe ( const Asset::Ident& idi
-             , string const& streamID
+             , string const& streamID     ////////////////////////////////////////TICKET #648
              , PProcPatt& wiring
              , string shortName
              , string longName
diff --git a/src/proc/asset/pipe.hpp b/src/proc/asset/pipe.hpp
index 35c64664d..aed616264 100644
--- a/src/proc/asset/pipe.hpp
+++ b/src/proc/asset/pipe.hpp
@@ -26,6 +26,7 @@
 
 #include "proc/asset/struct.hpp"
 #include "proc/asset/procpatt.hpp"
+#include "lib/streamtype.hpp"
 
 #include 
 
@@ -34,6 +35,7 @@
 namespace asset {
   
   using lumiera::P;
+  using lumiera::StreamType;
   using std::string;
   
   class Pipe;
@@ -49,9 +51,12 @@ namespace asset {
       ID (PPipe const&);
       
       /** allows a Pipe-ID to stand in for a full Pipe Asset
-       *  @throw error::Invalid when there is no corresponding Pipe
-       */
+       *  @throw error::Invalid when there is no corresponding Pipe */
       operator PPipe()  const;
+      
+      /** allows to fetch the StreamType directly just from a Pipe-ID
+       *  @throw error::Invalid when there is no corresponding Pipe */
+      StreamType::ID streamType()  const;
     };
   
   
@@ -65,7 +70,7 @@ namespace asset {
     : public Struct
     {
       PProcPatt wiringTemplate_;
-      const string streamID_;                   ///< @todo just a placeholder for now 10/10
+      StreamType::ID streamID_;              ////////////////////////////////////////TICKET #648
       
     public:
       string shortDesc;
@@ -84,7 +89,7 @@ namespace asset {
       
     public:
       string const& getPipeID()       const { return ident.name;      }
-      string const& getStreamID()     const { return streamID_;       }
+      StreamType::ID getStreamID()    const { return streamID_;       }   ////////////////////////////////////////TICKET #648
       PProcPatt const& getProcPatt()  const { return wiringTemplate_; }
       
       
@@ -104,8 +109,18 @@ namespace asset {
   inline ID::ID(HashVal id)        : ID (id)            {};
   inline ID::ID(Pipe const& pipe)  : ID (pipe.getID())  {};
   inline ID::ID(PPipe const& pipe) : ID (pipe->getID()) {};
-  inline ID::operator PPipe() const { return Pipe::lookup(*this); }
   
+  inline
+  ID::operator PPipe() const
+    {
+      return Pipe::lookup(*this);
+    }
+  
+  inline StreamType::ID
+  ID::streamType() const
+    {
+      return Pipe::lookup(*this)->getStreamID();
+    }
   
   
   
diff --git a/src/proc/asset/struct.cpp b/src/proc/asset/struct.cpp
index 9145c2ad8..70f893149 100644
--- a/src/proc/asset/struct.cpp
+++ b/src/proc/asset/struct.cpp
@@ -148,7 +148,7 @@ namespace asset {
     normaliseID (pipeID);
     normaliseID (streamID);
     static format descriptor("pipe(%s), stream(%s).");
-    Pipe* pP = impl_->fabricate (Query (descriptor % pipeID % streamID));
+    Pipe* pP = impl_->fabricate (Query (str(descriptor % pipeID % streamID)));
     return AssetManager::instance().wrap (*pP);
   }
   
diff --git a/src/proc/control/stypemanager.cpp b/src/proc/control/stypemanager.cpp
index 10131f130..4ba2fda19 100644
--- a/src/proc/control/stypemanager.cpp
+++ b/src/proc/control/stypemanager.cpp
@@ -79,6 +79,14 @@ namespace control {
   }
   
   
+  /** */
+  StreamType const&
+  STypeManager::getType (StreamType::ID stID) 
+  {
+    UNIMPLEMENTED ("get type just by symbolic ID (query defaults manager)");
+  }
+  
+  
   StreamType const& 
   STypeManager::getType (StreamType::Prototype const& protoType)
   {
diff --git a/src/proc/control/stypemanager.hpp b/src/proc/control/stypemanager.hpp
index 70003eef4..cd6a311df 100644
--- a/src/proc/control/stypemanager.hpp
+++ b/src/proc/control/stypemanager.hpp
@@ -53,6 +53,8 @@ namespace control {
        *  just a symbolic ID. Effectively this queries a default */
       StreamType const& getType (Symbol sTypeID) ;
       
+      StreamType const& getType (StreamType::ID stID) ;
+      
       /** build or retrieve a complete StreamType implementing the given Prototype */
       StreamType const& getType (StreamType::Prototype const& protoType) ;
       
diff --git a/tests/components/proc/asset/basicpipetest.cpp b/tests/components/proc/asset/basicpipetest.cpp
index 70f644ed1..e3491cba4 100644
--- a/tests/components/proc/asset/basicpipetest.cpp
+++ b/tests/components/proc/asset/basicpipetest.cpp
@@ -42,13 +42,13 @@ using std::string;
 using std::cout;
 
 
-namespace asset
-  {
-  namespace test
-    {
+namespace asset {
+namespace test  {
+  
     using mobject::Session;
     using lumiera::Query;
     using lumiera::query::normaliseID;
+    using lumiera::StreamType;
     
     
     
@@ -88,7 +88,7 @@ namespace asset
             ASSERT (thePipe);
             ASSERT (thePipe->getProcPatt());
             ASSERT (thePipe->getPipeID() == pID_sane);
-            ASSERT (thePipe->getStreamID() == sID);
+            ASSERT (thePipe->getStreamID() == StreamType::ID(sID));
             ASSERT (thePipe->shortDesc == pID_sane);
             
             Asset::Ident idi = thePipe->ident;
@@ -147,7 +147,7 @@ namespace asset
             string sID = pipe1->getStreamID(); // sort of a "default stream type"
             PPipe pipe3 = Pipe::query ("stream("+sID+")");
             ASSERT (pipe3);
-            ASSERT (pipe3->getStreamID() == sID);
+            ASSERT (pipe3->getStreamID() == StreamType::ID(sID));
             ASSERT (pipe3->getProcPatt() == Session::current->defaults (Query("stream("+sID+")")));
           }
         
diff --git a/tests/components/proc/mobject/output-mapping-test.cpp b/tests/components/proc/mobject/output-mapping-test.cpp
index db6f36ee1..5f4a5be1a 100644
--- a/tests/components/proc/mobject/output-mapping-test.cpp
+++ b/tests/components/proc/mobject/output-mapping-test.cpp
@@ -76,7 +76,7 @@ namespace test  {
             {
               PPipe srcP = Pipe::lookup (sourcePipeID);
               format queryPattern ("id(master_%1%), stream(%1%), ord(%2%)");
-              return Query (queryPattern % srcP->getStreamID() % seqNr);
+              return Query (str(queryPattern % srcP->getStreamID() % seqNr));
             }
         };
       
diff --git a/tests/components/proc/mobject/session/defsmanagerimpltest.cpp b/tests/components/proc/mobject/session/defsmanagerimpltest.cpp
index 954730804..44a2184cd 100644
--- a/tests/components/proc/mobject/session/defsmanagerimpltest.cpp
+++ b/tests/components/proc/mobject/session/defsmanagerimpltest.cpp
@@ -31,6 +31,7 @@
 #include "common/configrules.hpp"
 #include "proc/assetmanager.hpp"
 #include "proc/mobject/session.hpp"
+#include "lib/streamtype.hpp"
 
 #include 
 
@@ -49,6 +50,7 @@ namespace asset {
     
     using lumiera::ConfigRules;
     using lumiera::query::QueryHandler;
+    using lumiera::StreamType;
     
     
     
@@ -94,6 +96,7 @@ namespace asset {
         define_and_search ()
           {
             string sID = newID ("stream");
+            StreamType::ID stID (sID);
             
              // create Pipes explicitly 
             //  (without utilising default queries)
@@ -101,7 +104,7 @@ namespace asset {
             PPipe pipe2 = Struct::retrieve.newPipe (newID("pipe"), sID            );
             
             ASSERT (pipe1 != pipe2);
-            ASSERT (sID == pipe2->getStreamID());
+            ASSERT (stID == pipe2->getStreamID());
             
             ASSERT (!find (pipe1->getPipeID()), "accidental clash of random test-IDs");
             ASSERT (!find (pipe2->getPipeID()), "accidental clash of random test-IDs");
@@ -116,7 +119,7 @@ lumiera::query::setFakeBypass("stream("+sID+")"); //////////////////////////////
             ASSERT ( find (pipe1->getPipeID()), "failure declaring object as default");
             ASSERT ( find (pipe2->getPipeID()), "failure declaring object as default");
             
-            ASSERT (sID != pipe1->getStreamID(), "accidental clash");
+            ASSERT (stID != pipe1->getStreamID(), "accidental clash");
             ASSERT (!Session::current->defaults.define (pipe1, Query ("stream("+sID+")")));
                     // can't be registered with this query, due to failure caused by wrong stream-ID
           }
diff --git a/tests/components/proc/mobject/session/defsmanagertest.cpp b/tests/components/proc/mobject/session/defsmanagertest.cpp
index 608dce6db..8b67522c9 100644
--- a/tests/components/proc/mobject/session/defsmanagertest.cpp
+++ b/tests/components/proc/mobject/session/defsmanagertest.cpp
@@ -32,6 +32,7 @@
 #include "proc/asset/pipe.hpp"
 #include "proc/assetmanager.hpp"
 #include "proc/mobject/session.hpp"
+#include "lib/streamtype.hpp"
 
 #include 
 
@@ -49,6 +50,7 @@ namespace test  {
     using mobject::Session;
     using lumiera::Query;
     using lumiera::query::normaliseID;
+    using lumiera::StreamType;
     
     
     /** shortcut: run just a query
@@ -117,7 +119,7 @@ namespace test  {
         retrieveConstrainedDefault (string pID, string sID)
           {
             PPipe pipe1 = Pipe::query (""); // "the default pipe"
-            ASSERT (sID != pipe1->getStreamID(),
+            ASSERT ( pipe1->getStreamID() != StreamType::ID(sID),
                     "stream-ID \"%s\" not suitable for test, because "
                     "the default-pipe \"%s\" happens to have the same "
                     "stream-ID. We need it to be different", 
@@ -126,7 +128,7 @@ namespace test  {
             
             string query_for_sID ("stream("+sID+")");
             PPipe pipe2 = Pipe::query (query_for_sID);
-            ASSERT (sID == pipe2->getStreamID());
+            ASSERT (pipe2->getStreamID() == StreamType::ID(sID));
             ASSERT (pipe2 != pipe1);
             ASSERT (pipe2 == Pipe::query (query_for_sID));   // reproducible
           }

From 0464ca965c3ee85157d8236146c6bc4fcda974e4 Mon Sep 17 00:00:00 2001
From: Ichthyostega 
Date: Fri, 10 Dec 2010 18:12:56 +0100
Subject: [PATCH 15/28] fill in ModelPort and ModelPortRegistry definition
 stubs

making test pass the compiler
---
 .../mobject/builder/model-port-registry.cpp   | 181 ++++++++++++++++--
 .../mobject/builder/model-port-registry.hpp   |  96 +++++++++-
 src/proc/mobject/model-port.hpp               |  93 +++++++--
 tests/44builder.tests                         |   5 +
 tests/components/Makefile.am                  |   1 +
 .../builder/model-port-registry-test.cpp      | 107 ++++++++---
 6 files changed, 423 insertions(+), 60 deletions(-)

diff --git a/src/proc/mobject/builder/model-port-registry.cpp b/src/proc/mobject/builder/model-port-registry.cpp
index 87a26492e..2346c4b9f 100644
--- a/src/proc/mobject/builder/model-port-registry.cpp
+++ b/src/proc/mobject/builder/model-port-registry.cpp
@@ -53,19 +53,176 @@
 //using lumiera::Symbol;
 
 namespace mobject {
-namespace builder {
-  
-  
-  /**
-   * TODO type comment
-   */
-  class ModelPortTable
-    : boost::noncopyable
-    {
+  namespace builder {
+    
+    
+    /**
+     * TODO type comment
+     */
+    class ModelPortTable
+      : boost::noncopyable
+      {
+        
+      public:
+      };
+    
       
-    public:
-    };
+    typedef ModelPortRegistry::ModelPortDescriptor const& MPDescriptor;
+    
+      inline MPDescriptor
+      accessDescriptor() 
+      {
+        
+      }
+    
+    ModelPortRegistry&
+    ModelPortRegistry::setActiveInstance (ModelPortRegistry& newRegistry)
+    {
+      UNIMPLEMENTED ("handling of active model port registry"); 
+    }
+    
+    
+    /** */
+    ModelPortRegistry&
+    ModelPortRegistry::globalInstance()
+    {
+      UNIMPLEMENTED ("access the globally valid registry instance"); 
+    }
+   
+    
+    
+    /** */
+    bool
+    ModelPortRegistry::contains (ID pID)  const
+    {
+      UNIMPLEMENTED ("diagnostics querying the state of the pending transaction"); 
+    }
+    
+    
+    /** @return true if the given pipe-ID actually denotes an
+     *          existing, connected and usable model port. 
+     *  @note reflects the state of the publicly visible 
+     *          model port registry, \em not any model ports
+     *          being registered within a currently pending
+     *          transaction (ongoing build process). */
+    bool
+    ModelPortRegistry::isRegistered (ID key)  const
+    {
+      if (!key) return false;
+      
+      UNIMPLEMENTED ("query the publicly valid contents"); 
+    }
+    
+    
+    /** */
+    MPDescriptor
+    ModelPortRegistry::operator[] (ID key)  const
+    {
+      UNIMPLEMENTED ("access registered model port");
+    }
+    
+    
+    /** */
+    MPDescriptor
+    ModelPortRegistry::accessDescriptor (ID key)
+    {
+      UNIMPLEMENTED ("access the current global registry and fetch model port");
+    }
+    
+    
+    /** */
+    MPDescriptor
+    ModelPortRegistry::definePort (ID pipeA, ID element_exposing_this_port)
+    {
+      UNIMPLEMENTED ("create and register a new model port entry, within the pending transaction"); 
+    }
+    
+    
+    /** */
+    void
+    ModelPortRegistry::remove (PID key)
+    {
+      UNIMPLEMENTED ("remove a model port entry from the pending transaction"); 
+    }
+    
+    
+    /** */
+    void
+    ModelPortRegistry::clear()
+    {
+      UNIMPLEMENTED ("schedule removal of all registry contents into the pending transaction"); 
+    }
+    
+    
+    /** */
+    void
+    ModelPortRegistry::commit()
+    {
+      UNIMPLEMENTED ("transactional switch for new/modified model ports"); 
+    }
+    
+    
+    /** */
+    void
+    ModelPortRegistry::rollback()
+    {
+      UNIMPLEMENTED ("discard current transaction"); 
+    }
+  
+    
+    
+    LUMIERA_ERROR_DEFINE (DUPLICATE_MODEL_PORT, "Attempt to define a new model port with an pipe-ID already denoting an existing port");
+  
+  } // namespace builder  
   
   
   
-}} // namespace mobject
+  
+  LUMIERA_ERROR_DEFINE (INVALID_MODEL_PORT, "Referral to unknown model port");
+  LUMIERA_ERROR_DEFINE (UNCONNECTED_MODEL_PORT, "Attempt to operate on an existing but unconnected model port");
+
+  
+  ModelPort::ModelPort (ID refID)
+    : id_(refID)
+    {
+      builder::ModelPortRegistry::accessDescriptor (refID);
+    }
+  
+  
+  /** */
+  bool
+  ModelPort::exists (ID key)
+  {
+    return builder::ModelPortRegistry::globalInstance().isRegistered (key);
+  }
+  
+  
+  /** */
+  ID
+  ModelPort::pipe()  const
+  {
+    ENSURE (this->id_ == builder::ModelPortRegistry::accessDescriptor(this->id_).id);
+    
+    return builder::ModelPortRegistry::accessDescriptor(this->id_).id;
+  }
+  
+  
+  /** */
+  ID
+  ModelPort::holder()  const
+  {
+    return builder::ModelPortRegistry::accessDescriptor(this->id_).holder;
+  }
+  
+  
+  /** */
+  StreamType::ID
+  ModelPort::streamType() const
+  {
+    return this->id_.streamType();
+  }
+
+
+  
+  
+} // namespace mobject
diff --git a/src/proc/mobject/builder/model-port-registry.hpp b/src/proc/mobject/builder/model-port-registry.hpp
index 2ef87f126..53ddc6810 100644
--- a/src/proc/mobject/builder/model-port-registry.hpp
+++ b/src/proc/mobject/builder/model-port-registry.hpp
@@ -34,8 +34,6 @@
  ** for setting up such a registry, while all other parts of the system just access the current
  ** model ports through the mobject::ModelPort frontend.
  ** 
- ** TODO fill in more details?
- ** 
  ** @see ModelPort
  ** @see OutputDesignation
  ** @see ModelPortRegistry_test
@@ -45,7 +43,11 @@
 #ifndef PROC_MOBJECT_BUILDER_MODEL_PORT_REGISTRY_H
 #define PROC_MOBJECT_BUILDER_MODEL_PORT_REGISTRY_H
 
+#include "lib/error.hpp"
 #include "proc/asset/pipe.hpp"
+#include "proc/asset/struct.hpp"
+#include "proc/mobject/model-port.hpp"
+
 //#include "lib/opaque-holder.hpp"
 //#include "lib/meta/typelist-util.hpp"
 
@@ -56,17 +58,105 @@
 namespace mobject {
 namespace builder {
   
+  using asset::ID;
+  using asset::Pipe;
+//using asset::PPipe;
+  using asset::Struct;
+  
+  LUMIERA_ERROR_DECLARE (DUPLICATE_MODEL_PORT); ///< Attempt to define a new model port with an pipe-ID already denoting an existing port
+  
+  
   /**
-   * TODO type comment
+   * Management facility for tracking model ports.
+   * ModelPort handles are exposed as frontend for usage
+   * by client code. Model ports are discovered by the builder
+   * when re-creating the low-level model; during such an ongoing
+   * build process, newly discovered ports are accumulated within
+   * a transaction, which then gets committed atomically when the
+   * new model is complete and ready for use.
    */
   class ModelPortRegistry
     : boost::noncopyable
     {
       
+      typedef ID   PID;
+      typedef ID StID;
+      
     public:
+      /** @internal record to describe a model port */
+      struct ModelPortDescriptor;
+      
+      
+      static ModelPortRegistry&
+      setActiveInstance (ModelPortRegistry& newRegistry);
+      
+      static ModelPortRegistry&
+      globalInstance();
+
+      static ModelPortDescriptor const&
+      accessDescriptor (PID); 
+      
+      
+      ModelPortDescriptor const&
+      definePort (PID pipe, StID element_exposing_this_port);
+      
+      bool contains (PID)     const;
+      bool isRegistered (PID) const;
+      
+      ModelPortDescriptor const&
+      operator[] (PID)  const;
+      
+      
+      void remove (PID);
+      void clear();
+      
+      
+      /** activate pending model port changes.
+       *  Any accumulated changes and newly defined model ports
+       *  are promoted to become part of the current active configuration
+       *  with a single atomic (transactional) switch.
+       */
+      void commit();
+      
+      /** discard pending changes.
+       *  Silently drop model port definition changes since the last commit.
+       */
+      void rollback();
     };
   
   
   
+  /** ModelPortDescriptor records are used as actual storage
+   *  within the model port registration table; they are never
+   *  exposed to client code directly.
+   */
+  struct ModelPortRegistry::ModelPortDescriptor
+    {
+      const PID  id;
+      const StID holder;
+      
+      bool
+      isValid()  const
+        {
+          return bool(id);
+        }
+      
+      
+      ModelPortDescriptor()
+        : id(PID::INVALID)
+        , holder(StID::INVALID)
+        { }
+      
+      // default copy operations permitted
+      
+    protected:
+      ModelPortDescriptor (PID pipe, StID element_exposing_this_port)
+        : id(pipe)
+        , holder(element_exposing_this_port)
+        { }
+    };
+
+  
+  
 }} // namespace mobject::builder
 #endif
diff --git a/src/proc/mobject/model-port.hpp b/src/proc/mobject/model-port.hpp
index 634d1e0dc..cf98bc149 100644
--- a/src/proc/mobject/model-port.hpp
+++ b/src/proc/mobject/model-port.hpp
@@ -30,7 +30,7 @@
  ** and low-level view. A model port can be associated both to a pipe within a timeline
  ** in the HighLevelModel, as well as to denote a set of corresponding exit nodes within
  ** the segments of the render nodes network. Model ports are keyed by Pipe-ID and thus
- ** are unique within the application.
+ ** are bound to be unique within the application.
  ** 
  ** A model port is rather derived than configured; it emerges during the build process
  ** when a pipe claims an OutputDesignation and some other entity actually uses this
@@ -41,21 +41,22 @@
  ** 
  ** Because model ports are discovered this way, dynamically during the build process,
  ** at some point there is a transactional switch to promote the new configuration
- ** to be come the valid current model port configuration. After that switch, model ports
+ ** to become the valid current model port configuration. After that switch, model ports
  ** are immutable.
  ** 
  ** Model ports are to be accessed, enumerated and grouped in various ways, because each
  ** port belongs to a specific timeline and is used for producing data of a single
  ** StreamType solely. But all those referrals, searching and grouping happens only
  ** after the build process has discovered all model ports currently available.
- ** Thus we provide a MPortRef smart-pointer to ease handling of those access
- ** operations. The actual model port descriptors are owned and managed by
- ** the fixture; they are bulk allocated in a similar manner than the
+ ** Thus actually the ModelPort elements handed out to client code are just
+ ** smart-handles, accessing a global ModelPortRegistry behind the scenes.
+ ** Validity of these handles will be checked on each access. The actual
+ ** model port descriptors are owned and managed by the fixture;
+ ** they are bulk allocated in a similar manner than the
  ** ProcNode and WiringDescriptor objects.
  ** 
- ** TODO fill in more details?
- ** TODO where to put the ModelPortTable
- ** 
+ ** @see ModelPortRegistry_test abstract usage example
+ ** @see ModelPortRegistry management interface 
  ** @see OutputDesignation
  ** @see OutputMapping
  ** @see Timeline
@@ -66,23 +67,83 @@
 #define PROC_MOBJECT_MODEL_PORT_H
 
 #include "proc/asset/pipe.hpp"
-//#include "lib/opaque-holder.hpp"
-//#include "lib/meta/typelist-util.hpp"
-
-//extern "C" {
-//#include "lib/luid.h"
-//}
+#include "lib/bool-checkable.hpp"
+#include "lib/streamtype.hpp"
 
 namespace mobject {
   
+  LUMIERA_ERROR_DECLARE (INVALID_MODEL_PORT);      ///< Referral to unknown model port
+  LUMIERA_ERROR_DECLARE (UNCONNECTED_MODEL_PORT);  ///< Attempt to operate on an existing but unconnected model port
+  
+  
+  using asset::ID;
+  using lumiera::StreamType;
+  
+  
   /**
-   * TODO type comment
+   * Handle denoting a port within the model,
+   * where actually output data can be pulled.
+   * ModelPort is a frontend to be used by clients.
+   * These ModelPort handle objects may be copied and stored
+   * at will, but their validity will be verified on each access. 
+   * Actually, the Builder will discover any model ports and
+   * maintain a ModelPortRegistry behind the scenes.
+   * 
+   * Each model port corresponds to a (global) pipe within a
+   * specific Timeline; consequently each such port is also
+   * bound to produce data of a specific StreamType (as defined by
+   * the corresponding pipe). A model port may be in \em unconnected
+   * state, which can be checked by \c bool conversion. While the
+   * ModelPort handles are value objects, the identity of the
+   * underlying model port (descriptor) is given by the 
+   * corresponding pipe-ID, thus effectively resulting
+   * in a global namespace for model ports.
+   * 
+   * @see builder::ModelPortRegistry management interface
+   * @see ModelPortRegistry_test abstract usage example
    */
   class ModelPort
-    : boost::noncopyable
+    : public lib::BoolCheckable
     {
+      ID id_;
       
     public:
+      ModelPort()                         ///< \em unconnected model port
+        : id_(ID::INVALID)
+        { }
+      
+      ModelPort (ID refID);  ///< @note conversion from pipe-ID
+      
+      // using default copy operations
+      
+      
+      static bool exists (ID);
+      
+      ID   pipe()    const;
+      ID holder()  const;
+      StreamType::ID streamType() const;
+      
+      bool
+      isValid()  const
+        {
+          return exists (this->id_);
+        }
+      
+      
+      friend bool
+      operator== (ModelPort const& mp1, ModelPort const& mp2)
+      {
+        return mp1.id_ == mp2.id_;
+      }
+      
+      friend bool
+      operator!= (ModelPort const& mp1, ModelPort const& mp2)
+      {
+        return mp1.id_ != mp2.id_;
+      }
+      
+    private:
+      
     };
   
   
diff --git a/tests/44builder.tests b/tests/44builder.tests
index 6424f453f..5df8ef0a4 100644
--- a/tests/44builder.tests
+++ b/tests/44builder.tests
@@ -15,6 +15,11 @@ PLANNED "BuildSegment_test" BuildSegment_test <
 //#include 
 #include 
 
-//using boost::format;
-//using boost::scoped_ptr;
-using util::isSameObject;
-using util::isnil;
-using std::string;
-
 
 namespace mobject {
 namespace builder {
 namespace test  {
   
+  //using boost::format;
+  //using boost::scoped_ptr;
+  using util::isSameObject;
+  using util::isnil;
+  using std::string;
+  
   using asset::Pipe;
   using asset::PPipe;
+  using asset::Struct;
+  using asset::Timeline;
+  using asset::PTimeline;
+  using lumiera::Query;
+  
+  typedef asset::ID PID;
+  typedef asset::ID TID;
+  
   
-  //typedef asset::ID PID;
   namespace { // test environment
     
+    inline PID
+    getPipe (string id)
+    {
+      return Pipe::query("id("+id+")");
+    }
+    
+    inline TID
+    getTimeline (string id)
+    {
+      return asset::Struct::retrieve (Query ("id("+id+")"))->getID();
+    }
+    
+    typedef ModelPortRegistry::ModelPortDescriptor const& MPDescriptor;
+    
     struct TestContext
       {
         ModelPortRegistry registry_;
@@ -88,30 +111,35 @@ namespace test  {
         {
           TestContext ctx;
           
-          fabricating_ModelPorts (ctx);
+          fabricating_ModelPorts (ctx.registry_);
           accessing_ModelPorts();
-          transactionalSwitch (ctx);
+          transactionalSwitch (ctx.registry_);
         }
       
       
       void
       fabricating_ModelPorts (ModelPortRegistry& registry)
         {
-          ModelPortDescriptor& p1 = registry.definePort (pipeA, someTimeline);
-          ModelPortDescriptor& p2 = registry.definePort (pipeB, someTimeline);
+          /* == some Assets to play with == */
+          PID pipeA        = getPipe ("pipeA");
+          PID pipeB        = getPipe ("pipeB");
+          PID pipeWC       = getPipe ("WCpipe");
+          TID someTimeline = getTimeline ("some_test_Timeline");
           
-          CHECK (p1);
-          CHECK (p2);
+          // start out with defining some new model ports......
+          MPDescriptor p1 = registry.definePort (pipeA, someTimeline);
+          MPDescriptor p2 = registry.definePort (pipeB, someTimeline);
+          
+          CHECK (registry.contains (pipeA));
+          CHECK (registry.contains (pipeB));
           
           VERIFY_ERROR (DUPLICATE_MODEL_PORT, registry.definePort(pipeB, someTimeline) );
-          CHECK (p2);
+          CHECK (registry.contains (pipeB));
           
-          CHECK (p1.getID() == pipeA);
-          CHECK (p2.getID() == pipeB);
-          CHECK (p1.getPipe() == pipeA);
-          CHECK (p2.getPipe() == pipeB);
-          CHECK (p1.getTimeline() == someTimeline);
-          CHECK (p2.getTimeline() == someTimeline);
+          CHECK (p1.id == pipeA);
+          CHECK (p2.id == pipeB);
+          CHECK (p1.holder == someTimeline);
+          CHECK (p2.holder == someTimeline);
           
           registry.commit();
         }
@@ -120,6 +148,10 @@ namespace test  {
       void
       accessing_ModelPorts ()
         {
+          PID pipeA  = getPipe ("pipeA");
+          PID pipeB  = getPipe ("pipeB");
+          PID pipeWC = getPipe ("WCpipe");
+          
           ModelPort mp1(pipeA);
           ModelPort mp2(pipeB);
           
@@ -149,26 +181,32 @@ namespace test  {
           CHECK (mp1x.pipe() == pipeA);
           VERIFY_ERROR (UNCONNECTED_MODEL_PORT, mpNull.pipe());
           
-          CHECK (mp1.streamType() == pipeA.getStreamType());
+          CHECK (mp1.streamType() == pipeA.streamType());
         }
       
       
       void
       transactionalSwitch (ModelPortRegistry& registry)
         {
+          PID pipeA  = getPipe ("pipeA");
+          PID pipeB  = getPipe ("pipeB");
+          PID pipeWC = getPipe ("WCpipe");
+          
           CHECK ( ModelPort::exists (pipeB));
           CHECK (!ModelPort::exists (pipeWC));
           
           CHECK (ModelPort::exists (pipeA));
           CHECK (registry.contains (pipeA));
           registry.remove (pipeA);
-          CHECK (ModelPort::exists (pipeA));
+          CHECK ( ModelPort::exists (pipeA));
           CHECK (!registry.contains (pipeA));
-    
-          ModelPortDescriptor& p1 = registry.definePort (pipeA, anotherTimeline);
+          
+          // now create a new and differing definition of port A 
+          TID anotherTimeline = getTimeline ("another_test_Timeline");
+          MPDescriptor p1 = registry.definePort (pipeA, anotherTimeline);
           CHECK (registry.contains (pipeA));
-          CHECK (p1.getTimeline() == anotherTimeline);
-          CHECK (ModelPort(pipeA).timeline() != anotherTimeline);
+          CHECK (p1.holder == anotherTimeline);
+          CHECK (ModelPort(pipeA).holder() != anotherTimeline);
           
           registry.remove (pipeB);
           registry.definePort (pipeWC,anotherTimeline);
@@ -184,7 +222,7 @@ namespace test  {
           CHECK (portB);
           CHECK (portA.pipe() == pipeA);
           CHECK (portB.pipe() == pipeB);
-          CHECK (portA.timeline() != anotherTimeline);
+          CHECK (portA.holder() != anotherTimeline);
           
           registry.commit();
           CHECK ( ModelPort::exists (pipeA));
@@ -192,14 +230,25 @@ namespace test  {
           CHECK ( ModelPort::exists (pipeWC));
           CHECK ( portA);
           CHECK (!portB);
-          CHECK (portA.timeline() == anotherTimeline);
+          CHECK (portA.holder() == anotherTimeline);
           CHECK (portA.pipe() == pipeA);
           VERIFY_ERROR (UNCONNECTED_MODEL_PORT, portB.pipe());
           
           ModelPort pwc(pipeWC);
           CHECK (pwc);
           CHECK (pwc.pipe() == pipeWC);
-          CHECK (pwc.timeline() == anotherTimeline);
+          CHECK (pwc.holder() == anotherTimeline);
+          
+          registry.remove (pipeA);
+          registry.clear();
+          CHECK (!registry.contains (pipeA));
+          CHECK (!registry.contains (pipeB));
+          CHECK (!registry.contains (pipeWC));
+          
+          registry.rollback();
+          CHECK ( registry.contains (pipeA));
+          CHECK ( registry.contains (pipeB));
+          CHECK ( registry.contains (pipeWC));
         }
     };
   

From be6f555e047402bfee79c3861839f9810ddae044 Mon Sep 17 00:00:00 2001
From: Ichthyostega 
Date: Sat, 11 Dec 2010 01:52:02 +0100
Subject: [PATCH 16/28] Builder: registry for model ports coded up

passes compiler, but not yet unit test....
Needed to change asset::ID to encapsulate the embedded hash value
---
 src/include/logging.h                         |  10 +-
 src/proc/asset.hpp                            |   8 +-
 src/proc/mobject/builder/common.hpp           |  17 +-
 .../mobject/builder/model-port-registry.cpp   | 188 +++++++++++++-----
 .../mobject/builder/model-port-registry.hpp   |  62 ++++--
 src/proc/mobject/builderfacade.cpp            |   8 +-
 src/proc/mobject/builderfacade.hpp            |   1 +
 .../builder/model-port-registry-test.cpp      |  17 +-
 8 files changed, 209 insertions(+), 102 deletions(-)

diff --git a/src/include/logging.h b/src/include/logging.h
index d2420b0f8..d5123f48f 100644
--- a/src/include/logging.h
+++ b/src/include/logging.h
@@ -132,6 +132,12 @@ NOBUG_CPP_DEFINE_FLAG_PARENT    (   proc,                       progress);
 NOBUG_CPP_DEFINE_FLAG_PARENT    (    command,                   proc);
 /** progress log for session datastructure */
 NOBUG_CPP_DEFINE_FLAG_PARENT    (    session,                   proc);
+/** progress log for the builder and build process */
+NOBUG_CPP_DEFINE_FLAG_PARENT    (    builder,                   proc);
+/** progress log for running the engine */
+NOBUG_CPP_DEFINE_FLAG_PARENT    (    engine,                    proc);
+/** progress log for play- and render subsystem */
+NOBUG_CPP_DEFINE_FLAG_PARENT    (    play,                      proc);
 /** progress log for the gui */
 NOBUG_CPP_DEFINE_FLAG_PARENT    (   gui,                        progress);
 /** progress log for the support lib */
@@ -158,13 +164,13 @@ NOBUG_CPP_DEFINE_FLAG_PARENT    (  config,                      logging);
 
 /** base flag for software testing */
 NOBUG_CPP_DEFINE_FLAG_PARENT    (  test,                        logging);
-/** base flag for syncronization logging */
+/** base flag for synchronisation logging */
 NOBUG_CPP_DEFINE_FLAG_PARENT    (  sync,                        logging);       // do we need subsections here? backend_mutex_sync proc_mutex_sync etc?
 NOBUG_CPP_DEFINE_FLAG_PARENT    (   mutex_sync,                 sync);          //locking/unlocking mutexes
 NOBUG_CPP_DEFINE_FLAG_PARENT    (   cond_sync,                  sync);          //waiting and signalling condition vars
 /** base flag for memory related logging */
 NOBUG_CPP_DEFINE_FLAG_PARENT    (  memory,                      logging);
-/** memory busines of the proc layer */
+/** proc layer memory handling */
 NOBUG_CPP_DEFINE_FLAG_PARENT    (   proc_mem,                   memory);
 NOBUG_CPP_DEFINE_FLAG_PARENT    (    mobject_mem,               proc_mem);
 NOBUG_CPP_DEFINE_FLAG_PARENT    (    builder_mem,               proc_mem);
diff --git a/src/proc/asset.hpp b/src/proc/asset.hpp
index 80e5f2aa7..ef56fc632 100644
--- a/src/proc/asset.hpp
+++ b/src/proc/asset.hpp
@@ -103,11 +103,11 @@ namespace asset {
   template
   class ID
     {
+      HashVal hash_;
     public:
-      const HashVal hash;
-      ID (HashVal id)        : hash(id)         {}
-      ID (const KIND& asset) : hash(asset.getID()) {}
-      operator HashVal() const { return hash; }
+      ID (HashVal id)        : hash_(id)         {}
+      ID (const KIND& asset) : hash_(asset.getID()) {}
+      operator HashVal() const { return hash_; }
       
       static ID INVALID;
     };
diff --git a/src/proc/mobject/builder/common.hpp b/src/proc/mobject/builder/common.hpp
index e0503499b..ed3554c4c 100644
--- a/src/proc/mobject/builder/common.hpp
+++ b/src/proc/mobject/builder/common.hpp
@@ -24,25 +24,14 @@
 #ifndef MOBJECT_BUILDER_COMMON_H
 #define MOBJECT_BUILDER_COMMON_H
 
+#include "lib/error.hpp"
 #include "include/logging.h"
 
 
 namespace mobject {
-  namespace builder {
+namespace builder {
     
     
-    // TODO NOBUG_DECLARE_FLAG (builder_mem);
     
-    
-  } // namespace builder
-
-} // namespace mobject
+}} // namespace mobject::builder
 #endif
-
-/*
-// Local Variables:
-// mode: C
-// c-file-style: "gnu"
-// indent-tabs-mode: nil
-// End:
-*/
diff --git a/src/proc/mobject/builder/model-port-registry.cpp b/src/proc/mobject/builder/model-port-registry.cpp
index 2346c4b9f..86a444a70 100644
--- a/src/proc/mobject/builder/model-port-registry.cpp
+++ b/src/proc/mobject/builder/model-port-registry.cpp
@@ -37,7 +37,10 @@
 
 
 #include "lib/error.hpp"
+#include "include/logging.h"
+#include "lib/sync-classlock.hpp"
 //#include "lib/symbol.hpp"//
+#include "proc/mobject/builderfacade.hpp"
 #include "proc/mobject/model-port.hpp"
 #include "proc/mobject/builder/model-port-registry.hpp"
 
@@ -55,47 +58,72 @@
 namespace mobject {
   namespace builder {
     
+    namespace error = lumiera::error;
     
-    /**
-     * TODO type comment
-     */
-    class ModelPortTable
-      : boost::noncopyable
-      {
-        
-      public:
-      };
     
-      
     typedef ModelPortRegistry::ModelPortDescriptor const& MPDescriptor;
+    typedef lib::ClassLock LockRegistry;
     
-      inline MPDescriptor
-      accessDescriptor() 
-      {
-        
-      }
     
-    ModelPortRegistry&
-    ModelPortRegistry::setActiveInstance (ModelPortRegistry& newRegistry)
+    /** storage for the link to the 
+        global Registry instance currently in charge  */
+    lib::OptionalRef ModelPortRegistry::theGlobalRegistry;
+    
+    
+    
+    /** globally deactivate access to model ports */
+    void
+    ModelPortRegistry::shutdown ()
     {
-      UNIMPLEMENTED ("handling of active model port registry"); 
+      INFO (builder, "disabling ModelPort registry....");
+      LockRegistry global_lock;
+      theGlobalRegistry.clear(); 
     }
     
     
-    /** */
+    /** switch the implicit link to \em the global ModelPort registry
+     *  to point to the given implementation instance. Typically used within
+     *  the Builder subsystem lifecycle methods, or for unit tests to use
+     *  a test instance of the registry temporarily
+     * @return the registry instance previously in use or \c NULL
+     */
+    ModelPortRegistry*
+    ModelPortRegistry::setActiveInstance (ModelPortRegistry& newRegistry)
+    {
+      INFO (builder, "activating new ModelPort registry.");
+      LockRegistry global_lock;
+      ModelPortRegistry *previous = theGlobalRegistry.isValid()? 
+                                       &(theGlobalRegistry()) : 0; 
+      theGlobalRegistry.link_to (newRegistry);
+      return previous;
+    }
+    
+    
+    /** access the globally valid registry instance.
+     *  @throw error::State if this global registry is
+     *         already closed or not yet initialised. */
     ModelPortRegistry&
     ModelPortRegistry::globalInstance()
     {
-      UNIMPLEMENTED ("access the globally valid registry instance"); 
+      LockRegistry global_lock;
+      if (theGlobalRegistry.isValid())
+        return theGlobalRegistry();
+      
+      throw error::State ("global model port registry is not accessible"
+                         , LUMIERA_ERROR_BUILDER_LIFECYCLE); 
     }
    
     
     
-    /** */
+    /** does the transaction currently being built
+     *  already contain a model port registration for the given ID?
+     * @note this does \em not query registration state of the
+     *       global registry; use #isRegistered for that...*/
     bool
-    ModelPortRegistry::contains (ID pID)  const
+    ModelPortRegistry::contains (ID key)  const
     {
-      UNIMPLEMENTED ("diagnostics querying the state of the pending transaction"); 
+      return bool(key)
+          && util::contains (transaction_, key); 
     }
     
     
@@ -103,70 +131,117 @@ namespace mobject {
      *          existing, connected and usable model port. 
      *  @note reflects the state of the publicly visible 
      *          model port registry, \em not any model ports
-     *          being registered within a currently pending
-     *          transaction (ongoing build process). */
+     *          being registered within a pending transaction
+     *          (ongoing build process). */
     bool
     ModelPortRegistry::isRegistered (ID key)  const
     {
-      if (!key) return false;
-      
-      UNIMPLEMENTED ("query the publicly valid contents"); 
+      return bool(key)
+          && util::contains (currentReg_, key); 
     }
     
     
-    /** */
+    /** basic access operation: access the descriptor
+     *  of a currently valid model port.
+     * @note no locking (but #accessDescriptor does lock!) 
+     * @throw error::Logic if accessing a non registered port
+     * @throw error::State if accessing an invalid / disconnected port
+     */
     MPDescriptor
-    ModelPortRegistry::operator[] (ID key)  const
+    ModelPortRegistry::get (ID key)  const
     {
-      UNIMPLEMENTED ("access registered model port");
+      if (!key)
+        throw error::State ("This model port is disconnected or NIL"
+                           , LUMIERA_ERROR_UNCONNECTED_MODEL_PORT);
+      if (!isRegistered (key))
+        throw error::Logic ("Model port was never registered, or got unregistered meanwhile."
+                           ,LUMIERA_ERROR_INVALID_MODEL_PORT);
+      
+      MPTable::const_iterator pos = currentReg_.find (key);
+      ASSERT (pos != currentReg_.end());
+      ASSERT (pos->second.isValid());
+      return pos->second;
     }
     
     
-    /** */
+    /** access \em the globally valid model port for the given pipe.
+     *  This (static) function locks and accesses the global model port registry
+     *  to fetch the descriptor record. Typically invoked by client code
+     *  through the ModelPort frontend
+     * @throw error::State when registry is down or the model port is disconnected
+     * @throw error::Logic when the given key wasn't registered for a model port */
     MPDescriptor
     ModelPortRegistry::accessDescriptor (ID key)
     {
-      UNIMPLEMENTED ("access the current global registry and fetch model port");
+      LockRegistry global_lock;
+      return theGlobalRegistry().get(key);
     }
     
     
-    /** */
+    /* === Mutations === */
+    
+    /** create and register a new model port entry,
+     *  within the pending transaction */
     MPDescriptor
-    ModelPortRegistry::definePort (ID pipeA, ID element_exposing_this_port)
+    ModelPortRegistry::definePort (ID pipe, ID element_exposing_this_port)
     {
-      UNIMPLEMENTED ("create and register a new model port entry, within the pending transaction"); 
+      LockRegistry global_lock;
+      if (contains (pipe))
+        throw error::Logic ("attempt to register a model port with a pipe-ID, "
+                            "which has already been used to register a "
+                            "model port within this transaction (build process)."
+                           , LUMIERA_ERROR_DUPLICATE_MODEL_PORT);
+      return (transaction_[pipe] = ModelPortDescriptor(pipe, element_exposing_this_port));
     }
     
     
-    /** */
+    /** remove a model port entry from the pending transaction */
     void
     ModelPortRegistry::remove (PID key)
     {
-      UNIMPLEMENTED ("remove a model port entry from the pending transaction"); 
+      LockRegistry global_lock;
+      transaction_.erase (key);
     }
     
     
-    /** */
+    /** schedule removal of all registry contents.
+     *  When the currently pending transaction is committed,
+     *  all registered model ports will be removed */
     void
     ModelPortRegistry::clear()
     {
-      UNIMPLEMENTED ("schedule removal of all registry contents into the pending transaction"); 
+      LockRegistry global_lock;
+      transaction_.clear();
     }
     
     
-    /** */
+    /** transactional switch for new/modified model ports.
+     *  Promote the registered model ports from the currently
+     *  pending transaction to become the globally valid model ports
+     * @note automatically starts a new transaction, initialised
+     *       with the now published mappings.
+     */
     void
     ModelPortRegistry::commit()
     {
-      UNIMPLEMENTED ("transactional switch for new/modified model ports"); 
+      LockRegistry global_lock;
+      MPTable newTransaction(transaction_);
+      TRACE (builder, "committing new ModelPort list....");
+      swap (currentReg_, transaction_);
+      swap (transaction_, newTransaction);
     }
     
     
-    /** */
+    /** discard current transaction.
+     *  The global port registration thus
+     *  remains unaltered. */
     void
     ModelPortRegistry::rollback()
     {
-      UNIMPLEMENTED ("discard current transaction"); 
+      LockRegistry global_lock;
+      TRACE (builder, "discarding changes to ModelPort list (rollback)....");
+      MPTable newTransaction(transaction_);
+      swap (transaction_, newTransaction);
     }
   
     
@@ -189,7 +264,8 @@ namespace mobject {
     }
   
   
-  /** */
+  /** check if the global model port registration
+   *  contains a mapping for the given pipe-ID*/
   bool
   ModelPort::exists (ID key)
   {
@@ -197,25 +273,35 @@ namespace mobject {
   }
   
   
-  /** */
+  /** access the Pipe (ID) of the global model port registered
+   *  with the ID underlying this model port.
+   * @throw error::Logic if no model port is registered for this Pipe-ID
+   */
   ID
   ModelPort::pipe()  const
   {
-    ENSURE (this->id_ == builder::ModelPortRegistry::accessDescriptor(this->id_).id);
+    ENSURE (this->id_ == builder::ModelPortRegistry::accessDescriptor(this->id_).id());
     
-    return builder::ModelPortRegistry::accessDescriptor(this->id_).id;
+    return builder::ModelPortRegistry::accessDescriptor(this->id_).id();
   }
   
   
-  /** */
+  /** access the timeline (or similar structural element) holding
+   *  a global pipe which corresponds to this model port
+   * @throw error::Logic if no model port is registered for this Pipe-ID
+   */
   ID
   ModelPort::holder()  const
   {
-    return builder::ModelPortRegistry::accessDescriptor(this->id_).holder;
+    return builder::ModelPortRegistry::accessDescriptor(this->id_).holder();
   }
   
   
-  /** */
+  /** convenience shortcut to access the stream type
+   *  associated with the pipe-ID corresponding to this model port.
+   * @note no check if this model port actually is valid
+   * @throw error::Invalid in case of unknown/unregistered Pipe-ID
+   */
   StreamType::ID
   ModelPort::streamType() const
   {
diff --git a/src/proc/mobject/builder/model-port-registry.hpp b/src/proc/mobject/builder/model-port-registry.hpp
index 53ddc6810..e0c79e77f 100644
--- a/src/proc/mobject/builder/model-port-registry.hpp
+++ b/src/proc/mobject/builder/model-port-registry.hpp
@@ -34,6 +34,12 @@
  ** for setting up such a registry, while all other parts of the system just access the current
  ** model ports through the mobject::ModelPort frontend.
  ** 
+ ** @note the locking is rather coarse grained; basically we're using just one
+ **       single global lock for all ModelPortRegistry instances and all access/mutations,
+ **       as well as for accessing the globally valid Registry through the ModelPort frontend.
+ **       Assumed that usually there is just one Registry maintained by the builder, this is
+ **       likely to be sufficient.
+ ** 
  ** @see ModelPort
  ** @see OutputDesignation
  ** @see ModelPortRegistry_test
@@ -44,10 +50,13 @@
 #define PROC_MOBJECT_BUILDER_MODEL_PORT_REGISTRY_H
 
 #include "lib/error.hpp"
+#include "lib/optional-ref.hpp"
 #include "proc/asset/pipe.hpp"
 #include "proc/asset/struct.hpp"
 #include "proc/mobject/model-port.hpp"
 
+#include 
+
 //#include "lib/opaque-holder.hpp"
 //#include "lib/meta/typelist-util.hpp"
 
@@ -87,7 +96,9 @@ namespace builder {
       struct ModelPortDescriptor;
       
       
-      static ModelPortRegistry&
+      static void shutdown ();
+
+      static ModelPortRegistry*
       setActiveInstance (ModelPortRegistry& newRegistry);
       
       static ModelPortRegistry&
@@ -104,7 +115,7 @@ namespace builder {
       bool isRegistered (PID) const;
       
       ModelPortDescriptor const&
-      operator[] (PID)  const;
+      get (PID)  const;
       
       
       void remove (PID);
@@ -122,38 +133,51 @@ namespace builder {
        *  Silently drop model port definition changes since the last commit.
        */
       void rollback();
+      
+    private:
+      static lib::OptionalRef theGlobalRegistry;
+      
+      typedef std::map MPTable;
+      
+      MPTable currentReg_;
+      MPTable transaction_;
     };
   
   
   
   /** ModelPortDescriptor records are used as actual storage
-   *  within the model port registration table; they are never
-   *  exposed to client code directly.
+   *  within the model port registration table; they are immutable
+   *  value objects and never exposed to client code directly.
    */
-  struct ModelPortRegistry::ModelPortDescriptor
+  class ModelPortRegistry::ModelPortDescriptor
     {
-      const PID  id;
-      const StID holder;
+      PID  id_;
+      StID holder_;
       
-      bool
-      isValid()  const
-        {
-          return bool(id);
-        }
+    protected:
+      ModelPortDescriptor (PID pipe, StID element_exposing_this_port)
+        : id_(pipe)
+        , holder_(element_exposing_this_port)
+        { }
       
+      friend class ModelPortRegistry;
       
+    public:
       ModelPortDescriptor()
-        : id(PID::INVALID)
-        , holder(StID::INVALID)
+        : id_(PID::INVALID)
+        , holder_(StID::INVALID)
         { }
       
       // default copy operations permitted
       
-    protected:
-      ModelPortDescriptor (PID pipe, StID element_exposing_this_port)
-        : id(pipe)
-        , holder(element_exposing_this_port)
-        { }
+      bool
+      isValid()  const
+        {
+          return bool(id_);
+        }
+      
+      const PID  id()      const { return id_; }
+      const StID holder()  const { return holder_; }
     };
 
   
diff --git a/src/proc/mobject/builderfacade.cpp b/src/proc/mobject/builderfacade.cpp
index 99eb87ed9..cbf73bbbd 100644
--- a/src/proc/mobject/builderfacade.cpp
+++ b/src/proc/mobject/builderfacade.cpp
@@ -26,11 +26,6 @@
 
 namespace mobject {
   
-  namespace builder {
-    using ::NOBUG_FLAG(memory);
-    NOBUG_CPP_DEFINE_FLAG_PARENT(buildermem, memory);
-  }
-  
   
   /**
    * Main Operation of the Builder: 
@@ -42,6 +37,9 @@ namespace mobject {
     //////////////////////TODO
   }
   
+  LUMIERA_ERROR_DEFINE (BUILDER_LIFECYCLE, "Builder activated while in non operational state");
+  
+  
   
   
 } // namespace mobject
diff --git a/src/proc/mobject/builderfacade.hpp b/src/proc/mobject/builderfacade.hpp
index 86520d483..31ab936ab 100644
--- a/src/proc/mobject/builderfacade.hpp
+++ b/src/proc/mobject/builderfacade.hpp
@@ -31,6 +31,7 @@
 
 namespace mobject {
   
+  LUMIERA_ERROR_DECLARE (BUILDER_LIFECYCLE);  ///< Builder activated while in non operational state
   
   /**
    * Provides unified access to the builder functionality.
diff --git a/tests/components/proc/mobject/builder/model-port-registry-test.cpp b/tests/components/proc/mobject/builder/model-port-registry-test.cpp
index 2c57df4b9..3e948c6c9 100644
--- a/tests/components/proc/mobject/builder/model-port-registry-test.cpp
+++ b/tests/components/proc/mobject/builder/model-port-registry-test.cpp
@@ -74,7 +74,7 @@ namespace test  {
     struct TestContext
       {
         ModelPortRegistry registry_;
-        ModelPortRegistry& previous_;
+        ModelPortRegistry* previous_;
         
         /** setup */
         TestContext()
@@ -85,7 +85,10 @@ namespace test  {
         /** tear-down */
        ~TestContext()
           {
-            ModelPortRegistry::setActiveInstance (previous_);
+            if (previous_)
+              ModelPortRegistry::setActiveInstance (*previous_);
+            else
+              ModelPortRegistry::shutdown();
           }
       };
     
@@ -136,10 +139,10 @@ namespace test  {
           VERIFY_ERROR (DUPLICATE_MODEL_PORT, registry.definePort(pipeB, someTimeline) );
           CHECK (registry.contains (pipeB));
           
-          CHECK (p1.id == pipeA);
-          CHECK (p2.id == pipeB);
-          CHECK (p1.holder == someTimeline);
-          CHECK (p2.holder == someTimeline);
+          CHECK (pipeA        == p1.id());
+          CHECK (pipeB        == p2.id());
+          CHECK (someTimeline == p1.holder());
+          CHECK (someTimeline == p2.holder());
           
           registry.commit();
         }
@@ -205,7 +208,7 @@ namespace test  {
           TID anotherTimeline = getTimeline ("another_test_Timeline");
           MPDescriptor p1 = registry.definePort (pipeA, anotherTimeline);
           CHECK (registry.contains (pipeA));
-          CHECK (p1.holder == anotherTimeline);
+          CHECK (anotherTimeline == p1.holder());
           CHECK (ModelPort(pipeA).holder() != anotherTimeline);
           
           registry.remove (pipeB);

From 8a54e00b6bf1a6bce9506549847203a3d914c700 Mon Sep 17 00:00:00 2001
From: Ichthyostega 
Date: Sat, 11 Dec 2010 23:40:12 +0100
Subject: [PATCH 17/28] ModelPort registry unit test pass (closes #727)

---
 .../mobject/builder/model-port-registry.cpp   | 56 ++++++--------
 .../mobject/builder/model-port-registry.hpp   | 17 ++--
 src/proc/mobject/model-port.hpp               | 26 +++----
 .../mobject/session/sess-manager-impl.cpp     |  1 +
 tests/44builder.tests                         |  2 +-
 .../builder/model-port-registry-test.cpp      | 77 +++++++++++--------
 wiki/renderengine.html                        | 10 +--
 7 files changed, 92 insertions(+), 97 deletions(-)

diff --git a/src/proc/mobject/builder/model-port-registry.cpp b/src/proc/mobject/builder/model-port-registry.cpp
index 86a444a70..f674fd912 100644
--- a/src/proc/mobject/builder/model-port-registry.cpp
+++ b/src/proc/mobject/builder/model-port-registry.cpp
@@ -21,13 +21,13 @@
 * *****************************************************/
 
 
-/** @file model-port-registry.cpp 
+/** @file model-port-registry.cpp
  ** Implementation details of model port descriptors and references.
- ** Especially, the handling of the ModelPortTable datastructure is
+ ** Essentially the handling of the ModelPortRegistry datastructure is
  ** kept an opaque implementation detail and confined entirely within
- ** this translation unit.
- ** 
- ** TODO: comment necessary?
+ ** this translation unit. Both the client interface (ModelPort) and
+ ** the management interface (ModelPortRegistry) are backed by this
+ ** common translation unit.
  ** 
  ** @see OutputDesignation
  ** @see OutputMapping
@@ -39,22 +39,10 @@
 #include "lib/error.hpp"
 #include "include/logging.h"
 #include "lib/sync-classlock.hpp"
-//#include "lib/symbol.hpp"//
 #include "proc/mobject/builderfacade.hpp"
 #include "proc/mobject/model-port.hpp"
 #include "proc/mobject/builder/model-port-registry.hpp"
 
-//#include 
-//#include 
-#include 
-
-//using lumiera::query::QueryHandler;
-//using lumiera::query::removeTerm;
-//using lumiera::query::extractID;
-//using lumiera::ConfigRules;
-
-//using lumiera::Symbol;
-
 namespace mobject {
   namespace builder {
     
@@ -65,8 +53,8 @@ namespace mobject {
     typedef lib::ClassLock LockRegistry;
     
     
-    /** storage for the link to the 
-        global Registry instance currently in charge  */
+    /** storage for the link to the global
+        Registry instance currently in charge  */
     lib::OptionalRef ModelPortRegistry::theGlobalRegistry;
     
     
@@ -82,18 +70,19 @@ namespace mobject {
     
     
     /** switch the implicit link to \em the global ModelPort registry
-     *  to point to the given implementation instance. Typically used within
-     *  the Builder subsystem lifecycle methods, or for unit tests to use
-     *  a test instance of the registry temporarily
+     *  to point to the given implementation instance. Typically used
+     *  within the Builder subsystem lifecycle methods, or for
+     *  temporarily exchanging the registry for unit tests
      * @return the registry instance previously in use or \c NULL
      */
     ModelPortRegistry*
     ModelPortRegistry::setActiveInstance (ModelPortRegistry& newRegistry)
     {
-      INFO (builder, "activating new ModelPort registry.");
       LockRegistry global_lock;
       ModelPortRegistry *previous = theGlobalRegistry.isValid()? 
-                                       &(theGlobalRegistry()) : 0; 
+                                      &( theGlobalRegistry()) : 0;
+      INFO_IF (!previous, builder, "activating new ModelPort registry.");
+      WARN_IF ( previous, builder, "switching ModelPort registry instance.");
       theGlobalRegistry.link_to (newRegistry);
       return previous;
     }
@@ -112,7 +101,7 @@ namespace mobject {
       throw error::State ("global model port registry is not accessible"
                          , LUMIERA_ERROR_BUILDER_LIFECYCLE); 
     }
-   
+    
     
     
     /** does the transaction currently being built
@@ -128,8 +117,8 @@ namespace mobject {
     
     
     /** @return true if the given pipe-ID actually denotes an
-     *          existing, connected and usable model port. 
-     *  @note reflects the state of the publicly visible 
+     *          existing, connected and usable model port.
+     *  @note reflects the state of the publicly visible
      *          model port registry, \em not any model ports
      *          being registered within a pending transaction
      *          (ongoing build process). */
@@ -240,22 +229,22 @@ namespace mobject {
     {
       LockRegistry global_lock;
       TRACE (builder, "discarding changes to ModelPort list (rollback)....");
-      MPTable newTransaction(transaction_);
+      MPTable newTransaction(currentReg_);
       swap (transaction_, newTransaction);
     }
-  
+    
     
     
     LUMIERA_ERROR_DEFINE (DUPLICATE_MODEL_PORT, "Attempt to define a new model port with an pipe-ID already denoting an existing port");
-  
-  } // namespace builder  
+    
+  }// namespace builder  
   
   
   
   
   LUMIERA_ERROR_DEFINE (INVALID_MODEL_PORT, "Referral to unknown model port");
   LUMIERA_ERROR_DEFINE (UNCONNECTED_MODEL_PORT, "Attempt to operate on an existing but unconnected model port");
-
+  
   
   ModelPort::ModelPort (ID refID)
     : id_(refID)
@@ -307,8 +296,7 @@ namespace mobject {
   {
     return this->id_.streamType();
   }
-
-
+  
   
   
 } // namespace mobject
diff --git a/src/proc/mobject/builder/model-port-registry.hpp b/src/proc/mobject/builder/model-port-registry.hpp
index e0c79e77f..be69cac8b 100644
--- a/src/proc/mobject/builder/model-port-registry.hpp
+++ b/src/proc/mobject/builder/model-port-registry.hpp
@@ -57,19 +57,11 @@
 
 #include 
 
-//#include "lib/opaque-holder.hpp"
-//#include "lib/meta/typelist-util.hpp"
-
-//extern "C" {
-//#include "lib/luid.h"
-//}
-
 namespace mobject {
 namespace builder {
   
   using asset::ID;
   using asset::Pipe;
-//using asset::PPipe;
   using asset::Struct;
   
   LUMIERA_ERROR_DECLARE (DUPLICATE_MODEL_PORT); ///< Attempt to define a new model port with an pipe-ID already denoting an existing port
@@ -92,18 +84,19 @@ namespace builder {
       typedef ID StID;
       
     public:
+      
       /** @internal record to describe a model port */
       struct ModelPortDescriptor;
       
       
       static void shutdown ();
-
+      
       static ModelPortRegistry*
       setActiveInstance (ModelPortRegistry& newRegistry);
       
       static ModelPortRegistry&
       globalInstance();
-
+      
       static ModelPortDescriptor const&
       accessDescriptor (PID); 
       
@@ -134,6 +127,7 @@ namespace builder {
        */
       void rollback();
       
+      
     private:
       static lib::OptionalRef theGlobalRegistry;
       
@@ -145,6 +139,7 @@ namespace builder {
   
   
   
+  
   /** ModelPortDescriptor records are used as actual storage
    *  within the model port registration table; they are immutable
    *  value objects and never exposed to client code directly.
@@ -179,7 +174,7 @@ namespace builder {
       const PID  id()      const { return id_; }
       const StID holder()  const { return holder_; }
     };
-
+  
   
   
 }} // namespace mobject::builder
diff --git a/src/proc/mobject/model-port.hpp b/src/proc/mobject/model-port.hpp
index cf98bc149..7b033218b 100644
--- a/src/proc/mobject/model-port.hpp
+++ b/src/proc/mobject/model-port.hpp
@@ -24,7 +24,7 @@
  ** Organising the output data calculation possibilities.
  ** Model ports are conceptual entities, denoting the points where output might
  ** possibly be produced. There is an actual representation, a collection of small
- ** descriptor objects managed by the Fixture and organised within the ModelPortTable
+ ** descriptor objects managed by the Fixture and organised within the registry
  ** datastructure. Thus, while the actual ModelPort descriptor entities are located
  ** within and managed by the Fixture -- model port as a concept spans the high-level
  ** and low-level view. A model port can be associated both to a pipe within a timeline
@@ -44,16 +44,16 @@
  ** to become the valid current model port configuration. After that switch, model ports
  ** are immutable.
  ** 
- ** Model ports are to be accessed, enumerated and grouped in various ways, because each
- ** port belongs to a specific timeline and is used for producing data of a single
+ ** Model ports are to be accessed, enumerated and grouped in various ways, because
+ ** each port belongs to a specific timeline and is used to produce data of a single
  ** StreamType solely. But all those referrals, searching and grouping happens only
  ** after the build process has discovered all model ports currently available.
  ** Thus actually the ModelPort elements handed out to client code are just
  ** smart-handles, accessing a global ModelPortRegistry behind the scenes.
  ** Validity of these handles will be checked on each access. The actual
  ** model port descriptors are owned and managed by the fixture;
- ** they are bulk allocated in a similar manner than the
- ** ProcNode and WiringDescriptor objects.
+ ** @todo they might bulk allocated in a similar manner than the
+ **       ProcNode and WiringDescriptor objects are.
  ** 
  ** @see ModelPortRegistry_test abstract usage example
  ** @see ModelPortRegistry management interface 
@@ -72,8 +72,8 @@
 
 namespace mobject {
   
-  LUMIERA_ERROR_DECLARE (INVALID_MODEL_PORT);      ///< Referral to unknown model port
-  LUMIERA_ERROR_DECLARE (UNCONNECTED_MODEL_PORT);  ///< Attempt to operate on an existing but unconnected model port
+  LUMIERA_ERROR_DECLARE (INVALID_MODEL_PORT);     ///< Referral to unknown model port
+  LUMIERA_ERROR_DECLARE (UNCONNECTED_MODEL_PORT); ///< Attempt to operate on an existing but unconnected model port
   
   
   using asset::ID;
@@ -81,21 +81,21 @@ namespace mobject {
   
   
   /**
-   * Handle denoting a port within the model,
+   * Handle denoting a point within the model,
    * where actually output data can be pulled.
    * ModelPort is a frontend to be used by clients.
    * These ModelPort handle objects may be copied and stored
-   * at will, but their validity will be verified on each access. 
+   * at will, but their validity will be verified on each access.
    * Actually, the Builder will discover any model ports and
    * maintain a ModelPortRegistry behind the scenes.
    * 
    * Each model port corresponds to a (global) pipe within a
-   * specific Timeline; consequently each such port is also
+   * specific Timeline ("holder"); consequently each such port is also
    * bound to produce data of a specific StreamType (as defined by
    * the corresponding pipe). A model port may be in \em unconnected
-   * state, which can be checked by \c bool conversion. While the
-   * ModelPort handles are value objects, the identity of the
-   * underlying model port (descriptor) is given by the 
+   * state, which can be checked through \c bool conversion. While
+   * the ModelPort handles are value objects, the identity of the
+   * underlying model port (descriptor) is given by the
    * corresponding pipe-ID, thus effectively resulting
    * in a global namespace for model ports.
    * 
diff --git a/src/proc/mobject/session/sess-manager-impl.cpp b/src/proc/mobject/session/sess-manager-impl.cpp
index 51696928f..c3294d891 100644
--- a/src/proc/mobject/session/sess-manager-impl.cpp
+++ b/src/proc/mobject/session/sess-manager-impl.cpp
@@ -152,6 +152,7 @@ namespace session {
         closeSessionInterface()
           {                                             /////////////////////// TICKET #699
             INFO (session, "closing session interfaces.");
+            TODO ("actually close session interfaces :) and don't babble in the log when NOT closing anything...");
           }
         
         
diff --git a/tests/44builder.tests b/tests/44builder.tests
index 5df8ef0a4..f54364132 100644
--- a/tests/44builder.tests
+++ b/tests/44builder.tests
@@ -15,7 +15,7 @@ PLANNED "BuildSegment_test" BuildSegment_test <
-//#include 
-#include 
-
 
 namespace mobject {
 namespace builder {
 namespace test  {
   
-  //using boost::format;
-  //using boost::scoped_ptr;
   using util::isSameObject;
   using util::isnil;
-  using std::string;
   
   using asset::Pipe;
   using asset::PPipe;
@@ -53,6 +46,8 @@ namespace test  {
   
   typedef asset::ID PID;
   typedef asset::ID TID;
+    
+  typedef ModelPortRegistry::ModelPortDescriptor const& MPDescriptor;
   
   
   namespace { // test environment
@@ -69,8 +64,6 @@ namespace test  {
       return asset::Struct::retrieve (Query ("id("+id+")"))->getID();
     }
     
-    typedef ModelPortRegistry::ModelPortDescriptor const& MPDescriptor;
-    
     struct TestContext
       {
         ModelPortRegistry registry_;
@@ -91,14 +84,15 @@ namespace test  {
               ModelPortRegistry::shutdown();
           }
       };
-    
   }
   
   
+  
+  
   /*********************************************************************************
    * @test create a standalone model port registry to verify the behaviour of
-   *       model ports, accessed through reference handles. This test provides
-   *       an example setup detached from the real usage situation within the builder.
+   *       model ports, accessed through reference handles. This test provides an
+   *       example setup detached from the real usage situation within the builder.
    *       The ModelPortRegistry management interface is used to create and track a
    *       set of model ports, to be made visible by an atomic, transactional switch.
    *       The access for client code through the ModelPort frontend is then verified.
@@ -126,7 +120,6 @@ namespace test  {
           /* == some Assets to play with == */
           PID pipeA        = getPipe ("pipeA");
           PID pipeB        = getPipe ("pipeB");
-          PID pipeWC       = getPipe ("WCpipe");
           TID someTimeline = getTimeline ("some_test_Timeline");
           
           // start out with defining some new model ports......
@@ -158,17 +151,18 @@ namespace test  {
           ModelPort mp1(pipeA);
           ModelPort mp2(pipeB);
           
-          VERIFY_ERROR (INVALID_MODEL_PORT, ModelPort(pipeWC));
+          VERIFY_ERROR (INVALID_MODEL_PORT, ModelPort unbefitting(pipeWC) );
           
-          ModelPort mp1x(pipeA);
-          ModelPort mpNull;
+          ModelPort mp1x(pipeA);                 // can be created multiple times
+          ModelPort mp2x(mp1x);                  // can be copied at will
+          ModelPort mpNull;                      // can be default constructed (->unconnected)
           
           CHECK (mp1);
           CHECK (mp2);
           CHECK (mp1x);
-          CHECK (!mpNull);
+          CHECK (!mpNull);                       // bool check verifies setup and connected state
           
-          CHECK ( ModelPort::exists (pipeA));
+          CHECK ( ModelPort::exists (pipeA));    // this is the same check, but invoked just with an pipe-ID
           CHECK ( ModelPort::exists (pipeB));
           CHECK (!ModelPort::exists (pipeWC));
           
@@ -182,7 +176,8 @@ namespace test  {
           CHECK (mp1.pipe() == pipeA);
           CHECK (mp2.pipe() == pipeB);
           CHECK (mp1x.pipe() == pipeA);
-          VERIFY_ERROR (UNCONNECTED_MODEL_PORT, mpNull.pipe());
+          VERIFY_ERROR (UNCONNECTED_MODEL_PORT, mpNull.pipe()); // any further operations on an unconnected port will throw
+          VERIFY_ERROR (UNCONNECTED_MODEL_PORT, mpNull.holder());
           
           CHECK (mp1.streamType() == pipeA.streamType());
         }
@@ -201,8 +196,8 @@ namespace test  {
           CHECK (ModelPort::exists (pipeA));
           CHECK (registry.contains (pipeA));
           registry.remove (pipeA);
-          CHECK ( ModelPort::exists (pipeA));
-          CHECK (!registry.contains (pipeA));
+          CHECK (!registry.contains (pipeA));    // removed from the current (pending) transaction
+          CHECK ( ModelPort::exists (pipeA));    // but not yet publicly visible
           
           // now create a new and differing definition of port A 
           TID anotherTimeline = getTimeline ("another_test_Timeline");
@@ -211,16 +206,18 @@ namespace test  {
           CHECK (anotherTimeline == p1.holder());
           CHECK (ModelPort(pipeA).holder() != anotherTimeline);
           
-          registry.remove (pipeB);
-          registry.definePort (pipeWC,anotherTimeline);
+          registry.remove (pipeB);               // some more wired definitions 
+          registry.definePort (pipeWC, anotherTimeline);
           CHECK (!registry.contains (pipeB));
           CHECK ( registry.contains (pipeWC));
           CHECK ( ModelPort::exists (pipeB));
           CHECK (!ModelPort::exists (pipeWC));
-
-          ModelPort portA(pipeA);
+          CHECK ( registry.isRegistered (pipeB));   // this is the same as ModelPort::exists
+          CHECK (!registry.isRegistered (pipeWC)); // 
+                                                  //  Note: pending transaction not yet committed
+          ModelPort portA(pipeA);                // ...... thus the changes aren't reflected to client code
           ModelPort portB(pipeB);
-          VERIFY_ERROR (INVALID_MODEL_PORT, ModelPort(pipeWC));
+          VERIFY_ERROR (INVALID_MODEL_PORT, ModelPort ineptly(pipeWC));
           CHECK (portA);
           CHECK (portB);
           CHECK (portA.pipe() == pipeA);
@@ -228,30 +225,44 @@ namespace test  {
           CHECK (portA.holder() != anotherTimeline);
           
           registry.commit();
-          CHECK ( ModelPort::exists (pipeA));
+          CHECK ( ModelPort::exists (pipeA));    // now all our changes got publicly visible
           CHECK (!ModelPort::exists (pipeB));
           CHECK ( ModelPort::exists (pipeWC));
           CHECK ( portA);
           CHECK (!portB);
           CHECK (portA.holder() == anotherTimeline);
           CHECK (portA.pipe() == pipeA);
-          VERIFY_ERROR (UNCONNECTED_MODEL_PORT, portB.pipe());
+          VERIFY_ERROR (INVALID_MODEL_PORT, portB.pipe());
           
-          ModelPort pwc(pipeWC);
+          ModelPort pwc(pipeWC);                 // now clients may also use the now officially promoted new port
           CHECK (pwc);
           CHECK (pwc.pipe() == pipeWC);
           CHECK (pwc.holder() == anotherTimeline);
           
+          // Next: doing several changes,
+          //       but finally *not* committing them...
+          CHECK ( registry.contains (pipeA));
+          CHECK (!registry.contains (pipeB));
+          CHECK ( registry.contains (pipeWC));
           registry.remove (pipeA);
-          registry.clear();
+          registry.clear();                      // remove everything from the pending transaction
           CHECK (!registry.contains (pipeA));
           CHECK (!registry.contains (pipeB));
           CHECK (!registry.contains (pipeWC));
           
-          registry.rollback();
-          CHECK ( registry.contains (pipeA));
+          registry.definePort (pipeB, anotherTimeline);
           CHECK ( registry.contains (pipeB));
+          CHECK (!portB);                        // not committed and thus not visible
+          CHECK (portA);
+          CHECK (pwc);
+          
+          registry.rollback();
+          CHECK ( registry.contains (pipeA));    // no effect to the officialy visible state
+          CHECK (!registry.contains (pipeB));
           CHECK ( registry.contains (pipeWC));
+          
+          VERIFY_ERROR(INVALID_MODEL_PORT, registry.get(pipeB) );
+          CHECK (!portB);
         }
     };
   
diff --git a/wiki/renderengine.html b/wiki/renderengine.html
index 09e2a5006..6d8c87fce 100644
--- a/wiki/renderengine.html
+++ b/wiki/renderengine.html
@@ -2819,7 +2819,7 @@ These are used as token for dealing with other objects and have no identity of t
-
+
Any point where output possibly might be produced. Model port entities are located within the [[Fixture]] &mdash; model port as a concept spans the high-level and low-level view. A model port can be associated both to a pipe in the HighLevelModel but at the same time denotes a set of corresponding [[exit nodes|ExitNode]] within the [[segments|Segmentation]] of the render nodes network.
 
 A model port is rather derived than configured; it emerges when a pipe [[claims|WiringClaim]] an output destination and some other entity actually uses this designation as a target, either directly or indirectly. This match of provision and usage is detected during the build process and produces an entry in the fixture's model port table. These model ports in the fixture are keyed by ~Pipe-ID, thus each model port has an associated StreamType.
@@ -2827,13 +2827,13 @@ A model port is rather derived than configured; it emerges when a pipe [[claims|
 Model ports are the effective, resulting outputs of each timeline; additional ports result from [[connecting a viewer|ViewerPlayConnection]]. Any render or display process happens at a model port.
 
 !formal specification
-Model port is a //conceptual entity,// denoting the possibility to pull generated data of a distinct (stream)type from a specific bus within the model -- any possible output produced or provided by Lumiera is bound to appear at a model port. The namespace of model ports is global, each being denoted by a ~Pipe-ID.
+Model port is a //conceptual entity,// denoting the possibility to pull generated data of a distinct (stream)type from a specific bus within the model -- any possible output produced or provided by Lumiera is bound to appear at a model port. The namespace of model ports is global, each being associated with a ~Pipe-ID.
 
-Model ports are represented by small non-copyable descriptor objects with distinct identity, which are owned and managed by the [[Fixture]]. Clients are bound to resolve a model port on each usage, as configuration changes within the model might cause ports to appear and decease. Each model port belongs to a specific Timeline and is aware of this association, as is the timeline, allowing to get the collection of all ports of a given timeline. Besides, within the Fixture each model port refers to a specific [[segmentation of the time axis|Segmentation]] (relevant for this special timeline actually). Thus, with the help of this segmentation, a model port can yield an ExitNode to pull frames for a given time.
+Model ports are represented by small non-copyable descriptor objects with distinct identity, which are owned and managed by the [[Fixture]]. Clients are bound to resolve a model port on each usage, as configuration changes within the model might cause ports to appear and decease. To stress this usage pattern, actually {{{ModelPort}}} instances are small copyable value objects (smart handles), which can be used to access data within an opaque registry. Each model port belongs to a specific Timeline and is aware of this association, as is the timeline, allowing to get the collection of all ports of a given timeline. Besides, within the Fixture each model port refers to a specific [[segmentation of the time axis|Segmentation]] (relevant for this special timeline actually). Thus, with the help of this segmentation, a model port can yield an ExitNode to pull frames for a given time.
-
+
Model ports are conceptual entities, denoting the points where output might possibly be produced &rarr; see [[definition|ModelPort]].
 But there is an actual representation, a collection of small descriptor objects managed by the Fixture and organised within the model port table datastructure. Because model ports are discovered during the build process, we need the ability to (re)build this table dynamically, finally swapping in the modified configuration with a transactional switch. Only the builder is allowed to perform such mutations, while for client code model ports are immutable.
 
@@ -2851,7 +2851,7 @@ Model ports are added once and never changed. The corresponding timeline and pip
 !Implementation considerations
 The transactional switch creates a clear partitioning in the lifespan of the model port table. //Before// that point, entries are just added, but not accessed in any way. //After// that point, no further mutation occurs, but lookup is frequent and happens in a variety of different configurations and transient orderings.
 
-This observation leads to the idea of using //model port references// to provide all kinds of access, searching and reordering. These encapsulate the actual access by silently assuming reference to "the" global current model port configuration. Thus, the actual model port descriptors could be bulk allocated in a similar manner as the processing nodes and wiring descriptors. Access to stale model ports could be detected by the port references, allowing also for a {{{bool}}} checkable "has no port" information.
+This observation leads to the idea of using //model port references// as frontend to provide all kinds of access, searching and reordering. These encapsulate the actual access by silently assuming reference to "the" global current model port configuration. This way the actual model port descriptors could be bulk allocated in a similar manner as the processing nodes and wiring descriptors. Access to stale model ports could be detected by the port references, allowing also for a {{{bool}}} checkable "has no port" information.
 
 A model port registry, maintained by the builder, is responsible for storing the discovered model ports within a model port table, which is then swapped in after completing the build process. The {{{builder::ModelPortRegistry}}} acts as management interface, while client code accesses just the {{{ModelPort}}} frontend. A link to the actual registry instance is hooked into that frontend when bringing up the builder subsystem.
From c4282560ce03679f96c79e5f9f373a0feb69c4e6 Mon Sep 17 00:00:00 2001 From: Ichthyostega Date: Sun, 12 Dec 2010 01:53:23 +0100 Subject: [PATCH 18/28] fix two regressions --- src/proc/asset/struct-scheme.hpp | 9 +++++++++ src/proc/control/styperegistry.hpp | 4 ++-- tests/components/proc/mobject/output-mapping-test.cpp | 2 +- tests/lib/scoped-holder-transfer-test.cpp | 1 + 4 files changed, 13 insertions(+), 3 deletions(-) diff --git a/src/proc/asset/struct-scheme.hpp b/src/proc/asset/struct-scheme.hpp index c8e0d09a4..dd6f6f512 100644 --- a/src/proc/asset/struct-scheme.hpp +++ b/src/proc/asset/struct-scheme.hpp @@ -52,6 +52,9 @@ namespace session { class Clip; }} +namespace lumiera { + class StreamType; +} namespace asset{ @@ -104,6 +107,12 @@ namespace asset{ static Symbol catFolder() { return "pipes";} static Symbol idSymbol() { return "pipe"; } }; + template<> struct StructTraits + { + static Symbol namePrefix() { return "type"; } + static Symbol catFolder() { return "stream-types";} + static Symbol idSymbol() { return "stype"; } + }; template<> struct StructTraits { static Symbol namePrefix() { return "patt"; } diff --git a/src/proc/control/styperegistry.hpp b/src/proc/control/styperegistry.hpp index 5979582d2..63c33e841 100644 --- a/src/proc/control/styperegistry.hpp +++ b/src/proc/control/styperegistry.hpp @@ -23,7 +23,7 @@ /** @file styperegistry.hpp ** This is part of the \i implementation of the stream type manager (include). - ** Only used in stypemanager.cpp and accompaning unit tests. + ** Only used in stypemanager.cpp and accompanying unit tests. ** ** @see control::STypeManager ** @see lumiera::StreamType @@ -62,7 +62,7 @@ namespace control { /** - * @internal Helper for organizing preconfigured default objects. + * @internal Helper for organising preconfigured default objects. * Maintaines a collection of objects known or encountered as "default" * for a given type. This collection is ordered by "degree of constriction", * which is implemented by counting the number of predicates in the query diff --git a/tests/components/proc/mobject/output-mapping-test.cpp b/tests/components/proc/mobject/output-mapping-test.cpp index 5f4a5be1a..18dd9eb60 100644 --- a/tests/components/proc/mobject/output-mapping-test.cpp +++ b/tests/components/proc/mobject/output-mapping-test.cpp @@ -76,7 +76,7 @@ namespace test { { PPipe srcP = Pipe::lookup (sourcePipeID); format queryPattern ("id(master_%1%), stream(%1%), ord(%2%)"); - return Query (str(queryPattern % srcP->getStreamID() % seqNr)); + return Query (str(queryPattern % srcP->getStreamID().getSym() % seqNr)); } }; diff --git a/tests/lib/scoped-holder-transfer-test.cpp b/tests/lib/scoped-holder-transfer-test.cpp index ace319736..7bd65a530 100644 --- a/tests/lib/scoped-holder-transfer-test.cpp +++ b/tests/lib/scoped-holder-transfer-test.cpp @@ -69,6 +69,7 @@ namespace lib { throw to.getVal(); swap (from,to); + from.setVal(0); // remove the old Dummy from accounting (checksum) } }; From e7191ed3c6d6e0466dd05d332d770bb7b03bacf2 Mon Sep 17 00:00:00 2001 From: Ichthyostega Date: Mon, 13 Dec 2010 03:22:11 +0100 Subject: [PATCH 19/28] Planning Fixure: Segmentation datastructure (#726) --- src/proc/Makefile.am | 6 +- .../builder/fixture-change-detector.hpp | 81 +++++++++++++ ...entationtool.cpp => segmentation-tool.cpp} | 96 ++++++++------- .../mobject/builder/segmentation-tool.hpp | 78 ++++++++++++ src/proc/mobject/builder/segmentation.cpp | 85 +++++++++++++ src/proc/mobject/builder/segmentation.hpp | 87 ++++++++++++++ src/proc/mobject/builder/segmentationtool.hpp | 80 ------------- src/proc/mobject/builder/toolfactory.hpp | 2 +- tests/44builder.tests | 10 ++ tests/components/Makefile.am | 2 + .../builder/fixture-change-detector-test.cpp | 113 ++++++++++++++++++ .../segmentation-datastructure-test.cpp | 113 ++++++++++++++++++ wiki/renderengine.html | 46 ++++++- 13 files changed, 665 insertions(+), 134 deletions(-) create mode 100644 src/proc/mobject/builder/fixture-change-detector.hpp rename src/proc/mobject/builder/{segmentationtool.cpp => segmentation-tool.cpp} (50%) create mode 100644 src/proc/mobject/builder/segmentation-tool.hpp create mode 100644 src/proc/mobject/builder/segmentation.cpp create mode 100644 src/proc/mobject/builder/segmentation.hpp delete mode 100644 src/proc/mobject/builder/segmentationtool.hpp create mode 100644 tests/components/proc/mobject/builder/fixture-change-detector-test.cpp create mode 100644 tests/components/proc/mobject/builder/segmentation-datastructure-test.cpp diff --git a/src/proc/Makefile.am b/src/proc/Makefile.am index d2a185dbf..d8e58f786 100644 --- a/src/proc/Makefile.am +++ b/src/proc/Makefile.am @@ -109,7 +109,8 @@ liblumiprocmobjectbuilder_la_SOURCES = \ $(liblumiprocmobjectbuilder_la_srcdir)/assembler.cpp \ $(liblumiprocmobjectbuilder_la_srcdir)/conmanager.cpp \ $(liblumiprocmobjectbuilder_la_srcdir)/nodecreatortool.cpp \ - $(liblumiprocmobjectbuilder_la_srcdir)/segmentationtool.cpp \ + $(liblumiprocmobjectbuilder_la_srcdir)/segmentation.cpp \ + $(liblumiprocmobjectbuilder_la_srcdir)/segmentation-tool.cpp \ $(liblumiprocmobjectbuilder_la_srcdir)/toolfactory.cpp @@ -219,7 +220,8 @@ noinst_HEADERS += \ $(liblumiproc_la_srcdir)/mobject/builder/assembler.hpp \ $(liblumiproc_la_srcdir)/mobject/builder/buildertool.hpp \ $(liblumiproc_la_srcdir)/mobject/builder/conmanager.hpp \ - $(liblumiproc_la_srcdir)/mobject/builder/segmentationtool.hpp \ + $(liblumiproc_la_srcdir)/mobject/builder/segmentation.hpp \ + $(liblumiproc_la_srcdir)/mobject/builder/segmentation-tool.hpp \ $(liblumiproc_la_srcdir)/mobject/builder/toolfactory.hpp \ $(liblumiproc_la_srcdir)/mobject/builderfacade.hpp \ $(liblumiproc_la_srcdir)/mobject/explicitplacement.hpp \ diff --git a/src/proc/mobject/builder/fixture-change-detector.hpp b/src/proc/mobject/builder/fixture-change-detector.hpp new file mode 100644 index 000000000..7d25225f3 --- /dev/null +++ b/src/proc/mobject/builder/fixture-change-detector.hpp @@ -0,0 +1,81 @@ +/* + FIXTURE-CHANGE-DETECTOR.hpp - isolating changed segments and tainted processes + + Copyright (C) Lumiera.org + 2010, Hermann Vosseler + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + +*/ + +/** @file fixture-change-detector.hpp + ** Work out the part of the Fixture changed by a build process. + ** This facility helps to deal with ongoing render/playback processes, which might be + ** affected by the results of a build process. It's comprised of two distinct parts: + ** - a comparison tool allowing to spot equal and changed segments when considering + ** the old and the new version of the fixture before/after a build process. + ** - a registration service to establish a relation between play/render processes + ** and specific segments of the fixture. + ** Together, these allow to identify those ongoing processes which need to be cancelled + ** or restarted, because their results might be tainted by the changes induced by the + ** build process. Typically, these detection process runs just before commiting the + ** newly built fixture datastructure. + ** + ** @todo WIP-WIP-WIP as of 12/2010 + ** + ** @see Fixture + ** @see ModelPort + */ + + +#ifndef PROC_MOBJECT_BUILDER_FIXTURE_CHANGE_DETECTOR_H +#define PROC_MOBJECT_BUILDER_FIXTURE_CHANGE_DETECTOR_H + +#include "lib/error.hpp" +//#include "lib/optional-ref.hpp" +#include "proc/asset/pipe.hpp" +//#include "proc/asset/struct.hpp" +//#include "proc/mobject/model-port.hpp" + +//#include + +namespace mobject { +namespace builder { + + using asset::ID; + using asset::Pipe; +//using asset::Struct; + +//LUMIERA_ERROR_DECLARE (DUPLICATE_MODEL_PORT); ///< Attempt to define a new model port with an pipe-ID already denoting an existing port + + + /** + * TODO type comment + */ + class FixtureChangeDetector + : boost::noncopyable + { + + typedef ID PID; +// typedef ID StID; + + public: + + }; + + + +}} // namespace mobject::builder +#endif diff --git a/src/proc/mobject/builder/segmentationtool.cpp b/src/proc/mobject/builder/segmentation-tool.cpp similarity index 50% rename from src/proc/mobject/builder/segmentationtool.cpp rename to src/proc/mobject/builder/segmentation-tool.cpp index d0a18595d..b87109d68 100644 --- a/src/proc/mobject/builder/segmentationtool.cpp +++ b/src/proc/mobject/builder/segmentation-tool.cpp @@ -21,7 +21,7 @@ * *****************************************************/ -#include "proc/mobject/builder/segmentationtool.hpp" +#include "proc/mobject/builder/segmentation-tool.hpp" using mobject::Buildable; @@ -30,52 +30,50 @@ using mobject::session::Effect; namespace mobject { - namespace builder { - - /////////////////////////////////TICKET #414 - +namespace builder { - SegmentationTool::SegmentationTool(mobject::session::Fixture&) - { - UNIMPLEMENTED ("create new SegmentationTool"); - } - - - void - SegmentationTool::treat (Buildable& something) - { - UNIMPLEMENTED ("??? when partitioning timeline"); - } - - - void - SegmentationTool::treat (Clip& clip) - { - UNIMPLEMENTED ("consider clip when partitioning timeline"); - } - - - void - SegmentationTool::treat (Effect& effect) - { - UNIMPLEMENTED ("note applied effect when partitioning timeline"); - } - - - void - SegmentationTool::onUnknown (Buildable& target) - { - UNIMPLEMENTED ("catch-all when partitioning timeline"); - } - - - bool - SegmentationTool::empty() const - { - UNIMPLEMENTED ("detect an empty segmentation"); - } - - - } // namespace mobject::builder - -} // namespace mobject + /////////////////////////////////TICKET #414 + + + SegmentationTool::SegmentationTool(mobject::session::Fixture&) + { + UNIMPLEMENTED ("create new SegmentationTool"); + } + + + void + SegmentationTool::treat (Buildable& something) + { + UNIMPLEMENTED ("??? when partitioning timeline"); + } + + + void + SegmentationTool::treat (Clip& clip) + { + UNIMPLEMENTED ("consider clip when partitioning timeline"); + } + + + void + SegmentationTool::treat (Effect& effect) + { + UNIMPLEMENTED ("note applied effect when partitioning timeline"); + } + + + void + SegmentationTool::onUnknown (Buildable& target) + { + UNIMPLEMENTED ("catch-all when partitioning timeline"); + } + + + bool + SegmentationTool::empty() const + { + UNIMPLEMENTED ("detect an empty segmentation"); + } + + +}} // namespace mobject::builder diff --git a/src/proc/mobject/builder/segmentation-tool.hpp b/src/proc/mobject/builder/segmentation-tool.hpp new file mode 100644 index 000000000..a40f4c8f9 --- /dev/null +++ b/src/proc/mobject/builder/segmentation-tool.hpp @@ -0,0 +1,78 @@ +/* + SEGMENTATION-TOOL.hpp - Tool for creating a partitioning of the current timeline + + Copyright (C) Lumiera.org + 2008, Hermann Vosseler + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + +*/ + + +#ifndef MOBJECT_BUILDER_SEGMENTATION_TOOL_H +#define MOBJECT_BUILDER_SEGMENTATION_TOOL_H + + +#include "proc/mobject/builder/applicable-builder-target-types.hpp" + +#include "proc/mobject/session/segmentation.hpp" +#include "proc/mobject/session/fixture.hpp" //////TODO really on the header?? + + +#include +using std::list; + + + +namespace mobject { +namespace builder { + + + /** + * Tool implementation for deriving a partitioning of the current + * timeline, such that each Segment has a constant configuration. + * "Constant" means here, that any remaining changes over time + * can be represented by automation solely, without the need + * to change the node connections. + */ + class SegmentationTool + : public ApplicableBuilderTargetTypes + { + + public: + SegmentationTool (session::Fixture &) ; + + void treat (mobject::session::Clip& clip) ; + void treat (mobject::session::Effect& effect) ; + + void treat (mobject::Buildable& something) ; + + void onUnknown (Buildable& target) ; /////////TODO why doesn't the treat(Buildable) function shadow this?? + + bool empty() const; + + private: + typedef mobject::session::Segment Segment; + + /** Partitioning of the Timeline to be created by this tool. */ + //session::Segmentation& segments_; + ///////////////////////////////////////////TODO: either put it inline, or use a scopend_ptr!!!!!!!!!! + + }; + + + +}} // namespace mobject::builder +#endif diff --git a/src/proc/mobject/builder/segmentation.cpp b/src/proc/mobject/builder/segmentation.cpp new file mode 100644 index 000000000..7231dfd0a --- /dev/null +++ b/src/proc/mobject/builder/segmentation.cpp @@ -0,0 +1,85 @@ +/* + Segmentation - partitioning the effective timeline + + Copyright (C) Lumiera.org + 2010, Hermann Vosseler + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + +* *****************************************************/ + + +/** @file segmentation.cpp + ** Implementation details of fixture data structures. + ** + ** /////TODO file comment necessary? + ** + ** @see mobject::session::Fixture + ** + */ + + +#include "lib/error.hpp" +//#include "include/logging.h" +//#include "lib/sync-classlock.hpp" +//#include "proc/mobject/builderfacade.hpp" +#include "proc/mobject/builder/segmentation.hpp" +#include "proc/mobject/builder/fixture-change-detector.hpp" + +namespace mobject { +namespace builder { + + namespace error = lumiera::error; + + +// typedef ModelPortRegistry::ModelPortDescriptor const& MPDescriptor; + + + /** storage for the link to the global + Registry instance currently in charge */ +// lib::OptionalRef ModelPortRegistry::theGlobalRegistry; + + + /** access the globally valid registry instance. + * @throw error::State if this global registry is + * already closed or not yet initialised. */ +//ModelPortRegistry& +//ModelPortRegistry::globalInstance() +//{ +// LockRegistry global_lock; +// if (theGlobalRegistry.isValid()) +// return theGlobalRegistry(); +// +// throw error::State ("global model port registry is not accessible" +// , LUMIERA_ERROR_BUILDER_LIFECYCLE); +//} + + + + /** */ +// bool +// ModelPortRegistry::contains (ID key) const +// { +// return bool(key) +// && util::contains (transaction_, key); +// } + + + +//LUMIERA_ERROR_DEFINE (DUPLICATE_MODEL_PORT, "Attempt to define a new model port with an pipe-ID already denoting an existing port"); + + + +}}// namespace mobject::builder diff --git a/src/proc/mobject/builder/segmentation.hpp b/src/proc/mobject/builder/segmentation.hpp new file mode 100644 index 000000000..c3c73249c --- /dev/null +++ b/src/proc/mobject/builder/segmentation.hpp @@ -0,0 +1,87 @@ +/* + SEGMENTATION.hpp - partitioning the effective timeline + + Copyright (C) Lumiera.org + 2010, Hermann Vosseler + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + +*/ + +/** @file segmentation.hpp + ** Part of the Fixture datastructure to manage time segments of constant structure. + ** The Fixture is result of the build process and separation between high-level and + ** low-level model. It's kind of an effective resulting timeline, and split into segments + ** of constant wiring structure: whenever the processing nodes need to be wired differently + ** for some timespan, we start a new segment of the timeline. This might be for the duration + ** of a clip, or just for the duration of a transition, when the pipes of both clips need to + ** be wired up in parallel. + ** + ** @see Fixture + ** @see ModelPort + */ + + +#ifndef PROC_MOBJECT_BUILDER_SEGMENTATION_H +#define PROC_MOBJECT_BUILDER_SEGMENTATION_H + +#include "lib/error.hpp" +//#include "lib/optional-ref.hpp" +#include "proc/asset/pipe.hpp" +//#include "proc/asset/struct.hpp" +//#include "proc/mobject/model-port.hpp" + +//#include + +namespace mobject { +namespace builder { + + using asset::ID; + using asset::Pipe; +//using asset::Struct; + +//LUMIERA_ERROR_DECLARE (DUPLICATE_MODEL_PORT); ///< Attempt to define a new model port with an pipe-ID already denoting an existing port + + + /** + * TODO type comment + */ + class Segment + : boost::noncopyable + { + + typedef ID PID; +// typedef ID StID; + + public: + + }; + + + + + /** + * TODO type comment + */ + class Segmentation + { + + public: + }; + + + +}} // namespace mobject::builder +#endif diff --git a/src/proc/mobject/builder/segmentationtool.hpp b/src/proc/mobject/builder/segmentationtool.hpp deleted file mode 100644 index 2b88f572a..000000000 --- a/src/proc/mobject/builder/segmentationtool.hpp +++ /dev/null @@ -1,80 +0,0 @@ -/* - SEGMENTATIONTOOL.hpp - Tool for creating a partitioning of the current timeline - - Copyright (C) Lumiera.org - 2008, Hermann Vosseler - - This program is free software; you can redistribute it and/or - modify it under the terms of the GNU General Public License as - published by the Free Software Foundation; either version 2 of the - License, or (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - -*/ - - -#ifndef MOBJECT_BUILDER_SEGMENTATIONTOOL_H -#define MOBJECT_BUILDER_SEGMENTATIONTOOL_H - - -#include "proc/mobject/builder/applicable-builder-target-types.hpp" - -#include "proc/mobject/session/segmentation.hpp" -#include "proc/mobject/session/fixture.hpp" //////TODO really on the header?? - - -#include -using std::list; - - - -namespace mobject { - namespace builder { - - - /** - * Tool implementation for deriving a partitioning of the current - * timeline, such that each Segment has a constant configuration. - * "Constant" means here, that any remaining changes over time - * can be represented by automation solely, without the need - * to change the node connections. - */ - class SegmentationTool - : public ApplicableBuilderTargetTypes - { - - public: - SegmentationTool (session::Fixture &) ; - - void treat (mobject::session::Clip& clip) ; - void treat (mobject::session::Effect& effect) ; - - void treat (mobject::Buildable& something) ; - - void onUnknown (Buildable& target) ; /////////TODO why doesn't the treat(Buildable) function shadow this?? - - bool empty() const; - - private: - typedef mobject::session::Segment Segment; - - /** Partitioning of the Timeline to be created by this tool. */ - //session::Segmentation& segments_; - ///////////////////////////////////////////TODO: either put it inline, or use a scopend_ptr!!!!!!!!!! - - }; - - - - } // namespace mobject::builder - -} // namespace mobject -#endif diff --git a/src/proc/mobject/builder/toolfactory.hpp b/src/proc/mobject/builder/toolfactory.hpp index b283bea60..e17687ad4 100644 --- a/src/proc/mobject/builder/toolfactory.hpp +++ b/src/proc/mobject/builder/toolfactory.hpp @@ -25,7 +25,7 @@ #define MOBJECT_BUILDER_TOOLFACTORY_H #include "proc/mobject/session/fixture.hpp" -#include "proc/mobject/builder/segmentationtool.hpp" +#include "proc/mobject/builder/segmentation-tool.hpp" #include "proc/mobject/builder/nodecreatortool.hpp" #include "proc/mobject/builder/mould.hpp" #include "proc/engine/rendergraph.hpp" diff --git a/tests/44builder.tests b/tests/44builder.tests index f54364132..c5d20d870 100644 --- a/tests/44builder.tests +++ b/tests/44builder.tests @@ -15,6 +15,11 @@ PLANNED "BuildSegment_test" BuildSegment_test < + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + +* *****************************************************/ + + +#include "lib/test/run.hpp" +#include "lib/test/test-helper.hpp" +#include "proc/mobject/builder/fixture-change-detector.hpp" +#include "proc/asset/timeline.hpp" +#include "proc/asset/pipe.hpp" +#include "lib/query.hpp" +#include "lib/util.hpp" + + +namespace mobject { +namespace builder { +namespace test { + +// using util::isSameObject; +// using util::isnil; +// + using asset::Pipe; + using asset::PPipe; + using asset::Struct; + using asset::Timeline; + using asset::PTimeline; + using lumiera::Query; +// + typedef asset::ID PID; + typedef asset::ID TID; +// +// typedef ModelPortRegistry::ModelPortDescriptor const& MPDescriptor; + + + namespace { // test environment + + inline PID + getPipe (string id) + { + return Pipe::query("id("+id+")"); + } + + inline TID + getTimeline (string id) + { + return asset::Struct::retrieve (Query ("id("+id+")"))->getID(); + } + + struct TestContext + { + + /** setup */ + TestContext() + { } + + /** tear-down */ + ~TestContext() + { + } + }; + } + + + + + /********************************************************************************* + * @test TODO blubb + * + * @see mobject::builder::FixtureChangeDetector + */ + class FixtureChangeDetector_test : public Test + { + + virtual void + run (Arg) + { + TestContext ctx; + } + + + void + fabricating_ModelPorts () + { + } + + + }; + + + /** Register this test class... */ + LAUNCHER (FixtureChangeDetector_test, "unit builder"); + + + +}}} // namespace mobject::builder::test diff --git a/tests/components/proc/mobject/builder/segmentation-datastructure-test.cpp b/tests/components/proc/mobject/builder/segmentation-datastructure-test.cpp new file mode 100644 index 000000000..ac6c66d30 --- /dev/null +++ b/tests/components/proc/mobject/builder/segmentation-datastructure-test.cpp @@ -0,0 +1,113 @@ +/* + SegmentationDatastructure(Test) - verify basic properties of the Segmentation + + Copyright (C) Lumiera.org + 2010, Hermann Vosseler + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + +* *****************************************************/ + + +#include "lib/test/run.hpp" +#include "lib/test/test-helper.hpp" +#include "proc/mobject/builder/fixture-change-detector.hpp" +#include "proc/asset/timeline.hpp" +#include "proc/asset/pipe.hpp" +#include "lib/query.hpp" +#include "lib/util.hpp" + + +namespace mobject { +namespace builder { +namespace test { + +// using util::isSameObject; +// using util::isnil; +// + using asset::Pipe; + using asset::PPipe; + using asset::Struct; + using asset::Timeline; + using asset::PTimeline; + using lumiera::Query; +// + typedef asset::ID PID; + typedef asset::ID TID; +// +// typedef ModelPortRegistry::ModelPortDescriptor const& MPDescriptor; + + + namespace { // test environment + + inline PID + getPipe (string id) + { + return Pipe::query("id("+id+")"); + } + + inline TID + getTimeline (string id) + { + return asset::Struct::retrieve (Query ("id("+id+")"))->getID(); + } + + struct TestContext + { + + /** setup */ + TestContext() + { } + + /** tear-down */ + ~TestContext() + { + } + }; + } + + + + + /********************************************************************************* + * @test TODO blubb + * + * @see mobject::builder::FixtureChangeDetector + */ + class SegmentationDatastructure_test : public Test + { + + virtual void + run (Arg) + { + TestContext ctx; + } + + + void + fabricating_ModelPorts () + { + } + + + }; + + + /** Register this test class... */ + LAUNCHER (SegmentationDatastructure_test, "unit builder"); + + + +}}} // namespace mobject::builder::test diff --git a/wiki/renderengine.html b/wiki/renderengine.html index 6d8c87fce..5837913f4 100644 --- a/wiki/renderengine.html +++ b/wiki/renderengine.html @@ -1728,8 +1728,12 @@ To make the intended use of the classes more clear, consider the following two e 
a special ProcNode which is used to pull the finished output of one Render Pipeline (Tree or Graph). This term is already used in the Cinelerra2 codebase. I am unsure at the moment if it is a distinct subclass or rahter a specially configured ProcNode (a general design rule tells us to err in favour of the latter if in doubt).
-
-
A special kind (subclass) of [[Placement]]. As such it is always linked to a //Subject//, i.e. a MObject. But contrary to the (standard) placements, which may exhibit all kinds of fancy dynamic and scope dependent behaviour, within an explicit placement all properties are resolved and materialised. While the (standard) placement may contain an arbitrary list of LocatingPin objects, the resolution into an explicit placement performs a kind of »orthogonalisation«: each remaining LocatingPin defines exactly one degree of freedom independent of all others. Most notably, the explicit placement always specifies a absolute time and [[output designation|OutputDesignation]] for for locating the Subject.
+

+
A special kind (subclass) of [[Placement]]. As such it is always linked to a //Subject//, i.e. a MObject. But contrary to the (standard) placements, which may exhibit all kinds of fancy dynamic and scope dependent behaviour, within an explicit placement all properties are resolved and materialised. While the (standard) placement may contain an arbitrary list of LocatingPin objects, the resolution into an explicit placement performs a kind of »orthogonalisation«: each remaining LocatingPin defines exactly one degree of freedom independent of all others. Most notably, the explicit placement always specifies a absolute time and [[output designation|OutputDesignation]] for for locating the Subject. Explicit placements are ''immutable''.
+
+!!Implementation considerations
+Explicit placements are just created and never mutated, but copying and storage might become a problem.
+It would thus be desirable to have a fixed-sized allocation, able to hold the placement body as well as the (fixed) locating pins inline.
 

 

 

@@ -4675,6 +4679,44 @@ We need to detect attaching and detaching of
 * root &harr; [[Track]]
+
+
//Segmentation of timeline// denotes a data structure and a step in the BuildProcess.
+When [[building the fixture|BuildFixture]], ~MObjects -- as handled by their Placements -- are grouped below each timeline using them; Placements are then to be resolved into [[explicit Placements|ExplicitPlacement]], resulting in a single well defined time interval for each object. This allows to cut this effective timeline into slices of constant wiring structure, which are represented through the ''Segmentation Datastructure'', a time axis with segments holding object placements and [[exit nodes|ExitNode]]. &nbsp;&rarr; see [[structure of the Fixture|Fixture]]
+* for each Timeline we get a Segmentation
+** which in turn is a list of non-overlapping segments
+*** each holding
+**** an ExplicitPlacement for each covered object
+**** an ExitNode for each ModelPort of the corresponding timeline
+
+!Storage considerations
+;(1) build process
+:&rarr; a tree walk yields the placements per timeline, which then get //resolved//
+:&rarr; after //sorting,// the segmentation can be established, thereby copying placements spanning multiple segments
+:&rarr; only //after running the complete build process for each segment,// the list of model ports and exit nodes can be established
+;(2) commit stage
+: -- after the build process(es) are completed, the new fixture gets ''committed'', thus becoming the officially valid state to be rendered. As render processes might be going on in parallel, some kind of locking or barrier is required. It seems advisable to make the change into a single atomic hot-swap. Meaning we'd get a single access point to be protected. But there is another twist: We need to find out which render processes to cancel an restart, to pick up the changes introduced by this build process, which might include adding and deleting of timelines as a whole, and any changes to the segmentation grid. Because of the highly dynamic nature of the placements, on the other hand it isn't viable to expect the high-level model to provide this information. Thus we need to find out about a ''change coverage'' at this point. We might expand on that idea to //prune any new segments which aren't changed.// This way, only a write barrier would be necessary on switching the actually changed segments, and any render processes touching these would be //tainted.// Old allocations could be released after all tainted processes are known to be terminated.
+;(3) rendering use
+:Each play/render process employs a ''frame dispatch step'' to get the right exit node for pulling a given frame. From there on, the process proceeds into the [[processing nodes|ProcNodes]], interleaved with backend/scheduler actions due to splitting into individually scheduled jobs. The storage of these processing nodes and accompanying wiring descriptors is hooked up behind the individual segments, by sharing a common {{{AllocationCluster}}}. Yet the calculation of individual frames also depends on ''parameters'' and especially ''automation'' connected with objects in the high-level model. It is likely that there might be some sharing, as the intention was to allow ''live changes'' to automated values. <br/>{{red{WIP 12/2010}}} details need to be worked out. &rarr; [[parameter wiring concept|Wiring]]
+!!!observations
+* Storage and initialisation for explicit placements is an issue. We should strive at making that inline as much as possible.
+* the overall segmentation emerges from a sorting of time points, which are start points of explicit placements
+* after the segmentation has been built, the usage pattern changes entirely into a lookup of segment by time
+* the individual segments act as umbrella for a lot of further objects hooked up behind.
+* we need the ability to exchange or swap-in whole segments
+* each segment controls an AllocationCluster
+* we need to track processes for tainting
+* access happens per ModelPort
+
+!!!conclusions
+The Fixture is mostly comprised of the Segementation datastructure, but some other facilities are involved too
+# at top level, we need somehow to organise access per groups of model ports, actually grouped by timeline
+# during the build process, there is a collection of placements; this can be discarded afterwards
+# the backbone of the segmentation is closely linked to an ordering by time. Initially it should support sorting, access by time interval search later on.
+# discarding a segment (or failing to do so) has an high impact on the whole application. We should employ a reliable mechanism for that.
+# the frame dispatch and the tracking of processes can be combined; data duplication is a virtue when it comes to parallel processes
+# the process of comparing and tainting is broken out into a separate data structure to be used just once
+
+
A sequence is a collection of media objects, arranged onto a track tree. Sequences are the building blocks within the session. To be visible and editable, a session needs to be bound into a top-level [[Timeline]]. Alternatively, it may be used as a VirtualClip nested within another sequence.
 

From 1ce29b7d3c2fc76f3a791e56ea2df774d7fdaa24 Mon Sep 17 00:00:00 2001
From: Ichthyostega 
Date: Mon, 13 Dec 2010 04:46:05 +0100
Subject: [PATCH 20/28] minor tweaks to the RfC system

- add 'asciidoc' operation to rfc.sh
- put 'pro', 'con' and 'alternatives' in a common section 'Discussion'
---
 admin/rfc.sh         | 11 +++++++++--
 doc/template/rfc.txt | 14 +++++++++-----
 2 files changed, 18 insertions(+), 7 deletions(-)

diff --git a/admin/rfc.sh b/admin/rfc.sh
index f360b7393..24f720d26 100755
--- a/admin/rfc.sh
+++ b/admin/rfc.sh
@@ -4,7 +4,7 @@ shopt -s extglob
 
 function usage()
 {
-    less -F <<"EOF"
+    less <<"EOF"
 Script to maintain Lumiera RFC's
 
 usage:
@@ -22,6 +22,7 @@ commands (with  and [optional] parameters):
  show  [regex]    - Read RFC's (matching 'regex')
  create          - Create a new RFC
  edit <rfc> [chapter]   - Edit RFC at chapter
+ asciidoc <rfc>         - pass the rfc.txt to 'asciidoc' command
  comment <rfc>          - Add a new comment to a RFC
  draft <rfc>            - Change RFC to Draft state
  final <rfc>            - Change RFC to Final state
@@ -237,7 +238,7 @@ function edit()
 {
     # filename lineoffset chapter
     EDITOR="${EDITOR:-$(git config --get core.editor)}"
-    EDITOR="${EDITOR:-VISUAL}"
+    EDITOR="${EDITOR:-$VISUAL}"
 
     local file="$1"
     local line=0
@@ -370,6 +371,12 @@ edit)
         git add "$name"
     fi
     ;;
+asciidoc)
+    name=$(unique_name "$1")
+    if [[ "$name" ]]; then
+        asciidoc "${name}"
+    fi
+    ;;
 draft)
     name=$(unique_name "$1")
     if [[ "$name" ]]; then
diff --git a/doc/template/rfc.txt b/doc/template/rfc.txt
index b85efe175..0988835bd 100644
--- a/doc/template/rfc.txt
+++ b/doc/template/rfc.txt
@@ -25,13 +25,17 @@ Description
 
 Tasks
 ~~~~~
-// List what would need to be done to implement this Proposal in a few words:
-// * item ...
+// List what needs to be done to implement this Proposal:
+// * first step ([green]#✔ done#)
+// * second step [,yellow]#WIP#
 
 
+Discussion
+~~~~~~~~~~
+
 Pros
 ^^^^
-// add just a fact list/enumeration which make this suitable:
+// add a fact list/enumeration which make this suitable:
 //  * foo
 //  * bar ...
 
@@ -44,14 +48,14 @@ Cons
 
 
 Alternatives
-------------
+^^^^^^^^^^^^
 //alternatives: explain alternatives and tell why they are not viable:
 
 
 
 Rationale
 ---------
-//rationale: Describe why it should be done *this* way:
+//rationale: Give a concise summary why it should be done *this* way:
 
 
 

From ef95048de0bb47a703c4b5750e71c3526dfd168f Mon Sep 17 00:00:00 2001
From: Ichthyostega <prg@ichthyostega.de>
Date: Mon, 13 Dec 2010 04:46:44 +0100
Subject: [PATCH 21/28] formatting fixes for existing RfCs

---
 .../rfc_pending/EngineInterfaceOverview.txt   | 44 +++++++++++--------
 .../NormalizedDeviceCoordinates.txt           |  7 ++-
 .../rfc_pending/ProcPlacementMetaphor.txt     |  5 +++
 doc/devel/rfc_pending/RenderOptimizer.txt     |  5 +++
 .../ResourceManagementBudgeting.txt           |  7 ++-
 .../ResourceManagementProfiling.txt           |  7 ++-
 doc/devel/rfc_pending/Roadmap-first.txt       |  5 +++
 doc/devel/rfc_pending/StreamTypeSystem.txt    |  5 +--
 ...eadsSignalsAndImportantManagementTasks.txt |  7 ++-
 doc/devel/rfc_pending/WebsiteNavigation.txt   |  6 ++-
 10 files changed, 72 insertions(+), 26 deletions(-)

diff --git a/doc/devel/rfc_pending/EngineInterfaceOverview.txt b/doc/devel/rfc_pending/EngineInterfaceOverview.txt
index 4966339fc..9e242a27f 100644
--- a/doc/devel/rfc_pending/EngineInterfaceOverview.txt
+++ b/doc/devel/rfc_pending/EngineInterfaceOverview.txt
@@ -41,8 +41,8 @@ _corresponds to a single data stream_ to be rendered. Thus, when the play
 in _playing_ or _paused_ state, typically multiple corresponding render
 processes exist.
 
-* there is an displayer- or output slot, which got allocated on creation of the
-  process
+* there is an displayer- or output slot, which got allocated on creation
+  of the process
 * the process disposes calculated data frames "into" this slot
 * the process can be paused/started and stopped (aborted, halted).
 * some processes allow for changing parameters dynamically (e.g. speed,
@@ -52,23 +52,31 @@ processes exist.
 
 .Process parameters
 A process is linked to a single stream data format (a -> 
-link:StreamTypeSystem.html[stream implementation type]). + It is configured
-with _frame quantisation_ and _timings_, and a _model port_ identifier and
-_channel selector_.
+link:StreamTypeSystem.html[stream implementation type]). +
+It is configured with _frame quantisation_ and _timings_, and a _model port_
+identifier and _channel selector_.
+
+ quantisation::
+   translates time values into frame numbers. (In the most general
+   case this is a function, connected to the session)
+   
+ timings::
+   a definition to translate global model time units in real clock time,
+   including _alignment_ to an external time grid.
+   
+ model port::
+   a point in the (high level) model where output can be produced. +
+   This might be a global pipe in one of the model's timelines, or
+   it might be a _probe point_.
+   
+ channel::
+   within the session and high level model, details of the stream
+   implementation are abstracted. Typically, a global pipe (master bus
+   or subgroup) corresponds to a multichannel stream, and each of these
+   channels might be hooked up to an individual render process
+   (we have to work out if that's _always the case_ or just under
+   _some circumstances_)
 
- quantisation:: translates time values into frame numbers. (In the most general
- case this is a function, connected to the session) timings:: a definition to
- translate global model time units in real clock time, including _alignment_ to
- an external time grid. model port:: a point in the (high level) model where
- output can be produced. +
-              This might be a global pipe in one of the model's timelines, or
-              it might be a _probe point_.
- channel:: within the session and high level model, details of the stream
- implementation are abstracted. Typically,
-           a global pipe (master bus or subgroup) corresponds to a multichannel
-           stream, and each of these channels might be hooked up to an
-           individual render process (we have to work out if that's _always the
-           case_ or just under _some circumstances_)
 
 [NOTE]
 ===================
diff --git a/doc/devel/rfc_pending/NormalizedDeviceCoordinates.txt b/doc/devel/rfc_pending/NormalizedDeviceCoordinates.txt
index 4272b1816..87496b4e8 100644
--- a/doc/devel/rfc_pending/NormalizedDeviceCoordinates.txt
+++ b/doc/devel/rfc_pending/NormalizedDeviceCoordinates.txt
@@ -58,6 +58,11 @@ Tasks
 ^^^^^
 
 
+
+
+Discussion
+~~~~~~~~~~
+
 Pros
 ^^^^
 
@@ -75,7 +80,7 @@ Alternatives
 
 Rationale
 ~~~~~~~~~
-
+TBD
 
 
 
diff --git a/doc/devel/rfc_pending/ProcPlacementMetaphor.txt b/doc/devel/rfc_pending/ProcPlacementMetaphor.txt
index f12f33004..d6ba41545 100644
--- a/doc/devel/rfc_pending/ProcPlacementMetaphor.txt
+++ b/doc/devel/rfc_pending/ProcPlacementMetaphor.txt
@@ -109,6 +109,11 @@ Tasks
 
 
 
+
+
+Discussion
+~~~~~~~~~~
+
 Pros
 ^^^^
  * with just one concept, we get a lot of issues right, which many conventional
diff --git a/doc/devel/rfc_pending/RenderOptimizer.txt b/doc/devel/rfc_pending/RenderOptimizer.txt
index c10f7027d..ce2c57b7c 100644
--- a/doc/devel/rfc_pending/RenderOptimizer.txt
+++ b/doc/devel/rfc_pending/RenderOptimizer.txt
@@ -32,6 +32,11 @@ Tasks
 ^^^^^
 
 
+
+
+Discussion
+~~~~~~~~~~
+
 Pros
 ^^^^
 
diff --git a/doc/devel/rfc_pending/ResourceManagementBudgeting.txt b/doc/devel/rfc_pending/ResourceManagementBudgeting.txt
index 0ff21933e..ffa488e5c 100644
--- a/doc/devel/rfc_pending/ResourceManagementBudgeting.txt
+++ b/doc/devel/rfc_pending/ResourceManagementBudgeting.txt
@@ -73,6 +73,11 @@ Tasks
 // * item ...
 
 
+
+
+Discussion
+~~~~~~~~~~
+
 Pros
 ^^^^
 // add just a fact list/enumeration which make this suitable:
@@ -88,7 +93,7 @@ Cons
 
 
 Alternatives
-------------
+^^^^^^^^^^^^
 //alternatives: if possible explain/link alternatives and tell why they are not
   viable:
 
diff --git a/doc/devel/rfc_pending/ResourceManagementProfiling.txt b/doc/devel/rfc_pending/ResourceManagementProfiling.txt
index 7022d861c..bfd1b2731 100644
--- a/doc/devel/rfc_pending/ResourceManagementProfiling.txt
+++ b/doc/devel/rfc_pending/ResourceManagementProfiling.txt
@@ -134,6 +134,11 @@ Tasks
 // * item ...
 
 
+
+
+Discussion
+~~~~~~~~~~
+
 Pros
 ^^^^
 // add just a fact list/enumeration which make this suitable:
@@ -149,7 +154,7 @@ Cons
 
 
 Alternatives
-------------
+^^^^^^^^^^^^
 //alternatives: if possible explain/link alternatives and tell why they are not
   viable:
 
diff --git a/doc/devel/rfc_pending/Roadmap-first.txt b/doc/devel/rfc_pending/Roadmap-first.txt
index cdba0f267..a8a38d50a 100644
--- a/doc/devel/rfc_pending/Roadmap-first.txt
+++ b/doc/devel/rfc_pending/Roadmap-first.txt
@@ -136,6 +136,11 @@ Please review and discuss this proposal, consider if it's of any use setting it
 up this way...
 
 
+
+
+Discussion
+~~~~~~~~~~
+
 Pros
 ^^^^
  * doesn't hinder us
diff --git a/doc/devel/rfc_pending/StreamTypeSystem.txt b/doc/devel/rfc_pending/StreamTypeSystem.txt
index 077d1aed9..4a81eaf9b 100644
--- a/doc/devel/rfc_pending/StreamTypeSystem.txt
+++ b/doc/devel/rfc_pending/StreamTypeSystem.txt
@@ -10,8 +10,7 @@
 Stream Type System
 ------------------
 Especially in the Proc-Layer, we need a framework to deal with different
-"kinds" of media streams.
- +
+"kinds" of media streams. +
 This is the foundation to be able to define what can be connected and to
 separate out generic parts and isolate specific parts.
 
@@ -69,7 +68,7 @@ or selection regarding each of these levels.
    conversions. Examples for Prototypes are: stereoscopic (3D) video versus the
    common flat video lacking depth information, spatial audio systems
    (Ambisonics, Wave Field Synthesis), panorama simulating sound systems (5.1,
-   7.1,...), stereophonic and monaural audio.
+   7.1,...), binaural, stereophonic and monaural audio.
  * Besides the distinction by prototypes, there are the various *media
    implementation types*. This classification is not necessarily hierarchically
    related to the prototype classification, while in practice commonly there
diff --git a/doc/devel/rfc_pending/ThreadsSignalsAndImportantManagementTasks.txt b/doc/devel/rfc_pending/ThreadsSignalsAndImportantManagementTasks.txt
index e218e8e9e..69ca53595 100644
--- a/doc/devel/rfc_pending/ThreadsSignalsAndImportantManagementTasks.txt
+++ b/doc/devel/rfc_pending/ThreadsSignalsAndImportantManagementTasks.txt
@@ -113,6 +113,11 @@ We have appstate::maybeWait() which already does such a loop. It needs to be
 extended by the proposed things above.
 
 
+
+Discussion
+~~~~~~~~~~
+
+
 Pros
 ^^^^
 // add just a fact list/enumeration which make this suitable:
@@ -127,7 +132,7 @@ Cons
 
 
 Alternatives
-------------
+^^^^^^^^^^^^
 //alternatives: if possible explain/link alternatives and tell why they are not
 
 
diff --git a/doc/devel/rfc_pending/WebsiteNavigation.txt b/doc/devel/rfc_pending/WebsiteNavigation.txt
index 965897144..172b6543f 100644
--- a/doc/devel/rfc_pending/WebsiteNavigation.txt
+++ b/doc/devel/rfc_pending/WebsiteNavigation.txt
@@ -114,6 +114,10 @@ Tasks
 // * item ...
 
 
+
+Discussion
+~~~~~~~~~~
+
 Pros
 ^^^^
 // add just a fact list/enumeration which make this suitable:
@@ -129,7 +133,7 @@ Cons
 
 
 Alternatives
-------------
+^^^^^^^^^^^^
 //alternatives: explain alternatives and tell why they are not viable:
 
 

From 661e4f0da59b54c37ef85d41982aae6b90d63fe5 Mon Sep 17 00:00:00 2001
From: Stefan Kangas <skangas@skangas.se>
Date: Fri, 10 Dec 2010 02:55:40 +0100
Subject: [PATCH 22/28] Use CHECK instead of ASSERT in test suite.  (Ticket
 #250)

---
 tests/common/ref-array-test.cpp               |  42 +-
 .../proc/asset/asset-category-test.cpp        |  52 +--
 tests/components/proc/asset/basicpipetest.cpp |  98 ++---
 .../proc/asset/create-asset-test.cpp          | 194 +++++-----
 .../proc/asset/dependent-assets-test.cpp      | 202 +++++-----
 .../proc/asset/identityofassetstest.cpp       |  20 +-
 tests/components/proc/asset/makecliptest.cpp  |  14 +-
 .../proc/asset/orderingofassetstest.cpp       |  64 ++--
 .../control/argument-tuple-accept-test.cpp    |   2 +-
 .../proc/control/command-argument-test.cpp    | 290 +++++++-------
 .../proc/control/command-basic-test.cpp       |   6 +-
 .../proc/control/command-binding-test.cpp     |  20 +-
 .../control/command-clone-builder-test.cpp    |  42 +-
 .../proc/control/command-equality-test.cpp    | 118 +++---
 .../proc/control/command-mutation-test.cpp    |  30 +-
 .../proc/control/command-registry-test.cpp    | 114 +++---
 .../proc/control/command-use1-test.cpp        | 194 +++++-----
 .../proc/control/command-use2-test.cpp        |  42 +-
 .../proc/control/command-use3-test.cpp        |   4 +-
 .../control/handling-pattern-basics-test.cpp  | 126 +++---
 .../handling-pattern-standard-impl-test.cpp   |   4 +-
 .../proc/control/memento-tie-test.cpp         |  50 +--
 .../proc/engine/buff-table-test.cpp           |   2 +-
 .../proc/engine/node-basic-test.cpp           |   6 +-
 .../proc/mobject/builder/buildertooltest.cpp  |   8 +-
 .../proc/mobject/mobject-interface-test.cpp   |  10 +-
 .../proc/mobject/mobject-ref-test.cpp         | 362 +++++++++---------
 .../proc/mobject/placement-basic-test.cpp     |  52 +--
 .../proc/mobject/placement-hierarchy-test.cpp |  64 ++--
 .../placement-object-identity-test.cpp        |  24 +-
 .../proc/mobject/placement-ref-test.cpp       | 156 ++++----
 .../proc/mobject/session/addcliptest.cpp      |   2 +-
 .../mobject/session/defsmanagerimpltest.cpp   | 150 ++++----
 .../proc/mobject/session/defsmanagertest.cpp  | 130 +++----
 .../mobject/session/defsregistryimpltest.cpp  | 252 ++++++------
 .../proc/mobject/session/deletecliptest.cpp   |   8 +-
 .../session/placement-index-query-test.cpp    |   6 +-
 .../mobject/session/placement-index-test.cpp  | 272 ++++++-------
 .../mobject/session/placement-scope-test.cpp  |  40 +-
 .../session/query-focus-stack-test.cpp        | 108 +++---
 .../proc/mobject/session/query-focus-test.cpp |  50 +--
 .../mobject/session/rebuildfixturetest.cpp    |   4 +-
 .../proc/mobject/session/scope-path-test.cpp  | 222 +++++------
 .../proc/mobject/session/scope-query-test.cpp |   2 +-
 .../session/session-structure-test.cpp        |  44 +--
 .../mobject/session/sessionmanagertest.cpp    |   4 +-
 .../proc/mobject/session/testclip.cpp         |   2 +-
 tests/lib/allocationclustertest.cpp           |  22 +-
 tests/lib/appconfigtest.cpp                   |   2 +-
 tests/lib/bool-checkable-test.cpp             |   6 +-
 tests/lib/custom-shared-ptr-test.cpp          | 356 ++++++++---------
 tests/lib/exceptionerrortest.cpp              |  28 +-
 tests/lib/factory-special-test.cpp            |  16 +-
 tests/lib/functor-util-test.cpp               |  48 +--
 tests/lib/hash-indexed-test.cpp               |  34 +-
 tests/lib/item-wrapper-test.cpp               | 262 ++++++-------
 tests/lib/iter-adapter-test.cpp               |  62 +--
 tests/lib/iter-source-test.cpp                |  38 +-
 tests/lib/itertools-test.cpp                  | 200 +++++-----
 tests/lib/lifecycletest.cpp                   |   8 +-
 tests/lib/meta/config-flags-test.cpp          |   4 +-
 tests/lib/meta/function-closure-test.cpp      | 120 +++---
 tests/lib/meta/function-composition-test.cpp  | 326 ++++++++--------
 tests/lib/meta/function-erasure-test.cpp      |  58 +--
 tests/lib/meta/generator-test.cpp             |  74 ++--
 tests/lib/meta/type-tuple-test.cpp            | 252 ++++++------
 tests/lib/multifact-argument-test.cpp         |   6 +-
 tests/lib/multifact-test.cpp                  |   6 +-
 tests/lib/opaque-holder-test.cpp              |  98 ++---
 tests/lib/opaque-unchecked-buffer-test.cpp    |  14 +-
 tests/lib/query/query-utils-test.cpp          |  40 +-
 tests/lib/scoped-holder-test.cpp              | 114 +++---
 tests/lib/scoped-ptrvect-test.cpp             |  40 +-
 tests/lib/scopedholdertransfertest.cpp        | 160 ++++----
 tests/lib/singleton-subclass-test.cpp         |  96 ++---
 tests/lib/singleton-test.cpp                  |   2 +-
 tests/lib/singletontestmocktest.cpp           |  14 +-
 tests/lib/streamtypebasicstest.cpp            |  26 +-
 tests/lib/sub-id-test.cpp                     |   2 +-
 tests/lib/subsystem-runner-test.cpp           |  82 ++--
 tests/lib/symbol-hashtable-test.cpp           | 148 +++----
 tests/lib/symbol-test.cpp                     |  36 +-
 tests/lib/sync-classlock-test.cpp             |   4 +-
 tests/lib/sync-locking-test.cpp               |   2 +-
 tests/lib/sync-timedwait-test.cpp             | 114 +++---
 tests/lib/sync-waiting-test.cpp               |   8 +-
 tests/lib/test/test-helper-test.cpp           |   8 +-
 tests/lib/thread-wrapper-join-test.cpp        |   2 +-
 tests/lib/thread-wrapper-test.cpp             |   2 +-
 tests/lib/time-wrapper-test.cpp               |  90 ++---
 tests/lib/typed-allocation-manager-test.cpp   |  50 +--
 tests/lib/typed-counter-test.cpp              |  30 +-
 tests/lib/util-foreach-test.cpp               |  28 +-
 tests/lib/vectortransfertest.cpp              |  96 ++---
 94 files changed, 3471 insertions(+), 3471 deletions(-)

diff --git a/tests/common/ref-array-test.cpp b/tests/common/ref-array-test.cpp
index 92e799069..2d18f1f11 100644
--- a/tests/common/ref-array-test.cpp
+++ b/tests/common/ref-array-test.cpp
@@ -129,12 +129,12 @@ namespace test{
           
           RefArray<I> & rArr (subWrap);
           
-          ASSERT (subWrap.size()==subz.size());
-          ASSERT (INSTANCEOF(I, &rArr[0]));
+          CHECK (subWrap.size()==subz.size());
+          CHECK (INSTANCEOF(I, &rArr[0]));
           for (size_t i=0; i<rArr.size(); ++i)
             {
-              ASSERT (&rArr[i] == &subz[i]);
-              ASSERT (rArr[i].op(i) == subz[i].op(i));
+              CHECK (&rArr[i] == &subz[i]);
+              CHECK (rArr[i].op(i) == subz[i].op(i));
             }
         }
       
@@ -146,12 +146,12 @@ namespace test{
           vector<Sub2> & vect (subz);
           RefArray<I> & rArr (subz);
           
-          ASSERT (vect.size()==subz.size());
-          ASSERT (INSTANCEOF(I, &rArr[0]));
+          CHECK (vect.size()==subz.size());
+          CHECK (INSTANCEOF(I, &rArr[0]));
           for (size_t i=0; i<rArr.size(); ++i)
             {
-              ASSERT (&rArr[i] == &vect[i]);
-              ASSERT (rArr[i].op(i) == vect[i].op(i));
+              CHECK (&rArr[i] == &vect[i]);
+              CHECK (rArr[i].op(i) == vect[i].op(i));
             }
         }
       
@@ -164,17 +164,17 @@ namespace test{
           RefArrayTable<I,20,Sub1> tab;  
           // creates 20 Sub1-objects in-place
           // which are indeed located within the object
-          ASSERT (sizeof(tab) >= 20 * sizeof(Sub1));
-          ASSERT (ADR(tab) < ADR(tab[19]) && ADR(tab[19]) < ADR(tab) + sizeof(tab));
+          CHECK (sizeof(tab) >= 20 * sizeof(Sub1));
+          CHECK (ADR(tab) < ADR(tab[19]) && ADR(tab[19]) < ADR(tab) + sizeof(tab));
           
           RefArray<I> & rArr (tab);
           
-          ASSERT (20 == tab.size());
-          ASSERT (INSTANCEOF(I, &rArr[0]));
+          CHECK (20 == tab.size());
+          CHECK (INSTANCEOF(I, &rArr[0]));
           for (size_t i=0; i<rArr.size(); ++i)
             {
-              ASSERT (i*sizeof(Sub1) == ADR(rArr[i]) - ADR(rArr[0]) ); // indeed array-like storage
-              ASSERT (int(i+1) == rArr[i].op(i));                     //  check the known result
+              CHECK (i*sizeof(Sub1) == ADR(rArr[i]) - ADR(rArr[0]) ); // indeed array-like storage
+              CHECK (int(i+1) == rArr[i].op(i));                     //  check the known result
             }
         }
       
@@ -186,7 +186,7 @@ namespace test{
           
           void operator() (void* place)
             {
-              ASSERT (place);
+              CHECK (place);
               new(place) SUB (offset_++); // note: varying ctor parameter
             }
         };
@@ -198,9 +198,9 @@ namespace test{
           Fac<Sub1> theFact;
           RefArrayTable<I,30,Sub1> tab (theFact);
           RefArray<I> & rArr (tab);
-          ASSERT (30 == tab.size());
+          CHECK (30 == tab.size());
           for (size_t i=0; i<rArr.size(); ++i)
-            ASSERT (int(i+i) == rArr[i].op(i)); // each one has gotten another offset ctor parameter
+            CHECK (int(i+i) == rArr[i].op(i)); // each one has gotten another offset ctor parameter
         }
       
       
@@ -216,15 +216,15 @@ namespace test{
                   {
                     Fac<Sub3> factory;
                     RefArrayTable<I,30,Sub3> table (factory);
-                    ASSERT (Sub3::sum == (29+1)*29/2);
+                    CHECK (Sub3::sum == (29+1)*29/2);
                   }
-                  ASSERT (Sub3::sum == 0);
+                  CHECK (Sub3::sum == 0);
                 }
               
               catch(long id)
                 {
-                  ASSERT (id == Sub3::trigger);
-                  ASSERT (Sub3::sum == id);
+                  CHECK (id == Sub3::trigger);
+                  CHECK (Sub3::sum == id);
                   // meaning: all objects have been cleaned up,
                   // with the exception of the one hitting the trigger
             }   }
diff --git a/tests/components/proc/asset/asset-category-test.cpp b/tests/components/proc/asset/asset-category-test.cpp
index a211cd963..b58f3297b 100644
--- a/tests/components/proc/asset/asset-category-test.cpp
+++ b/tests/components/proc/asset/asset-category-test.cpp
@@ -82,16 +82,16 @@ namespace test {
           Category c3 (VIDEO,"bin1/subbin");
           Category c4 (EFFECT,"some_kind");
           
-          ASSERT ( c1.hasKind(VIDEO) );
-          ASSERT (!c1.hasKind(AUDIO) );
-          ASSERT ( c2.isWithin(c1) );
-          ASSERT ( c3.isWithin(c2) );
-          ASSERT ( c3.isWithin(c1) );
-          ASSERT (!c1.isWithin(c2) );
-          ASSERT (!c2.isWithin(c3) );
-          ASSERT (!c1.isWithin(c3) );
-          ASSERT (!c3.isWithin(c4) );
-          ASSERT (!c4.isWithin(c3) );
+          CHECK ( c1.hasKind(VIDEO) );
+          CHECK (!c1.hasKind(AUDIO) );
+          CHECK ( c2.isWithin(c1) );
+          CHECK ( c3.isWithin(c2) );
+          CHECK ( c3.isWithin(c1) );
+          CHECK (!c1.isWithin(c2) );
+          CHECK (!c2.isWithin(c3) );
+          CHECK (!c1.isWithin(c3) );
+          CHECK (!c3.isWithin(c4) );
+          CHECK (!c4.isWithin(c3) );
         }
       
       
@@ -104,30 +104,30 @@ namespace test {
           Category c5 (STRUCT);
           Category c6 (META);
           
-          ASSERT (0 > c1.compare(c2));
-          ASSERT (0 > c2.compare(c3));
-          ASSERT (0 > c3.compare(c4));
-          ASSERT (0 > c4.compare(c5));
-          ASSERT (0 > c5.compare(c6));
+          CHECK (0 > c1.compare(c2));
+          CHECK (0 > c2.compare(c3));
+          CHECK (0 > c3.compare(c4));
+          CHECK (0 > c4.compare(c5));
+          CHECK (0 > c5.compare(c6));
           
-          ASSERT (0 ==c1.compare(c1));
-          ASSERT (0 > c1.compare(c6));
+          CHECK (0 ==c1.compare(c1));
+          CHECK (0 > c1.compare(c6));
           
           Category c21 (VIDEO,"bin1");
           Category c22 (VIDEO,"bin2");
           Category c23 (VIDEO,"bin2/sub");
           
-          ASSERT (0 > c1.compare(c21));
-          ASSERT (0 > c2.compare(c21));
-          ASSERT (0 < c22.compare(c21));
-          ASSERT (0 < c23.compare(c22));
-          ASSERT (0 < c23.compare(c21));
-          ASSERT ( 0==c22.compare(c22));
+          CHECK (0 > c1.compare(c21));
+          CHECK (0 > c2.compare(c21));
+          CHECK (0 < c22.compare(c21));
+          CHECK (0 < c23.compare(c22));
+          CHECK (0 < c23.compare(c21));
+          CHECK ( 0==c22.compare(c22));
           
           
-          ASSERT ( c2 == c2 );
-          ASSERT ( c2 != c22 );
-          ASSERT ( c2 != c3 );
+          CHECK ( c2 == c2 );
+          CHECK ( c2 != c22 );
+          CHECK ( c2 != c3 );
         }
     };
   
diff --git a/tests/components/proc/asset/basicpipetest.cpp b/tests/components/proc/asset/basicpipetest.cpp
index 70f644ed1..e15533e0e 100644
--- a/tests/components/proc/asset/basicpipetest.cpp
+++ b/tests/components/proc/asset/basicpipetest.cpp
@@ -81,25 +81,25 @@ namespace asset
           { 
             string pID_sane (pID);
             normaliseID (pID_sane);
-            ASSERT (pID_sane != pID);
+            CHECK (pID_sane != pID);
             
             PPipe thePipe = asset::Struct::retrieve.newPipe (pID,sID);
             
-            ASSERT (thePipe);
-            ASSERT (thePipe->getProcPatt());
-            ASSERT (thePipe->getPipeID() == pID_sane);
-            ASSERT (thePipe->getStreamID() == sID);
-            ASSERT (thePipe->shortDesc == pID_sane);
+            CHECK (thePipe);
+            CHECK (thePipe->getProcPatt());
+            CHECK (thePipe->getPipeID() == pID_sane);
+            CHECK (thePipe->getStreamID() == sID);
+            CHECK (thePipe->shortDesc == pID_sane);
             
             Asset::Ident idi = thePipe->ident;
-            ASSERT (idi.org == "lumi");
-            ASSERT (contains (idi.name, thePipe->getPipeID()));
-            ASSERT (contains (idi.name, thePipe->getStreamID()));
+            CHECK (idi.org == "lumi");
+            CHECK (contains (idi.name, thePipe->getPipeID()));
+            CHECK (contains (idi.name, thePipe->getStreamID()));
 
             Category cat (idi.category);
             Category refcat (STRUCT,"pipes");
-            ASSERT ( cat.hasKind(STRUCT) );
-            ASSERT ( cat.isWithin(refcat) );
+            CHECK ( cat.hasKind(STRUCT) );
+            CHECK ( cat.isWithin(refcat) );
           }
         
         
@@ -108,20 +108,20 @@ namespace asset
             normaliseID (pID);
             
             PPipe pipe1 = Pipe::query ("pipe("+pID+")");
-            ASSERT (pipe1);
-            ASSERT (pipe1->getPipeID() == pID);
+            CHECK (pipe1);
+            CHECK (pipe1->getPipeID() == pID);
             
             string pID2 = "another-" + pID;
             PPipe pipe2 = Pipe::query ("pipe("+pID2+")");
-            ASSERT (pipe2);
-            ASSERT (pipe2 != pipe1);
+            CHECK (pipe2);
+            CHECK (pipe2 != pipe1);
             Category c1 = pipe1->ident.category;
             Category c2 = pipe2->ident.category;
-            ASSERT (c1 == c2);
+            CHECK (c1 == c2);
             
             PPipe pipe3 = Pipe::query ("pipe("+pID2+")");
 //////////////////////////////////////////////////////////////TODO: that's broken; creating a new one instead to find the existing one, as it should be            
-            ASSERT (pipe3 == pipe2);
+            CHECK (pipe3 == pipe2);
           }
         
         
@@ -129,26 +129,26 @@ namespace asset
           { 
             PPipe pipe1 = Pipe::query (""); // "the default pipe"
             PPipe pipe2;
-            ASSERT (pipe1);
-            ASSERT (pipe1 == Session::current->defaults (Query<Pipe>()));
-            ASSERT (pipe1->ident.category.hasKind(VIDEO));
-            ASSERT (pipe1->getProcPatt());
+            CHECK (pipe1);
+            CHECK (pipe1 == Session::current->defaults (Query<Pipe>()));
+            CHECK (pipe1->ident.category.hasKind(VIDEO));
+            CHECK (pipe1->getProcPatt());
             PProcPatt propa = Session::current->defaults (Query<const ProcPatt>("pipe(default)"));
-            ASSERT (propa == pipe1->getProcPatt());
+            CHECK (propa == pipe1->getProcPatt());
             
             // several variants to query for "the default pipe"
             pipe2 = Session::current->defaults(Query<Pipe> ());
-            ASSERT (pipe2 == pipe1);
+            CHECK (pipe2 == pipe1);
             pipe2 = asset::Struct::retrieve (Query<Pipe> ());
-            ASSERT (pipe2 == pipe1);
+            CHECK (pipe2 == pipe1);
             pipe2 = asset::Struct::retrieve (Query<Pipe> ("pipe(default)"));
-            ASSERT (pipe2 == pipe1);
+            CHECK (pipe2 == pipe1);
             
             string sID = pipe1->getStreamID(); // sort of a "default stream type"
             PPipe pipe3 = Pipe::query ("stream("+sID+")");
-            ASSERT (pipe3);
-            ASSERT (pipe3->getStreamID() == sID);
-            ASSERT (pipe3->getProcPatt() == Session::current->defaults (Query<const ProcPatt>("stream("+sID+")")));
+            CHECK (pipe3);
+            CHECK (pipe3->getStreamID() == sID);
+            CHECK (pipe3->getProcPatt() == Session::current->defaults (Query<const ProcPatt>("stream("+sID+")")));
           }
         
         
@@ -158,46 +158,46 @@ namespace asset
             typedef P<const ProcPatt> PProcPatt;
             
             PPipe thePipe = Pipe::query ("pipe("+pID+")");
-            ASSERT (thePipe);
+            CHECK (thePipe);
             PProcPatt thePatt = thePipe->getProcPatt();
-            ASSERT (thePatt);
-            ASSERT (dependencyCheck (thePipe, thePatt));
+            CHECK (thePatt);
+            CHECK (dependencyCheck (thePipe, thePatt));
             
             PProcPatt pattern2 = thePatt->newCopy("another");
-            ASSERT (thePatt != pattern2);
-            ASSERT (!dependencyCheck (thePipe, pattern2));
+            CHECK (thePatt != pattern2);
+            CHECK (!dependencyCheck (thePipe, pattern2));
             TODO ("add something to the new pattern, e.g. an effect");
 
               // now querying for a pipe using this pattern (created on-the-fly)
              //  note: because the pattern is new, this new pipe will be used as
             //         default pipe for this pattern automatically
             PPipe pipe2x = Pipe::query ("pattern(another)");
-            ASSERT (pattern2 == pipe2x->getProcPatt());
-            ASSERT (pipe2x == Session::current->defaults (Query<Pipe>("pattern(another)")));
+            CHECK (pattern2 == pipe2x->getProcPatt());
+            CHECK (pipe2x == Session::current->defaults (Query<Pipe>("pattern(another)")));
             
             thePipe->switchProcPatt(pattern2);
-            ASSERT ( dependencyCheck (thePipe, pattern2));
-            ASSERT (!dependencyCheck (thePipe, thePatt));
+            CHECK ( dependencyCheck (thePipe, pattern2));
+            CHECK (!dependencyCheck (thePipe, thePatt));
             
             AssetManager& aMang = AssetManager::instance();
-            ASSERT ( aMang.known (thePipe->getID()));
-            ASSERT ( aMang.known (thePatt->getID()));
-            ASSERT ( aMang.known (pattern2->getID()));
+            CHECK ( aMang.known (thePipe->getID()));
+            CHECK ( aMang.known (thePatt->getID()));
+            CHECK ( aMang.known (pattern2->getID()));
             aMang.remove (pattern2->getID());
-            ASSERT ( aMang.known (thePatt->getID()));
-            ASSERT (!aMang.known (pattern2->getID()));
-            ASSERT (!aMang.known (thePipe->getID()));  // has been unlinked too, because dependant on pattern2
+            CHECK ( aMang.known (thePatt->getID()));
+            CHECK (!aMang.known (pattern2->getID()));
+            CHECK (!aMang.known (thePipe->getID()));  // has been unlinked too, because dependant on pattern2
             
-            ASSERT (thePipe);
+            CHECK (thePipe);
             PProcPatt pattern3 = thePipe->getProcPatt();                                   /////TODO: transition to P<>
-            ASSERT (thePipe->getProcPatt());
-            ASSERT (              pattern3 == pattern2); // but is still valid, as long as the ref is alive....
+            CHECK (thePipe->getProcPatt());
+            CHECK (              pattern3 == pattern2); // but is still valid, as long as the ref is alive....
             
             PPipe pipe3x = Pipe::query ("pattern(another)");
             pattern3 = pipe3x->getProcPatt();                                              /////TODO: transition to P<>
-            ASSERT (pattern3 != pattern2);  // because pattern2 is already unlinked...
-            ASSERT (pipe3x == Session::current->defaults (Query<Pipe>("pattern(another)")));
-            ASSERT (pipe3x != pipe2x);                 // ..we got a new default pipe for "pattern(another)" too!
+            CHECK (pattern3 != pattern2);  // because pattern2 is already unlinked...
+            CHECK (pipe3x == Session::current->defaults (Query<Pipe>("pattern(another)")));
+            CHECK (pipe3x != pipe2x);                 // ..we got a new default pipe for "pattern(another)" too!
             
             
             TRACE (asset_mem, "leaving BasicPipe_test::dependProcPatt()");
diff --git a/tests/components/proc/asset/create-asset-test.cpp b/tests/components/proc/asset/create-asset-test.cpp
index cec6d97ef..2c4adf382 100644
--- a/tests/components/proc/asset/create-asset-test.cpp
+++ b/tests/components/proc/asset/create-asset-test.cpp
@@ -1,23 +1,23 @@
 /*
   CreateAsset(Test)  -  constructing and registering Assets
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2 of the
   License, or (at your option) any later version.
- 
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
@@ -37,168 +37,168 @@ using std::string;
 
 namespace asset {
 namespace test {
-  
-  
-  
-  
+
+
+
+
   /***********************************************************************
    * @test creating new Assets and registering them with the AssetManager.
    * @see  proc_interface::AssetManager#reg
    */
   class CreateAsset_test : public Test
     {
-      virtual void run(Arg arg) 
+      virtual void run(Arg arg)
         {
           createMedia();
           factoryVariants();
-          
+
           if (!isnil (arg))
             dumpAssetManager();
           TRACE (asset_mem, "leaving CreateAsset_test::run()");
         }
-      
-      
+
+
                                                           ////////////////////////////////////TICKET #589
       typedef P<Media> PM;                                                         /////TODO: transition to P<>
-      
+
       /** @test Creating and automatically registering Asset instances.
        *        Re-Retrieving the newly created objects from AssetManager.
-       *        Checking AssetManager access functions, esp. getting 
+       *        Checking AssetManager access functions, esp. getting
        *        different kinds of Assets by ID, querying with the
-       *        wrong Category and querying unknown IDs. 
+       *        wrong Category and querying unknown IDs.
        */
       void createMedia()
-        { 
+        {
           Category cat(VIDEO,"bin1");
           Asset::Ident key("Name-1", cat, "ichthyo", 5);
           PM mm1 = asset::Media::create(key,"testfile.mov");
           PM mm2 = asset::Media::create("testfile1.mov", cat);
           PM mm3 = asset::Media::create("testfile2.mov", VIDEO);
-          
+
           // Assets have been registered and can be retrieved by ID
           AssetManager& aMang = AssetManager::instance();
           PM registered;                                                         /////TODO: transition to P<>
           registered = aMang.getAsset (mm1->getID());
-          ASSERT (registered == mm1);
+          CHECK (registered == mm1);
           registered = aMang.getAsset (mm2->getID());
-          ASSERT (registered == mm2);
+          CHECK (registered == mm2);
           registered = aMang.getAsset (mm3->getID());
-          ASSERT (registered == mm3);
-          
+          CHECK (registered == mm3);
+
           registered = aMang.getAsset (mm1->getID());
-          ASSERT (registered != mm2);
-/* 
+          CHECK (registered != mm2);
+/*
 * TODO: switch back to original version
 *       once the transition to P<XX> is done...
-* 
-          ASSERT (aMang.getAsset (mm1->getID()) == mm1);
-          ASSERT (aMang.getAsset (mm2->getID()) == mm2);
-          ASSERT (aMang.getAsset (mm3->getID()) == mm3);
-          
-          ASSERT (aMang.getAsset (mm1->getID()) != mm2);
-*/        
+*
+          CHECK (aMang.getAsset (mm1->getID()) == mm1);
+          CHECK (aMang.getAsset (mm2->getID()) == mm2);
+          CHECK (aMang.getAsset (mm3->getID()) == mm3);
+
+          CHECK (aMang.getAsset (mm1->getID()) != mm2);
+*/
           PAsset aa1 = aMang.getAsset (ID<Asset>(mm1->getID()));   // note we get an Asset ref
-          ASSERT (aa1 == mm1);
+          CHECK (aa1 == mm1);
           PM mX1 = aMang.getAsset (mm1->getID());                // ..and now we get a Media ref
-          ASSERT (mX1 == mm1);
-          ASSERT (mX1 == aa1);
-          
-          ASSERT (aMang.known (mm1->getID()));
-          ASSERT (aMang.known (mm2->getID()));
-          ASSERT (aMang.known (mm3->getID()));
-          
-          ASSERT ( !aMang.known (mm3->getID(), Category(AUDIO))); // not found within AUDIO-Category
-          try 
-            { // can't be found if specifying wrong Asset kind.... 
+          CHECK (mX1 == mm1);
+          CHECK (mX1 == aa1);
+
+          CHECK (aMang.known (mm1->getID()));
+          CHECK (aMang.known (mm2->getID()));
+          CHECK (aMang.known (mm3->getID()));
+
+          CHECK ( !aMang.known (mm3->getID(), Category(AUDIO))); // not found within AUDIO-Category
+          try
+            { // can't be found if specifying wrong Asset kind....
               aMang.getAsset (ID<asset::Proc>(mm1->getID()));
               NOTREACHED();
             }
-          catch (lumiera::error::Invalid& xxx) {ASSERT (xxx.getID()==LUMIERA_ERROR_WRONG_ASSET_KIND);}
-          try 
-            { // try accessing nonexistent ID 
+          catch (lumiera::error::Invalid& xxx) {CHECK (xxx.getID()==LUMIERA_ERROR_WRONG_ASSET_KIND);}
+          try
+            { // try accessing nonexistent ID
               aMang.getAsset (ID<Asset> (1234567890));
               NOTREACHED();
             }
-          catch (lumiera::error::Invalid& xxx) {ASSERT (xxx.getID()==LUMIERA_ERROR_UNKNOWN_ASSET_ID);}
+          catch (lumiera::error::Invalid& xxx) {CHECK (xxx.getID()==LUMIERA_ERROR_UNKNOWN_ASSET_ID);}
           lumiera_error (); // reset errorflag
-          
-          
+
+
           // checking the Ident-Fields
-          ASSERT (mm1->ident.name == "Name-1");
-          ASSERT (mm2->ident.name == "testfile1");
-          ASSERT (mm3->ident.name == "testfile2");
-          
-          ASSERT (cat == Category (VIDEO,"bin1"));
-          ASSERT (mm1->ident.category == Category (VIDEO,"bin1"));
-          ASSERT (mm2->ident.category == Category (VIDEO,"bin1"));
-          ASSERT (mm3->ident.category == Category (VIDEO       ));
-          
-          ASSERT (mm1->ident.org == "ichthyo");
-          ASSERT (mm2->ident.org == "lumi");
-          ASSERT (mm3->ident.org == "lumi");
-          
-          ASSERT (mm1->ident.version == 5);
-          ASSERT (mm2->ident.version == 1);
-          ASSERT (mm3->ident.version == 1);
-          
-          ASSERT (mm1->getFilename() == "testfile.mov");
-          ASSERT (mm2->getFilename() == "testfile1.mov");
-          ASSERT (mm3->getFilename() == "testfile2.mov");
-          
-          
+          CHECK (mm1->ident.name == "Name-1");
+          CHECK (mm2->ident.name == "testfile1");
+          CHECK (mm3->ident.name == "testfile2");
+
+          CHECK (cat == Category (VIDEO,"bin1"));
+          CHECK (mm1->ident.category == Category (VIDEO,"bin1"));
+          CHECK (mm2->ident.category == Category (VIDEO,"bin1"));
+          CHECK (mm3->ident.category == Category (VIDEO       ));
+
+          CHECK (mm1->ident.org == "ichthyo");
+          CHECK (mm2->ident.org == "lumi");
+          CHECK (mm3->ident.org == "lumi");
+
+          CHECK (mm1->ident.version == 5);
+          CHECK (mm2->ident.version == 1);
+          CHECK (mm3->ident.version == 1);
+
+          CHECK (mm1->getFilename() == "testfile.mov");
+          CHECK (mm2->getFilename() == "testfile1.mov");
+          CHECK (mm3->getFilename() == "testfile2.mov");
+
+
           TRACE (asset_mem, "leaving test method scope");
         }
-      
-      
+
+
       /** @test different variants of calling the MediaFactory,
-       *        with focus on the behaviour of the basic Asset 
-       *        creation machinery. Covers filling out Asset's 
+       *        with focus on the behaviour of the basic Asset
+       *        creation machinery. Covers filling out Asset's
        *        datafields, amending missing pieces of information.
        */
       void factoryVariants()
-        { 
+        {
           PM candi;
-          
+
           Asset::Ident key1("Au-1", Category(AUDIO), "ichthyo", 5);
           candi = asset::Media::create(key1);
-          ASSERT ( checkProperties (candi, key1, ""));
-          
+          CHECK ( checkProperties (candi, key1, ""));
+
           candi = asset::Media::create(key1, string("testfile.wav"));
-          ASSERT ( checkProperties (candi, key1, "testfile.wav"));
-          
+          CHECK ( checkProperties (candi, key1, "testfile.wav"));
+
           Asset::Ident key2("", Category(AUDIO), "ichthyo", 5);
           candi = asset::Media::create(key2, string("testfile2.wav"));
-          ASSERT ( checkProperties (candi, key2, "testfile2.wav"));
-          ASSERT (key2.name == "testfile2"); // name filled in automatically 
-          
+          CHECK ( checkProperties (candi, key2, "testfile2.wav"));
+          CHECK (key2.name == "testfile2"); // name filled in automatically
+
           candi = asset::Media::create(string("testfile3.wav"), Category(AUDIO));
-          ASSERT ( checkProperties (candi, Asset::Ident("testfile3", Category(AUDIO), "lumi", 1)
+          CHECK ( checkProperties (candi, Asset::Ident("testfile3", Category(AUDIO), "lumi", 1)
                                          , "testfile3.wav"));
-          
+
           candi = asset::Media::create("some/path/testfile4.wav", Category(AUDIO));
-          ASSERT ( checkProperties (candi, Asset::Ident("testfile4", Category(AUDIO), "lumi", 1)
+          CHECK ( checkProperties (candi, Asset::Ident("testfile4", Category(AUDIO), "lumi", 1)
                                          , "some/path/testfile4.wav"));
-          
+
           candi = asset::Media::create("", Category(AUDIO,"sub/bin"));
-          ASSERT ( checkProperties (candi, Asset::Ident("nil", Category(AUDIO,"sub/bin"), "lumi", 1)
+          CHECK ( checkProperties (candi, Asset::Ident("nil", Category(AUDIO,"sub/bin"), "lumi", 1)
                                          , ""));
-          
+
           candi = asset::Media::create("", AUDIO);
-          ASSERT ( checkProperties (candi, Asset::Ident("nil", Category(AUDIO), "lumi", 1)
+          CHECK ( checkProperties (candi, Asset::Ident("nil", Category(AUDIO), "lumi", 1)
                                          , ""));
         }
-      
+
       bool checkProperties (PM object, Asset::Ident identity, string filename)
         {
-          return identity == object->ident   
+          return identity == object->ident
               && filename == object->getFilename();
         }
     };
-  
-  
+
+
   /** Register this test class... */
   LAUNCHER (CreateAsset_test, "unit asset");
-  
-  
-  
+
+
+
 }} // namespace asset::test
diff --git a/tests/components/proc/asset/dependent-assets-test.cpp b/tests/components/proc/asset/dependent-assets-test.cpp
index e2234602d..8661e6efd 100644
--- a/tests/components/proc/asset/dependent-assets-test.cpp
+++ b/tests/components/proc/asset/dependent-assets-test.cpp
@@ -1,23 +1,23 @@
 /*
   DependentAssets(Test)  -  check the asset dependency handling
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2 of the
   License, or (at your option) any later version.
- 
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
@@ -35,10 +35,10 @@ using util::isnil;
 
 namespace asset{
 namespace test {
-    
-    
-    
-    
+
+
+
+
     /*******************************************************************
      * @test the handling of Assets dependent on other Assets and the
      *       enabling/disabling of Assets.
@@ -47,142 +47,142 @@ namespace test {
      */
     class DependentAssets_test : public Test
       {
-        virtual void run (Arg) 
+        virtual void run (Arg)
           {
              checkDependencyMechanics ();
              checkUnlinking ();
              checkEnablementPropagation ();
              checkRealAssetDependencyRegistration ();
           }
-        
+
         typedef TestAsset<Asset> TA;
         typedef TA::PA PTestA;
-        
-        
+
+
         /** @test check operation of basic asset dependency support
          */
         void checkDependencyMechanics ()
           {
             PAsset a1 = TA::create();
-            ASSERT (isnil (a1->getParents()));
-            ASSERT (isnil (a1->getDependant()));
-            
+            CHECK (isnil (a1->getParents()));
+            CHECK (isnil (a1->getDependant()));
+
             PTestA a2 = TA::create(a1);
-            ASSERT (a1 == a2->getParents()[0]);  // TestAsset registered a1 as parent
-            ASSERT (a2 == a1->getDependant()[0]);
-            
+            CHECK (a1 == a2->getParents()[0]);  // TestAsset registered a1 as parent
+            CHECK (a2 == a1->getDependant()[0]);
+
             PAsset a3 = TA::create();
             a2->set_depend(a3);
-            ASSERT (a3 == a2->getParents()[1]);
-            ASSERT (a2 == a3->getDependant()[0]);
-            ASSERT (!contains (a1->getDependant(), a3));
+            CHECK (a3 == a2->getParents()[1]);
+            CHECK (a2 == a3->getDependant()[0]);
+            CHECK (!contains (a1->getDependant(), a3));
           }
-        
-        
+
+
         /** @test unlink operation removing inter asset links
          */
         void checkUnlinking ()
           {
             PTestA a1_ = TA::create();
             PAsset a1 (a1_);
-            PTestA a2_ = TA::create(a1);                   
-            PAsset a2 (a2_);                   
-            PAsset a3  = TA::create(a2);                   
-            ASSERT (a1 == a2->getParents()[0]);
-            ASSERT (a2 == a1->getDependant()[0]);
-            ASSERT (a2 == a3->getParents()[0]);
-            ASSERT (a3 == a2->getDependant()[0]);
-            
+            PTestA a2_ = TA::create(a1);
+            PAsset a2 (a2_);
+            PAsset a3  = TA::create(a2);
+            CHECK (a1 == a2->getParents()[0]);
+            CHECK (a2 == a1->getDependant()[0]);
+            CHECK (a2 == a3->getParents()[0]);
+            CHECK (a3 == a2->getDependant()[0]);
+
             a2_->call_unlink();
-            ASSERT (isnil (a2->getDependant()));
-            ASSERT (!contains (a1->getDependant(), a2));  // has been propagated up
-            ASSERT (!isnil (a2->getParents()));
-            ASSERT (contains (a3->getParents(), a2));   // but up-links remain intact
-            
+            CHECK (isnil (a2->getDependant()));
+            CHECK (!contains (a1->getDependant(), a2));  // has been propagated up
+            CHECK (!isnil (a2->getParents()));
+            CHECK (contains (a3->getParents(), a2));   // but up-links remain intact
+
             a2_->call_unlink(a1->getID());
             a2_->set_depend(a1);
             PAsset a4 = TA::create(a1);
-            ASSERT (a1 == a2->getParents()[0]);
-            ASSERT (a1 == a4->getParents()[0]);
-            ASSERT (a2 == a1->getDependant()[0]);
-            ASSERT (a4 == a1->getDependant()[1]);
-            
+            CHECK (a1 == a2->getParents()[0]);
+            CHECK (a1 == a4->getParents()[0]);
+            CHECK (a2 == a1->getDependant()[0]);
+            CHECK (a4 == a1->getDependant()[1]);
+
             a1_->call_unlink(a4->getID());
-            ASSERT (!contains (a1->getDependant(), a4));  // selectively removed
-            ASSERT ( contains (a1->getDependant(), a2));
-            ASSERT (a1 == a4->getParents()[0]);           // no propagation
+            CHECK (!contains (a1->getDependant(), a4));  // selectively removed
+            CHECK ( contains (a1->getDependant(), a2));
+            CHECK (a1 == a4->getParents()[0]);           // no propagation
           }
-        
-        
-        /** @test enabling and disabling an asset should 
+
+
+        /** @test enabling and disabling an asset should
          *        propagate to dependant assets
          */
         void checkEnablementPropagation ()
           {
             PAsset a1 = TA::create();
-            PTestA a2_= TA::create(a1);                
+            PTestA a2_= TA::create(a1);
             PAsset a2 (a2_);
             PAsset a3 = TA::create();   // not dependant
-            
-            ASSERT (a1->isActive());
-            ASSERT (a2->isActive());
-            ASSERT (a3->isActive());
-            
+
+            CHECK (a1->isActive());
+            CHECK (a2->isActive());
+            CHECK (a3->isActive());
+
             a1->enable(false);
-            ASSERT (!a1->isActive());
-            ASSERT (!a2->isActive());
-            ASSERT (a3->isActive());
-            
+            CHECK (!a1->isActive());
+            CHECK (!a2->isActive());
+            CHECK (a3->isActive());
+
             a2->enable(true);
-            ASSERT (!a1->isActive());
-            ASSERT (!a2->isActive());  // ignored because parent is disabled
-            
+            CHECK (!a1->isActive());
+            CHECK (!a2->isActive());  // ignored because parent is disabled
+
             a1->enable(true);
-            ASSERT (a1->isActive());
-            ASSERT (a2->isActive());
-            
+            CHECK (a1->isActive());
+            CHECK (a2->isActive());
+
             a2->enable(false);
-            ASSERT (a1->isActive());
-            ASSERT (!a2->isActive());  // disabling not propagated to parent
+            CHECK (a1->isActive());
+            CHECK (!a2->isActive());  // disabling not propagated to parent
             a2->enable(true);
-            ASSERT (a1->isActive());
-            ASSERT (a2->isActive());
-            
+            CHECK (a1->isActive());
+            CHECK (a2->isActive());
+
             a3->enable(false);
-            ASSERT (a1->isActive());
-            ASSERT (a2->isActive());
-            ASSERT (!a3->isActive());  // no dependency...
-            
+            CHECK (a1->isActive());
+            CHECK (a2->isActive());
+            CHECK (!a3->isActive());  // no dependency...
+
             a1->enable(false);
             a3->enable();
-            ASSERT (!a1->isActive());
-            ASSERT (!a2->isActive());
-            ASSERT (a3->isActive());
-            
+            CHECK (!a1->isActive());
+            CHECK (!a2->isActive());
+            CHECK (a3->isActive());
+
             a1->enable();
             a2_->set_depend(a3); // now add a new parent dependency
             a3->enable(false);
-            ASSERT (a1->isActive());
-            ASSERT (!a2->isActive()); // has been propagated via the new dependency
-            ASSERT (!a3->isActive());
-            
+            CHECK (a1->isActive());
+            CHECK (!a2->isActive()); // has been propagated via the new dependency
+            CHECK (!a3->isActive());
+
             a2->enable(true);
-            ASSERT (a1->isActive());  // no change because one of the parents is disbled
-            ASSERT (!a2->isActive()); 
-            ASSERT (!a3->isActive());
+            CHECK (a1->isActive());  // no change because one of the parents is disbled
+            CHECK (!a2->isActive());
+            CHECK (!a3->isActive());
             a1->enable(false);
-            ASSERT (!a1->isActive());
+            CHECK (!a1->isActive());
             a3->enable(true);
-            ASSERT (!a1->isActive());  // no propagation because the disabled other parent (a1)
-            ASSERT (!a2->isActive()); 
-            ASSERT (a3->isActive());
+            CHECK (!a1->isActive());  // no propagation because the disabled other parent (a1)
+            CHECK (!a2->isActive());
+            CHECK (a3->isActive());
             a1->enable(true);
-            ASSERT (a1->isActive());  // but now propagation is possible
-            ASSERT (a2->isActive()); 
-            ASSERT (a3->isActive());
+            CHECK (a1->isActive());  // but now propagation is possible
+            CHECK (a2->isActive());
+            CHECK (a3->isActive());
           }
-        
-        
+
+
         /** @test each real world asset subclass has to care
          *        for registering and deregistering any additional
          *        dependencies. Here we collect some more prominent
@@ -196,16 +196,16 @@ namespace test {
             typedef P<Clip>  PC;
             PM mm = asset::Media::create("test-1", VIDEO);
             PC cc = mm->createClip()->findClipAsset();
-            ASSERT (dependencyCheck (cc,mm));
-            
+            CHECK (dependencyCheck (cc,mm));
+
           }
-        
+
       };
-    
-    
+
+
     /** Register this test class... */
     LAUNCHER (DependentAssets_test, "unit function asset");
-    
-    
-    
+
+
+
 }} // namespace asset::test
diff --git a/tests/components/proc/asset/identityofassetstest.cpp b/tests/components/proc/asset/identityofassetstest.cpp
index d2fb11911..95df1e15c 100644
--- a/tests/components/proc/asset/identityofassetstest.cpp
+++ b/tests/components/proc/asset/identityofassetstest.cpp
@@ -74,22 +74,22 @@ namespace asset
             
             Asset::Ident idi (mm1->ident);         // duplicate Ident record
             PM mm1X = asset::Media::create (idi); //  note: we actually don't call any ctor
-            ASSERT (mm1 == mm1X);                //         instead, we got mm1 back.
+            CHECK (mm1 == mm1X);                //         instead, we got mm1 back.
             
             PM mm2 = asset::Media::create (idi,"testfile2.mov");
             
-            ASSERT (mm1->getID() == mm2->getID()); // different object, same hash
+            CHECK (mm1->getID() == mm2->getID()); // different object, same hash
 
             AssetManager& aMang = AssetManager::instance();
-            ASSERT (aMang.getAsset (mm1->getID()) == mm2); // record of mm1 was replaced by mm2
-            ASSERT (aMang.getAsset (mm2->getID()) == mm2);
+            CHECK (aMang.getAsset (mm1->getID()) == mm2); // record of mm1 was replaced by mm2
+            CHECK (aMang.getAsset (mm2->getID()) == mm2);
             
-            ASSERT (aMang.known (mm1->getID()));
-            ASSERT (aMang.known (mm2->getID()));
-            ASSERT (mm1->ident.name == "testfile1");
-            ASSERT (mm2->ident.name == "testfile1");
-            ASSERT (mm1->getFilename() == "testfile1.mov");
-            ASSERT (mm2->getFilename() == "testfile2.mov");
+            CHECK (aMang.known (mm1->getID()));
+            CHECK (aMang.known (mm2->getID()));
+            CHECK (mm1->ident.name == "testfile1");
+            CHECK (mm2->ident.name == "testfile1");
+            CHECK (mm1->getFilename() == "testfile1.mov");
+            CHECK (mm2->getFilename() == "testfile2.mov");
             
             
             TRACE (asset_mem, "leaving test method scope");
diff --git a/tests/components/proc/asset/makecliptest.cpp b/tests/components/proc/asset/makecliptest.cpp
index 7f9d0581c..29169849a 100644
--- a/tests/components/proc/asset/makecliptest.cpp
+++ b/tests/components/proc/asset/makecliptest.cpp
@@ -60,14 +60,14 @@ namespace asset {
             PC cc = mm->createClip();
             PM cm = cc->getMedia();
             
-            ASSERT (cm);
-            ASSERT (Time(0) < cc->getLength());
-            ASSERT (cm->ident.category.hasKind (VIDEO));
-            ASSERT (cm->getFilename() == mm->getFilename());
+            CHECK (cm);
+            CHECK (Time(0) < cc->getLength());
+            CHECK (cm->ident.category.hasKind (VIDEO));
+            CHECK (cm->getFilename() == mm->getFilename());
 TODO ("implement Processing Pattern!!!");   
-//            ASSERT (cm->howtoProc() == mm->howtoProc());
-            ASSERT (cm->ident.org == mm->ident.org);
-            ASSERT (dependencyCheck (cm,mm));
+//            CHECK (cm->howtoProc() == mm->howtoProc());
+            CHECK (cm->ident.org == mm->ident.org);
+            CHECK (dependencyCheck (cm,mm));
 
             TRACE (asset_mem,   "leaving MakeClip_test::run()");
             TRACE (mobject_mem, "leaving MakeClip_test::run()");
diff --git a/tests/components/proc/asset/orderingofassetstest.cpp b/tests/components/proc/asset/orderingofassetstest.cpp
index d87b00d3b..98c43b9b4 100644
--- a/tests/components/proc/asset/orderingofassetstest.cpp
+++ b/tests/components/proc/asset/orderingofassetstest.cpp
@@ -74,45 +74,45 @@ namespace asset {
             
             
             // ordering of keys
-            ASSERT (key1 == key2);
-            ASSERT (key2 != key3);
-            ASSERT (key3 != key4);
-            ASSERT (key4 != key5);
-            ASSERT (key1 != key5);
+            CHECK (key1 == key2);
+            CHECK (key2 != key3);
+            CHECK (key3 != key4);
+            CHECK (key4 != key5);
+            CHECK (key1 != key5);
 
-            ASSERT ( 0 > key2.compare(key3));
-            ASSERT ( 0 < key3.compare(key2));
+            CHECK ( 0 > key2.compare(key3));
+            CHECK ( 0 < key3.compare(key2));
 
-            ASSERT ( 0 > key3.compare(key4));
-            ASSERT ( 0 > key4.compare(key5));
-            ASSERT ( 0 > key1.compare(key5));
-            ASSERT ( 0 > key2.compare(key5));
-            ASSERT ( 0 > key3.compare(key5));
-            ASSERT ( 0 > key1.compare(key3));
-            ASSERT ( 0 > key1.compare(key4));
-            ASSERT ( 0 > key2.compare(key4));
+            CHECK ( 0 > key3.compare(key4));
+            CHECK ( 0 > key4.compare(key5));
+            CHECK ( 0 > key1.compare(key5));
+            CHECK ( 0 > key2.compare(key5));
+            CHECK ( 0 > key3.compare(key5));
+            CHECK ( 0 > key1.compare(key3));
+            CHECK ( 0 > key1.compare(key4));
+            CHECK ( 0 > key2.compare(key4));
             
             
             // ordering of Asset smart ptrs
-            ASSERT (mm1 == mm2);
-            ASSERT (mm2 != mm3);
-            ASSERT (mm3 != mm4);
-            ASSERT (mm4 != mm5);
-            ASSERT (mm1 != mm5);
+            CHECK (mm1 == mm2);
+            CHECK (mm2 != mm3);
+            CHECK (mm3 != mm4);
+            CHECK (mm4 != mm5);
+            CHECK (mm1 != mm5);
 
-            ASSERT (mm2 < mm3);
-            ASSERT (mm2 <= mm3);
-            ASSERT (mm3 > mm2);
-            ASSERT (mm3 >= mm2);
+            CHECK (mm2 < mm3);
+            CHECK (mm2 <= mm3);
+            CHECK (mm3 > mm2);
+            CHECK (mm3 >= mm2);
 
-            ASSERT (mm3 < mm4);
-            ASSERT (mm4 < mm5);
-            ASSERT (mm1 < mm5);
-            ASSERT (mm2 < mm5);
-            ASSERT (mm3 < mm5);
-            ASSERT (mm1 < mm3);
-            ASSERT (mm1 < mm4);
-            ASSERT (mm2 < mm4);
+            CHECK (mm3 < mm4);
+            CHECK (mm4 < mm5);
+            CHECK (mm1 < mm5);
+            CHECK (mm2 < mm5);
+            CHECK (mm3 < mm5);
+            CHECK (mm1 < mm3);
+            CHECK (mm1 < mm4);
+            CHECK (mm2 < mm4);
 
           }
       };
diff --git a/tests/components/proc/control/argument-tuple-accept-test.cpp b/tests/components/proc/control/argument-tuple-accept-test.cpp
index 34efd4bd3..db0c7a12f 100644
--- a/tests/components/proc/control/argument-tuple-accept-test.cpp
+++ b/tests/components/proc/control/argument-tuple-accept-test.cpp
@@ -112,7 +112,7 @@ namespace test    {
           cout << showSizeof(testTime) << endl;
           
           cout << testTime.getHead() << endl;
-          ASSERT (23 == testTime.getTail().getHead());
+          CHECK (23 == testTime.getTail().getHead());
         }
       
     };
diff --git a/tests/components/proc/control/command-argument-test.cpp b/tests/components/proc/control/command-argument-test.cpp
index bdf7b2724..ac9c857cf 100644
--- a/tests/components/proc/control/command-argument-test.cpp
+++ b/tests/components/proc/control/command-argument-test.cpp
@@ -1,23 +1,23 @@
 /*
   CommandArgument(Test)  -  checking storage of specifically typed command arguments
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2 of the
   License, or (at your option) any later version.
- 
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
@@ -51,77 +51,77 @@ using std::endl;
 
 namespace control {
 namespace test    {
-  
+
   using lib::test::showSizeof;
   using lib::test::randTime;
   using namespace lumiera::typelist;
-  
-  
-  
-  
-  
+
+
+
+
+
   namespace { // test helpers
-    
+
     ostringstream protocol;     ///< used to verify the test function calls
-    
-    
-    /** 
+
+
+    /**
      * watching the instance creation
-     * of some parameter values 
+     * of some parameter values
      */
     template<typename TY>
     struct Tracker
       {
         TY element_;
         static int instanceCnt;
-        
+
         Tracker (TY init = TY())     : element_(init)         { ++instanceCnt; }
         Tracker (Tracker const& otr) : element_(otr.element_) { ++instanceCnt; }
        ~Tracker()                                             { --instanceCnt; }
-        
+
         TY&
         operator* ()
           {
             return element_;
           }
-        
+
         operator string()  const { return element_; }
-        
+
         friend ostream&
         operator<< (ostream& out, const Tracker& tra)
           {
             return out << tra.element_;
           }
-        
+
         friend bool
         operator== (Tracker const& tra1, Tracker const& tra2)
           {
             return tra1.element_ == tra2.element_;
           }
       };
-    
+
     template<typename TY>
     int Tracker<TY>::instanceCnt (0);
-    
-    
+
+
     /** Dummy custom memento datatype
      *  @note memento needs to be equality comparable
      */
     struct Sint5
       {
         int i[5];
-        
+
         friend bool
         operator== (Sint5 const& i1, Sint5 const& i2)
           {
             return i1.i == i2.i;
           }
       };
-      
-    
-    
+
+
+
     /* === functions to implement test-"operation" & UNDO === */
-    
+
     void
     doIt (Tracker<Time> time, Tracker<string> str, int rand)
       {
@@ -129,88 +129,88 @@ namespace test    {
         cout << "invoke operation..." << endl;
         protocol << fmt % *time % *str % rand;
       }
-    
+
     Tracker<string>
     captureState (Tracker<Time>, Tracker<string> xstr, int)
       {
         cout << "capture state..." << endl;
         return protocol.str() + *xstr;
       }
-    
+
     void
     undoIt (Tracker<Time> time, Tracker<string>, int, Tracker<string> memento)
       {
         cout << "undo... memento=" << memento << endl;
         protocol << "undoIt(time="<<time<<")----memento-:"<< *memento;
       }
-    
-    
+
+
     ///  another dummy-UNDO function
     void dummyU (int,int,int) { }
     int  dummyC (int u,int o) { return u + rand() % (o-u+1); }
-    
-    
-    
+
+
+
     void
     showIt (CmdClosure& clo)
       {
         cout << clo << endl;
       }
-    
+
     void
     checkSerialisation (CmdClosure& clo)
       {
         TODO ("implement serialisation/de-serialisation-Check");
         cout << "would be serialised....." << clo << endl;
-        
+
         // serialise, then de-serialise into a new instance and compare both
       }
-    
-    
+
+
   } // test-helper implementation
-  
-  
-  
-  
-  
-  
+
+
+
+
+
+
   typedef lib::ScopedPtrVect<CmdClosure> ArgTuples;
-  
+
   /***************************************************************************
    * @test Check storage handling of the command parameters and state memento.
-   * 
+   *
    * @see  control::CommandArgumentHolder
    * @see  command-basic-test.hpp
    */
   class CommandArgument_test : public Test
     {
-      
+
       virtual void
-      run (Arg) 
+      run (Arg)
         {
           ArgTuples testTuples;
           Tracker<Time>::instanceCnt = 0;
           Tracker<string>::instanceCnt = 0;
-          
+
           createTuples (testTuples);
           checkArgumentComparison ();
           serialiseArgTuples (testTuples);
           testTuples.clear();
-          
+
           simulateCmdLifecycle();
-          
-          // verify all dtors properly called... 
-          ASSERT (0 == Tracker<Time>::instanceCnt);
-          ASSERT (0 == Tracker<string>::instanceCnt);
+
+          // verify all dtors properly called...
+          CHECK (0 == Tracker<Time>::instanceCnt);
+          CHECK (0 == Tracker<string>::instanceCnt);
         }
-      
-      
+
+
       typedef Tracker<Time> TTime;
       typedef Tracker<string> Tstr;
-      
-      
-      
-      
+
+
+
+
       /** @test create various argument tuples and re-access their contents */
       void
       createTuples (ArgTuples& tup)
@@ -219,102 +219,102 @@ namespace test    {
           typedef ArgumentHolder<void(int),      void*> A2;
           typedef ArgumentHolder<void(int,Time), int>   A3;
           typedef ArgumentHolder<void(int,Time), Sint5> A4;
-          
+
           typedef ArgumentHolder<void(TTime,Tstr,int), Tstr>  A5;
-          
-          
+
+
           A1* arg1 = new A1(); tup.manage (arg1);
           A2* arg2 = new A2(); tup.manage (arg2);
           A3* arg3 = new A3(); tup.manage (arg3);
           A4* arg4 = new A4(); tup.manage (arg4);
           A5* arg5 = new A5(); tup.manage (arg5);
-          
-          ASSERT (isnil (*arg1));
-          ASSERT (isnil (*arg2));
-          ASSERT (isnil (*arg3));
-          ASSERT (isnil (*arg4));
-          ASSERT (isnil (*arg5));
-          
+
+          CHECK (isnil (*arg1));
+          CHECK (isnil (*arg2));
+          CHECK (isnil (*arg3));
+          CHECK (isnil (*arg4));
+          CHECK (isnil (*arg5));
+
           for_each (tup, showIt);
-          
+
           arg1->storeTuple (tuple::makeNullTuple());
           arg2->storeTuple (tuple::make (rand() % 10));
           arg3->storeTuple (tuple::make (rand() % 10, randTime()));
           arg4->storeTuple (tuple::make (rand() % 10, randTime()));
-          
+
           arg5->storeTuple (tuple::make (TTime (randTime()), Tstr("glorious"), rand() % 25));
-          
-          ASSERT (!arg5->canUndo());
-          
+
+          CHECK (!arg5->canUndo());
+
           arg5->tie(undoIt, captureState)
                 .tieCaptureFunc()                         // bind capturing function to memento storage,
                   (TTime(), Tstr("destruction"), 11);    //  then invoke the bound capturing mechanism
-          
-          ASSERT (arg5->canUndo());
-          ASSERT (*arg5->memento() == "destruction");
-          
+
+          CHECK (arg5->canUndo());
+          CHECK (*arg5->memento() == "destruction");
+
           VERIFY_ERROR(MISSING_MEMENTO, arg4->memento().i[3] = 513 );
-          
+
           for_each (tup, showIt);
         }
-      
-      
-      
+
+
+
       /** @test serialise and de-serialise each tuple and check validity
        *  @todo unimplemented, waiting on Serialiser
        */
-      void 
+      void
       serialiseArgTuples (ArgTuples& tup)
         {
           for_each (tup, checkSerialisation);
         }
-      
-      
-      
+
+
+
       /** @test verify the comparison operators */
       void
       checkArgumentComparison ()
         {
           ArgumentHolder<void(int,int), int> one, two;
-          ASSERT (one == two);               // empty, identically typed argument holders -->equal
-          
+          CHECK (one == two);               // empty, identically typed argument holders -->equal
+
           one.tie(dummyU,dummyC)
               .tieCaptureFunc()(1,9);
-          ASSERT (one != two);               // now one contains captured UNDO state
-          
+          CHECK (one != two);               // now one contains captured UNDO state
+
           two.tie(dummyU,dummyC)
               .tieCaptureFunc()(1,9);
           two.memento() = one.memento();     // put the same UNDO state in both
-          ASSERT (one == two);               // ...makes them equal again 
-          
+          CHECK (one == two);               // ...makes them equal again
+
           one.storeTuple (tuple::make (1,2));
-          ASSERT (one != two);               // verify argument tuple comparison
-          ASSERT (two != one);
-          ASSERT (!isnil (one));
-          ASSERT ( isnil (two));
-          
+          CHECK (one != two);               // verify argument tuple comparison
+          CHECK (two != one);
+          CHECK (!isnil (one));
+          CHECK ( isnil (two));
+
           two.storeTuple (tuple::make (3,4));
-          ASSERT (!isnil (two));
-          ASSERT (one != two);
-          ASSERT (two != one);
-          
+          CHECK (!isnil (two));
+          CHECK (one != two);
+          CHECK (two != one);
+
           one.storeTuple (tuple::make (1,4));
-          ASSERT (!isnil (one));
-          ASSERT (one != two);
-          ASSERT (two != one);
-          
+          CHECK (!isnil (one));
+          CHECK (one != two);
+          CHECK (two != one);
+
           one.storeTuple (tuple::make (3,4));
-          ASSERT (!isnil (one));
-          ASSERT (one == two);
-          ASSERT (two == one);
+          CHECK (!isnil (one));
+          CHECK (one == two);
+          CHECK (two == one);
           two.memento() = 12345;
-          ASSERT (!isnil (two));
-          ASSERT (one != two);
-          ASSERT (two != one);
+          CHECK (!isnil (two));
+          CHECK (one != two);
+          CHECK (two != one);
         }
-      
-      
-      
+
+
+
       /** @test simulate a complete command lifecycle with regards to the
        *        storage handling of the command parameters and state memento.
        */
@@ -324,71 +324,71 @@ namespace test    {
           typedef void SIG_do(Tracker<Time>, Tracker<string>, int);
           typedef ArgumentHolder<SIG_do, Tracker<string> >   Args;
           typedef MementoTie<SIG_do, Tracker<string> >  MemHolder;
-          
+
           Args args;
-          ASSERT (isnil (args));
+          CHECK (isnil (args));
           cout << showSizeof(args) << endl;
-          
+
           // store a set of parameter values, later to be used on invocation
           args.storeTuple (
             tuple::make (TTime(randTime()), Tstr("Lumiera rocks"), rand() % 100));
-          ASSERT (!isnil (args));
+          CHECK (!isnil (args));
           cout << args << endl;
-          
-          ASSERT (!args.canUndo());
+
+          CHECK (!args.canUndo());
           VERIFY_ERROR(MISSING_MEMENTO,  args.memento() );
-          
+
           MemHolder& memHolder = args.tie(undoIt,captureState);
-          ASSERT (!memHolder);   // no stored memento.... 
-          ASSERT (!args.canUndo());
-          
+          CHECK (!memHolder);   // no stored memento....
+          CHECK (!args.canUndo());
+
           function<SIG_do> doItFun = doIt;
           function<SIG_do> undoFun = memHolder.tieUndoFunc();
           function<SIG_do> captFun = memHolder.tieCaptureFunc();
-          
+
           typedef function<void()> OpFun;
-          
-          // now close all the functions with the stored parameter values... 
+
+          // now close all the functions with the stored parameter values...
           OpFun bound_doItFun = std::tr1::bind (&CmdClosure::invoke, args, CmdFunctor(doItFun));
           OpFun bound_undoFun = std::tr1::bind (&CmdClosure::invoke, args, CmdFunctor(undoFun));
           OpFun bound_captFun = std::tr1::bind (&CmdClosure::invoke, args, CmdFunctor(captFun));
-          
+
           protocol.seekp(0);
           protocol << "START...";
-          
+
           bound_captFun();
           cout << "captured state: " << args.memento() << endl;
-          ASSERT (memHolder);
-          ASSERT (!isnil (*args.memento()));
-          ASSERT (args.canUndo());
+          CHECK (memHolder);
+          CHECK (!isnil (*args.memento()));
+          CHECK (args.canUndo());
           cout << args << endl;
-          
+
           bound_doItFun();
           cout << protocol.str() << endl;
           bound_undoFun();
           cout << protocol.str() << endl;
-          
+
           // Commands can serve as prototype to be copied....
           Args argsCopy (args);
           bound_captFun();
           protocol.seekp(0);
           protocol << "RESET...";
-          
+
           args.storeTuple (
             tuple::make (TTime(Time(123456)), Tstr("unbelievable"), rand() %100));
           cout << "modified: " << args     << endl;
           cout << "copied  : " << argsCopy << endl;    // holds still the old params & memento
-          
+
           bound_undoFun();
           cout << protocol.str() << endl;
         }
-      
+
     };
-  
-  
-  
+
+
+
   /** Register this test class... */
   LAUNCHER (CommandArgument_test, "unit controller");
-  
-  
+
+
 }} // namespace control::test
diff --git a/tests/components/proc/control/command-basic-test.cpp b/tests/components/proc/control/command-basic-test.cpp
index f75d2b81b..528436430 100644
--- a/tests/components/proc/control/command-basic-test.cpp
+++ b/tests/components/proc/control/command-basic-test.cpp
@@ -101,13 +101,13 @@ namespace test    {
           Command ourCmd = Command::get("test.command1");
           
           // invoke the command
-          ASSERT (*obj == Time(5));
+          CHECK (*obj == Time(5));
           ourCmd();
-          ASSERT (*obj == Time(5) + Time(randVal));
+          CHECK (*obj == Time(5) + Time(randVal));
           
           // undo the effect of the command
           ourCmd.undo();
-          ASSERT (*obj == Time(5));
+          CHECK (*obj == Time(5));
         }
     };
   
diff --git a/tests/components/proc/control/command-binding-test.cpp b/tests/components/proc/control/command-binding-test.cpp
index 3de2b2217..ee20869a8 100644
--- a/tests/components/proc/control/command-binding-test.cpp
+++ b/tests/components/proc/control/command-binding-test.cpp
@@ -65,8 +65,8 @@ namespace test    {
           Command::remove("test.command3.1");
           Command::remove("test.command3.2");
           
-          ASSERT (cnt_defs == Command::definition_count());
-          ASSERT (cnt_inst == Command::instance_count());
+          CHECK (cnt_defs == Command::definition_count());
+          CHECK (cnt_inst == Command::instance_count());
         }
       
       
@@ -83,7 +83,7 @@ namespace test    {
               .execSync()
               ;
           
-          ASSERT ( 1 == command3::check_);
+          CHECK ( 1 == command3::check_);
           
           CommandDef ("test.command3.2")
               .operation (command3::operate)
@@ -91,28 +91,28 @@ namespace test    {
               .undoOperation (command3::undoIt)
               ;
           Command com ("test.command3.2");
-          ASSERT (com.canExec());
+          CHECK (com.canExec());
           cout << string(com) << endl;
           
           com();
-          ASSERT ( 2 == command3::check_);
+          CHECK ( 2 == command3::check_);
           com.undo();
-          ASSERT ( 1 == command3::check_);
+          CHECK ( 1 == command3::check_);
           
           Command commi = com.newInstance();
           com();
           com();
           com();
-          ASSERT ( 4 == command3::check_);
+          CHECK ( 4 == command3::check_);
           
           commi.undo();  // it uses the inherited UNDO state
-          ASSERT ( 1 == command3::check_);
+          CHECK ( 1 == command3::check_);
           
           com.undo();
-          ASSERT ( 3 == command3::check_);
+          CHECK ( 3 == command3::check_);
           
           Command::get("test.command3.1").undo();
-          ASSERT ( 0 == command3::check_);
+          CHECK ( 0 == command3::check_);
         }
     };
   
diff --git a/tests/components/proc/control/command-clone-builder-test.cpp b/tests/components/proc/control/command-clone-builder-test.cpp
index 035af61ff..568ba6c90 100644
--- a/tests/components/proc/control/command-clone-builder-test.cpp
+++ b/tests/components/proc/control/command-clone-builder-test.cpp
@@ -73,7 +73,7 @@ namespace test    {
       run (Arg) 
         {
           CommandRegistry& registry = CommandRegistry::instance();
-          ASSERT (®istry);
+          CHECK (®istry);
           uint cnt_inst = registry.instance_count();
           
           {
@@ -83,7 +83,7 @@ namespace test    {
             verifySeparation (source, clone);
           }
           
-          ASSERT (cnt_inst == registry.instance_count());
+          CHECK (cnt_inst == registry.instance_count());
         }
       
       
@@ -100,12 +100,12 @@ namespace test    {
           function<Sig_capt> c_Fun (command1::capture);
           function<Sig_undo> u_Fun (command1::undoIt);
           
-          ASSERT (o_Fun && c_Fun && u_Fun);
+          CHECK (o_Fun && c_Fun && u_Fun);
           PCmdImpl cmd = registry.newCommandImpl(o_Fun,c_Fun,u_Fun);
           
           // make ready for execution
           bindRandArgument (*cmd);
-          ASSERT (cmd->canExec());
+          CHECK (cmd->canExec());
           return cmd;
         }
       
@@ -117,7 +117,7 @@ namespace test    {
           typedef Types<int> ArgType;
           TypedArguments<Tuple<ArgType> > arg (tuple::make (rand() % 10000));
           cmd.setArguments (arg);
-          ASSERT (cmd.canExec());
+          CHECK (cmd.canExec());
         }
       
       
@@ -129,10 +129,10 @@ namespace test    {
       void
       verifySeparation (PCmdImpl orig, PCmdImpl copy)
         {
-          ASSERT (orig && copy);
-          ASSERT (orig->canExec());
-          ASSERT (copy->canExec());
-          ASSERT (orig == copy);
+          CHECK (orig && copy);
+          CHECK (orig->canExec());
+          CHECK (copy->canExec());
+          CHECK (orig == copy);
           
           
           // prepare for command invocation on implementation level....
@@ -141,29 +141,29 @@ namespace test    {
           command1::check_ = 0;
           
           bindRandArgument (*orig);
-          ASSERT ( orig->canExec());
-          ASSERT (!orig->canUndo());
+          CHECK ( orig->canExec());
+          CHECK (!orig->canUndo());
           testExec.invoke (*orig, "Execute original");     // EXEC 1
           long state_after_exec1 = command1::check_;
-          ASSERT (command1::check_ > 0);
-          ASSERT (orig->canUndo());
-          ASSERT (orig != copy);
+          CHECK (command1::check_ > 0);
+          CHECK (orig->canUndo());
+          CHECK (orig != copy);
           
-          ASSERT (!copy->canUndo());
+          CHECK (!copy->canUndo());
           testExec.invoke (*copy, "Execute clone");        // EXEC 2
-          ASSERT (command1::check_ != state_after_exec1);
-          ASSERT (copy->canUndo());
-          ASSERT (copy != orig);
+          CHECK (command1::check_ != state_after_exec1);
+          CHECK (copy->canUndo());
+          CHECK (copy != orig);
           
           // invoke UNDO on the clone
           testUndo.invoke (*copy, "Undo clone");           // UNDO 2
-          ASSERT (command1::check_ == state_after_exec1);
+          CHECK (command1::check_ == state_after_exec1);
           
           // invoke UNDO on original
           testUndo.invoke (*orig, "Undo original");        // UNDO 1
-          ASSERT (command1::check_ ==0);
+          CHECK (command1::check_ ==0);
           
-          ASSERT (copy != orig);
+          CHECK (copy != orig);
         }
       
     };
diff --git a/tests/components/proc/control/command-equality-test.cpp b/tests/components/proc/control/command-equality-test.cpp
index fc8986fbc..ce400384d 100644
--- a/tests/components/proc/control/command-equality-test.cpp
+++ b/tests/components/proc/control/command-equality-test.cpp
@@ -119,9 +119,9 @@ namespace test    {
       virtual void
       run (Arg) 
         {
-          ASSERT (&oper_1 != &oper_2);
-          ASSERT (&capt_1 != &capt_2);
-          ASSERT (&undo_1 != &undo_2);
+          CHECK (&oper_1 != &oper_2);
+          CHECK (&capt_1 != &capt_2);
+          CHECK (&undo_1 != &undo_2);
           
           verifyMutationEquality();
           verifyMementoEquality();
@@ -144,23 +144,23 @@ namespace test    {
           Mutation mut1 (oFun_1);
           Mutation muti (oFun_1);
           Mutation mut2 (oFun_2);
-          ASSERT (mut1 == mut1);
-          ASSERT (mut1 == muti);
-          ASSERT (muti == mut1);
-          ASSERT (mut1 != mut2);
-          ASSERT (mut2 != mut1);
-          ASSERT (muti != mut2);
-          ASSERT (mut2 != muti);
+          CHECK (mut1 == mut1);
+          CHECK (mut1 == muti);
+          CHECK (muti == mut1);
+          CHECK (mut1 != mut2);
+          CHECK (mut2 != mut1);
+          CHECK (muti != mut2);
+          CHECK (mut2 != muti);
           
           Mutation umu (oFun_empty);    // empty operation function
-          ASSERT (mut1 != umu);
+          CHECK (mut1 != umu);
           
           Mutation mut_u0 (uFun_empty); // empty undo function
-          ASSERT (mut_u0 != umu);
-          ASSERT (mut_u0 != muti);
+          CHECK (mut_u0 != umu);
+          CHECK (mut_u0 != muti);
           
           Mutation mut_u1 (uFun_1); 
-          ASSERT (mut_u0 != mut_u1);    // function signatures differing
+          CHECK (mut_u0 != mut_u1);    // function signatures differing
         }
       
       
@@ -169,40 +169,40 @@ namespace test    {
         {
           ArgHolder a1 (tuple::make ('a'));
           ArgHolder a2 (tuple::make ('z'));
-          ASSERT (a1 == a1);
-          ASSERT (a1 != a2);
-          ASSERT (a2 != a1);
+          CHECK (a1 == a1);
+          CHECK (a1 != a2);
+          CHECK (a2 != a1);
           
           TypedArguments<ArgTuple> newArgs (tuple::make ('z'));
           a1.bindArguments(newArgs);
-          ASSERT (a1 == a2);
-          ASSERT (a2 == a1);
+          CHECK (a1 == a2);
+          CHECK (a2 == a1);
           
           typedef ArgumentHolder<Sig_oper,string> AHImpl;
           AHImpl abuff1;
           AHImpl abuff2;
-          ASSERT (abuff1 == abuff2);
+          CHECK (abuff1 == abuff2);
           abuff1.bindArguments(newArgs);
-          ASSERT (abuff1 != abuff2);
+          CHECK (abuff1 != abuff2);
           abuff2.bindArguments(newArgs);
-          ASSERT (abuff1 == abuff2);
+          CHECK (abuff1 == abuff2);
           UndoMutation umu1 (abuff1.tie (undo_1, capt_1));
-          ASSERT (abuff1 != abuff2);                       // abuff2 isn't tied yet, i.e. has no undo/capture function
+          CHECK (abuff1 != abuff2);                       // abuff2 isn't tied yet, i.e. has no undo/capture function
           UndoMutation umu2 (abuff2.tie (undo_1, capt_1));
-          ASSERT (abuff1 == abuff2);                       // same capture function, no memento state!
+          CHECK (abuff1 == abuff2);                       // same capture function, no memento state!
           
           umu1.captureState(a1);
-          ASSERT (abuff1 != abuff2);
+          CHECK (abuff1 != abuff2);
           umu2.captureState(a1);
-          ASSERT (abuff1 == abuff2); // same functions, same memento state
+          CHECK (abuff1 == abuff2); // same functions, same memento state
           
           check_ += "fake";          // manipulate the "state" to be captured
           umu2.captureState(a1);     // capture again...
-          ASSERT (abuff1 != abuff2); // captured memento differs!
+          CHECK (abuff1 != abuff2); // captured memento differs!
           
           UndoMutation umu3 (abuff2.tie (undo_1, capt_2));
           umu3.captureState(a1);
-          ASSERT (abuff1 != abuff2); // differing functions detected
+          CHECK (abuff1 != abuff2); // differing functions detected
         }
       
       
@@ -222,40 +222,40 @@ namespace test    {
           MemHolder m21 (uFun_2, cFun_empty);   // note: unbound capture function
           MemHolder m22 (uFun_2, cFun_2);
           
-          ASSERT (m11 == m11);
-          ASSERT (m12 == m12);
-          ASSERT (m21 == m21);
-          ASSERT (m22 == m22);
-          ASSERT (!(m11 != m11));
+          CHECK (m11 == m11);
+          CHECK (m12 == m12);
+          CHECK (m21 == m21);
+          CHECK (m22 == m22);
+          CHECK (!(m11 != m11));
           
-          ASSERT (m11 != m12);
-          ASSERT (m11 != m21);
-          ASSERT (m11 != m22);
-          ASSERT (m12 != m11);
-          ASSERT (m12 != m21);
-          ASSERT (m12 != m22);
-          ASSERT (m21 != m11);
-          ASSERT (m21 != m12);
-          ASSERT (m21 != m22);
-          ASSERT (m22 != m11);
-          ASSERT (m22 != m12);
-          ASSERT (m22 != m21);
+          CHECK (m11 != m12);
+          CHECK (m11 != m21);
+          CHECK (m11 != m22);
+          CHECK (m12 != m11);
+          CHECK (m12 != m21);
+          CHECK (m12 != m22);
+          CHECK (m21 != m11);
+          CHECK (m21 != m12);
+          CHECK (m21 != m22);
+          CHECK (m22 != m11);
+          CHECK (m22 != m12);
+          CHECK (m22 != m21);
           
           MemHolder m22x (m22); // clone copy
-          ASSERT (!m22x);
-          ASSERT (m22 == m22x); // same functions, no state --> equal
+          CHECK (!m22x);
+          CHECK (m22 == m22x); // same functions, no state --> equal
           
           m22x.tieCaptureFunc() ('x');   // produce a memento state
-          ASSERT (!isnil (m22x.getState()));
+          CHECK (!isnil (m22x.getState()));
           
-          ASSERT (m22 != m22x);
+          CHECK (m22 != m22x);
           m22.tieCaptureFunc() ('x'); // get same value into the memento within m22
-          ASSERT (m22 == m22x);
+          CHECK (m22 == m22x);
           
           // document shortcomings on UndoMutation comparisons
           UndoMutation umu11 (m11);
           UndoMutation umu12 (m11);    // note: due to cloning the embedded functor,
-          ASSERT (umu11 != umu12);     //       our hacked-in comparison operator fails
+          CHECK (umu11 != umu12);     //       our hacked-in comparison operator fails
         }
       
       
@@ -275,22 +275,22 @@ namespace test    {
           
           Command c1 = Command::get(COMMAND1);
           Command c2 = Command::get(COMMAND2);
-          ASSERT (c1 == c1);
-          ASSERT (c1 != c2);
-          ASSERT (c2 != c1);
+          CHECK (c1 == c1);
+          CHECK (c1 != c2);
+          CHECK (c2 != c1);
           
           Command cx = c1;
-          ASSERT (c1 == cx);
-          ASSERT (cx == c1);
-          ASSERT (!isSameObject (c1, c2));
+          CHECK (c1 == cx);
+          CHECK (cx == c1);
+          CHECK (!isSameObject (c1, c2));
           
           // verify equality matches behaviour
           string protocol1 = execCommand(c1);
           string protocolX = execCommand(cx);
           string protocol2 = execCommand(c2);
           
-          ASSERT (protocol1 == protocolX);
-          ASSERT (protocol1 != protocol2);
+          CHECK (protocol1 == protocolX);
+          CHECK (protocol1 != protocol2);
         }
       
       
diff --git a/tests/components/proc/control/command-mutation-test.cpp b/tests/components/proc/control/command-mutation-test.cpp
index d02822743..7dd5a19eb 100644
--- a/tests/components/proc/control/command-mutation-test.cpp
+++ b/tests/components/proc/control/command-mutation-test.cpp
@@ -104,7 +104,7 @@ namespace test    {
           Mutation functor (funky);
           
           MissingArguments<SIG_fun> nullClosure;
-          ASSERT (!nullClosure);
+          CHECK (!nullClosure);
           cout << "empty placeholder closure: " << nullClosure << endl;
           VERIFY_ERROR (UNBOUND_ARGUMENTS, functor(nullClosure) );
           
@@ -113,15 +113,15 @@ namespace test    {
           Closure<void(int)> close_over (param);
           
           CmdClosure& closure (close_over);
-          ASSERT (closure);
+          CHECK (closure);
           
           cout << "param values: " << closure << endl;
           
           testVal = 0;
           functor(closure);
-          ASSERT (testVal == 23);
+          CHECK (testVal == 23);
           functor(closure);
-          ASSERT (testVal == 2*23);
+          CHECK (testVal == 2*23);
         }
       
       
@@ -150,7 +150,7 @@ namespace test    {
           
           MemHolder mementoHolder (undo_func,cap_func);
           UndoMutation undoFunctor (mementoHolder);
-          ASSERT (!mementoHolder);
+          CHECK (!mementoHolder);
           
           MissingArguments<void(void)> nullClosure;
           VERIFY_ERROR (UNBOUND_ARGUMENTS, undoFunctor(nullClosure) );
@@ -159,29 +159,29 @@ namespace test    {
           Tuple<Types<> > param;
           Closure<void()> clo (param);
           
-          ASSERT (!mementoHolder);
+          CHECK (!mementoHolder);
           VERIFY_ERROR (MISSING_MEMENTO, undoFunctor (clo) );
           VERIFY_ERROR (MISSING_MEMENTO, mementoHolder.getState() );
           
           testVal = 11;
           undoFunctor.captureState(clo);
-          ASSERT (mementoHolder);
-          ASSERT (testVal == 11);
+          CHECK (mementoHolder);
+          CHECK (testVal == 11);
           
           int mem = mementoHolder.getState();
           cout << "saved state: " << mem << endl;
           
           undoFunctor(clo);
-          ASSERT (testVal == 11 + 11);
+          CHECK (testVal == 11 + 11);
           undoFunctor(clo);
-          ASSERT (testVal == 11 + 11 + 11);
+          CHECK (testVal == 11 + 11 + 11);
           undoFunctor.captureState(clo);
-          ASSERT (33 == mementoHolder.getState());
+          CHECK (33 == mementoHolder.getState());
           undoFunctor(clo);
-          ASSERT (testVal == 33 + 33);
+          CHECK (testVal == 33 + 33);
           testVal = 9;
           undoFunctor(clo);
-          ASSERT (testVal == 42);
+          CHECK (testVal == 42);
         }
       
       
@@ -201,11 +201,11 @@ namespace test    {
           int rr (rand() % 100);
           testVal = rr;
           bound_cap_func();       // invoke state capturing 
-          ASSERT (rr == mementoHolder.getState());
+          CHECK (rr == mementoHolder.getState());
           
           testVal = 10;        // meanwhile "somehow" mutate the state
           bound_undo_func();  // invoking the undo() feeds back the memento
-          ASSERT (testVal == 10+rr);
+          CHECK (testVal == 10+rr);
         }
     };
   
diff --git a/tests/components/proc/control/command-registry-test.cpp b/tests/components/proc/control/command-registry-test.cpp
index dae04ca7a..c44c8edef 100644
--- a/tests/components/proc/control/command-registry-test.cpp
+++ b/tests/components/proc/control/command-registry-test.cpp
@@ -73,7 +73,7 @@ namespace test    {
       run (Arg) 
         {
           CommandRegistry& registry = CommandRegistry::instance();
-          ASSERT (®istry);
+          CHECK (®istry);
           
           cnt_defs = registry.index_size();
           cnt_inst = registry.instance_count();
@@ -87,17 +87,17 @@ namespace test    {
           
           // this command definition is
           // represented internally by a prototype instance
-          ASSERT (++cnt_inst == registry.instance_count());
-          ASSERT (++cnt_defs == registry.index_size());
+          CHECK (++cnt_inst == registry.instance_count());
+          CHECK (++cnt_defs == registry.index_size());
           
           checkRegistration (registry);
           checkAllocation(registry);
           
-          ASSERT (cnt_inst == registry.instance_count());
-          ASSERT (cnt_defs == registry.index_size());
+          CHECK (cnt_inst == registry.instance_count());
+          CHECK (cnt_defs == registry.index_size());
           
           Command::remove (TEST_CMD);
-          ASSERT (--cnt_inst == registry.instance_count());
+          CHECK (--cnt_inst == registry.instance_count());
         }
       
       
@@ -108,59 +108,59 @@ namespace test    {
       void
       checkRegistration (CommandRegistry& registry)
         {
-          ASSERT (cnt_inst == registry.instance_count());
+          CHECK (cnt_inst == registry.instance_count());
           
           Command cmd1 = registry.queryIndex (TEST_CMD);
-          ASSERT (cmd1);
-          ASSERT (TEST_CMD == registry.findDefinition(cmd1));
+          CHECK (cmd1);
+          CHECK (TEST_CMD == registry.findDefinition(cmd1));
           
           Command nonexistant = registry.queryIndex("miraculous");
-          ASSERT (!nonexistant);
+          CHECK (!nonexistant);
           
           // now create a clone, registered under a different ID
           Command cmd2 = cmd1.storeDef(TEST_CMD2);
-          ASSERT (cmd2 == cmd1);
+          CHECK (cmd2 == cmd1);
           cmd2.bind(54321);
-          ASSERT (cmd2 != cmd1);
+          CHECK (cmd2 != cmd1);
           
           // this created exactly one additional instance allocation:
-          ASSERT (1+cnt_inst == registry.instance_count());
-          ASSERT (1+cnt_defs == registry.index_size());
+          CHECK (1+cnt_inst == registry.instance_count());
+          CHECK (1+cnt_defs == registry.index_size());
           // ...and another index entry
           
           
           Command cmdX = registry.queryIndex(TEST_CMD2);
-          ASSERT (cmdX == cmd2);
-          ASSERT (cmdX != cmd1);
+          CHECK (cmdX == cmd2);
+          CHECK (cmdX != cmd1);
           
-          ASSERT (registry.remove(TEST_CMD2));
-          ASSERT (!registry.queryIndex(TEST_CMD2));
-          ASSERT (cnt_defs == registry.index_size());        //  removed from index
-          ASSERT (1+cnt_inst == registry.instance_count()); //...but still alive
+          CHECK (registry.remove(TEST_CMD2));
+          CHECK (!registry.queryIndex(TEST_CMD2));
+          CHECK (cnt_defs == registry.index_size());        //  removed from index
+          CHECK (1+cnt_inst == registry.instance_count()); //...but still alive
           
           // create a new registration..
           registry.track(TEST_CMD2, cmd2);
-          ASSERT (registry.queryIndex(TEST_CMD2));
-          ASSERT (1+cnt_defs == registry.index_size()); // again holding two distinct entries
-          ASSERT (cmdX == cmd2);
-          ASSERT (cmdX != cmd1);
+          CHECK (registry.queryIndex(TEST_CMD2));
+          CHECK (1+cnt_defs == registry.index_size()); // again holding two distinct entries
+          CHECK (cmdX == cmd2);
+          CHECK (cmdX != cmd1);
           
-          ASSERT (TEST_CMD  == registry.findDefinition(cmd1));
-          ASSERT (TEST_CMD2 == registry.findDefinition(cmd2));
-          ASSERT (TEST_CMD2 == registry.findDefinition(cmdX));
+          CHECK (TEST_CMD  == registry.findDefinition(cmd1));
+          CHECK (TEST_CMD2 == registry.findDefinition(cmd2));
+          CHECK (TEST_CMD2 == registry.findDefinition(cmdX));
           
-          ASSERT ( registry.remove(TEST_CMD2));
-          ASSERT (!registry.remove("miraculous"));
+          CHECK ( registry.remove(TEST_CMD2));
+          CHECK (!registry.remove("miraculous"));
           
-          ASSERT (!registry.queryIndex(TEST_CMD2));
-          ASSERT ( registry.queryIndex(TEST_CMD));
-          ASSERT (cnt_defs == registry.index_size());       // the index entry is gone,
+          CHECK (!registry.queryIndex(TEST_CMD2));
+          CHECK ( registry.queryIndex(TEST_CMD));
+          CHECK (cnt_defs == registry.index_size());       // the index entry is gone,
           
-          ASSERT (1+cnt_inst == registry.instance_count()); // but the allocation still lives
+          CHECK (1+cnt_inst == registry.instance_count()); // but the allocation still lives
           cmdX.close();
-          ASSERT (1+cnt_inst == registry.instance_count());
+          CHECK (1+cnt_inst == registry.instance_count());
           cmd2.close();
-          ASSERT (0+cnt_inst == registry.instance_count()); // ...as long as it's still referred
+          CHECK (0+cnt_inst == registry.instance_count()); // ...as long as it's still referred
         }
       
       
@@ -182,8 +182,8 @@ namespace test    {
           function<Sig_capt> c_Fun (command1::capture);
           function<Sig_undo> u_Fun (command1::undoIt);
           
-          ASSERT (o_Fun && c_Fun && u_Fun);
-          ASSERT (cnt_inst == registry.instance_count());
+          CHECK (o_Fun && c_Fun && u_Fun);
+          CHECK (cnt_inst == registry.instance_count());
           
           // when the CommandDef is complete, it issues the
           // allocation call to the registry behind the scenes....
@@ -191,42 +191,42 @@ namespace test    {
           typedef shared_ptr<CommandImpl> PImpl;
           
           PImpl pImpl = registry.newCommandImpl(o_Fun,c_Fun,u_Fun);
-          ASSERT (1+cnt_inst == registry.instance_count());
+          CHECK (1+cnt_inst == registry.instance_count());
           
-          ASSERT (pImpl);
-          ASSERT (pImpl->isValid());
-          ASSERT (!pImpl->canExec());
-          ASSERT (1 == pImpl.use_count());   // no magic involved, we hold the only instance
+          CHECK (pImpl);
+          CHECK (pImpl->isValid());
+          CHECK (!pImpl->canExec());
+          CHECK (1 == pImpl.use_count());   // no magic involved, we hold the only instance
           
           PImpl clone = registry.createCloneImpl(*pImpl);
-          ASSERT (clone->isValid());
-          ASSERT (!clone->canExec());
-          ASSERT (1 == clone.use_count());
-          ASSERT (1 == pImpl.use_count());
-          ASSERT (2+cnt_inst == registry.instance_count());
+          CHECK (clone->isValid());
+          CHECK (!clone->canExec());
+          CHECK (1 == clone.use_count());
+          CHECK (1 == pImpl.use_count());
+          CHECK (2+cnt_inst == registry.instance_count());
           
-          ASSERT (!isSameObject (*pImpl, *clone));
-          ASSERT (*pImpl == *clone);
+          CHECK (!isSameObject (*pImpl, *clone));
+          CHECK (*pImpl == *clone);
           
-          ASSERT (!pImpl->canExec());
+          CHECK (!pImpl->canExec());
           typedef Types<int> ArgType;
           TypedArguments<Tuple<ArgType> > arg (Tuple<ArgType>(98765));
           pImpl->setArguments(arg);
-          ASSERT (pImpl->canExec());
+          CHECK (pImpl->canExec());
           
-          ASSERT (!clone->canExec()); // this proves the clone has indeed a separate identity
-          ASSERT (*pImpl != *clone);
+          CHECK (!clone->canExec()); // this proves the clone has indeed a separate identity
+          CHECK (*pImpl != *clone);
           
           // discard the first clone and overwrite with a new one
           clone = registry.createCloneImpl(*pImpl);
-          ASSERT (2+cnt_inst == registry.instance_count());
-          ASSERT (*pImpl == *clone);
-          ASSERT (clone->canExec());
+          CHECK (2+cnt_inst == registry.instance_count());
+          CHECK (*pImpl == *clone);
+          CHECK (clone->canExec());
           
           clone.reset();
           pImpl.reset();
           // corresponding allocation slots cleared automatically
-          ASSERT (cnt_inst == registry.instance_count());
+          CHECK (cnt_inst == registry.instance_count());
         }
       
     };
diff --git a/tests/components/proc/control/command-use1-test.cpp b/tests/components/proc/control/command-use1-test.cpp
index 8e2452551..68c37ebff 100644
--- a/tests/components/proc/control/command-use1-test.cpp
+++ b/tests/components/proc/control/command-use1-test.cpp
@@ -80,9 +80,9 @@ namespace test    {
           stringRepresentation();
           undef();
           
-          ASSERT (0 == command1::check_);
-          ASSERT (cnt_defs == Command::definition_count());
-          ASSERT (cnt_inst == Command::instance_count());
+          CHECK (0 == command1::check_);
+          CHECK (cnt_defs == Command::definition_count());
+          CHECK (cnt_inst == Command::instance_count());
         }
       
       
@@ -98,10 +98,10 @@ namespace test    {
               .execSync()
               ;
           
-          ASSERT (randVal == command1::check_);
+          CHECK (randVal == command1::check_);
           
           Command::get("test.command1.1").undo();
-          ASSERT ( 0 == command1::check_);
+          CHECK ( 0 == command1::check_);
         }
       
       
@@ -115,36 +115,36 @@ namespace test    {
                  .undoOperation (command1::undoIt)
                  ;
           }
-          ASSERT (CommandDef("test.command1.2"));
+          CHECK (CommandDef("test.command1.2"));
           
           Command com ("test.command1.2");
-          ASSERT (com);
-          ASSERT (com == Command::get("test.command1.2"));
-          ASSERT (contains (str(com), "test.command1.2"));
-          ASSERT (contains (str(com), "{def}"));
-          ASSERT (!com.canExec());
+          CHECK (com);
+          CHECK (com == Command::get("test.command1.2"));
+          CHECK (contains (str(com), "test.command1.2"));
+          CHECK (contains (str(com), "{def}"));
+          CHECK (!com.canExec());
           VERIFY_ERROR (UNBOUND_ARGUMENTS, com() );
-          ASSERT ( 0 == command1::check_);
+          CHECK ( 0 == command1::check_);
           
           VERIFY_ERROR (INVALID_ARGUMENTS, com.bind ("foo") );
           com.bind (random());             // note: run-time type check only
-          ASSERT ( com.canExec());
-          ASSERT (!com.canUndo());
+          CHECK ( com.canExec());
+          CHECK (!com.canUndo());
           com();
-          ASSERT (randVal == command1::check_);
+          CHECK (randVal == command1::check_);
           com.undo();
-          ASSERT ( 0 == command1::check_);
+          CHECK ( 0 == command1::check_);
           
           // the following shortcut does the same:
           invoke ("test.command1.2") (1234);
-          ASSERT ( 1234 == command1::check_);
+          CHECK ( 1234 == command1::check_);
           
           // another shortcut, with static type check:
 //        invoke (command1::operate) (5678);                                  //////////////////TICKET #291  : unimplemented for now (9/09)
-//        ASSERT ( 1234+5678 == command1::check_);
+//        CHECK ( 1234+5678 == command1::check_);
           
           com.undo();
-          ASSERT ( 0 == command1::check_);
+          CHECK ( 0 == command1::check_);
         }
       
       
@@ -155,43 +155,43 @@ namespace test    {
           VERIFY_ERROR (INVALID_COMMAND, Command::get("test.command1.2") );
           
           CommandDef def ("test.command1.2");
-          ASSERT (!def);
+          CHECK (!def);
           
           def.operation (command1::operate)
              .captureUndo (command1::capture);
-          ASSERT (!def);                       // undo functor still missing
+          CHECK (!def);                       // undo functor still missing
           VERIFY_ERROR (INVALID_COMMAND, Command::get("test.command1.2") );
           
           def.operation (command1::operate)
              .captureUndo (command1::capture)
              .undoOperation (command1::undoIt);
-          ASSERT (def);
-          ASSERT (CommandDef("test.command1.2"));
-          ASSERT (Command::get("test.command1.2"));
+          CHECK (def);
+          CHECK (CommandDef("test.command1.2"));
+          CHECK (Command::get("test.command1.2"));
           
-          ASSERT ( Command::defined("test.command1.2"));
-          ASSERT (!Command::canExec("test.command1.2"));
-          ASSERT (!Command::canUndo("test.command1.2"));
+          CHECK ( Command::defined("test.command1.2"));
+          CHECK (!Command::canExec("test.command1.2"));
+          CHECK (!Command::canUndo("test.command1.2"));
           
           Command com = Command::get("test.command1.2");
-          ASSERT (com);
-          ASSERT (!com.canExec());
-          ASSERT (!com.canUndo());
+          CHECK (com);
+          CHECK (!com.canExec());
+          CHECK (!com.canUndo());
           
           com.bind (11111);
-          ASSERT ( Command::defined("test.command1.2"));
-          ASSERT ( Command::canExec("test.command1.2"));
-          ASSERT (!Command::canUndo("test.command1.2"));
+          CHECK ( Command::defined("test.command1.2"));
+          CHECK ( Command::canExec("test.command1.2"));
+          CHECK (!Command::canUndo("test.command1.2"));
           
           com();
-          ASSERT ( Command::defined("test.command1.2"));
-          ASSERT ( Command::canExec("test.command1.2"));
-          ASSERT ( Command::canUndo("test.command1.2"));
+          CHECK ( Command::defined("test.command1.2"));
+          CHECK ( Command::canExec("test.command1.2"));
+          CHECK ( Command::canUndo("test.command1.2"));
           
           com.undo();
-          ASSERT ( Command::defined("test.command1.2"));
-          ASSERT ( Command::canExec("test.command1.2"));
-          ASSERT ( Command::canUndo("test.command1.2"));
+          CHECK ( Command::defined("test.command1.2"));
+          CHECK ( Command::canExec("test.command1.2"));
+          CHECK ( Command::canUndo("test.command1.2"));
         }
       
       
@@ -205,7 +205,7 @@ namespace test    {
                .bind (random())
                ;
           
-          ASSERT (Command::get("test.command1.3").canExec());
+          CHECK (Command::get("test.command1.3").canExec());
         }
       
       
@@ -213,73 +213,73 @@ namespace test    {
       usePrototype()
         {
           Command c1 = Command::get("test.command1.3");
-          ASSERT (c1);
-          ASSERT (c1.canExec());
-          ASSERT (!c1.canUndo());
+          CHECK (c1);
+          CHECK (c1.canExec());
+          CHECK (!c1.canUndo());
           
           Command c2 = c1.newInstance();
-          ASSERT (c2);
-          ASSERT (c2.canExec());
-          ASSERT (!c2.canUndo());
+          CHECK (c2);
+          CHECK (c2.canExec());
+          CHECK (!c2.canUndo());
           
-          ASSERT (c1 == c2);
-          ASSERT (!isSameObject(c1, c2));
+          CHECK (c1 == c2);
+          CHECK (!isSameObject(c1, c2));
           
-          ASSERT (0 == command1::check_);
+          CHECK (0 == command1::check_);
           
           c1();
           
-          ASSERT (randVal == command1::check_);
-          ASSERT ( c1.canUndo());
-          ASSERT (!c2.canUndo());
-          ASSERT (c1 != c2);
+          CHECK (randVal == command1::check_);
+          CHECK ( c1.canUndo());
+          CHECK (!c2.canUndo());
+          CHECK (c1 != c2);
           
           c2();
-          ASSERT (randVal + randVal == command1::check_);
-          ASSERT (c2.canUndo());
-          ASSERT (c1 != c2);
+          CHECK (randVal + randVal == command1::check_);
+          CHECK (c2.canUndo());
+          CHECK (c1 != c2);
           
           c1.undo();
-          ASSERT (0 == command1::check_);
+          CHECK (0 == command1::check_);
           c2.undo();
-          ASSERT (randVal == command1::check_);
+          CHECK (randVal == command1::check_);
           
           c2.bind(23);
           c2();
-          ASSERT (randVal + 23 == command1::check_);
+          CHECK (randVal + 23 == command1::check_);
           
           // you should not use a command more than once (but it works...)
           c1();
-          ASSERT (randVal + 23 + randVal == command1::check_);
+          CHECK (randVal + 23 + randVal == command1::check_);
           c1.undo();
-          ASSERT (randVal + 23 == command1::check_);
+          CHECK (randVal + 23 == command1::check_);
           // note we've overwritten the previous undo state
           // and get the sate captured on the second invocation
           
           c2.undo();
-          ASSERT (randVal == command1::check_);
+          CHECK (randVal == command1::check_);
           c1.undo();
-          ASSERT (randVal + 23 == command1::check_);
+          CHECK (randVal + 23 == command1::check_);
           
           // use the current sate of c2 as Prototype for new command definition
           c2.storeDef ("test.command1.4");
           Command c4 = Command::get("test.command1.4");
-          ASSERT (c4);
-          ASSERT (c4.canExec());
-          ASSERT (c4.canUndo());
-          ASSERT (c4 == c2);
-          ASSERT (c4 != c1);
+          CHECK (c4);
+          CHECK (c4.canExec());
+          CHECK (c4.canUndo());
+          CHECK (c4 == c2);
+          CHECK (c4 != c1);
           c4();
-          ASSERT (c4 != c2); // now lives independently from the original
-          ASSERT (randVal + 2*23 == command1::check_);
+          CHECK (c4 != c2); // now lives independently from the original
+          CHECK (randVal + 2*23 == command1::check_);
           
           c4.bind(int(-command1::check_)); // new command argument binding
           c4();
-          ASSERT (0 == command1::check_);
+          CHECK (0 == command1::check_);
           c2();
-          ASSERT (23 == command1::check_);
+          CHECK (23 == command1::check_);
           c2.undo();
-          ASSERT (0 == command1::check_);
+          CHECK (0 == command1::check_);
         }
       
       
@@ -292,13 +292,13 @@ namespace test    {
               .captureUndo (command1::capture)   \
               .undoOperation (command1::undoIt)
           
-          ASSERT (CommandDef ("test.command1.1"));
+          CHECK (CommandDef ("test.command1.1"));
           VERIFY_ERROR (DUPLICATE_COMMAND, BUILD_NEW_COMMAND_DEF ("test.command1.1") );
-          ASSERT (CommandDef ("test.command1.2"));
+          CHECK (CommandDef ("test.command1.2"));
           VERIFY_ERROR (DUPLICATE_COMMAND, BUILD_NEW_COMMAND_DEF ("test.command1.2") );
-          ASSERT (CommandDef ("test.command1.3"));
+          CHECK (CommandDef ("test.command1.3"));
           VERIFY_ERROR (DUPLICATE_COMMAND, BUILD_NEW_COMMAND_DEF ("test.command1.3") );
-          ASSERT (CommandDef ("test.command1.4"));
+          CHECK (CommandDef ("test.command1.4"));
           VERIFY_ERROR (DUPLICATE_COMMAND, BUILD_NEW_COMMAND_DEF ("test.command1.4") );
         }
       
@@ -331,21 +331,21 @@ namespace test    {
       void
       undef()
         {
-          ASSERT (CommandDef ("test.command1.1"));
-          ASSERT (CommandDef ("test.command1.2"));
-          ASSERT (CommandDef ("test.command1.3"));
-          ASSERT (CommandDef ("test.command1.4"));
+          CHECK (CommandDef ("test.command1.1"));
+          CHECK (CommandDef ("test.command1.2"));
+          CHECK (CommandDef ("test.command1.3"));
+          CHECK (CommandDef ("test.command1.4"));
           
-          ASSERT (Command::get("test.command1.1"));
-          ASSERT (Command::get("test.command1.2"));
-          ASSERT (Command::get("test.command1.3"));
-          ASSERT (Command::get("test.command1.4"));
+          CHECK (Command::get("test.command1.1"));
+          CHECK (Command::get("test.command1.2"));
+          CHECK (Command::get("test.command1.3"));
+          CHECK (Command::get("test.command1.4"));
           
           VERIFY_ERROR (INVALID_COMMAND, Command::get("miracle"));
           VERIFY_ERROR (INVALID_COMMAND, invoke ("miracle") (1,2,3));
           
           CommandDef unbelievable ("miracle");
-          ASSERT (!unbelievable);
+          CHECK (!unbelievable);
           
           Command miracle;
           // but because the miracle isn't yet defined, any use throws
@@ -353,19 +353,19 @@ namespace test    {
           VERIFY_ERROR (INVALID_COMMAND, miracle.execSync());
           VERIFY_ERROR (INVALID_COMMAND, miracle.undo());
           VERIFY_ERROR (INVALID_COMMAND, miracle());
-          ASSERT (!miracle.canExec());
-          ASSERT (!miracle.canUndo());
-          ASSERT (!miracle);
+          CHECK (!miracle.canExec());
+          CHECK (!miracle.canUndo());
+          CHECK (!miracle);
           
           Command c5 (Command::get("test.command1.5"));
           
-          ASSERT (Command::remove("test.command1.1"));
-          ASSERT (Command::remove("test.command1.2"));
-          ASSERT (Command::remove("test.command1.3"));
-          ASSERT (Command::remove("test.command1.4"));
-          ASSERT (Command::remove("test.command1.5"));
+          CHECK (Command::remove("test.command1.1"));
+          CHECK (Command::remove("test.command1.2"));
+          CHECK (Command::remove("test.command1.3"));
+          CHECK (Command::remove("test.command1.4"));
+          CHECK (Command::remove("test.command1.5"));
           
-          ASSERT (!Command::remove("miracle")); // there is no such thing...
+          CHECK (!Command::remove("miracle")); // there is no such thing...
           
           VERIFY_ERROR (INVALID_COMMAND,   Command::get("test.command1.1"));
           VERIFY_ERROR (INVALID_COMMAND,   Command::get("test.command1.2"));
@@ -378,8 +378,8 @@ namespace test    {
           // note, removed the registered definitions,
           // but existing instances remain valid...
           // thus we're free to create new instances...
-          ASSERT (c5.isValid());
-          ASSERT (c5.canExec());
+          CHECK (c5.isValid());
+          CHECK (c5.canExec());
         }
     };
   
diff --git a/tests/components/proc/control/command-use2-test.cpp b/tests/components/proc/control/command-use2-test.cpp
index a0acf000f..9b407d90e 100644
--- a/tests/components/proc/control/command-use2-test.cpp
+++ b/tests/components/proc/control/command-use2-test.cpp
@@ -122,8 +122,8 @@ namespace test    {
           
           Command::remove ("test.command2");
           Command::remove ("test.command2.1");
-          ASSERT (cnt_defs == Command::definition_count());
-          ASSERT (cnt_inst == Command::instance_count());
+          CHECK (cnt_defs == Command::definition_count());
+          CHECK (cnt_inst == Command::instance_count());
         }
       
       
@@ -133,31 +133,31 @@ namespace test    {
         {
           Command com = Command::get("test.command2");
           
-          ASSERT (!protocolled("invoked"));
+          CHECK (!protocolled("invoked"));
           
           bool res = com();
           
-          ASSERT (res);
-          ASSERT (protocolled("invoked"));
-          ASSERT (protocolled(randVal_));
+          CHECK (res);
+          CHECK (protocolled("invoked"));
+          CHECK (protocolled(randVal_));
           
           res = com.undo();
-          ASSERT (res);        // UNDO invoked successfully
-          ASSERT (!protocolled(randVal_));
-          ASSERT (protocolled("UNDO"));
+          CHECK (res);        // UNDO invoked successfully
+          CHECK (!protocolled(randVal_));
+          CHECK (protocolled("UNDO"));
           
           blowUp_ = true;
           string current = command2::check_.str();
           
           res = com();
-          ASSERT (!res);       // not executed successfully (exception thrown)
-          ASSERT (command2::check_.str() == current);
-          ASSERT (LUMIERA_ERROR_EXTERNAL == lumiera_error());
+          CHECK (!res);       // not executed successfully (exception thrown)
+          CHECK (command2::check_.str() == current);
+          CHECK (LUMIERA_ERROR_EXTERNAL == lumiera_error());
           
           res = com.undo();
-          ASSERT (!res);       // UNDO failed (exception thrown)
-          ASSERT (command2::check_.str() == current);
-          ASSERT (LUMIERA_ERROR_EXTERNAL == lumiera_error());
+          CHECK (!res);       // UNDO failed (exception thrown)
+          CHECK (command2::check_.str() == current);
+          CHECK (LUMIERA_ERROR_EXTERNAL == lumiera_error());
           
           blowUp_ = false;
         }
@@ -171,14 +171,14 @@ namespace test    {
           
           blowUp_ = false;
           com.exec(HandlingPattern::SYNC_THROW);
-          ASSERT (protocolled(randVal_));
+          CHECK (protocolled(randVal_));
           
           blowUp_ = true;
           string current = command2::check_.str();
           HandlingPattern const& doThrow = HandlingPattern::get(HandlingPattern::SYNC_THROW);
           
           VERIFY_ERROR( EXTERNAL, com.exec (doThrow) );
-          ASSERT (command2::check_.str() == current);
+          CHECK (command2::check_.str() == current);
           
           // we can achieve the same effect,
           // after changing the default HandlingPatern for this command instance
@@ -187,15 +187,15 @@ namespace test    {
           
           Command com2 = Command::get("test.command2.1");
           VERIFY_ERROR( EXTERNAL, com2() );
-          ASSERT (command2::check_.str() == current);
+          CHECK (command2::check_.str() == current);
 
           blowUp_ = false;
           com2();
-          ASSERT (command2::check_.str() > current);
-          ASSERT (protocolled(randVal_));
+          CHECK (command2::check_.str() > current);
+          CHECK (protocolled(randVal_));
           
           com2.undo();
-          ASSERT (!protocolled(randVal_));
+          CHECK (!protocolled(randVal_));
         }
     };
   
diff --git a/tests/components/proc/control/command-use3-test.cpp b/tests/components/proc/control/command-use3-test.cpp
index c69f1bb24..441acd881 100644
--- a/tests/components/proc/control/command-use3-test.cpp
+++ b/tests/components/proc/control/command-use3-test.cpp
@@ -89,10 +89,10 @@ namespace test    {
           UNIMPLEMENTED ("more elaborate command handling patterns");
           ////////////////////////////////////////////////////////////////////////////////TODO: devise tests for async, repeated and compound sequences
           
-          ASSERT (cnt_inst == Command::instance_count());
+          CHECK (cnt_inst == Command::instance_count());
           
           Command::remove ("test.command1.1");
-          ASSERT (cnt_defs == Command::definition_count());
+          CHECK (cnt_defs == Command::definition_count());
         }
       
       
diff --git a/tests/components/proc/control/handling-pattern-basics-test.cpp b/tests/components/proc/control/handling-pattern-basics-test.cpp
index 16f6ff878..b18fc28c3 100644
--- a/tests/components/proc/control/handling-pattern-basics-test.cpp
+++ b/tests/components/proc/control/handling-pattern-basics-test.cpp
@@ -1,23 +1,23 @@
 /*
   HandlingPatternBasics(Test)  -  verify elementary operation of a command handling pattern
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2 of the
   License, or (at your option) any later version.
- 
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
@@ -36,29 +36,29 @@
 
 namespace control {
 namespace test    {
-  
-  
+
+
   using lib::Symbol;
   using std::tr1::function;
   using std::rand;
-  
-  
+
+
   namespace { // test data and helpers...
-  
+
     Symbol TEST_CMD  = "test.command1.handling";
     HandlingPattern::ID TEST_PATTERN = HandlingPattern::DUMMY;
   }
-  
+
   typedef shared_ptr<CommandImpl> PCommandImpl;
   typedef HandlingPattern const& HaPatt;
-  
-  
-  
+
+
+
   /**********************************************************************************
    * @test operate and verify a simple dummy command handling pattern.
    * @note this test covers mainly the behaviour of a handling pattern as a concept,
    *       not so much the behaviour of the (standard) handling pattern implementations.
-   * 
+   *
    * @see HandlingPattern
    * @see BasicHandlingPattern
    * @see command.hpp
@@ -66,28 +66,28 @@ namespace test    {
    */
   class HandlingPatternBasics_test : public Test
     {
-      
+
       uint cnt_inst;
-      
-      
+
+
       virtual void
-      run (Arg) 
+      run (Arg)
         {
           CommandRegistry& registry = CommandRegistry::instance();
-          ASSERT (®istry);
-          
+          CHECK (®istry);
+
           cnt_inst = registry.instance_count();
-      
+
           {
             PCommandImpl pCom = buildTestCommand(registry);
             checkExec (pCom);
             checkUndo (pCom);
           }
-          
-          ASSERT (cnt_inst == registry.instance_count());
+
+          CHECK (cnt_inst == registry.instance_count());
         }
-      
-      
+
+
       /** create a command implementation frame usable for tests.
        *  This simulates what normally happens within a CommandDef.
        *  The created CommandImpl isn't registered, and thus will
@@ -96,74 +96,74 @@ namespace test    {
       PCommandImpl
       buildTestCommand (CommandRegistry& registry)
         {
-          
+
           typedef void Sig_oper(int);
           typedef long Sig_capt(int);
           typedef void Sig_undo(int,long);
-          
+
           function<Sig_oper> o_Fun (command1::operate);
           function<Sig_capt> c_Fun (command1::capture);
           function<Sig_undo> u_Fun (command1::undoIt);
-          
-          ASSERT (o_Fun && c_Fun && u_Fun);
-          
+
+          CHECK (o_Fun && c_Fun && u_Fun);
+
           // when the CommandDef is complete, it issues the
           // allocation call to the registry behind the scenes....
-          
+
           PCommandImpl pImpl = registry.newCommandImpl(o_Fun,c_Fun,u_Fun);
-          ASSERT (pImpl); 
-          ASSERT (*pImpl);
+          CHECK (pImpl);
+          CHECK (*pImpl);
           return pImpl;
         }
-      
-      
+
+
       void
       checkExec (PCommandImpl com)
         {
-          ASSERT (com);
-          ASSERT (!com->canExec());
-          
+          CHECK (com);
+          CHECK (!com->canExec());
+
           typedef Types<int> ArgType;
           const int ARGU (1 + rand() % 1000);
           Tuple<ArgType> tuple(ARGU);
           TypedArguments<Tuple<ArgType> > arg(tuple);
           com->setArguments(arg);
-          
-          ASSERT (com->canExec());
-          ASSERT (!com->canUndo());
+
+          CHECK (com->canExec());
+          CHECK (!com->canUndo());
           command1::check_ = 0;
-          
+
           HaPatt patt = HandlingPattern::get(TEST_PATTERN);
           ExecResult res = patt.invoke(*com, TEST_CMD);
-          
-          ASSERT (res);
-          ASSERT (ARGU == command1::check_);
-          ASSERT (com->canUndo());
+
+          CHECK (res);
+          CHECK (ARGU == command1::check_);
+          CHECK (com->canUndo());
         }
-      
-      
+
+
       void
       checkUndo (PCommandImpl com)
         {
-          ASSERT (com);
-          ASSERT (com->canExec());
-          ASSERT (com->canUndo());
-          
-          ASSERT (command1::check_ > 0);
-          
+          CHECK (com);
+          CHECK (com->canExec());
+          CHECK (com->canUndo());
+
+          CHECK (command1::check_ > 0);
+
           HaPatt ePatt = HandlingPattern::get(TEST_PATTERN);
           HaPatt uPatt = ePatt.howtoUNDO();
           ExecResult res = uPatt.invoke(*com, TEST_CMD);
-          
-          ASSERT (res);
-          ASSERT (command1::check_ == 0);
+
+          CHECK (res);
+          CHECK (command1::check_ == 0);
         }
-      
+
     };
-  
-  
+
+
   /** Register this test class... */
   LAUNCHER (HandlingPatternBasics_test, "function controller");
-  
-  
+
+
 }} // namespace control::test
diff --git a/tests/components/proc/control/handling-pattern-standard-impl-test.cpp b/tests/components/proc/control/handling-pattern-standard-impl-test.cpp
index a83eed6d7..996116a50 100644
--- a/tests/components/proc/control/handling-pattern-standard-impl-test.cpp
+++ b/tests/components/proc/control/handling-pattern-standard-impl-test.cpp
@@ -108,13 +108,13 @@ namespace test    {
       run (Arg) 
         {
           CommandRegistry& registry = CommandRegistry::instance();
-          ASSERT (®istry);
+          CHECK (®istry);
           
           cnt_inst = registry.instance_count();
           
           UNIMPLEMENTED ("unit test to cover the standard command handling patterns");
           
-          ASSERT (cnt_inst == registry.instance_count());
+          CHECK (cnt_inst == registry.instance_count());
         }
     };
   
diff --git a/tests/components/proc/control/memento-tie-test.cpp b/tests/components/proc/control/memento-tie-test.cpp
index 20a40e1fa..5ba7a7cdf 100644
--- a/tests/components/proc/control/memento-tie-test.cpp
+++ b/tests/components/proc/control/memento-tie-test.cpp
@@ -99,7 +99,7 @@ namespace test    {
           
           MemHolder mementoHolder (undo_func,cap_func);
           
-          ASSERT (sizeof(MemHolder) <= sizeof(int)                   // storage for the memento
+          CHECK (sizeof(MemHolder) <= sizeof(int)                   // storage for the memento
                                      + 2 * sizeof(function<void()>)  // storage for the 2 undecorated functors
                                      + ALIGNMENT);
           
@@ -113,21 +113,21 @@ namespace test    {
           testVal = 0;
           bound_cap_func(rr);     // invoke state capturing 
           
-          ASSERT (rr == mementoHolder.getState());
+          CHECK (rr == mementoHolder.getState());
           
           testVal = 10;           // meanwhile "somehow" mutate the state
           bound_undo_func(0);     // invoking the undo() feeds back the memento
-          ASSERT (testVal == 10-rr);
+          CHECK (testVal == 10-rr);
           
           // this cycle can be repeated with different state values
           rr = (rand() %100);
           testVal = rr;
           bound_cap_func(5);      // capture new state
-          ASSERT (5+rr == mementoHolder.getState());
+          CHECK (5+rr == mementoHolder.getState());
           
           testVal = -20;
           bound_undo_func(3*rr);
-          ASSERT (testVal == -20 + 3*rr - (5+rr));
+          CHECK (testVal == -20 + 3*rr - (5+rr));
         }
       
       
@@ -144,34 +144,34 @@ namespace test    {
           MemHolder m21 (u2_fun, c1_fun);
           MemHolder m22 (u2_fun, c2_fun);
           
-          ASSERT (!m11 && !m12 && !m21 && !m22);
-          ASSERT ( (m11 == m11));
-          ASSERT (!(m11 != m11));
+          CHECK (!m11 && !m12 && !m21 && !m22);
+          CHECK ( (m11 == m11));
+          CHECK (!(m11 != m11));
           
-          ASSERT (m11 != m12);
-          ASSERT (m11 != m21);
-          ASSERT (m11 != m22);
-          ASSERT (m12 != m11);
-          ASSERT (m12 != m21);
-          ASSERT (m12 != m22);
-          ASSERT (m21 != m11);
-          ASSERT (m21 != m12);
-          ASSERT (m21 != m22);
-          ASSERT (m22 != m11);
-          ASSERT (m22 != m12);
-          ASSERT (m22 != m21);
+          CHECK (m11 != m12);
+          CHECK (m11 != m21);
+          CHECK (m11 != m22);
+          CHECK (m12 != m11);
+          CHECK (m12 != m21);
+          CHECK (m12 != m22);
+          CHECK (m21 != m11);
+          CHECK (m21 != m12);
+          CHECK (m21 != m22);
+          CHECK (m22 != m11);
+          CHECK (m22 != m12);
+          CHECK (m22 != m21);
          
           MemHolder m22x (m22); // clone copy
-          ASSERT (!m22x);
-          ASSERT (m22 == m22x); // same functions, no state --> equal
+          CHECK (!m22x);
+          CHECK (m22 == m22x); // same functions, no state --> equal
           
           testVal = 0;
           m22x.tieCaptureFunc() (1 + (rand() % 9));   // produce a random memento value != 0
-          ASSERT (0 < m22x.getState());
+          CHECK (0 < m22x.getState());
           
-          ASSERT (m22 != m22x);
+          CHECK (m22 != m22x);
           m22.tieCaptureFunc() (m22x.getState()); // get the same value into the memento within m22
-          ASSERT (m22 == m22x);
+          CHECK (m22 == m22x);
         }
     };
   
diff --git a/tests/components/proc/engine/buff-table-test.cpp b/tests/components/proc/engine/buff-table-test.cpp
index 8827c8990..4342b46ad 100644
--- a/tests/components/proc/engine/buff-table-test.cpp
+++ b/tests/components/proc/engine/buff-table-test.cpp
@@ -162,7 +162,7 @@ namespace test  {
           
           ++counter;
           BuffTableChunk thisChunk (numbers, *pStorage);
-          ASSERT (consistencyCheck (thisChunk, numbers, lastLevel));
+          CHECK (consistencyCheck (thisChunk, numbers, lastLevel));
           
           uint nrBranches ( 1 + (rand() % WIDTH_MAX));
           while (nrBranches--)
diff --git a/tests/components/proc/engine/node-basic-test.cpp b/tests/components/proc/engine/node-basic-test.cpp
index bff44a4df..e5b44d739 100644
--- a/tests/components/proc/engine/node-basic-test.cpp
+++ b/tests/components/proc/engine/node-basic-test.cpp
@@ -89,13 +89,13 @@ namespace test  {
           
           PEffect pEffect = createTestEffectMObject();
           ProcNode* pNode = nodeFab (pEffect, setup);
-          ASSERT (pNode);
+          CHECK (pNode);
           
           TestContext simulatedInvocation;
           BuffHandle result = pNode->pull(simulatedInvocation, 0);
           
-          ASSERT (result);
-          // ASSERT we got calculated data in the result buffer
+          CHECK (result);
+          // CHECK we got calculated data in the result buffer
         } 
     };
   
diff --git a/tests/components/proc/mobject/builder/buildertooltest.cpp b/tests/components/proc/mobject/builder/buildertooltest.cpp
index 4c419a971..3aacaebfe 100644
--- a/tests/components/proc/mobject/builder/buildertooltest.cpp
+++ b/tests/components/proc/mobject/builder/buildertooltest.cpp
@@ -70,7 +70,7 @@ namespace test    {
             { 
               Placement<Clip>& pC = getPlacement<Clip>();
               cout << "Clip on media : "<< str(pC->getMedia()) <<"\n";
-              ASSERT (pC->operator==(c));
+              CHECK (pC->operator==(c));
               log_ = string (pC);
             }
           void treat (AbstractMO&)
@@ -120,17 +120,17 @@ namespace test    {
               cout << "apply (tool, clip);\n";
               apply (tool, clip);
               INFO (test, "got Wrapper = %s", t1.log_.c_str());
-              ASSERT (t1.log_ == string(clip));
+              CHECK (t1.log_ == string(clip));
               
               cout << "apply (tool, test1);\n"; 
               apply (tool, test1);
               INFO (test, "got Wrapper = %s", t1.log_.c_str());
-              ASSERT (t1.log_ == string(test1));
+              CHECK (t1.log_ == string(test1));
               
               cout << "apply (tool, test2);\n"; 
               apply (tool, test2);
               INFO (test, "got Wrapper = %s", t1.log_.c_str());
-              ASSERT (t1.log_ == string(test2));
+              CHECK (t1.log_ == string(test2));
             } 
         };
       
diff --git a/tests/components/proc/mobject/mobject-interface-test.cpp b/tests/components/proc/mobject/mobject-interface-test.cpp
index 49717737f..8c46b75f1 100644
--- a/tests/components/proc/mobject/mobject-interface-test.cpp
+++ b/tests/components/proc/mobject/mobject-interface-test.cpp
@@ -93,11 +93,11 @@ namespace test    {
           PDummy testDummy1(*new DummyMO);
           PDummy testDummy2(*new TestSubMO1);
           
-          ASSERT (testClip1->isValid());
-          ASSERT (testClip2->isValid());
-          ASSERT (testLabel1->isValid());
-          ASSERT (testDummy1->isValid());
-          ASSERT (testDummy2->isValid());
+          CHECK (testClip1->isValid());
+          CHECK (testClip2->isValid());
+          CHECK (testLabel1->isValid());
+          CHECK (testDummy1->isValid());
+          CHECK (testDummy2->isValid());
           
           Time lenC1 = testClip1->getLength();
           Time lenC2 = testClip2->getLength();
diff --git a/tests/components/proc/mobject/mobject-ref-test.cpp b/tests/components/proc/mobject/mobject-ref-test.cpp
index 2bd8239a7..0cd49fc59 100644
--- a/tests/components/proc/mobject/mobject-ref-test.cpp
+++ b/tests/components/proc/mobject/mobject-ref-test.cpp
@@ -1,23 +1,23 @@
 /*
   MObjectRef(Test)  -  validating basic properties of the external MObject reference tag
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2 of the
   License, or (at your option) any later version.
- 
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
@@ -45,19 +45,19 @@ using std::endl;
 
 namespace mobject {
 namespace test    {
-  
+
   namespace { // shortcut for checking use-counts
-    
+
     bool
     checkUseCount (size_t cnt, uint additional=0)
     {
       static uint base_count=0;
       if (!additional) // called for init
         base_count = cnt;
-      
+
       return cnt == base_count + additional;
     }
-    
+
     template<class REF>
     bool
     checkUseCount (REF const& ref, uint additional)
@@ -65,72 +65,72 @@ namespace test    {
       return checkUseCount(ref.use_count(), additional);
     }
   }
-  
-  
+
+
   using lumiera::Time;
   using session::Clip;
   using session::PMedia;
-  
+
   using session::SessionServiceMockIndex;
   using session::PPIdx;
-  
-  
-  
+
+
+
   /***************************************************************************
    * @test properties and behaviour of the external reference-mechanism for
    *       MObjects placed into the session. We create a simple, simulated
    *       "session" (no real session datastructure) and a mock PlacementIndex.
    *       Then we add two Placements, which can be used then to build
-   *       MObjectRef instances to validate their behaviour. 
+   *       MObjectRef instances to validate their behaviour.
    * @see  mobject::Placement
    * @see  mobject::MObject
    * @see  mobject::PlacementRef_test
    */
   class MObjectRef_test : public Test
     {
-      
+
       typedef Placement<MObject>        PMObj;
       typedef Placement<Clip>           PClip;
       typedef TestPlacement<TestSubMO1> PSub1;
-      
-      
+
+
       virtual void
-      run (Arg) 
+      run (Arg)
         {
-          
+
           // create data simulating a "Session"
           PMObj  testClip1 = asset::Media::create("test-1", asset::VIDEO)->createClip();
           PMObj  testClip2 = asset::Media::create("test-2", asset::VIDEO)->createClip();
-          
+
           // set up a tie to fixed start positions (i.e. "properties of placement")
           testClip1.chain(Time(10));
           testClip2.chain(Time(20));
-          
-          ASSERT (testClip1->isValid());
-          ASSERT (testClip2->isValid());
-          ASSERT (2 == testClip1.use_count());  // one by the placement and one by the clip-Asset
-          ASSERT (2 == testClip2.use_count());
-          
-          
+
+          CHECK (testClip1->isValid());
+          CHECK (testClip2->isValid());
+          CHECK (2 == testClip1.use_count());  // one by the placement and one by the clip-Asset
+          CHECK (2 == testClip2.use_count());
+
+
           // Prepare an (test)Index
           PPIdx index = SessionServiceMockIndex::install();
           PMO& root = index->getRoot();
-          
+
           // Add the Clips to "session" (here: dummy index)
           PMObj::ID clip1ID = index->insert (testClip1, root);
           PMObj::ID clip2ID = index->insert (testClip2, root);
-          ASSERT (2 == index->size());
-          
+          CHECK (2 == index->size());
+
           // use the IDs returned on insertion to fetch
           // language references to the placement instance within the index
           // we'll use these language refs as base to create MObejctRef handles.
           PMObj& pClip1 = index->find(clip1ID);
           PMObj& pClip2 = index->find(clip2ID);
-          
-          ASSERT (3 == pClip1.use_count());   // clip-Asset, original placement, new placement in index
-          ASSERT (3 == pClip2.use_count());
+
+          CHECK (3 == pClip1.use_count());   // clip-Asset, original placement, new placement in index
+          CHECK (3 == pClip2.use_count());
           checkUseCount(pClip1.use_count());  // set ref point for later checks
-          
+
           // extract various kinds of IDs and refs
           PMObj &         rP1 (pClip1);
           PMObj const&    rP2 (pClip2);
@@ -140,8 +140,8 @@ namespace test    {
           ///////////////////////////////////////////TODO: check the C-API representation here
           PlacementRef<Clip>    ref1 (id1);
           PlacementRef<MObject> ref2 (pClip2);
-          
-          
+
+
           // -----Tests------------------
           checkBuildMObjectRef (rP1,  &pClip1);
           checkBuildMObjectRef (rP2,  &pClip2);
@@ -151,224 +151,224 @@ namespace test    {
           ///////////////////////////////////////////TODO: check the C-API representation here
           checkBuildMObjectRef (ref1, &pClip1);
           checkBuildMObjectRef (ref2, &pClip2);
-          
+
           checkComparison(rP1,rP2);
           checkLifecycle (rP1,rP2);
           checkTypeHandling (luid);
           // -----Tests------------------
-          
+
           // verify clean state
           index->remove (pClip1);
           index->remove (pClip2);                // note: this invalidates pClip1 and pClip2;
-          ASSERT (!ref1);
-          ASSERT (!ref2);
-          ASSERT (0 == index->size());
-          ASSERT (1 == index.use_count());
-          ASSERT (2 == testClip1.use_count());
-          ASSERT (2 == testClip2.use_count());
+          CHECK (!ref1);
+          CHECK (!ref2);
+          CHECK (0 == index->size());
+          CHECK (1 == index.use_count());
+          CHECK (2 == testClip1.use_count());
+          CHECK (2 == testClip2.use_count());
           index.reset();
         }
-      
-      
-      
+
+
+
       template<typename REF>
       void
       checkBuildMObjectRef (REF& refObj, void* placementAdr)
         {
           MORef<Clip> rMO;
-          ASSERT (!rMO);                    // still empty (not bound)
-          ASSERT (0==rMO.use_count());
+          CHECK (!rMO);                    // still empty (not bound)
+          CHECK (0==rMO.use_count());
           cout << string(rMO)     << endl;                 /////////////////////TICKET #527
           cout << showSizeof(rMO) << endl;
-          
+
           // activate by binding to provided ref
           rMO.activate(refObj);
-          ASSERT (rMO);                     // now bound
+          CHECK (rMO);                     // now bound
           cout << string(rMO)     << endl;                 /////////////////////TICKET #527
-          
+
           // access MObject (Clip API)
 //        cout << rMO->operator string() << endl;          /////////////////////TICKET #428
           PMedia media = rMO->getMedia();
           cout << str(media) << endl;                      /////////////////////TICKET #520
           Time mediaLength = media->getLength();
-          ASSERT (Time(0) < mediaLength);
-          ASSERT (rMO->isValid());
-          
+          CHECK (Time(0) < mediaLength);
+          CHECK (rMO->isValid());
+
           // access the Placement-API
-          ASSERT (checkUseCount(rMO, 1));          // now rMO shares ownership with the Placement --> use-count += 1
-          ASSERT (Time(0) < rMO.getStartTime());  // (internally, this resolves to an ExplicitPlacement)  /////////TICKET #332
-          ASSERT ( rMO.isCompatible<MObject>());
-          ASSERT ( rMO.isCompatible<Clip>());
-          ASSERT (!rMO.isCompatible<TestSubMO1>());
+          CHECK (checkUseCount(rMO, 1));          // now rMO shares ownership with the Placement --> use-count += 1
+          CHECK (Time(0) < rMO.getStartTime());  // (internally, this resolves to an ExplicitPlacement)  /////////TICKET #332
+          CHECK ( rMO.isCompatible<MObject>());
+          CHECK ( rMO.isCompatible<Clip>());
+          CHECK (!rMO.isCompatible<TestSubMO1>());
           Time start = rMO.getStartTime();
-          
+
           // re-link to the Placement (note we get the Clip API!)
           Placement<Clip> & refP = rMO.getPlacement();
-          ASSERT (refP.isValid());
-          ASSERT (refP.use_count() == rMO.use_count());
-          ASSERT (checkUseCount(refP, 1));  // use count not changed
-          ASSERT (&refP == placementAdr);   // actually denotes the address of the original Placement in the "session"
+          CHECK (refP.isValid());
+          CHECK (refP.use_count() == rMO.use_count());
+          CHECK (checkUseCount(refP, 1));  // use count not changed
+          CHECK (&refP == placementAdr);   // actually denotes the address of the original Placement in the "session"
           cout << string(refP) << endl;
-          
+
           ExplicitPlacement exPla = refP.resolve();
-          ASSERT (exPla.time == start);     // recovered Placement resolves to the same time as provided by the proxied API
-          ASSERT (checkUseCount(refP, 2));  // but now we've indeed created an additional owner (exPla)
-          ASSERT (checkUseCount(rMO, 2));
+          CHECK (exPla.time == start);     // recovered Placement resolves to the same time as provided by the proxied API
+          CHECK (checkUseCount(refP, 2));  // but now we've indeed created an additional owner (exPla)
+          CHECK (checkUseCount(rMO, 2));
         }
-      
-      
+
+
       void
       checkComparison (PMO const& p1, PMO const& p2)
         {
           PlacementRef<Clip>    pRef1 (p1);
           PlacementRef<MObject> pRef2 (p2);
-          
+
           MORef<MObject> rM;
           MORef<Clip>    rC;
-          
+
           rM.activate (p1);
           rC.activate (p2);
-          ASSERT (rM && rC);
-          ASSERT (!(rM == rC) && !(rC == rM));
-          ASSERT ( (rM != rC) &&  (rC != rM));
-          
+          CHECK (rM && rC);
+          CHECK (!(rM == rC) && !(rC == rM));
+          CHECK ( (rM != rC) &&  (rC != rM));
+
           // mixed comparisons
-          ASSERT ( (rM == pRef1) &&  (pRef1 == rM));
-          ASSERT ( (rC == pRef2) &&  (pRef2 == rC));
-          ASSERT (!(rM != pRef1) && !(pRef1 != rM));
-          ASSERT (!(rC != pRef2) && !(pRef2 != rC));
-          ASSERT ( (rM != pRef2) &&  (pRef2 != rM));
-          ASSERT ( (rC != pRef1) &&  (pRef1 != rC));
-          ASSERT (!(rM == pRef2) && !(pRef2 == rM));
-          ASSERT (!(rC == pRef1) && !(pRef1 == rC));
-          
-          ASSERT ( (rM == p1.getID()) );
-          ASSERT ( (rC == p2.getID()) );
-          ASSERT (!(rM != p1.getID()) );
-          ASSERT (!(rC != p2.getID()) );
-          ASSERT ( (rM != p2.getID()) );
-          ASSERT ( (rC != p1.getID()) );
-          ASSERT (!(rM == p2.getID()) );
-          ASSERT (!(rC == p1.getID()) );
-          
-          
+          CHECK ( (rM == pRef1) &&  (pRef1 == rM));
+          CHECK ( (rC == pRef2) &&  (pRef2 == rC));
+          CHECK (!(rM != pRef1) && !(pRef1 != rM));
+          CHECK (!(rC != pRef2) && !(pRef2 != rC));
+          CHECK ( (rM != pRef2) &&  (pRef2 != rM));
+          CHECK ( (rC != pRef1) &&  (pRef1 != rC));
+          CHECK (!(rM == pRef2) && !(pRef2 == rM));
+          CHECK (!(rC == pRef1) && !(pRef1 == rC));
+
+          CHECK ( (rM == p1.getID()) );
+          CHECK ( (rC == p2.getID()) );
+          CHECK (!(rM != p1.getID()) );
+          CHECK (!(rC != p2.getID()) );
+          CHECK ( (rM != p2.getID()) );
+          CHECK ( (rC != p1.getID()) );
+          CHECK (!(rM == p2.getID()) );
+          CHECK (!(rC == p1.getID()) );
+
+
           rC.activate (pRef1);
-          ASSERT ( (rM == rC) &&  (rC == rM));
-          ASSERT (!(rM != rC) && !(rC != rM));
-          
-          ASSERT ( (rC == pRef1) &&  (pRef1 == rC));
-          ASSERT (!(rC != pRef1) && !(pRef1 != rC));
-          ASSERT ( (rC != pRef2) &&  (pRef2 != rC));
-          ASSERT (!(rC == pRef2) && !(pRef2 == rC));
-          
-          ASSERT ( (rC == p1.getID()) );
-          ASSERT (!(rC != p1.getID()) );
-          ASSERT ( (rC != p2.getID()) );
-          ASSERT (!(rC == p2.getID()) );
-          
-          
+          CHECK ( (rM == rC) &&  (rC == rM));
+          CHECK (!(rM != rC) && !(rC != rM));
+
+          CHECK ( (rC == pRef1) &&  (pRef1 == rC));
+          CHECK (!(rC != pRef1) && !(pRef1 != rC));
+          CHECK ( (rC != pRef2) &&  (pRef2 != rC));
+          CHECK (!(rC == pRef2) && !(pRef2 == rC));
+
+          CHECK ( (rC == p1.getID()) );
+          CHECK (!(rC != p1.getID()) );
+          CHECK ( (rC != p2.getID()) );
+          CHECK (!(rC == p2.getID()) );
+
+
           rM.close();
-          ASSERT (!rM);
-          ASSERT (!(rM == rC) && !(rC == rM));
-          ASSERT ( (rM != rC) &&  (rC != rM));
-          
-          ASSERT (!(rM == pRef1) && !(pRef1 == rM));
-          ASSERT ( (rM != pRef1) &&  (pRef1 != rM));
-          ASSERT ( (rM != pRef2) &&  (pRef2 != rM));
-          ASSERT (!(rM == pRef2) && !(pRef2 == rM));
-          
-          ASSERT (!(rM == p1.getID()) );
-          ASSERT ( (rM != p1.getID()) );
-          ASSERT ( (rM != p2.getID()) );
-          ASSERT (!(rM == p2.getID()) );
+          CHECK (!rM);
+          CHECK (!(rM == rC) && !(rC == rM));
+          CHECK ( (rM != rC) &&  (rC != rM));
+
+          CHECK (!(rM == pRef1) && !(pRef1 == rM));
+          CHECK ( (rM != pRef1) &&  (pRef1 != rM));
+          CHECK ( (rM != pRef2) &&  (pRef2 != rM));
+          CHECK (!(rM == pRef2) && !(pRef2 == rM));
+
+          CHECK (!(rM == p1.getID()) );
+          CHECK ( (rM != p1.getID()) );
+          CHECK ( (rM != p2.getID()) );
+          CHECK (!(rM == p2.getID()) );
         }
-      
-      
+
+
       void
       checkLifecycle (PMObj const& p1, PMObj const& p2)
         {
-          ASSERT (checkUseCount(p1, 0));
-          ASSERT (checkUseCount(p2, 0));
-          
+          CHECK (checkUseCount(p1, 0));
+          CHECK (checkUseCount(p2, 0));
+
           MORef<Clip> rMO;
-          ASSERT (!rMO);
-          ASSERT (0 == rMO.use_count());
-          
+          CHECK (!rMO);
+          CHECK (0 == rMO.use_count());
+
           rMO.activate(p1);
-          ASSERT (rMO);
-          ASSERT (rMO->getMedia()->getFilename() == "test-1");
-          ASSERT (checkUseCount(rMO, 1));
-          ASSERT (checkUseCount(p1,  1)); // sharing ownership
-          ASSERT (checkUseCount(p2,  0));
-          
+          CHECK (rMO);
+          CHECK (rMO->getMedia()->getFilename() == "test-1");
+          CHECK (checkUseCount(rMO, 1));
+          CHECK (checkUseCount(p1,  1)); // sharing ownership
+          CHECK (checkUseCount(p2,  0));
+
           rMO.activate(p2);
-          ASSERT (rMO);
-          ASSERT (rMO->getMedia()->getFilename() == "test-2");
-          ASSERT (checkUseCount(rMO, 1));
-          ASSERT (checkUseCount(p1,  0)); // detached, use count dropped to previous value
-          ASSERT (checkUseCount(p2,  1)); // sharing ownership
-          
+          CHECK (rMO);
+          CHECK (rMO->getMedia()->getFilename() == "test-2");
+          CHECK (checkUseCount(rMO, 1));
+          CHECK (checkUseCount(p1,  0)); // detached, use count dropped to previous value
+          CHECK (checkUseCount(p2,  1)); // sharing ownership
+
           rMO.activate(p2);
-          ASSERT (checkUseCount(rMO, 1)); // no change
-          
+          CHECK (checkUseCount(rMO, 1)); // no change
+
           rMO.close();
-          ASSERT (!rMO);
-          ASSERT (checkUseCount(p1,  0));
-          ASSERT (checkUseCount(p2,  0));
-          
+          CHECK (!rMO);
+          CHECK (checkUseCount(p1,  0));
+          CHECK (checkUseCount(p2,  0));
+
           VERIFY_ERROR (BOTTOM_MOBJECTREF, rMO.getPlacement() );
           VERIFY_ERROR (BOTTOM_MOBJECTREF, rMO->getMedia()    );
         }
-      
+
       void
       checkTypeHandling (LumieraUid luid)
         {
           MObjectRef rMObj;
           MORef<Clip> rClip;
           MORef<TestSubMO1> rSub1;
-          
-          ASSERT ( ! rMObj.use_count());
-          ASSERT ( ! rClip.use_count());
-          ASSERT ( ! rSub1.use_count());
-          
+
+          CHECK ( ! rMObj.use_count());
+          CHECK ( ! rClip.use_count());
+          CHECK ( ! rSub1.use_count());
+
           rMObj.activate(luid);
-          ASSERT (checkUseCount(rMObj, 1));
-          ASSERT ( ! rClip.use_count());
-          ASSERT ( ! rSub1.use_count());
-          
+          CHECK (checkUseCount(rMObj, 1));
+          CHECK ( ! rClip.use_count());
+          CHECK ( ! rSub1.use_count());
+
           rClip.activate(rMObj);              // attach on existing MObjectRef
-          ASSERT (checkUseCount(rMObj, 2));
-          ASSERT (checkUseCount(rClip, 2));
-          ASSERT ( ! rSub1.use_count());
-          
+          CHECK (checkUseCount(rMObj, 2));
+          CHECK (checkUseCount(rClip, 2));
+          CHECK ( ! rSub1.use_count());
+
           // impossible, because Clip isn't a subclass of TestSubMO1:
           VERIFY_ERROR (INVALID_PLACEMENTREF, rSub1.activate(luid) );
           VERIFY_ERROR (INVALID_PLACEMENTREF, rSub1 = rMObj        );
-          
-          ASSERT (rMObj->isValid());
-          ASSERT (rClip->isValid());
-          ASSERT (rMObj.getPlacement().getID() == rClip.getPlacement().getID());
-          
+
+          CHECK (rMObj->isValid());
+          CHECK (rClip->isValid());
+          CHECK (rMObj.getPlacement().getID() == rClip.getPlacement().getID());
+
           // doesn't compile, because the function isn't on MObject API:
           // rMObj->getMedia();
-          
+
           rClip.close();
-          ASSERT (checkUseCount(rMObj, 1));
-          ASSERT ( ! rClip.use_count());
-          
+          CHECK (checkUseCount(rMObj, 1));
+          CHECK ( ! rClip.use_count());
+
           // can assign, because the actual type is checked:
           rClip = rMObj;
-          ASSERT (checkUseCount(rMObj, 2));
-          ASSERT (checkUseCount(rClip, 2));
-          
+          CHECK (checkUseCount(rMObj, 2));
+          CHECK (checkUseCount(rClip, 2));
+
           cout << string(rClip) << endl;                         //////////TICKET #527
           cout << string(rClip->getMedia()->ident) << endl;      //////////TICKET #520
         }
     };
-  
-  
+
+
   /** Register this test class... */
   LAUNCHER (MObjectRef_test, "unit session");
-  
-  
+
+
 }} // namespace mobject::test
diff --git a/tests/components/proc/mobject/placement-basic-test.cpp b/tests/components/proc/mobject/placement-basic-test.cpp
index b020173cc..ff9f41069 100644
--- a/tests/components/proc/mobject/placement-basic-test.cpp
+++ b/tests/components/proc/mobject/placement-basic-test.cpp
@@ -1,23 +1,23 @@
 /*
   PlacementBasic(Test)  -  basic Placement and MObject handling
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2 of the
   License, or (at your option) any later version.
- 
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
@@ -43,11 +43,11 @@ using std::cout;
 namespace mobject {
   namespace session {
     namespace test  {
-      
+
       using asset::VIDEO;
-      
-      
-      
+
+
+
       /*******************************************************************
        * @test basic behaviour of Placements and access to MObjects.
        * @see  mobject::Placement
@@ -59,9 +59,9 @@ namespace mobject {
         {
           typedef shared_ptr<asset::Media> PM;
           typedef shared_ptr<asset::Clip> PCA;
-          
+
           virtual void
-          run (Arg) 
+          run (Arg)
             {
               // create Clip-MObject, which is wrapped into a placement (smart ptr)
               PM media = asset::Media::create("test-1", VIDEO);
@@ -70,32 +70,32 @@ namespace mobject {
 
               // use of the Clip-MObject interface by dereferencing the placement
               PM clip_media = pc->getMedia();
-              ASSERT (clip_media->ident.category.hasKind (VIDEO));
-              
+              CHECK (clip_media->ident.category.hasKind (VIDEO));
+
               // using the Placement interface
               // TODO: how to handle insufficiently determinated Placement? Throw?
               FixedLocation & fixloc = pc.chain(Time(1)); // TODO: the track??
               ExplicitPlacement expla = pc.resolve();
-              ASSERT (expla.time == Time(1));
-              ASSERT (!expla.chain.isOverdetermined());
-//            ASSERT (*expla == *pc);  ////////////////////////////////////////////TICKET #511 define equivalence of locating chains and solutions
-              
+              CHECK (expla.time == Time(1));
+              CHECK (!expla.chain.isOverdetermined());
+//            CHECK (*expla == *pc);  ////////////////////////////////////////////TICKET #511 define equivalence of locating chains and solutions
+
               // now overconstraining with another Placement
               pc.chain(Time(2));
               ExplicitPlacement expla2 = pc.resolve();
-              ASSERT (expla2.time == Time(2)); // the latest addition wins
-              ASSERT (expla2.chain.isOverdetermined()); 
-            } 
+              CHECK (expla2.time == Time(2)); // the latest addition wins
+              CHECK (expla2.chain.isOverdetermined());
+            }
         };
-      
-      
+
+
       /** Register this test class... */
       LAUNCHER (PlacementBasic_test, "unit session");
-      
-      
-      
+
+
+
     } // namespace test
-  
+
   } // namespace session
 
 } // namespace mobject
diff --git a/tests/components/proc/mobject/placement-hierarchy-test.cpp b/tests/components/proc/mobject/placement-hierarchy-test.cpp
index 4a2d8514e..1bea743ee 100644
--- a/tests/components/proc/mobject/placement-hierarchy-test.cpp
+++ b/tests/components/proc/mobject/placement-hierarchy-test.cpp
@@ -79,24 +79,24 @@ namespace test    {
           
           PMObj  pClip = asset::Media::create("test-1", asset::VIDEO)->createClip();
           
-          ASSERT (INSTANCEOF (Placement<MObject>, &pSub1));
-          ASSERT (INSTANCEOF (Placement<MObject>, &pSub2));
-          ASSERT (INSTANCEOF (Placement<MObject>, &pSub3));
-          ASSERT (INSTANCEOF (Placement<MObject>, &pSubM));
+          CHECK (INSTANCEOF (Placement<MObject>, &pSub1));
+          CHECK (INSTANCEOF (Placement<MObject>, &pSub2));
+          CHECK (INSTANCEOF (Placement<MObject>, &pSub3));
+          CHECK (INSTANCEOF (Placement<MObject>, &pSubM));
           
-          ASSERT (INSTANCEOF (Placement<DummyMO>, &pSub1));
-          ASSERT (INSTANCEOF (Placement<DummyMO>, &pSub2));
-          ASSERT (INSTANCEOF (Placement<DummyMO>, &pSub3));
+          CHECK (INSTANCEOF (Placement<DummyMO>, &pSub1));
+          CHECK (INSTANCEOF (Placement<DummyMO>, &pSub2));
+          CHECK (INSTANCEOF (Placement<DummyMO>, &pSub3));
           
-          ASSERT (INSTANCEOF (TestPlacement<DummyMO>, &pSub1));
-          ASSERT (INSTANCEOF (TestPlacement<DummyMO>, &pSub2));
-          ASSERT (INSTANCEOF (TestPlacement<DummyMO>, &pSub3));
+          CHECK (INSTANCEOF (TestPlacement<DummyMO>, &pSub1));
+          CHECK (INSTANCEOF (TestPlacement<DummyMO>, &pSub2));
+          CHECK (INSTANCEOF (TestPlacement<DummyMO>, &pSub3));
           
-          ASSERT ( INSTANCEOF (TestPlacement<TestSubMO2>,  &pSub3));
+          CHECK ( INSTANCEOF (TestPlacement<TestSubMO2>,  &pSub3));
           
           // the following won't succeed...
-//        ASSERT (INSTANCEOF (TestPlacement<TestSubMO21>, &pSub2)); // parent not instance of subclass
-//        ASSERT (INSTANCEOF (TestPlacement<TestSubMO2>,  &pSub1)); // separate branch in the hierarchy
+//        CHECK (INSTANCEOF (TestPlacement<TestSubMO21>, &pSub2)); // parent not instance of subclass
+//        CHECK (INSTANCEOF (TestPlacement<TestSubMO2>,  &pSub1)); // separate branch in the hierarchy
           
           cout << showSizeof(pSub1) << endl;
           cout << showSizeof(pSub2) << endl;
@@ -104,8 +104,8 @@ namespace test    {
           cout << showSizeof(pSubM) << endl;
           cout << showSizeof(pClip) << endl;
           
-          ASSERT (sizeof(pSub1) == sizeof(pSub3));
-          ASSERT (sizeof(pClip) == sizeof(pSub3));
+          CHECK (sizeof(pSub1) == sizeof(pSub3));
+          CHECK (sizeof(pClip) == sizeof(pSub3));
           
           cout << string(pSub1) << endl;
           cout << string(pSub2) << endl;
@@ -118,12 +118,12 @@ namespace test    {
           
           pSub3->specialAPI();
           
-          ASSERT (2 == pSubM.use_count());
-          ASSERT (2 == pSub3.use_count());
+          CHECK (2 == pSubM.use_count());
+          CHECK (2 == pSub3.use_count());
           pClip = pSubM;                      // slicing and shared ownership
-          ASSERT (3 == pSubM.use_count());
-          ASSERT (3 == pSub3.use_count());
-          ASSERT (3 == pClip.use_count());
+          CHECK (3 == pSubM.use_count());
+          CHECK (3 == pSub3.use_count());
+          CHECK (3 == pClip.use_count());
           
           
           // now do a brute-force re-interpretation
@@ -131,8 +131,8 @@ namespace test    {
           PSub21& hijacked = reinterpret_cast<PSub21&> (pClip);
           
           hijacked->specialAPI();
-          ASSERT (3 == hijacked.use_count());
-          ASSERT (hijacked.getID() == pClip.getID());
+          CHECK (3 == hijacked.use_count());
+          CHECK (hijacked.getID() == pClip.getID());
           
           cout << format_PlacementID(pSub1) << endl;
           cout << format_PlacementID(pSub2) << endl;
@@ -141,11 +141,11 @@ namespace test    {
           cout << format_PlacementID(pClip) << endl;
           
           pClip = pSub1;
-          ASSERT (2 == pSubM.use_count());
-          ASSERT (2 == pSub3.use_count());
+          CHECK (2 == pSubM.use_count());
+          CHECK (2 == pSub3.use_count());
           
-          ASSERT (2 == pClip.use_count());
-          ASSERT (2 == pSub1.use_count());
+          CHECK (2 == pClip.use_count());
+          CHECK (2 == pSub1.use_count());
           
 ///////////////////////////////////////////////////////////////////////////////TODO: find a way to configure NoBug to throw in case of assertion
 ///////////////////////////////////////////////////////////////////////////////TODO: configure NoBug specifically for the testsuite
@@ -154,12 +154,12 @@ namespace test    {
 #endif
           
           // runtime type diagnostics based on pointee RTTI
-          ASSERT ( pSub2.isCompatible<MObject>());
-          ASSERT ( pSub2.isCompatible<DummyMO>());
-          ASSERT ( pSub2.isCompatible<TestSubMO2>());
-          ASSERT (!pSub2.isCompatible<TestSubMO21>());
-          ASSERT (!pSub2.isCompatible<TestSubMO1>());
-          ASSERT (!pSub2.isCompatible<Clip>());
+          CHECK ( pSub2.isCompatible<MObject>());
+          CHECK ( pSub2.isCompatible<DummyMO>());
+          CHECK ( pSub2.isCompatible<TestSubMO2>());
+          CHECK (!pSub2.isCompatible<TestSubMO21>());
+          CHECK (!pSub2.isCompatible<TestSubMO1>());
+          CHECK (!pSub2.isCompatible<Clip>());
         }
     };
   
diff --git a/tests/components/proc/mobject/placement-object-identity-test.cpp b/tests/components/proc/mobject/placement-object-identity-test.cpp
index dad475fb0..dee2467bd 100644
--- a/tests/components/proc/mobject/placement-object-identity-test.cpp
+++ b/tests/components/proc/mobject/placement-object-identity-test.cpp
@@ -84,10 +84,10 @@ namespace test    {
           pClip1.chain(Time(10));
           pClip2.chain(Time(20));
           
-          ASSERT (pClip1->isValid());
-          ASSERT (pClip2->isValid());
-          ASSERT (2 == pClip1.use_count());  // one by the placement and one by the clip-Asset
-          ASSERT (2 == pClip2.use_count());
+          CHECK (pClip1->isValid());
+          CHECK (pClip2->isValid());
+          CHECK (2 == pClip1.use_count());  // one by the placement and one by the clip-Asset
+          CHECK (2 == pClip2.use_count());
           
           ////////////////TODO direct comparisons
           ////////////////TODO direct comparisons
@@ -118,24 +118,24 @@ namespace test    {
           PlacementRef<MObject> ref2 (pClip2);
           
           MORef<Clip> rMO;
-          ASSERT (!rMO);                    // still empty (not bound)
+          CHECK (!rMO);                    // still empty (not bound)
           
           // activate by binding to provided ref
           rMO.activate(refObj);
-          ASSERT (rMO);                     // now bound
+          CHECK (rMO);                     // now bound
           
           ///TODO access Placement, fetch ID
           
           // re-link to the Placement (note we get the Clip API!)
           Placement<Clip> & refP = rMO.getPlacement();
-          ASSERT (refP);
-          ASSERT (3 == refP.use_count());
-          ASSERT (&refP == placementAdr);   // actually denotes the address of the original Placement in the "session"
+          CHECK (refP);
+          CHECK (3 == refP.use_count());
+          CHECK (&refP == placementAdr);   // actually denotes the address of the original Placement in the "session"
           
           ExplicitPlacement exPla = refP.resolve();
-          ASSERT (exPla.time == start);     // recovered Placement resolves to the same time as provided by the proxied API
-          ASSERT (4 == refP.use_count());   // but now we've indeed created an additional owner (exPla)
-          ASSERT (4 == rMO.use_count());
+          CHECK (exPla.time == start);     // recovered Placement resolves to the same time as provided by the proxied API
+          CHECK (4 == refP.use_count());   // but now we've indeed created an additional owner (exPla)
+          CHECK (4 == rMO.use_count());
           
           
           ////////////////TODO now do the cross comparisons
diff --git a/tests/components/proc/mobject/placement-ref-test.cpp b/tests/components/proc/mobject/placement-ref-test.cpp
index 23ee75583..50dcd2411 100644
--- a/tests/components/proc/mobject/placement-ref-test.cpp
+++ b/tests/components/proc/mobject/placement-ref-test.cpp
@@ -1,23 +1,23 @@
 /*
   PlacementRef(Test)  -  generic reference to a Placement within the Session
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2 of the
   License, or (at your option) any later version.
- 
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
@@ -44,13 +44,13 @@ using std::endl;
 namespace mobject {
 namespace session {
 namespace test    {
-  
+
   using namespace mobject::test;
   typedef TestPlacement<TestSubMO21> PSub;
-  
+
   typedef PlacementMO::ID P_ID;
-  
-  
+
+
   /***************************************************************************
    * @test properties and behaviour of the reference-mechanism for Placements.
    *       We create an mock placement index and install it to be used
@@ -65,126 +65,126 @@ namespace test    {
    */
   class PlacementRef_test : public Test
     {
-      
+
       virtual void
-      run (Arg) 
+      run (Arg)
         {
           PSub testPlacement1(*new TestSubMO21);
           PSub testPlacement2(*new TestSubMO21);
           testPlacement2.chain(Time(2));     // define start time of Placement-2 to be at t=2
-          
+
           // Prepare an (test)Index backing the PlacementRefs
           PPIdx index = SessionServiceMockIndex::install();
           PMO& root = index->getRoot();
-          
+
           P_ID id1   = index->insert (testPlacement1, root);
           P_ID tmpID = index->insert (testPlacement2, root);
-          ASSERT (2 == index->size());
-          
+          CHECK (2 == index->size());
+
           // References to the "live" placements within our test index
           PMO&  p1 = index->find(id1);
           PMO&  p2 = index->find(tmpID);
-          
+
           PlacementMO::Id<TestSubMO21> id2 = p2.recastID<TestSubMO21>();
-          ASSERT (id2);
-          ASSERT (id2 != p1.getID());
-          
+          CHECK (id2);
+          CHECK (id2 != p1.getID());
+
           // create placement refs
           PlacementRef<TestSubMO21> ref1 (p1);
           PlacementRef<TestSubMO21> ref2 (id2);
-          
+
           PlacementRef<MObject> refX (ref2);
-          
-          ASSERT (ref1);
-          ASSERT (ref2);
-          ASSERT (refX);
-          ASSERT (ref1 != ref2);
-          ASSERT (ref2 == refX);
-          
+
+          CHECK (ref1);
+          CHECK (ref2);
+          CHECK (refX);
+          CHECK (ref1 != ref2);
+          CHECK (ref2 == refX);
+
           // indeed a "reference": resolves to the same memory location
-          ASSERT (isSameObject (p1, *ref1));
-          ASSERT (isSameObject (p2, *ref2));
-          ASSERT (isSameObject (p2, *refX));
-          
+          CHECK (isSameObject (p1, *ref1));
+          CHECK (isSameObject (p2, *ref2));
+          CHECK (isSameObject (p2, *refX));
+
           cout << string(*ref1) << endl;
           cout << string(*ref2) << endl;
           cout << string(*refX) << endl;
-          
+
           // PlacementRef mimics placement behaviour
           ref1->specialAPI();
-          ASSERT (2 == ref1.use_count());
-          ASSERT (2 == ref2.use_count());
+          CHECK (2 == ref1.use_count());
+          CHECK (2 == ref2.use_count());
           ExplicitPlacement exPla = refX.resolve();
-          ASSERT (exPla.time == Time(2));          // indeed get back the time we set on p2 above
-          ASSERT (3 == ref2.use_count());          // exPla shares ownership with p2
-          
-          ASSERT (index->contains(ref1));          // ref can stand-in for a placement-ID 
-          ASSERT (sizeof(id2) == sizeof(ref2));    // (and is actually implemented based on an ID)
-          
+          CHECK (exPla.time == Time(2));          // indeed get back the time we set on p2 above
+          CHECK (3 == ref2.use_count());          // exPla shares ownership with p2
+
+          CHECK (index->contains(ref1));          // ref can stand-in for a placement-ID
+          CHECK (sizeof(id2) == sizeof(ref2));    // (and is actually implemented based on an ID)
+
           // assignment on placement refs
           refX = ref1;
-          ASSERT (ref1 != ref2);
-          ASSERT (ref1 == refX);
-          ASSERT (ref2 != refX);
-          
+          CHECK (ref1 != ref2);
+          CHECK (ref1 == refX);
+          CHECK (ref2 != refX);
+
           // re-assignment with a new placement
           refX = p2;
-          ASSERT (refX == ref2);
-          ASSERT (isSameObject (*refX, p2));
+          CHECK (refX == ref2);
+          CHECK (isSameObject (*refX, p2));
           refX = p1.getID();
-          ASSERT (refX == ref1);
-          ASSERT (refX != ref2);
-          ASSERT (isSameObject (*refX, p1));
-          
+          CHECK (refX == ref1);
+          CHECK (refX != ref2);
+          CHECK (isSameObject (*refX, p1));
+
           LumieraUid luid2 (p2.getID().get());
           refX = luid2;                            // assignment works even based on a plain LUID
           ref2 = ref1;
           ref1 = refX;                             // dynamic type check when downcasting
-          ASSERT (isSameObject (p1, *ref2));
-          ASSERT (isSameObject (p2, *ref1));
+          CHECK (isSameObject (p1, *ref2));
+          CHECK (isSameObject (p2, *ref1));
           refX = ref2;
           ref2 = ref1;
           ref1 = refX;
-          ASSERT (isSameObject (p1, *ref1));
-          ASSERT (isSameObject (p1, *refX));
-          ASSERT (isSameObject (p2, *ref2));
-          ASSERT (ref1 != ref2);
-          ASSERT (ref1 == refX);
-          ASSERT (ref2 != refX);
-          
+          CHECK (isSameObject (p1, *ref1));
+          CHECK (isSameObject (p1, *refX));
+          CHECK (isSameObject (p2, *ref2));
+          CHECK (ref1 != ref2);
+          CHECK (ref1 == refX);
+          CHECK (ref2 != refX);
+
           // resolution is indeed "live", we see changes to the referred placement
-          ASSERT (refX.resolve().time == Time::MIN);
+          CHECK (refX.resolve().time == Time::MIN);
           p1.chain = p2.chain;                     // do a change on the placement within index....
-          ASSERT (refX.resolve().time == Time(2)); // now we get the time tie we originally set on p2
-          
-          ASSERT (p1.getID() != p2.getID());       // but the instance identities are still unaltered
-          ASSERT (2 == ref1.use_count());
-          ASSERT (3 == ref2.use_count());          // one more because of shared ownership with exPla
-          
-          
+          CHECK (refX.resolve().time == Time(2)); // now we get the time tie we originally set on p2
+
+          CHECK (p1.getID() != p2.getID());       // but the instance identities are still unaltered
+          CHECK (2 == ref1.use_count());
+          CHECK (3 == ref2.use_count());          // one more because of shared ownership with exPla
+
+
           // actively removing p2 invalidates the other refs to
           index->remove (ref1);
-          ASSERT (!ref1);                          // checks invalidity without throwing
-          ASSERT (!refX);
+          CHECK (!ref1);                          // checks invalidity without throwing
+          CHECK (!refX);
           VERIFY_ERROR(NOT_IN_SESSION, *ref1 );
-          
+
           // deliberately create an invalid PlacementRef
           PlacementRef<TestSubMO21> bottom;
-          ASSERT (!bottom);
+          CHECK (!bottom);
           VERIFY_ERROR(BOTTOM_PLACEMENTREF, *bottom );
           VERIFY_ERROR(BOTTOM_PLACEMENTREF, bottom->specialAPI() );
           VERIFY_ERROR(BOTTOM_PLACEMENTREF, bottom.resolve() );
-          
+
           //consistency check; then reset PlacementRef index to default
-          ASSERT (1 == index->size());
-          ASSERT (index->isValid());
+          CHECK (1 == index->size());
+          CHECK (index->isValid());
           index.reset();
         }
     };
-  
-  
+
+
   /** Register this test class... */
   LAUNCHER (PlacementRef_test, "unit session");
-  
-  
+
+
 }}} // namespace mobject::session::test
diff --git a/tests/components/proc/mobject/session/addcliptest.cpp b/tests/components/proc/mobject/session/addcliptest.cpp
index 09022956f..541d0289a 100644
--- a/tests/components/proc/mobject/session/addcliptest.cpp
+++ b/tests/components/proc/mobject/session/addcliptest.cpp
@@ -62,7 +62,7 @@ namespace mobject
               sess->attach (clip);
 
 ///////////////////////////////////////////////////////////////////TICKET #499              
-//            ASSERT (sess->currEDL().contains (clip));
+//            CHECK (sess->currEDL().contains (clip));
               // TODO: Clip-Asset and Placement magic??
             } 
         };
diff --git a/tests/components/proc/mobject/session/defsmanagerimpltest.cpp b/tests/components/proc/mobject/session/defsmanagerimpltest.cpp
index 954730804..a520f3350 100644
--- a/tests/components/proc/mobject/session/defsmanagerimpltest.cpp
+++ b/tests/components/proc/mobject/session/defsmanagerimpltest.cpp
@@ -1,23 +1,23 @@
 /*
   DefsManagerImpl(Test)  -  checking implementation details of the defaults manager
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2 of the
   License, or (at your option) any later version.
- 
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
@@ -41,37 +41,37 @@ using std::string;
 
 namespace asset {
   namespace test {
-    
+
     using mobject::Session;
     using lib::Symbol;
     using lumiera::Query;
     using lumiera::query::normaliseID;
-    
+
     using lumiera::ConfigRules;
     using lumiera::query::QueryHandler;
-    
-    
-    
+
+
+
     /** shortcut: query for given Pipe-ID */
-    bool 
-    find (const string& pID) 
-    { 
-      return Session::current->defaults.search (Query<Pipe> ("pipe("+pID+")")); 
+    bool
+    find (const string& pID)
+    {
+      return Session::current->defaults.search (Query<Pipe> ("pipe("+pID+")"));
     }
-    
-    
+
+
     format pattern ("dummy_%s_%i");
-    
+
     /** create a random new ID */
-    string 
+    string
     newID (Symbol prefix)
     {
       return str (pattern % prefix % std::rand());
     }
-    
-    
-    
-    
+
+
+
+
     /************************************************************************
      * @test verify some general assumptions regarding implementation details
      *       of the the defaults manager.
@@ -80,90 +80,90 @@ namespace asset {
     class DefsManagerImpl_test : public Test
       {
         virtual void
-        run(Arg) 
+        run(Arg)
           {
             define_and_search();
             string pipeID = create();
             forget(pipeID);
           }
-        
-        
-        
-        
+
+
+
+
         void
         define_and_search ()
           {
             string sID = newID ("stream");
-            
-             // create Pipes explicitly 
-            //  (without utilising default queries)
-            PPipe pipe1 = Struct::retrieve.newPipe (newID("pipe"), newID("stream")); 
-            PPipe pipe2 = Struct::retrieve.newPipe (newID("pipe"), sID            );
-            
-            ASSERT (pipe1 != pipe2);
-            ASSERT (sID == pipe2->getStreamID());
-            
-            ASSERT (!find (pipe1->getPipeID()), "accidental clash of random test-IDs");
-            ASSERT (!find (pipe2->getPipeID()), "accidental clash of random test-IDs");
-            
-            // now declare that these objects should be considered "default"
-lumiera::query::setFakeBypass("");  /////////////////////////////////////////////////TODO mock resolution            
-            ASSERT (Session::current->defaults.define (pipe1, Query<Pipe> (""))); // unrestricted default
 
-lumiera::query::setFakeBypass("stream("+sID+")"); ///////////////////////////////////TODO mock resolution            
-            ASSERT (Session::current->defaults.define (pipe2, Query<Pipe> ("stream("+sID+")")));
-            
-            ASSERT ( find (pipe1->getPipeID()), "failure declaring object as default");
-            ASSERT ( find (pipe2->getPipeID()), "failure declaring object as default");
-            
-            ASSERT (sID != pipe1->getStreamID(), "accidental clash");
-            ASSERT (!Session::current->defaults.define (pipe1, Query<Pipe> ("stream("+sID+")")));
+             // create Pipes explicitly
+            //  (without utilising default queries)
+            PPipe pipe1 = Struct::retrieve.newPipe (newID("pipe"), newID("stream"));
+            PPipe pipe2 = Struct::retrieve.newPipe (newID("pipe"), sID            );
+
+            CHECK (pipe1 != pipe2);
+            CHECK (sID == pipe2->getStreamID());
+
+            CHECK (!find (pipe1->getPipeID()), "accidental clash of random test-IDs");
+            CHECK (!find (pipe2->getPipeID()), "accidental clash of random test-IDs");
+
+            // now declare that these objects should be considered "default"
+lumiera::query::setFakeBypass("");  /////////////////////////////////////////////////TODO mock resolution
+            CHECK (Session::current->defaults.define (pipe1, Query<Pipe> (""))); // unrestricted default
+
+lumiera::query::setFakeBypass("stream("+sID+")"); ///////////////////////////////////TODO mock resolution
+            CHECK (Session::current->defaults.define (pipe2, Query<Pipe> ("stream("+sID+")")));
+
+            CHECK ( find (pipe1->getPipeID()), "failure declaring object as default");
+            CHECK ( find (pipe2->getPipeID()), "failure declaring object as default");
+
+            CHECK (sID != pipe1->getStreamID(), "accidental clash");
+            CHECK (!Session::current->defaults.define (pipe1, Query<Pipe> ("stream("+sID+")")));
                     // can't be registered with this query, due to failure caused by wrong stream-ID
           }
-        
-        
+
+
         const string&
         create()
-          { 
+          {
             string sID = newID ("stream");
             Query<Pipe> query_for_streamID ("stream("+sID+")");
-            
+
             // issue a ConfigQuery directly, without involving the DefaultsManager
-            QueryHandler<Pipe>& typeHandler = ConfigRules::instance();  
+            QueryHandler<Pipe>& typeHandler = ConfigRules::instance();
             PPipe pipe1;
             typeHandler.resolve (pipe1, query_for_streamID);
-            ASSERT (pipe1);
-            
-            ASSERT (!find (pipe1->getPipeID()));
+            CHECK (pipe1);
+
+            CHECK (!find (pipe1->getPipeID()));
             PPipe pipe2 = Session::current->defaults.create (query_for_streamID);
-            ASSERT (pipe2);
-            ASSERT (pipe2 == pipe1);
-            ASSERT ( find (pipe1->getPipeID())); // now declared as "default Pipe" for this stream-ID
-            
+            CHECK (pipe2);
+            CHECK (pipe2 == pipe1);
+            CHECK ( find (pipe1->getPipeID())); // now declared as "default Pipe" for this stream-ID
+
             return pipe1->getPipeID();
           }
-        
-        
-        void 
+
+
+        void
         forget (string pID)
-          { 
+          {
             PPipe pipe = Pipe::query ("pipe("+pID+")");
             REQUIRE (find (pipe->getPipeID()), "need an object registered as default");
             long cnt = pipe.use_count();
-            
+
             // now de-register the pipe as "default Pipe"
-            ASSERT (Session::current->defaults.forget (pipe));
-            ASSERT (!find (pipe->getPipeID()));
-            ASSERT (cnt == pipe.use_count());   // indicates DefaultsManager holding only a weak ref.
+            CHECK (Session::current->defaults.forget (pipe));
+            CHECK (!find (pipe->getPipeID()));
+            CHECK (cnt == pipe.use_count());   // indicates DefaultsManager holding only a weak ref.
           }
       };
-    
-    
+
+
     /** Register this test class... */
     LAUNCHER (DefsManagerImpl_test, "function session");
-    
-    
-    
+
+
+
   } // namespace test
 
 } // namespace asset
diff --git a/tests/components/proc/mobject/session/defsmanagertest.cpp b/tests/components/proc/mobject/session/defsmanagertest.cpp
index 608dce6db..9372cec8d 100644
--- a/tests/components/proc/mobject/session/defsmanagertest.cpp
+++ b/tests/components/proc/mobject/session/defsmanagertest.cpp
@@ -1,23 +1,23 @@
 /*
   DefsManager(Test)  -  checking basic behaviour of the defaults manager
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2 of the
   License, or (at your option) any later version.
- 
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
@@ -43,33 +43,33 @@ using std::string;
 
 namespace asset {
 namespace test  {
-    
+
     using util::cStr;
     using lib::Symbol;
     using mobject::Session;
     using lumiera::Query;
     using lumiera::query::normaliseID;
-    
-    
+
+
     /** shortcut: run just a query
      *  without creating new instances
      */
-    bool 
-    find (Query<Pipe>& q) 
+    bool
+    find (Query<Pipe>& q)
     {
       return Session::current->defaults.search (q);
     }
-    
-    
-    
-    
+
+
+
+
     /***********************************************************************
      * @test basic behaviour of the defaults manager ("the big picture")
      *       - retrieving a "default" object repeatedly
      *       - retrieving a more constrained "default" object
      *       - failure registers a new "default"
      *       - instance management
-     * 
+     *
      * Using pipe assets as an example. The defaults manager shouldn't
      * interfere with memory management (it holds weak refs).
      */
@@ -80,85 +80,85 @@ namespace test  {
           {
             string pipeID   = isnil(arg)?  "Black Hole" : arg[1];
             string streamID = 2>arg.size()? "teststream" : arg[2] ;
-            
+
             normaliseID (pipeID);
             normaliseID (streamID);
-            
+
             retrieveSimpleDefault (pipeID);
             retrieveConstrainedDefault (pipeID, streamID);
             failureCreatesNewDefault();
             verifyRemoval();
           }
-        
-        
-        
-        
+
+
+
+
         void
         retrieveSimpleDefault (string)
-          { 
+          {
             PPipe pipe1 = Pipe::query (""); // "the default pipe"
             PPipe pipe2;
-            
+
             // several variants to query for "the default pipe"
             pipe2 = Pipe::query ("");
-            ASSERT (pipe2 == pipe1);
+            CHECK (pipe2 == pipe1);
             pipe2 = Pipe::query ("default(X)");
-            ASSERT (pipe2 == pipe1);
+            CHECK (pipe2 == pipe1);
             pipe2 = Session::current->defaults(Query<Pipe> ());
-            ASSERT (pipe2 == pipe1);
+            CHECK (pipe2 == pipe1);
             pipe2 = asset::Struct::retrieve (Query<Pipe> ());
-            ASSERT (pipe2 == pipe1);
+            CHECK (pipe2 == pipe1);
             pipe2 = asset::Struct::retrieve (Query<Pipe> ("default(P)"));
-            ASSERT (pipe2 == pipe1);
+            CHECK (pipe2 == pipe1);
           }
-        
-        
+
+
         void
         retrieveConstrainedDefault (string pID, string sID)
           {
             PPipe pipe1 = Pipe::query (""); // "the default pipe"
-            ASSERT (sID != pipe1->getStreamID(),
+            CHECK (sID != pipe1->getStreamID(),
                     "stream-ID \"%s\" not suitable for test, because "
                     "the default-pipe \"%s\" happens to have the same "
-                    "stream-ID. We need it to be different", 
+                    "stream-ID. We need it to be different",
                     sID.c_str(), pID.c_str()
                    );
-            
+
             string query_for_sID ("stream("+sID+")");
             PPipe pipe2 = Pipe::query (query_for_sID);
-            ASSERT (sID == pipe2->getStreamID());
-            ASSERT (pipe2 != pipe1);
-            ASSERT (pipe2 == Pipe::query (query_for_sID));   // reproducible
+            CHECK (sID == pipe2->getStreamID());
+            CHECK (pipe2 != pipe1);
+            CHECK (pipe2 == Pipe::query (query_for_sID));   // reproducible
           }
-        
-        
+
+
         void
         failureCreatesNewDefault()
-          { 
+          {
             PPipe pipe1 = Session::current->defaults(Query<Pipe> ()); // "the default pipe"
-            
-            string new_pID (str (format ("dummy_%s_%i") 
+
+            string new_pID (str (format ("dummy_%s_%i")
                                  % pipe1->getPipeID()
                                  % std::rand()
-                                ));     // make random new pipeID  
+                                ));     // make random new pipeID
             Query<Pipe> query_for_new ("pipe("+new_pID+")");
-            
-            ASSERT (!find (query_for_new));                             // check it doesn't exist 
+
+            CHECK (!find (query_for_new));                             // check it doesn't exist
             PPipe pipe2 = Session::current->defaults (query_for_new);   // triggers creation
-            ASSERT ( find (query_for_new));                             // check it exists now
-            
-            ASSERT (pipe1 != pipe2);
-            ASSERT (pipe2 == Session::current->defaults (query_for_new));
+            CHECK ( find (query_for_new));                             // check it exists now
+
+            CHECK (pipe1 != pipe2);
+            CHECK (pipe2 == Session::current->defaults (query_for_new));
           }
-        
-        
+
+
         /** verify the defaults manager holds only weak refs,
          *  so if an object goes out of scope, any defaults entries
          *  are purged silently
          */
         void
         verifyRemoval()
-          { 
+          {
             Symbol pID ("some_pipe");
             Query<Pipe> query_for_pID ("pipe("+pID+")");
             size_t hash;
@@ -166,30 +166,30 @@ namespace test  {
                 // create new pipe and declare it to be a default
                 PPipe pipe1 = Struct::retrieve.newInstance<Pipe> (pID);
                 Session::current->defaults.define(pipe1);
-                
-                ASSERT (2 == pipe1.use_count());                        // the pipe1 smart-ptr and the AssetManager
+
+                CHECK (2 == pipe1.use_count());                        // the pipe1 smart-ptr and the AssetManager
                 hash = pipe1->getID();
               }
               // pipe1 out of scope....
              //  AssetManager now should hold the only ref
             ID<Asset> assetID (hash);
-              
+
             AssetManager& aMang (AssetManager::instance());
-            ASSERT ( aMang.known (assetID));
+            CHECK ( aMang.known (assetID));
             aMang.remove (assetID);
-            ASSERT (!aMang.known (assetID));
-            
-            
-            ASSERT (!find(query_for_pID));                              // bare default-query should fail...
+            CHECK (!aMang.known (assetID));
+
+
+            CHECK (!find(query_for_pID));                              // bare default-query should fail...
             PPipe pipe2 = Session::current->defaults (query_for_pID);   // triggers re-creation
-            ASSERT ( find(query_for_pID));                              // should succeed again
+            CHECK ( find(query_for_pID));                              // should succeed again
           }
       };
-    
-    
-    
+
+
+
     /** Register this test class... */
     LAUNCHER (DefsManager_test, "function session");
-    
-    
+
+
 }} // namespace asset::test
diff --git a/tests/components/proc/mobject/session/defsregistryimpltest.cpp b/tests/components/proc/mobject/session/defsregistryimpltest.cpp
index dcfde3a55..5e5799385 100644
--- a/tests/components/proc/mobject/session/defsregistryimpltest.cpp
+++ b/tests/components/proc/mobject/session/defsregistryimpltest.cpp
@@ -1,23 +1,23 @@
 /*
   DefsRegistryImpl(Test)  -  verifying correct behaviour of the defaults registry
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2 of the
   License, or (at your option) any later version.
- 
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
@@ -51,21 +51,21 @@ using std::map;
 namespace mobject {
   namespace session {
     namespace test  {
-      
+
       format typePatt ("Dummy<%2i>");
       format instancePatt ("obj_%s_%i");
       format predicatePatt ("%s_%2i( %s )");
-      
-      
-      
+
+
+
       /** create a random new ID */
-      string 
+      string
       newID (string prefix)
       {
         return str (instancePatt % prefix % rand());
       }
-      
-      
+
+
       /** template for generating some different test types */
       template<int I>
       struct Dummy
@@ -74,19 +74,19 @@ namespace mobject {
           string instanceID;
           operator string ()                  const { return instanceID; }
           bool operator== (const Dummy& odu)  const { return this == &odu; }
-          
-          
+
+
           Dummy () : instanceID (newID (name)) {}
         };
-        
+
       template<int I>
       string Dummy<I>::name = str (typePatt % I);
-      
-      
-      
-      
-      
-      
+
+
+
+
+
+
       /************************************************************************
        * @test build an registry table (just for this test) configured for
        *       some artificial test Types. Register some entries and verify
@@ -97,63 +97,63 @@ namespace mobject {
       class DefsRegistryImpl_test : public Test
         {
           scoped_ptr<DefsRegistry> reg_;
-          
+
           typedef lumiera::P<Dummy<13> > O;
           typedef lumiera::P<Dummy<23> > P;
-          
+
           typedef Query<Dummy<13> > Q13;
           typedef Query<Dummy<23> > Q23;
-          
+
           typedef DefsRegistry::Iter<Dummy<13> > Iter13;
           typedef DefsRegistry::Iter<Dummy<23> > Iter23;
-          
-          
+
+
           // fabricating Objects wrapped into smart-ptrs
           lib::factory::RefcountFac<Dummy<13> > oFac;
           lib::factory::RefcountFac<Dummy<23> > pFac;
-          
+
           O o1, o2, o3;
           Q13 q1, q2, q3, q4, q5;
           map<Q23, P> ps;
-          
+
         public:
           DefsRegistryImpl_test ()
-            : o1 (oFac()), o2 (oFac()), o3 (oFac()), 
+            : o1 (oFac()), o2 (oFac()), o3 (oFac()),
               q1 (garbage_query (1)),
               q2 (garbage_query (2)),
               q3 (garbage_query (3)),
               q4 (garbage_query (4)),
               q5 (garbage_query (5))
             { }
-          
-          
-          virtual void 
-          run (Arg) 
+
+
+          virtual void
+          run (Arg)
             {
               this->reg_.reset (new DefsRegistry);
-              
+
               fill_table ();
               check_query ();
               check_remove ();
             }
-          
-          
-          
-          
+
+
+
+
           void
           fill_table ()
             {
                // at start the registry is indeed empty
               //  thus a query doesn't yield any results....
-              ASSERT ( ! *(reg_->candidates(Q13 ("something"))) );
-              
+              CHECK ( ! *(reg_->candidates(Q13 ("something"))) );
+
               reg_->put (o1, q5);
               reg_->put (o2, q4);
               reg_->put (o3, q3);
               reg_->put (o3, q2);
               reg_->put (o2, q1);
               reg_->put (o1, Q13()); // the empty query
-             
+
               ps.clear();
               for (int i=0; i<100; ++i)
                 {
@@ -164,133 +164,133 @@ namespace mobject {
                   px->instanceID = qx;
                 }
             }
-          
-          
+
+
           void
           check_query ()
             {
               Iter13 i (reg_->candidates(Q13 ("irrelevant query")));
-              ASSERT ( i.hasNext());
-              ASSERT ( *i++ == o1);  // ordered according to the degree of the queries
-              ASSERT ( *i++ == o2);
-              ASSERT ( *i++ == o3);
-              ASSERT ( *i++ == o3);
-              ASSERT ( *i++ == o2);
-              ASSERT ( *i   == o1);
-              ASSERT (!i.hasNext());
-              ASSERT (! *++i ); // null after end
-              
+              CHECK ( i.hasNext());
+              CHECK ( *i++ == o1);  // ordered according to the degree of the queries
+              CHECK ( *i++ == o2);
+              CHECK ( *i++ == o3);
+              CHECK ( *i++ == o3);
+              CHECK ( *i++ == o2);
+              CHECK ( *i   == o1);
+              CHECK (!i.hasNext());
+              CHECK (! *++i ); // null after end
+
               i = reg_->candidates(q3);
-              ASSERT ( *i++ == o3);  // found by direct match
-              ASSERT ( *i++ == o1);  // followed by the ordered enumeration
-              ASSERT ( *i++ == o2);
-              ASSERT ( *i++ == o3);
-              ASSERT ( *i++ == o3);
-              ASSERT ( *i++ == o2);
-              ASSERT ( *i++ == o1);
-              ASSERT (!i.hasNext());
-              
+              CHECK ( *i++ == o3);  // found by direct match
+              CHECK ( *i++ == o1);  // followed by the ordered enumeration
+              CHECK ( *i++ == o2);
+              CHECK ( *i++ == o3);
+              CHECK ( *i++ == o3);
+              CHECK ( *i++ == o2);
+              CHECK ( *i++ == o1);
+              CHECK (!i.hasNext());
+
               i = reg_->candidates(Q13());
-              ASSERT ( *i++ == o1);  // found by direct match to the empty query
-              ASSERT ( *i++ == o1);
-              ASSERT ( *i++ == o2);
-              ASSERT ( *i++ == o3);
-              ASSERT ( *i++ == o3);
-              ASSERT ( *i++ == o2);
-              ASSERT ( *i++ == o1);
-              ASSERT (!i.hasNext());
-              
+              CHECK ( *i++ == o1);  // found by direct match to the empty query
+              CHECK ( *i++ == o1);
+              CHECK ( *i++ == o2);
+              CHECK ( *i++ == o3);
+              CHECK ( *i++ == o3);
+              CHECK ( *i++ == o2);
+              CHECK ( *i++ == o1);
+              CHECK (!i.hasNext());
+
               uint d=0;
               uint d_prev=0;
               Iter23 j = reg_->candidates(Q23 ("some crap"));
               for ( ; *j ; ++j )
                 {
-                  ASSERT ( *j );
+                  CHECK ( *j );
                   Q23 qx ((*j)->instanceID);
-                  ASSERT ( ps[qx] == (*j));
+                  CHECK ( ps[qx] == (*j));
                   d = lumiera::query::countPred (qx);
-                  ASSERT ( d_prev <= d );
+                  CHECK ( d_prev <= d );
                   d_prev = d;
                 }
-              ASSERT (!j.hasNext());
-              
+              CHECK (!j.hasNext());
+
               // calling with an arbitrary (registered) query
               // yields the corresponding object at start of the enumeration
               j = reg_->candidates(ps.begin()->first);
-              ASSERT ( *j == ps.begin()->second);
-              
+              CHECK ( *j == ps.begin()->second);
+
             }
-          
-          
+
+
           void
           check_remove ()
             {
               reg_->forget (o2);
-              
+
               Iter13 i (reg_->candidates(q4));
-              ASSERT ( i.hasNext());
-              ASSERT ( *i++ == o1);  // ordered according to the degree of the queries
+              CHECK ( i.hasNext());
+              CHECK ( *i++ == o1);  // ordered according to the degree of the queries
                                      // but the o2 entries are missing
-              ASSERT ( *i++ == o3);
-              ASSERT ( *i++ == o3);
+              CHECK ( *i++ == o3);
+              CHECK ( *i++ == o3);
                                      // missing
-              ASSERT ( *i   == o1);
-              ASSERT (!i.hasNext());
-              
+              CHECK ( *i   == o1);
+              CHECK (!i.hasNext());
+
               o3.reset(); // killing the only reference....
                          //  expires the weak ref in the registry
 
               i = reg_->candidates(Q13 ("something"));
-              ASSERT ( i.hasNext());
-              ASSERT ( *i++ == o1);  // ordered according to the degree of the queries
+              CHECK ( i.hasNext());
+              CHECK ( *i++ == o1);  // ordered according to the degree of the queries
                                      // but now also the o3 entries are missing...
-              ASSERT ( *i   == o1);
-              ASSERT (!i.hasNext());
-              
-              ASSERT ( reg_->put (o1, q5));  // trying to register the same object at the same place
+              CHECK ( *i   == o1);
+              CHECK (!i.hasNext());
+
+              CHECK ( reg_->put (o1, q5));  // trying to register the same object at the same place
                                              // doesn't change anything (but counts as "success")
               i = reg_->candidates(q5);
-              ASSERT ( *i++ == o1); // direct match
-              ASSERT ( *i++ == o1);
-              ASSERT ( *i++ == o1);
-              ASSERT (!i.hasNext());
-              
-              ASSERT (!reg_->put (o2, q5));  // trying to (re)register o2 with a existing query
+              CHECK ( *i++ == o1); // direct match
+              CHECK ( *i++ == o1);
+              CHECK ( *i++ == o1);
+              CHECK (!i.hasNext());
+
+              CHECK (!reg_->put (o2, q5));  // trying to (re)register o2 with a existing query
                                              // counts as failure (nothing changes)
               i = reg_->candidates(q5);
-              ASSERT ( *i++ == o1); // direct match
-              ASSERT ( *i++ == o1);
-              ASSERT ( *i++ == o1);
-              ASSERT (!i.hasNext());
-              
-              ASSERT ( reg_->put (o2, q2));  // trying to (re)register o2 with another query succeeds
-              i = reg_->candidates(q2);
-              ASSERT ( *i++ == o2); // direct match
-              ASSERT ( *i++ == o1);
-              ASSERT ( *i++ == o2); // inserted here in the dataset
-              ASSERT ( *i++ == o1);
-              ASSERT (!i.hasNext());
-              
-              ASSERT ( reg_->forget (o1));
-              ASSERT (!reg_->forget (o1)); // failure, because it's already removed
-              ASSERT ( reg_->forget (o2)); 
+              CHECK ( *i++ == o1); // direct match
+              CHECK ( *i++ == o1);
+              CHECK ( *i++ == o1);
+              CHECK (!i.hasNext());
 
-              o3 = oFac();        // another object is another object (it's irrelevant...) 
-              
+              CHECK ( reg_->put (o2, q2));  // trying to (re)register o2 with another query succeeds
               i = reg_->candidates(q2);
-              ASSERT (! (*i)); // empty
+              CHECK ( *i++ == o2); // direct match
+              CHECK ( *i++ == o1);
+              CHECK ( *i++ == o2); // inserted here in the dataset
+              CHECK ( *i++ == o1);
+              CHECK (!i.hasNext());
+
+              CHECK ( reg_->forget (o1));
+              CHECK (!reg_->forget (o1)); // failure, because it's already removed
+              CHECK ( reg_->forget (o2));
+
+              o3 = oFac();        // another object is another object (it's irrelevant...)
+
+              i = reg_->candidates(q2);
+              CHECK (! (*i)); // empty
             }
-          
+
         };
-      
-      
+
+
       /** Register this test class... */
       LAUNCHER (DefsRegistryImpl_test, "function session");
-      
-      
-      
+
+
+
     } // namespace test
-    
+
   } // namespace mobject
 
 } // namespace mobject
diff --git a/tests/components/proc/mobject/session/deletecliptest.cpp b/tests/components/proc/mobject/session/deletecliptest.cpp
index fa447bcfd..07d275607 100644
--- a/tests/components/proc/mobject/session/deletecliptest.cpp
+++ b/tests/components/proc/mobject/session/deletecliptest.cpp
@@ -74,13 +74,13 @@ namespace test    {
                                                               // global Var assigned in buildTestsession1()
           PMedia media = clipPlacement->getMedia();
           IDA clipAID = media->getID();
-          ASSERT (clipPlacement);
+          CHECK (clipPlacement);
           
           sess->remove (clipPlacement);
           
-          ASSERT (!sess->currEDL().find(SESSION1_CLIP));            // Session forgot the Clip/Placement
-          ASSERT (!aMang.known (clipAID));                          // corresponding Clip Asset has disappeared
-          ASSERT (!clipPlacement->getMedia());                      // internal cross-links removed
+          CHECK (!sess->currEDL().find(SESSION1_CLIP));            // Session forgot the Clip/Placement
+          CHECK (!aMang.known (clipAID));                          // corresponding Clip Asset has disappeared
+          CHECK (!clipPlacement->getMedia());                      // internal cross-links removed
 #endif    /////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #639 : work out how to search within the Model!!
         }
     };
diff --git a/tests/components/proc/mobject/session/placement-index-query-test.cpp b/tests/components/proc/mobject/session/placement-index-query-test.cpp
index cb7ef3fb3..aa4694d77 100644
--- a/tests/components/proc/mobject/session/placement-index-query-test.cpp
+++ b/tests/components/proc/mobject/session/placement-index-query-test.cpp
@@ -73,15 +73,15 @@ namespace test    {
           QueryResolver const& resolver1 (SessionServiceExploreScope::getResolver());
           QueryResolver const& resolver2 (SessionServiceExploreScope::getResolver());
           
-          ASSERT (isSameObject (resolver1, resolver2));
+          CHECK (isSameObject (resolver1, resolver2));
           
           PlacementMO& root1 = index->getRoot();          
           PlacementMO& root2 = SessionServiceExploreScope::getScopeRoot();          
-          ASSERT (isSameObject (root1, root2));
+          CHECK (isSameObject (root1, root2));
           
           PlacementMO& elm1 = *ContentsQuery<TestSubMO21>(root1).resolveBy(resolver1);
           PlacementMO& elm2 = *(index->getReferrers(root1));
-          ASSERT (isSameObject (elm1, elm2));
+          CHECK (isSameObject (elm1, elm2));
         }
       
       void
diff --git a/tests/components/proc/mobject/session/placement-index-test.cpp b/tests/components/proc/mobject/session/placement-index-test.cpp
index 7c43bcf69..6873527a2 100644
--- a/tests/components/proc/mobject/session/placement-index-test.cpp
+++ b/tests/components/proc/mobject/session/placement-index-test.cpp
@@ -1,23 +1,23 @@
 /*
   PlacementIndex(Test)  -  facility keeping track of Placements within the Session
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2 of the
   License, or (at your option) any later version.
- 
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
@@ -45,12 +45,12 @@ using std::endl;
 namespace mobject {
 namespace session {
 namespace test    {
-  
+
   using session::test::TestClip;
-  
+
   typedef PlacementIndex& Idx;
-  
-  
+
+
   /***************************************************************************
    * @test basic behaviour of the index mechanism used to keep track
    *       of individual Placements as added to the current Session.
@@ -61,151 +61,151 @@ namespace test    {
    */
   class PlacementIndex_test : public Test
     {
-      
+
       virtual void
-      run (Arg) 
+      run (Arg)
         {
           PlacementIndex index (make_dummyRoot());
-          ASSERT (index.isValid());
-          
+          CHECK (index.isValid());
+
           checkSimpleInsertRemove (index);
           has_size (0, index);
-          
+
           PMO::ID elmID = checkSimpleAccess (index);
-          ASSERT (index.isValid());
+          CHECK (index.isValid());
           has_size (2, index);
-          
+
           checkTypedAccess (index, elmID);
           has_size (3, index);
-          
+
           checkScopeHandling (index);
           has_size (9, index);
-          
+
           checkContentsEnumeration (index);
-          
+
           has_size (9, index);
-          ASSERT (index.isValid());
-          
+          CHECK (index.isValid());
+
           index.clear();
           has_size (0, index);
-          ASSERT (index.isValid());
+          CHECK (index.isValid());
         }
-      
+
       void
       has_size(uint siz, Idx index)
         {
-          ASSERT (siz == index.size());
+          CHECK (siz == index.size());
         }
-      
-      
+
+
       void
       checkSimpleInsertRemove (Idx index)
         {
           PMO clip = TestClip::create();
           PMO& root = index.getRoot();
-          
-          ASSERT (0 == index.size());
-          
+
+          CHECK (0 == index.size());
+
           PMO::ID elmID = index.insert (clip, root);
-          ASSERT (1 == index.size());
-          ASSERT ( index.contains (elmID));
-          ASSERT (!index.contains (clip)); // index stores copies
-          
+          CHECK (1 == index.size());
+          CHECK ( index.contains (elmID));
+          CHECK (!index.contains (clip)); // index stores copies
+
           index.remove(clip); // has no effect
-          ASSERT (1 == index.size());
+          CHECK (1 == index.size());
           index.remove(elmID);
-          ASSERT (0 == index.size());
-          ASSERT (!index.contains (elmID));
-          ASSERT ( index.contains (root));
+          CHECK (0 == index.size());
+          CHECK (!index.contains (elmID));
+          CHECK ( index.contains (root));
         }
-      
-      
+
+
       PMO::ID
       checkSimpleAccess (Idx index)
         {
           PMO testObj = TestClip::create();
           PMO& root = index.getRoot();
           PMO::ID elmID = index.insert (testObj, root);
-          
+
           PMO& elm = index.find(elmID);
-          ASSERT (elmID == elm.getID());
-          ASSERT (!isSameObject (elm,testObj));  // note: placements are registered as copy
-          ASSERT (isSameDef(elm,testObj));      //        they are semantically equivalent    ////////TICKET #511
-          ASSERT (elmID != testObj.getID());   //         but have a distinct identity
-          
+          CHECK (elmID == elm.getID());
+          CHECK (!isSameObject (elm,testObj));  // note: placements are registered as copy
+          CHECK (isSameDef(elm,testObj));      //        they are semantically equivalent    ////////TICKET #511
+          CHECK (elmID != testObj.getID());   //         but have a distinct identity
+
           PMO::ID elmID2 = index.insert(testObj, root);
-          ASSERT (elmID2 != elmID);         //            ...and each insert creates a new instance
-          ASSERT (testObj != index.find (elmID));
-          ASSERT (testObj != index.find (elmID2));
-          ASSERT (isSameDef(testObj, index.find(elmID)));
-          ASSERT (isSameDef(testObj, index.find(elmID2)));
-          ASSERT (!isSameObject (testObj, index.find(elmID2)));
-          ASSERT (!isSameObject (elm, index.find(elmID2)));
-          
+          CHECK (elmID2 != elmID);         //            ...and each insert creates a new instance
+          CHECK (testObj != index.find (elmID));
+          CHECK (testObj != index.find (elmID2));
+          CHECK (isSameDef(testObj, index.find(elmID)));
+          CHECK (isSameDef(testObj, index.find(elmID2)));
+          CHECK (!isSameObject (testObj, index.find(elmID2)));
+          CHECK (!isSameObject (elm, index.find(elmID2)));
+
           // can repeatedly retrieve a reference to the same object
-          ASSERT ( isSameObject (elm, index.find(elmID )));
-          ASSERT ( isSameObject (elm, index.find(elmID )));
-          
+          CHECK ( isSameObject (elm, index.find(elmID )));
+          CHECK ( isSameObject (elm, index.find(elmID )));
+
           // can also re-access objects by previous ref
-          ASSERT ( isSameObject (elm, index.find(elm)));
+          CHECK ( isSameObject (elm, index.find(elm)));
           return elmID;
         }
-      
-      
-           
+
+
+
       void
       checkTypedAccess (Idx index, PMO::ID elmID)
         {
           PMO& elm = index.find(elmID);
-          ASSERT (elmID == elm.getID());
-          
+          CHECK (elmID == elm.getID());
+
           typedef Placement<Clip> PClip;
           PClip anotherTestClip = TestClip::create();
-          
+
           typedef PlacementMO::Id<Clip> IDClip;
           IDClip clipID = index.insert(anotherTestClip, elmID);
           // retaining the more specific type info
-          
+
           // access as MObject...
           PMO::ID mID = clipID;
           PMO& asMO = index.find(mID);
-          
+
           // access as Clip
           PClip& asClip = index.find(clipID);
-          ASSERT (LENGTH_TestClip == asClip->getMedia()->getLength());  // using the Clip API
-          
-          ASSERT ( isSameObject(asMO,asClip));
-          ASSERT (!isSameObject(asClip, anotherTestClip)); // always inserting a copy into the PlacementIndex
+          CHECK (LENGTH_TestClip == asClip->getMedia()->getLength());  // using the Clip API
+
+          CHECK ( isSameObject(asMO,asClip));
+          CHECK (!isSameObject(asClip, anotherTestClip)); // always inserting a copy into the PlacementIndex
         }
-      
-      
+
+
       void
       checkInvalidRef (Idx index)
         {
           RefPlacement invalid;
           PlacementMO::ID invalidID (invalid);
-          ASSERT (!bool(invalidID));
-          ASSERT (!bool(invalid));
-          
+          CHECK (!bool(invalidID));
+          CHECK (!bool(invalid));
+
           VERIFY_ERROR(BOTTOM_PLACEMENTREF, index.find(invalid) );
           VERIFY_ERROR(BOTTOM_PLACEMENTREF, index.find(invalidID) );
           VERIFY_ERROR(BOTTOM_PLACEMENTREF, index.getScope(invalidID) );
-          
-          ASSERT (!index.contains(invalidID));
-          
+
+          CHECK (!index.contains(invalidID));
+
           PMO testObj = TestClip::create();
           VERIFY_ERROR(INVALID_SCOPE, index.insert(testObj, invalidID) );
-          
-          ASSERT (false == index.remove(invalidID));
+
+          CHECK (false == index.remove(invalidID));
         }
-      
-      
+
+
       void
       checkScopeHandling (Idx index)
         {
           PMO testObj = TestClip::create();
           PMO& root = index.getRoot();
-          
+
           typedef PMO::ID ID;
           ID e1 = index.insert (testObj, root);
           ID e11 = index.insert (testObj, e1);
@@ -215,34 +215,34 @@ namespace test    {
           ID e132 = index.insert (testObj, e13);
           ID e133 = index.insert (testObj, e13);
           ID e1331 = index.insert (testObj, e133);
-          
-          ASSERT (index.isValid());
-          ASSERT (root == index.getScope(e1));
-          ASSERT (e1   == index.getScope(e11).getID());
-          ASSERT (e1   == index.getScope(e12).getID());
-          ASSERT (e1   == index.getScope(e13).getID());
-          ASSERT (e13  == index.getScope(e131).getID());
-          ASSERT (e13  == index.getScope(e132).getID());
-          ASSERT (e13  == index.getScope(e133).getID());
-          ASSERT (e133 == index.getScope(e1331).getID());
-          ASSERT (e1 != e13);
-          ASSERT (e13 != e133);
-          
-          ASSERT (index.getScope(e11) == index.getScope(index.find(e11)));
-          ASSERT (index.getScope(e131) == index.getScope(index.find(e131)));
-          
+
+          CHECK (index.isValid());
+          CHECK (root == index.getScope(e1));
+          CHECK (e1   == index.getScope(e11).getID());
+          CHECK (e1   == index.getScope(e12).getID());
+          CHECK (e1   == index.getScope(e13).getID());
+          CHECK (e13  == index.getScope(e131).getID());
+          CHECK (e13  == index.getScope(e132).getID());
+          CHECK (e13  == index.getScope(e133).getID());
+          CHECK (e133 == index.getScope(e1331).getID());
+          CHECK (e1 != e13);
+          CHECK (e13 != e133);
+
+          CHECK (index.getScope(e11) == index.getScope(index.find(e11)));
+          CHECK (index.getScope(e131) == index.getScope(index.find(e131)));
+
           VERIFY_ERROR(NONEMPTY_SCOPE, index.remove(e13) ); // can't remove a scope-constituting element
           VERIFY_ERROR(NONEMPTY_SCOPE, index.remove(e133) );
-          
-          ASSERT (index.contains(e1331));
-          ASSERT (index.remove(e1331));
-          ASSERT (!index.contains(e1331));
-          ASSERT (!index.remove(e1331));
-          
-          ASSERT (index.remove(e133));     // but can remove an scope, after emptying it
-          ASSERT (!index.contains(e133));
-          ASSERT (index.isValid());
-          
+
+          CHECK (index.contains(e1331));
+          CHECK (index.remove(e1331));
+          CHECK (!index.contains(e1331));
+          CHECK (!index.remove(e1331));
+
+          CHECK (index.remove(e133));     // but can remove an scope, after emptying it
+          CHECK (!index.contains(e133));
+          CHECK (index.isValid());
+
           // build a complete new subtree
           uint siz   = index.size();
           ID e1321   = index.insert (testObj, e132);
@@ -258,22 +258,22 @@ namespace test    {
           ID e132142 = index.insert (testObj, e13214);
           ID e132143 = index.insert (testObj, e13214);
           ID e132144 = index.insert (testObj, e13214);
-          
+
           // ...and kill it recursively in one sway
           index.clear (e1321);
-          ASSERT (!index.contains (e1321));
-          ASSERT (!index.contains (e13211));
-          ASSERT (!index.contains (e13213));
-          ASSERT (!index.contains (e132131));
-          ASSERT (!index.contains (e132144));
-          ASSERT (siz == index.size());
-          ASSERT (index.isValid());
+          CHECK (!index.contains (e1321));
+          CHECK (!index.contains (e13211));
+          CHECK (!index.contains (e13213));
+          CHECK (!index.contains (e132131));
+          CHECK (!index.contains (e132144));
+          CHECK (siz == index.size());
+          CHECK (index.isValid());
         }
-      
-      
-      
+
+
+
       typedef PlacementIndex::iterator Iter;
-      
+
       /** @test drill down into the tree-like structure
        *        and enumerate the contents of each element, if any
        */
@@ -281,14 +281,14 @@ namespace test    {
       checkContentsEnumeration (Idx index)
         {
           PMO& root = index.getRoot();
-          
+
           Iter rootContents = index.getReferrers (root.getID());
-          ASSERT (rootContents);
-          
+          CHECK (rootContents);
+
           discover (index, rootContents, 0);
         }
-      
-      
+
+
       void
       discover (Idx index, Iter iter, uint level)
         {
@@ -296,30 +296,30 @@ namespace test    {
           for ( ; iter; ++iter )
             {
               cout << indent(level) << "::" << string(*iter) << endl;
-              
+
               ++count;
               Iter scopeContents = index.getReferrers (iter->getID());
               if (scopeContents)
                 discover (index, scopeContents, level+1);
             }
-          
+
           static format summary ("...%i elements at Level %i");
           cout << indent(level) << summary % count % level << endl;
-          
-          ASSERT (!iter);
-          ASSERT (0 < count);
+
+          CHECK (!iter);
+          CHECK (0 < count);
         }
-      
+
       static string
       indent (uint level)
         {
-          return string (level, ' '); 
+          return string (level, ' ');
         }
     };
-  
-  
+
+
   /** Register this test class... */
   LAUNCHER (PlacementIndex_test, "unit session");
-  
-  
+
+
 }}} // namespace mobject::session::test
diff --git a/tests/components/proc/mobject/session/placement-scope-test.cpp b/tests/components/proc/mobject/session/placement-scope-test.cpp
index f3efca615..bcf086077 100644
--- a/tests/components/proc/mobject/session/placement-scope-test.cpp
+++ b/tests/components/proc/mobject/session/placement-scope-test.cpp
@@ -99,7 +99,7 @@ namespace test    {
           for (_Iter ii = contents_of_testSession(sess); ii; ++ii)
             {
               PlacementMO& elm = *ii;
-              ASSERT (elm.isValid());
+              CHECK (elm.isValid());
               Scope const& scope1 = Scope::containing(elm);
               std::cout << "Scope: " << string(scope1) << std::endl;
               std::cout << string(elm) << std::endl;
@@ -109,11 +109,11 @@ namespace test    {
               
               // verify this with the scope registered within the index...
               PlacementMO& scopeTop = sess->getScope(elm);
-              ASSERT (scope1 == scopeTop);
-              ASSERT (scope2 == scopeTop);
-              ASSERT (scope1 == scope2);
+              CHECK (scope1 == scopeTop);
+              CHECK (scope2 == scopeTop);
+              CHECK (scope1 == scope2);
               
-              ASSERT (!isSameObject (scope1,scope2));
+              CHECK (!isSameObject (scope1,scope2));
             }
         }
       
@@ -128,23 +128,23 @@ namespace test    {
           Scope scope2(aPlac);
           Scope nil;
           
-          ASSERT (scope1 == scope2); ASSERT (scope2 == scope1);
-          ASSERT (scope1 != nil);    ASSERT (nil != scope1);
-          ASSERT (scope2 != nil);    ASSERT (nil != scope2);
+          CHECK (scope1 == scope2); CHECK (scope2 == scope1);
+          CHECK (scope1 != nil);    CHECK (nil != scope1);
+          CHECK (scope2 != nil);    CHECK (nil != scope2);
           
-          ASSERT (aPlac == scope1);  ASSERT (scope1 == aPlac);
-          ASSERT (aPlac == scope2);  ASSERT (scope2 == aPlac);
-          ASSERT (aPlac != nil);     ASSERT (nil != aPlac);
+          CHECK (aPlac == scope1);  CHECK (scope1 == aPlac);
+          CHECK (aPlac == scope2);  CHECK (scope2 == aPlac);
+          CHECK (aPlac != nil);     CHECK (nil != aPlac);
           
           Scope par (scope1.getParent());
-          ASSERT (scope1 != par);    ASSERT (par != scope1);
-          ASSERT (scope2 != par);    ASSERT (par != scope2);
+          CHECK (scope1 != par);    CHECK (par != scope1);
+          CHECK (scope2 != par);    CHECK (par != scope2);
           
           PlacementMO& placm2 (scope2.getTop());
-          ASSERT (aPlac.getID() == placm2.getID());
+          CHECK (aPlac.getID() == placm2.getID());
           
           PlacementMO& parPlac (par.getTop());
-          ASSERT (aPlac.getID() != parPlac.getID());
+          CHECK (aPlac.getID() != parPlac.getID());
         }
       
       
@@ -163,8 +163,8 @@ namespace test    {
             {
               _Iter pathIter = pathToRoot(*elm);
               Scope const& enclosing = Scope::containing(*elm);
-              ASSERT (enclosing == Scope(*elm).getParent());
-              ASSERT (*pathIter == Scope(*elm));
+              CHECK (enclosing == Scope(*elm).getParent());
+              CHECK (*pathIter == Scope(*elm));
               
               for ( ; pathIter; ++pathIter)
                 {
@@ -175,7 +175,7 @@ namespace test    {
                       PlacementMO& top = sco.getTop();
                       PlacementMO& root = sess->getRoot();
                       
-                      ASSERT (isSameObject (top,root));
+                      CHECK (isSameObject (top,root));
                     }
                   else
                     {
@@ -183,8 +183,8 @@ namespace test    {
                       PlacementMO& top = sco.getTop();
                       Scope parentsScope = Scope::containing(top);
                       PlacementMO& topsTop = sess->getScope(top);   ///////////////////TODO impact of Binding a Sequence? see Ticket #311
-                      ASSERT (topsTop == parentsScope);
-                      ASSERT (isSameObject (topsTop, parentsScope.getTop()));
+                      CHECK (topsTop == parentsScope);
+                      CHECK (isSameObject (topsTop, parentsScope.getTop()));
                     }}}
         }
       
diff --git a/tests/components/proc/mobject/session/query-focus-stack-test.cpp b/tests/components/proc/mobject/session/query-focus-stack-test.cpp
index 109bea1f5..de09676d4 100644
--- a/tests/components/proc/mobject/session/query-focus-stack-test.cpp
+++ b/tests/components/proc/mobject/session/query-focus-stack-test.cpp
@@ -77,9 +77,9 @@ namespace test    {
         {
           QueryFocusStack stack;
           
-          ASSERT (!isnil (stack));
-          ASSERT (!isnil (stack.top()));
-          ASSERT (stack.top().isRoot());
+          CHECK (!isnil (stack));
+          CHECK (!isnil (stack.top()));
+          CHECK (stack.top().isRoot());
         }
       
       
@@ -93,39 +93,39 @@ namespace test    {
           intrusive_ptr_add_ref (&firstFrame);
           stack.top().navigate(startPoint);
           stack.top().moveUp();
-          ASSERT (Scope(startPoint).getParent() == stack.top().getLeaf());
-          ASSERT (1 == stack.size());
+          CHECK (Scope(startPoint).getParent() == stack.top().getLeaf());
+          CHECK (1 == stack.size());
           
           // now open a second path frame, pushing aside the initial one
           ScopePath& secondFrame = stack.push(startPoint);
           intrusive_ptr_add_ref (&secondFrame);
-          ASSERT (2 == stack.size());
-          ASSERT (secondFrame == stack.top());
-          ASSERT (secondFrame.getLeaf() == startPoint);
-          ASSERT (secondFrame.getLeaf() != firstFrame.getLeaf());
+          CHECK (2 == stack.size());
+          CHECK (secondFrame == stack.top());
+          CHECK (secondFrame.getLeaf() == startPoint);
+          CHECK (secondFrame.getLeaf() != firstFrame.getLeaf());
           
           // can still reach and manipulate the ref-count of the first frame
           intrusive_ptr_add_ref (&firstFrame);
-          ASSERT (2 == firstFrame.ref_count());
-          ASSERT (1 == secondFrame.ref_count());
+          CHECK (2 == firstFrame.ref_count());
+          CHECK (1 == secondFrame.ref_count());
           
           // can use/navigate the stack top frame
           stack.top().goRoot();
-          ASSERT (!stack.top()); // now indeed at root == no path
-          ASSERT (secondFrame.getLeaf().isRoot());
-          ASSERT (secondFrame == stack.top());
+          CHECK (!stack.top()); // now indeed at root == no path
+          CHECK (secondFrame.getLeaf().isRoot());
+          CHECK (secondFrame == stack.top());
           
           // now drop back to the first frame:
-          ASSERT (1 == secondFrame.ref_count());
+          CHECK (1 == secondFrame.ref_count());
           intrusive_ptr_release (&secondFrame);
-          ASSERT (0 == secondFrame.ref_count());
+          CHECK (0 == secondFrame.ref_count());
           stack.pop_unused();
-          ASSERT (1 == stack.size());
-          ASSERT (firstFrame == stack.top());
+          CHECK (1 == stack.size());
+          CHECK (firstFrame == stack.top());
           
           // ...still pointing at the previous location
-          ASSERT (Scope(startPoint).getParent() == stack.top().getLeaf());
-          ASSERT (2 == firstFrame.ref_count());
+          CHECK (Scope(startPoint).getParent() == stack.top().getLeaf());
+          CHECK (2 == firstFrame.ref_count());
         }
       
       
@@ -137,47 +137,47 @@ namespace test    {
           
           ScopePath& firstFrame = stack.top();   // remember for later
           stack.top().navigate(startPoint);
-          ASSERT (1 == stack.size());
+          CHECK (1 == stack.size());
           intrusive_ptr_add_ref (&firstFrame);
           
           // now open two new frames, but don't add ref-counts on them
           ScopePath& secondFrame = stack.push(startPoint);
           ScopePath& thirdFrame  = stack.push(startPoint);
-          ASSERT (3 == stack.size());
-          ASSERT (1 == firstFrame.ref_count());
-          ASSERT (0 == secondFrame.ref_count());
-          ASSERT (0 == thirdFrame.ref_count());
+          CHECK (3 == stack.size());
+          CHECK (1 == firstFrame.ref_count());
+          CHECK (0 == secondFrame.ref_count());
+          CHECK (0 == thirdFrame.ref_count());
           
           // any ref to top detects the non-referred-to state (by ref count==0)
           // and will automatically pop and clean up...
           ScopePath& newTop = stack.top();
-          ASSERT (1 == stack.size());
-          ASSERT (firstFrame == stack.top());
-          ASSERT (isSameObject(newTop, firstFrame));
-          ASSERT (stack.top().getLeaf() == startPoint);
+          CHECK (1 == stack.size());
+          CHECK (firstFrame == stack.top());
+          CHECK (isSameObject(newTop, firstFrame));
+          CHECK (stack.top().getLeaf() == startPoint);
           
           // second exercise: a pop_unused may even completely empty the stack
           ScopePath& anotherFrame = stack.push(startPoint);
-          ASSERT (0 == anotherFrame.ref_count());
-          ASSERT (1 == firstFrame.ref_count());
+          CHECK (0 == anotherFrame.ref_count());
+          CHECK (1 == firstFrame.ref_count());
           intrusive_ptr_release (&firstFrame);
-          ASSERT (0 == firstFrame.ref_count());
-          ASSERT (firstFrame.getLeaf() == startPoint);
+          CHECK (0 == firstFrame.ref_count());
+          CHECK (firstFrame.getLeaf() == startPoint);
           
           stack.pop_unused();
-          ASSERT (1 == stack.size());
+          CHECK (1 == stack.size());
                           // Note: don't use previously taken pointers
                           //       or references anymore, after the stack
                           //       triggered a cleanup!
           ScopePath& anotherFrame2 = stack.top();
-          ASSERT (0 == anotherFrame2.ref_count());
-          ASSERT (anotherFrame2.getLeaf().isRoot());
+          CHECK (0 == anotherFrame2.ref_count());
+          CHECK (anotherFrame2.getLeaf().isRoot());
           anotherFrame2.navigate(startPoint);
-          ASSERT (anotherFrame2.getLeaf() == startPoint);
+          CHECK (anotherFrame2.getLeaf() == startPoint);
           
           stack.top();
-          ASSERT (1 == stack.size());
-          ASSERT (stack.top().getLeaf().isRoot());
+          CHECK (1 == stack.size());
+          CHECK (stack.top().getLeaf().isRoot());
         }
       
       
@@ -189,7 +189,7 @@ namespace test    {
           
           ScopePath& firstFrame = stack.top();   // remember for later
           stack.top().navigate(startPoint);
-          ASSERT (1 == stack.size());
+          CHECK (1 == stack.size());
           intrusive_ptr_add_ref (&firstFrame);
           
           ScopePath beforeInvalidNavigation = firstFrame;
@@ -197,15 +197,15 @@ namespace test    {
           
           // try to navigate to an invalid place
           VERIFY_ERROR (INVALID_SCOPE, stack.top().navigate (unrelatedScope) );
-          ASSERT (1 == stack.size());
-          ASSERT (1 == firstFrame.ref_count());
-          ASSERT (stack.top().getLeaf() == startPoint);
+          CHECK (1 == stack.size());
+          CHECK (1 == firstFrame.ref_count());
+          CHECK (stack.top().getLeaf() == startPoint);
           
           // try to push an invalid place
           VERIFY_ERROR (INVALID_SCOPE, stack.push (unrelatedScope) );
-          ASSERT (1 == stack.size());
-          ASSERT (1 == firstFrame.ref_count());
-          ASSERT (stack.top().getLeaf() == startPoint);
+          CHECK (1 == stack.size());
+          CHECK (1 == firstFrame.ref_count());
+          CHECK (stack.top().getLeaf() == startPoint);
         }
       
       
@@ -215,7 +215,7 @@ namespace test    {
           QueryFocusStack stack;
           intrusive_ptr_add_ref (&stack.top());
           stack.top().moveUp();
-          ASSERT (stack.top().empty());
+          CHECK (stack.top().empty());
           
           PMO& startPoint = retrieve_startElm();
           intrusive_ptr_add_ref ( & stack.push(startPoint) );
@@ -227,16 +227,16 @@ namespace test    {
           intrusive_ptr_add_ref ( & stack.push(startPoint) );
           intrusive_ptr_add_ref ( & stack.push(startPoint) );
           intrusive_ptr_add_ref ( & stack.push(startPoint) );
-          ASSERT (10 == stack.size());
+          CHECK (10 == stack.size());
           stack.pop_unused();
-          ASSERT (10 == stack.size());
-          ASSERT (1 == stack.top().ref_count());
+          CHECK (10 == stack.size());
+          CHECK (1 == stack.top().ref_count());
           
           stack.clear();
-          ASSERT (1 == stack.size());
-          ASSERT (!stack.top().empty());
-          ASSERT (stack.top().getLeaf().isRoot());
-          ASSERT (0 == stack.top().ref_count());
+          CHECK (1 == stack.size());
+          CHECK (!stack.top().empty());
+          CHECK (stack.top().getLeaf().isRoot());
+          CHECK (0 == stack.top().ref_count());
         }
       
     };
diff --git a/tests/components/proc/mobject/session/query-focus-test.cpp b/tests/components/proc/mobject/session/query-focus-test.cpp
index 946250c37..f66d89dd2 100644
--- a/tests/components/proc/mobject/session/query-focus-test.cpp
+++ b/tests/components/proc/mobject/session/query-focus-test.cpp
@@ -79,7 +79,7 @@ namespace test    {
           
           QueryFocus theFocus;
           theFocus.reset();
-          ASSERT (Scope(root) == Scope(theFocus));
+          CHECK (Scope(root) == Scope(theFocus));
           
           checkNavigation (theFocus);
           
@@ -87,10 +87,10 @@ namespace test    {
           manipulate_subFocus();
           
           QueryFocus currentFocus;
-          ASSERT (scopePosition == Scope(currentFocus));
-          ASSERT (currentFocus == theFocus);
-          ASSERT (2 == refs(currentFocus));
-          ASSERT (2 == refs(theFocus));
+          CHECK (scopePosition == Scope(currentFocus));
+          CHECK (currentFocus == theFocus);
+          CHECK (2 == refs(currentFocus));
+          CHECK (2 == refs(theFocus));
         }
       
       
@@ -101,24 +101,24 @@ namespace test    {
       checkNavigation (QueryFocus& focus)
         {
           focus.reset();
-          ASSERT (Scope(focus).isRoot());
+          CHECK (Scope(focus).isRoot());
           
           PMO& someObj = *focus.query<TestSubMO1>();
                          // by construction of the test fixture,
                          // we know this object is root -> ps2 -> ps3
           
-          ASSERT (Scope(focus).isRoot());
+          CHECK (Scope(focus).isRoot());
           focus.attach (someObj);
-          ASSERT (!Scope(focus).isRoot());
+          CHECK (!Scope(focus).isRoot());
           ScopePath path = focus.currentPath();
-          ASSERT (someObj == path.getLeaf());
-          ASSERT (Scope(focus).getParent().getParent().isRoot());
+          CHECK (someObj == path.getLeaf());
+          CHECK (Scope(focus).getParent().getParent().isRoot());
           
           focus.attach (path.getLeaf().getParent());
-          ASSERT (Scope(focus) == path.getLeaf().getParent());
-          ASSERT (someObj != Scope(focus));
-          ASSERT (path.contains (focus.currentPath()));
-          ASSERT (focus.currentPath().getLeaf().getParent().isRoot());
+          CHECK (Scope(focus) == path.getLeaf().getParent());
+          CHECK (someObj != Scope(focus));
+          CHECK (path.contains (focus.currentPath()));
+          CHECK (focus.currentPath().getLeaf().getParent().isRoot());
           
             // as the focus now has been moved up one level,
            //  we'll re-discover the original starting point as immediate child
@@ -134,19 +134,19 @@ namespace test    {
         {
           QueryFocus original;    // automatically attaches to current stack top
           uint num_refs = refs (original);
-          ASSERT (num_refs > 1);  // because the run() function also holds a ref
+          CHECK (num_refs > 1);  // because the run() function also holds a ref
           
           QueryFocus subF = QueryFocus::push();
           cout << string(subF) << endl;
-          ASSERT (subF == original);
+          CHECK (subF == original);
           
-          ASSERT (       1 == refs(subF) );
-          ASSERT (num_refs == refs(original));
+          CHECK (       1 == refs(subF) );
+          CHECK (num_refs == refs(original));
           
           { // temporarily creating an independent focus attached differently
             QueryFocus subF2 = QueryFocus::push(Scope(subF).getParent());
-            ASSERT (subF2 != subF);
-            ASSERT (subF == original);
+            CHECK (subF2 != subF);
+            CHECK (subF == original);
             cout << string(subF2) << endl;
             
             ScopeQuery<TestSubMO21>::iterator ii = subF2.explore<TestSubMO21>();
@@ -160,15 +160,15 @@ namespace test    {
             
             subF2.pop(); // releasing this focus and re-attaching to what's on stack top
             cout << string(subF2) << "<<<--after pop()" << endl;
-            ASSERT (subF2 == subF);
-            ASSERT (2 == refs(subF2));  // both are now attached to the same path
-            ASSERT (2 == refs(subF));
+            CHECK (subF2 == subF);
+            CHECK (2 == refs(subF2));  // both are now attached to the same path
+            CHECK (2 == refs(subF));
           }
           // subF2 went out of scope, but no auto-pop happens (because subF is still there)
           cout << string(subF) << endl;
           
-          ASSERT (       1 == refs(subF));
-          ASSERT (num_refs == refs(original));
+          CHECK (       1 == refs(subF));
+          CHECK (num_refs == refs(original));
          // when subF goes out of scope now, auto-pop will happen...
         }
       
diff --git a/tests/components/proc/mobject/session/rebuildfixturetest.cpp b/tests/components/proc/mobject/session/rebuildfixturetest.cpp
index 43a77ef07..751eb5b80 100644
--- a/tests/components/proc/mobject/session/rebuildfixturetest.cpp
+++ b/tests/components/proc/mobject/session/rebuildfixturetest.cpp
@@ -58,7 +58,7 @@ namespace test    {
           PSess sess = Session::current;
           sess.clear();
           buildTestsession1();
-          ASSERT (sess->isValid());
+          CHECK (sess->isValid());
           sess->rebuildFixture();
 #if false ////////////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #548
           TODO ("check the fixture has been touched. e.g. by hash.");
@@ -79,7 +79,7 @@ namespace test    {
 ////TODO do we still support this? can it be replaced by a directly checking predicate on ExplicitPlacement??
           
 //        PMO originalPlacement = explicitPlacement->subject->getPlacement();
-//        ASSERT (edl.contains(originalPlacement));
+//        CHECK (edl.contains(originalPlacement));
 #endif ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #548
         }
     };
diff --git a/tests/components/proc/mobject/session/scope-path-test.cpp b/tests/components/proc/mobject/session/scope-path-test.cpp
index 156052c9d..e2f9cc3d3 100644
--- a/tests/components/proc/mobject/session/scope-path-test.cpp
+++ b/tests/components/proc/mobject/session/scope-path-test.cpp
@@ -69,7 +69,7 @@ namespace test    {
           // Prepare an (test)Index backing the PlacementRefs
           PPIdx index = build_testScopes();
           PMO& startPlacement = retrieve_startElm();
-          ASSERT (startPlacement.isValid());
+          CHECK (startPlacement.isValid());
           
           checkInvalidScopeDetection();
           ScopePath testPath = buildPath (startPlacement);
@@ -91,10 +91,10 @@ namespace test    {
           ScopePath path2 (startScope);
           ScopePath path3 (path2);
           
-          ASSERT (path);
-          ASSERT (path.contains (startScope));
-          ASSERT ( path.getLeaf() == path2.getLeaf());
-          ASSERT (path2.getLeaf() == path3.getLeaf());
+          CHECK (path);
+          CHECK (path.contains (startScope));
+          CHECK ( path.getLeaf() == path2.getLeaf());
+          CHECK (path2.getLeaf() == path3.getLeaf());
           
           return path;
         }
@@ -125,10 +125,10 @@ namespace test    {
         {
           Scope refScope(refPlacement);
           ScopePath::iterator ii = path.begin();
-          ASSERT (ii);
+          CHECK (ii);
           while (++ii)
             {
-              ASSERT (*ii == refScope.getParent());
+              CHECK (*ii == refScope.getParent());
               refScope = *ii;
             }
         }
@@ -137,86 +137,86 @@ namespace test    {
       void
       checkRelations (ScopePath path1, PMO& refPlacement)
         {
-          ASSERT (path1.contains (refPlacement));
+          CHECK (path1.contains (refPlacement));
           
           Scope refScope (refPlacement);
-          ASSERT (path1.contains (refScope));
-          ASSERT (path1.endsAt (refScope));
+          CHECK (path1.contains (refScope));
+          CHECK (path1.endsAt (refScope));
           
           ScopePath path2 (refScope);
-          ASSERT (path2.contains (refScope));
-          ASSERT (path2.endsAt (refScope));
+          CHECK (path2.contains (refScope));
+          CHECK (path2.endsAt (refScope));
           
-          ASSERT (path1 == path2);
-          ASSERT (!isSameObject (path1,path2));
+          CHECK (path1 == path2);
+          CHECK (!isSameObject (path1,path2));
           
           Scope parent = path2.moveUp();
-          ASSERT (path2.endsAt (parent));
-          ASSERT (path1.endsAt (refScope));
-          ASSERT (parent == refScope.getParent());
-          ASSERT (path1 != path2);
-          ASSERT (path2 != path1);
-          ASSERT (path1.contains (path2));
-          ASSERT (!disjoint(path1,path2));
-          ASSERT (path2 == commonPrefix(path1,path2));
-          ASSERT (path2 == commonPrefix(path2,path1));
-          ASSERT (path1 != commonPrefix(path1,path2));
-          ASSERT (path1 != commonPrefix(path2,path1));
+          CHECK (path2.endsAt (parent));
+          CHECK (path1.endsAt (refScope));
+          CHECK (parent == refScope.getParent());
+          CHECK (path1 != path2);
+          CHECK (path2 != path1);
+          CHECK (path1.contains (path2));
+          CHECK (!disjoint(path1,path2));
+          CHECK (path2 == commonPrefix(path1,path2));
+          CHECK (path2 == commonPrefix(path2,path1));
+          CHECK (path1 != commonPrefix(path1,path2));
+          CHECK (path1 != commonPrefix(path2,path1));
         }
       
       
       void
       rootPath (ScopePath refPath)
         {
-          ASSERT ( refPath);
+          CHECK ( refPath);
           refPath.goRoot();
-          ASSERT (!refPath);
-          ASSERT (!refPath.empty());
-          ASSERT (!refPath.isValid());
-          ASSERT (1 == refPath.length());
+          CHECK (!refPath);
+          CHECK (!refPath.empty());
+          CHECK (!refPath.isValid());
+          CHECK (1 == refPath.length());
           
           ScopePath defaultPath;
-          ASSERT (!defaultPath);
-          ASSERT (refPath == defaultPath);
+          CHECK (!defaultPath);
+          CHECK (refPath == defaultPath);
         }
       
       
       void
       invalidPath (ScopePath refPath, PMO& refPlacement)
         {
-          ASSERT (refPath);
-          ASSERT (!ScopePath::INVALID);
-          ASSERT (isnil (ScopePath::INVALID));
-          ASSERT ("!" == string(ScopePath::INVALID));
+          CHECK (refPath);
+          CHECK (!ScopePath::INVALID);
+          CHECK (isnil (ScopePath::INVALID));
+          CHECK ("!" == string(ScopePath::INVALID));
           
           ScopePath invalidP (ScopePath::INVALID);
-          ASSERT (isnil (invalidP));
-          ASSERT (invalidP == ScopePath::INVALID);
-          ASSERT (!isSameObject (invalidP, ScopePath::INVALID));
+          CHECK (isnil (invalidP));
+          CHECK (invalidP == ScopePath::INVALID);
+          CHECK (!isSameObject (invalidP, ScopePath::INVALID));
           
-          ASSERT (refPath.contains (refPlacement));
-          ASSERT (!invalidP.contains (refPlacement));
+          CHECK (refPath.contains (refPlacement));
+          CHECK (!invalidP.contains (refPlacement));
           
           Scope refScope (refPlacement);
-          ASSERT (!invalidP.contains (refScope));
+          CHECK (!invalidP.contains (refScope));
           VERIFY_ERROR (EMPTY_SCOPE_PATH, invalidP.endsAt (refScope) ); // Logic: can't inspect the end of nothing
           
-          ASSERT (refPath.contains (invalidP));            // If the moon is made of green cheese, I'll eat my hat!
-          ASSERT (!invalidP.contains (refPath));
-          ASSERT (invalidP == commonPrefix(refPath,invalidP));
-          ASSERT (invalidP == commonPrefix(invalidP,refPath));
+          CHECK (refPath.contains (invalidP));            // If the moon is made of green cheese, I'll eat my hat!
+          CHECK (!invalidP.contains (refPath));
+          CHECK (invalidP == commonPrefix(refPath,invalidP));
+          CHECK (invalidP == commonPrefix(invalidP,refPath));
           
           VERIFY_ERROR (EMPTY_SCOPE_PATH, invalidP.moveUp() );
           Scope root = refPath.goRoot();
-          ASSERT (1 == refPath.length());
+          CHECK (1 == refPath.length());
           
           Scope const& nil = refPath.moveUp();
-          ASSERT (refPath.empty());
-          ASSERT (!nil.isValid());
-          ASSERT (refPath == invalidP);
-          ASSERT (invalidP.contains (nil));
-          ASSERT (invalidP.contains (refPath));
-          ASSERT (!invalidP.contains (refScope));
+          CHECK (refPath.empty());
+          CHECK (!nil.isValid());
+          CHECK (refPath == invalidP);
+          CHECK (invalidP.contains (nil));
+          CHECK (invalidP.contains (refPath));
+          CHECK (!invalidP.contains (refScope));
           
           VERIFY_ERROR (EMPTY_SCOPE_PATH, refPath.navigate(root) );
           
@@ -232,31 +232,31 @@ namespace test    {
           ScopePath path2 (startScope);
           ScopePath path3 (path2);
           
-          ASSERT (path1.contains (startScope));
-          ASSERT (path2.contains (startScope));
-          ASSERT (path3.contains (startScope));
+          CHECK (path1.contains (startScope));
+          CHECK (path2.contains (startScope));
+          CHECK (path3.contains (startScope));
           
-          ASSERT (path1 == path2);
-          ASSERT (path2 == path3);
-          ASSERT (path1 == path3);
-          ASSERT (!isSameObject (path1,path2));
-          ASSERT (!isSameObject (path2,path3));
-          ASSERT (!isSameObject (path1,path3));
+          CHECK (path1 == path2);
+          CHECK (path2 == path3);
+          CHECK (path1 == path3);
+          CHECK (!isSameObject (path1,path2));
+          CHECK (!isSameObject (path2,path3));
+          CHECK (!isSameObject (path1,path3));
           
           Scope parent = path3.moveUp();
-          ASSERT (path1 == path2);
-          ASSERT (path2 != path3);
-          ASSERT (path1 != path3);
+          CHECK (path1 == path2);
+          CHECK (path2 != path3);
+          CHECK (path1 != path3);
           
           path2 = path3;
-          ASSERT (path1 != path2);
-          ASSERT (path2 == path3);
-          ASSERT (path1 != path3);
+          CHECK (path1 != path2);
+          CHECK (path2 == path3);
+          CHECK (path1 != path3);
           
           path2 = ScopePath::INVALID;
-          ASSERT (path1 != path2);
-          ASSERT (path2 != path3);
-          ASSERT (path1 != path3);
+          CHECK (path1 != path2);
+          CHECK (path2 != path3);
+          CHECK (path1 != path3);
         }
       
       
@@ -312,28 +312,28 @@ namespace test    {
           #define __SHOWPATH(N) cout << "Step("<<N<<"): "<< string(path) << endl;
           
           ScopePath path (refPath);               __SHOWPATH(1)
-          ASSERT (path == refPath);
+          CHECK (path == refPath);
           
           Scope leaf = path.getLeaf();
           Scope parent = path.moveUp();           __SHOWPATH(2)
-          ASSERT (path != refPath);
-          ASSERT (refPath.contains (path));
-          ASSERT (refPath.endsAt (leaf));
-          ASSERT (path.endsAt (parent));
-          ASSERT (parent == leaf.getParent());
-          ASSERT (parent == path.getLeaf());
+          CHECK (path != refPath);
+          CHECK (refPath.contains (path));
+          CHECK (refPath.endsAt (leaf));
+          CHECK (path.endsAt (parent));
+          CHECK (parent == leaf.getParent());
+          CHECK (parent == path.getLeaf());
           
           Scope root = path.goRoot();             __SHOWPATH(3)
-          ASSERT (path != refPath);
-          ASSERT (path.endsAt (root));
-          ASSERT (refPath.contains (path));
-          ASSERT (!path.endsAt (parent));
-          ASSERT (!path.endsAt (leaf));
+          CHECK (path != refPath);
+          CHECK (path.endsAt (root));
+          CHECK (refPath.contains (path));
+          CHECK (!path.endsAt (parent));
+          CHECK (!path.endsAt (leaf));
           
           path.navigate (parent);                 __SHOWPATH(4)
-          ASSERT (path.endsAt (parent));
-          ASSERT (!path.endsAt (root));
-          ASSERT (!path.endsAt (leaf));
+          CHECK (path.endsAt (parent));
+          CHECK (!path.endsAt (root));
+          CHECK (!path.endsAt (leaf));
           
           TestPlacement<> newNode (*new DummyMO);
           PMO& parentRefPoint = parent.getTop();
@@ -342,29 +342,29 @@ namespace test    {
                   index->insert (newNode, parentRefPoint));
           path.navigate (newLocation);            __SHOWPATH(5)
           Scope sibling = path.getLeaf();
-          ASSERT (sibling == newLocation);
-          ASSERT (parent == sibling.getParent());
-          ASSERT (path.endsAt (sibling));
-          ASSERT (path.contains (parent));
-          ASSERT (path.contains (root));
-          ASSERT (!refPath.contains (path));
-          ASSERT (!path.contains (refPath));
-          ASSERT (!disjoint (path,refPath));
-          ASSERT (!disjoint (refPath,path));
+          CHECK (sibling == newLocation);
+          CHECK (parent == sibling.getParent());
+          CHECK (path.endsAt (sibling));
+          CHECK (path.contains (parent));
+          CHECK (path.contains (root));
+          CHECK (!refPath.contains (path));
+          CHECK (!path.contains (refPath));
+          CHECK (!disjoint (path,refPath));
+          CHECK (!disjoint (refPath,path));
           
           ScopePath prefix = commonPrefix (path,refPath);
-          ASSERT (prefix == commonPrefix (refPath,path));
-          ASSERT (prefix.endsAt (parent));
-          ASSERT (!prefix.contains (leaf));
-          ASSERT (!prefix.contains (sibling));
+          CHECK (prefix == commonPrefix (refPath,path));
+          CHECK (prefix.endsAt (parent));
+          CHECK (!prefix.contains (leaf));
+          CHECK (!prefix.contains (sibling));
           path.navigate (prefix.getLeaf());       __SHOWPATH(6)
-          ASSERT (path == prefix);
+          CHECK (path == prefix);
           
           // try to navigate to an unconnected location...
           ScopePath beforeInvalidNavigation = path;
           Scope const& unrelatedScope (fabricate_invalidScope());
           VERIFY_ERROR (INVALID_SCOPE, path.navigate (unrelatedScope) );
-          ASSERT (path == beforeInvalidNavigation); // not messed up by the incident
+          CHECK (path == beforeInvalidNavigation); // not messed up by the incident
           
           // now explore a completely separate branch....
           PMO& separatePlacement = *explore_testScope (
@@ -372,13 +372,13 @@ namespace test    {
                                        *explore_testScope (
                                          root.getTop())));
           path.navigate (separatePlacement);
-          ASSERT (path);
-          ASSERT (disjoint (path,refPath));
-          ASSERT (path.contains(separatePlacement));
+          CHECK (path);
+          CHECK (disjoint (path,refPath));
+          CHECK (path.contains(separatePlacement));
           Scope other = path.getLeaf();
-          ASSERT (isSameObject (other.getTop(), separatePlacement));
+          CHECK (isSameObject (other.getTop(), separatePlacement));
           ScopePath rootPrefix = commonPrefix (path,refPath);
-          ASSERT (rootPrefix.endsAt (root));
+          CHECK (rootPrefix.endsAt (root));
           
         }
       
@@ -387,14 +387,14 @@ namespace test    {
       void
       clear (ScopePath& path, PPIdx index)
         {
-          ASSERT (path);
+          CHECK (path);
           PMO& rootNode = index->getRoot();
-          ASSERT (path.getLeaf() != rootNode);
+          CHECK (path.getLeaf() != rootNode);
           
           path.clear();
-          ASSERT (!path);
-          ASSERT (!isnil (path));
-          ASSERT (path.getLeaf() == rootNode);
+          CHECK (!path);
+          CHECK (!isnil (path));
+          CHECK (path.getLeaf() == rootNode);
         }
     };
   
diff --git a/tests/components/proc/mobject/session/scope-query-test.cpp b/tests/components/proc/mobject/session/scope-query-test.cpp
index 994adb8dd..293863383 100644
--- a/tests/components/proc/mobject/session/scope-query-test.cpp
+++ b/tests/components/proc/mobject/session/scope-query-test.cpp
@@ -112,7 +112,7 @@ namespace test    {
           ScopeQuery<TestSubMO21> allM021(scope, CONTENTS);
           ScopeQuery<TestSubMO21>::iterator specialEl (issue(allM021));
           ++specialEl; // step in to second solution found...
-          ASSERT (specialEl);
+          CHECK (specialEl);
           
           discover (ScopeQuery<MObject>    (*specialEl, PARENTS) , "parents of the second TestSubMO2 element found");
           discover (ScopeQuery<MObject>    (*specialEl, CHILDREN), "children of the this TestSubMO2 element");
diff --git a/tests/components/proc/mobject/session/session-structure-test.cpp b/tests/components/proc/mobject/session/session-structure-test.cpp
index 5f725c0e5..19921ce6b 100644
--- a/tests/components/proc/mobject/session/session-structure-test.cpp
+++ b/tests/components/proc/mobject/session/session-structure-test.cpp
@@ -64,7 +64,7 @@ namespace test    {
       run (Arg) 
         {
           Session::current.reset();
-          ASSERT (Session::current.isUp());
+          CHECK (Session::current.isUp());
           
           verify_defaultStructure();
         }
@@ -75,7 +75,7 @@ namespace test    {
         {
           
           PSess sess = Session::current;
-          ASSERT (sess->isValid());
+          CHECK (sess->isValid());
           
           UNIMPLEMENTED("the real standard structure of the session"); //////////////////////////TICKET #499
           
@@ -83,53 +83,53 @@ namespace test    {
           
 /////TODO the following is code from the old session mockup... try to rephrase it into the new (real) session API
 //        
-          ASSERT (0 <= sess->currEDL().size());                // TODO implement
-          ASSERT (0 <= sess->getFixture()->size());             // TODO implement
-          ASSERT (sess->currEDL().getTracks()->isValid());
+          CHECK (0 <= sess->currEDL().size());                // TODO implement
+          CHECK (0 <= sess->getFixture()->size());             // TODO implement
+          CHECK (sess->currEDL().getTracks()->isValid());
           
 //              PAsset track = sess->currEDL().getTracks()[0];    // TODO obsolete
 //              AssetManager& aMang = AssetManager::instance();
-//              ASSERT (track == aMang.getAsset (track->getID()));
+//              CHECK (track == aMang.getAsset (track->getID()));
           
 #endif //////////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #546              
           UNIMPLEMENTED ("how to refer to tracks...");
           
-          ASSERT (0 < sess->timelines.size());
+          CHECK (0 < sess->timelines.size());
           PTimeline til = sess->timelines[0];
           
-          ASSERT (0 < sess->sequences.size());
+          CHECK (0 < sess->sequences.size());
           PSequence seq = sess->sequences[0];
           
 #if false //////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #546              
-          ASSERT (isSameObject (seq, til->getSequence()));
+          CHECK (isSameObject (seq, til->getSequence()));
           
           //verify default timeline
           Axis& axis = til->getAxis();
-          ASSERT (Time(0) == axis.origin());
-          ASSERT (Time(0) == til->length());                   ////////////////////////TICKET #177
+          CHECK (Time(0) == axis.origin());
+          CHECK (Time(0) == til->length());                   ////////////////////////TICKET #177
           
           //verify global pipes
           //TODO
           
           //verify default sequence
           RTrack rootTrack = seq->rootTrack();
-          ASSERT (rootTrack->isValid());
-          ASSERT (Time(0) == rootTrack->length());
-          ASSERT (0 == rootTrack->subTracks.size());
-          ASSERT (0 == rootTrack->clips.size());
+          CHECK (rootTrack->isValid());
+          CHECK (Time(0) == rootTrack->length());
+          CHECK (0 == rootTrack->subTracks.size());
+          CHECK (0 == rootTrack->clips.size());
           //TODO verify the output slots of the sequence
           
           //TODO now use the generic query API to discover the same structure.
-          ASSERT (til == *(sess->all<Timeline>()));
-          ASSERT (seq == *(sess->all<Sequence>()));
-          ASSERT (rootTrack == *(sess->all<Track>()));
-          ASSERT (! sess->all<Clip>());
+          CHECK (til == *(sess->all<Timeline>()));
+          CHECK (seq == *(sess->all<Sequence>()));
+          CHECK (rootTrack == *(sess->all<Track>()));
+          CHECK (! sess->all<Clip>());
           
           QueryFocus& focus = sess->focus();
-          ASSERT (rootTrack == focus.getObject());
+          CHECK (rootTrack == focus.getObject());
           focus.navigate (til);
-          ASSERT (til.getBinding() == focus.getObject());
-          ASSERT (rootTrack == *(focus.children()));
+          CHECK (til.getBinding() == focus.getObject());
+          CHECK (rootTrack == *(focus.children()));
 #endif //////////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #546              
         }
     };
diff --git a/tests/components/proc/mobject/session/sessionmanagertest.cpp b/tests/components/proc/mobject/session/sessionmanagertest.cpp
index eb6162e26..e116ca9f2 100644
--- a/tests/components/proc/mobject/session/sessionmanagertest.cpp
+++ b/tests/components/proc/mobject/session/sessionmanagertest.cpp
@@ -59,7 +59,7 @@ namespace test    {
           string serialized;
           saveSession (serialized);
           loadSession (serialized);
-          ASSERT (checkTestsession1());
+          CHECK (checkTestsession1());
         } 
       
       
@@ -68,7 +68,7 @@ namespace test    {
       getCurrentSession ()
         {
           PSess sess = Session::current;
-          ASSERT (sess->isValid());
+          CHECK (sess->isValid());
         }
       
       
diff --git a/tests/components/proc/mobject/session/testclip.cpp b/tests/components/proc/mobject/session/testclip.cpp
index a721d8e1c..37cda9636 100644
--- a/tests/components/proc/mobject/session/testclip.cpp
+++ b/tests/components/proc/mobject/session/testclip.cpp
@@ -79,7 +79,7 @@ namespace test    {
     : Clip(testbed_1().clipA_,
            testbed_1().media_)
   {
-    ASSERT (isValid());
+    CHECK (isValid());
   }
   
   
diff --git a/tests/lib/allocationclustertest.cpp b/tests/lib/allocationclustertest.cpp
index 42ea6fcca..7a91e5a3d 100644
--- a/tests/lib/allocationclustertest.cpp
+++ b/tests/lib/allocationclustertest.cpp
@@ -175,14 +175,14 @@ namespace lib {
             Dummy<37>& ref3 = clu.create<Dummy<37> > (c2);
             Dummy<1234>& rX = clu.create<Dummy<1234> > (c3,c4,c5);
             
-            ASSERT (&ref1);
-            ASSERT (&ref2);
-            ASSERT (&ref3);
-            ASSERT (&rX);
+            CHECK (&ref1);
+            CHECK (&ref2);
+            CHECK (&ref3);
+            CHECK (&rX);
             TRACE (test, "%s", showSizeof(rX).c_str());
             
-            ASSERT (123==ref2.getID());
-            ASSERT (3+4+5==rX.getID());
+            CHECK (123==ref2.getID());
+            CHECK (3+4+5==rX.getID());
             // shows that the returned references actually
             // point at the objects we created. Just use them
             // and let them go. When clu goes out of scope,
@@ -193,20 +193,20 @@ namespace lib {
         void
         checkAllocation()
           {
-            ASSERT (0==checksum);
+            CHECK (0==checksum);
             {
               ClusterList clusters (NUM_CLUSTERS);
               for_each (clusters, fillIt);
-              ASSERT (0!=checksum);
+              CHECK (0!=checksum);
             }
-            ASSERT (0==checksum);
+            CHECK (0==checksum);
           }
         
         
         void
         checkErrorHandling()
           {
-            ASSERT (0==checksum);
+            CHECK (0==checksum);
             {
               randomFailures = true;
               
@@ -224,7 +224,7 @@ namespace lib {
                   }                 //  thus dtor won't be called. Repair the checksum!
             }
             randomFailures = false;
-            ASSERT (0==checksum);
+            CHECK (0==checksum);
           }
       };
     
diff --git a/tests/lib/appconfigtest.cpp b/tests/lib/appconfigtest.cpp
index f3b551492..b7e6cb310 100644
--- a/tests/lib/appconfigtest.cpp
+++ b/tests/lib/appconfigtest.cpp
@@ -46,7 +46,7 @@ namespace lumiera {
         void testAccess (const string& key)
         {
 //        string ver = lumiera::AppState::get(key);
-//        ASSERT ( !util::isnil(ver));
+//        CHECK ( !util::isnil(ver));
         }
       };
     
diff --git a/tests/lib/bool-checkable-test.cpp b/tests/lib/bool-checkable-test.cpp
index 501bcb622..ede6aba25 100644
--- a/tests/lib/bool-checkable-test.cpp
+++ b/tests/lib/bool-checkable-test.cpp
@@ -88,12 +88,12 @@ namespace test{
               if (test)
                 cout << i << "\n";
               
-              ASSERT (test.isValid() == bool(test) );
-              ASSERT (test.isValid() != !test);
+              CHECK (test.isValid() == bool(test) );
+              CHECK (test.isValid() != !test);
             }
           
           cout << showSizeof<ExampleCustomType123>() <<"\n";
-          ASSERT (sizeof (int) == sizeof (ExampleCustomType123));
+          CHECK (sizeof (int) == sizeof (ExampleCustomType123));
         }
     };
   
diff --git a/tests/lib/custom-shared-ptr-test.cpp b/tests/lib/custom-shared-ptr-test.cpp
index fe85e5149..646086be8 100644
--- a/tests/lib/custom-shared-ptr-test.cpp
+++ b/tests/lib/custom-shared-ptr-test.cpp
@@ -1,23 +1,23 @@
 /*
   CustomSharedPtr(Test)  -  ref counting, equality and comparisons
- 
+
   Copyright (C)         Lumiera.org
     2008-2010,          Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2 of the
   License, or (at your option) any later version.
- 
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
@@ -33,37 +33,37 @@
 
 namespace lib {
 namespace test{
-  
+
   using lumiera::P;
   using std::string;
   using std::tr1::shared_ptr;
   using std::tr1::weak_ptr;
-  
+
   using lumiera::error::LUMIERA_ERROR_ASSERTION;
-  
-  
-  struct X 
+
+
+  struct X
     : boost::totally_ordered<X>
     {
       long x_;
-      
+
       X(long x=0)  : x_(x) {}
       operator long () { return x_; }
-      
+
       bool operator<  (const X& ox)  const { return x_ <  ox.x_; }
       bool operator== (const X& ox)  const { return x_ == ox.x_; }
-      
+
       virtual ~X() {} // using RTTI
     };
-  
+
   struct XX : public X
     {
       long xx_;
-      
+
       XX(long x=0)  : X(x), xx_(x+1) {}
     };
-  
-  
+
+
   /****************************************************************
    * @test assure correct behaviour of lumiera's custom shared-ptr,
    *       including ADL of operators, shared ownership, typing
@@ -73,101 +73,101 @@ namespace test{
   class CustomSharedPtr_test : public Test
     {
       virtual void
-      run (Arg) 
+      run (Arg)
         {
           check_refcounting ();
           check_shared_ownership ();
           check_type_relations ();
           check_ordering ();
         }
-      
-      
+
+
       /** @test smart-ptr basic behaviour */
       void
       check_refcounting ()
         {
           P<X> p1 (new X(7));
-          ASSERT (p1);
-          ASSERT (1 == p1.use_count());
-          ASSERT (7 == p1->x_);
-          
+          CHECK (p1);
+          CHECK (1 == p1.use_count());
+          CHECK (7 == p1->x_);
+
             {
               P<X> p2 (new X(9));
-              ASSERT (1 == p2.use_count());
-              
+              CHECK (1 == p2.use_count());
+
               p2.swap (p1);
-              ASSERT (1 == p1.use_count());
-              ASSERT (1 == p2.use_count());
-              
+              CHECK (1 == p1.use_count());
+              CHECK (1 == p2.use_count());
+
               p2 = p1;
-              ASSERT (2 == p1.use_count());
-              ASSERT (2 == p2.use_count());
+              CHECK (2 == p1.use_count());
+              CHECK (2 == p2.use_count());
             }
-            
-          ASSERT (1 == p1.use_count());
-          ASSERT (9 == p1->x_);
-          
+
+          CHECK (1 == p1.use_count());
+          CHECK (9 == p1->x_);
+
           p1.reset();
-          ASSERT (0 == p1.use_count());
-          ASSERT (!p1);
+          CHECK (0 == p1.use_count());
+          CHECK (!p1);
         }
-      
-      
+
+
       /** @test cooperation with other shared-ptr types */
       void
       check_shared_ownership ()
         {
           std::auto_ptr<X> au (new X(22));
-          ASSERT (au.get());
-          
+          CHECK (au.get());
+
           P<X> pX (au);
-          ASSERT (!au.get());
-          ASSERT (pX);
-          ASSERT (1 == pX.use_count());
-          ASSERT (22 == pX->x_);
-          
+          CHECK (!au.get());
+          CHECK (pX);
+          CHECK (1 == pX.use_count());
+          CHECK (22 == pX->x_);
+
           weak_ptr<X> wX (pX);
-          ASSERT (wX.lock());
-          ASSERT (1 == pX.use_count());
-          
+          CHECK (wX.lock());
+          CHECK (1 == pX.use_count());
+
           shared_ptr<X> sp1 (wX);
-          shared_ptr<X> sp2 (pX); 
+          shared_ptr<X> sp2 (pX);
           shared_ptr<X> sp3; sp3 = pX;
-          
-          ASSERT (22 == sp3->x_);
-          ASSERT (4 == pX.use_count());
-          ASSERT (*pX  == *sp1);
-          ASSERT (*sp1 == *sp2);
-          ASSERT (*sp2 == *sp3);
-          
+
+          CHECK (22 == sp3->x_);
+          CHECK (4 == pX.use_count());
+          CHECK (*pX  == *sp1);
+          CHECK (*sp1 == *sp2);
+          CHECK (*sp2 == *sp3);
+
           P<X> pX2;
           pX2.swap(pX);
-          ASSERT (!pX);
-          ASSERT (0 == pX.use_count());
-          ASSERT (4 == pX2.use_count());
-          
+          CHECK (!pX);
+          CHECK (0 == pX.use_count());
+          CHECK (4 == pX2.use_count());
+
           P<X, P<X> > pXX (pX2);  // a different type, but compatible pointers
           pX2 = pX;
-          ASSERT (!pX2);
-          ASSERT (0 == pX2.use_count());
-          ASSERT (4 == pXX.use_count());
-          
+          CHECK (!pX2);
+          CHECK (0 == pX2.use_count());
+          CHECK (4 == pXX.use_count());
+
           sp3 = sp2 = sp1 = pX;
-          ASSERT (22 == pXX->x_);
-          ASSERT (1 == pXX.use_count());
-          ASSERT (!sp1);
-          ASSERT (!sp2);
-          ASSERT (!sp3);
-          
-          ASSERT (22 == wX.lock()->x_);
-          ASSERT (1 == pXX.use_count());
-          
+          CHECK (22 == pXX->x_);
+          CHECK (1 == pXX.use_count());
+          CHECK (!sp1);
+          CHECK (!sp2);
+          CHECK (!sp3);
+
+          CHECK (22 == wX.lock()->x_);
+          CHECK (1 == pXX.use_count());
+
           pXX.reset();
-          ASSERT (!pXX);
-          ASSERT (!wX.lock());
+          CHECK (!pXX);
+          CHECK (!wX.lock());
         }
-      
-      
+
+
       /** @test building type relationships on smart-ptrs */
       void
       check_type_relations ()
@@ -179,135 +179,135 @@ namespace test{
           P<XX,shared_ptr<long> > pLo;// Base: shared_ptr<long>       (rather nonsense, but well...)
           P<X,string> pLoL;           // Base: std::string
           P<string> pLoLoL;           // Base: shared_ptr<string>
-          
-          ASSERT (INSTANCEOF (shared_ptr<X>, &pX));
-          
-          ASSERT ( INSTANCEOF (shared_ptr<XX>, &pX1));
-//        ASSERT (!INSTANCEOF (shared_ptr<X>,  &pX1));     // doesn't compile (no RTTI) -- that's correct
-//        ASSERT (!INSTANCEOF (P<X>,           &pX1));     // similar, type mismatch detected by compiler
-          
-          ASSERT ( INSTANCEOF (shared_ptr<X>,  &pX2));
-//        ASSERT (!INSTANCEOF (shared_ptr<XX>, &pX2));
-          ASSERT ( INSTANCEOF (P<X>,           &pX2));
-          
-          ASSERT ( INSTANCEOF (shared_ptr<X>,  &pX3));
-//        ASSERT (!INSTANCEOF (shared_ptr<XX>, &pX3));
-//        ASSERT (!INSTANCEOF (P<X>,           &pX3));
-          
-          ASSERT ( INSTANCEOF (shared_ptr<long>, &pLo));
-//        ASSERT (!INSTANCEOF (shared_ptr<X>,    &pLo));
-//        ASSERT (!INSTANCEOF (P<X>,             &pLo));
-          
-//        ASSERT (!INSTANCEOF (shared_ptr<long>, &pLoL));
-//        ASSERT (!INSTANCEOF (shared_ptr<X>,    &pLoL));
-//        ASSERT (!INSTANCEOF (P<X>,             &pLoL));
-          ASSERT ( INSTANCEOF (string,           &pLoL));
-          
-          ASSERT ( INSTANCEOF (shared_ptr<string>, &pLoLoL));
-//        ASSERT (!INSTANCEOF (string,             &pLoLoL));
-//        ASSERT (!INSTANCEOF (shared_ptr<X>,      &pLoLoL));
-          
+
+          CHECK (INSTANCEOF (shared_ptr<X>, &pX));
+
+          CHECK ( INSTANCEOF (shared_ptr<XX>, &pX1));
+//        CHECK (!INSTANCEOF (shared_ptr<X>,  &pX1));     // doesn't compile (no RTTI) -- that's correct
+//        CHECK (!INSTANCEOF (P<X>,           &pX1));     // similar, type mismatch detected by compiler
+
+          CHECK ( INSTANCEOF (shared_ptr<X>,  &pX2));
+//        CHECK (!INSTANCEOF (shared_ptr<XX>, &pX2));
+          CHECK ( INSTANCEOF (P<X>,           &pX2));
+
+          CHECK ( INSTANCEOF (shared_ptr<X>,  &pX3));
+//        CHECK (!INSTANCEOF (shared_ptr<XX>, &pX3));
+//        CHECK (!INSTANCEOF (P<X>,           &pX3));
+
+          CHECK ( INSTANCEOF (shared_ptr<long>, &pLo));
+//        CHECK (!INSTANCEOF (shared_ptr<X>,    &pLo));
+//        CHECK (!INSTANCEOF (P<X>,             &pLo));
+
+//        CHECK (!INSTANCEOF (shared_ptr<long>, &pLoL));
+//        CHECK (!INSTANCEOF (shared_ptr<X>,    &pLoL));
+//        CHECK (!INSTANCEOF (P<X>,             &pLoL));
+          CHECK ( INSTANCEOF (string,           &pLoL));
+
+          CHECK ( INSTANCEOF (shared_ptr<string>, &pLoLoL));
+//        CHECK (!INSTANCEOF (string,             &pLoLoL));
+//        CHECK (!INSTANCEOF (shared_ptr<X>,      &pLoLoL));
+
           pX = pX1;   // OK: pointee subtype...
           pX = pX2;   // invokes shared_ptr<X>::operator= (shared_ptr<X> const&)
           pX = pX3;
 //        pX = pLo;   // similar, but long*   not assignable to X*
 //        pX = pLoL;  // similar, but string* not assignable to X*
 //        pX = pLoLoL;   // same...
-                        //  you won't be able to do much with the "LoLo"-Types, 
+                        //  you won't be able to do much with the "LoLo"-Types,
                        //   as their types and pointee types's relations don't match
-          
+
           pX.reset (new XX(5));
-          ASSERT (5 == *pX);      // implicit conversion from X to long
-          
+          CHECK (5 == *pX);      // implicit conversion from X to long
+
           pX2 = pX;               // works, because both are implemented in terms of shared_ptr<X>
-          ASSERT (5 == pX2->x_); 
-          ASSERT (6 == pX2->xx_); // using the XX interface (performing dynamic downcast)
-          
+          CHECK (5 == pX2->x_);
+          CHECK (6 == pX2->xx_); // using the XX interface (performing dynamic downcast)
+
           pX3.reset (new X(7));   // again works because implemented in terms of shared_ptr<X>
           pX2 = pX3;              // same
-          ASSERT (pX2);           // both contain indeed a valid pointer....
-          ASSERT (pX3);
-          ASSERT (! pX2.get());        // but dynamic cast to XX at access fails
-          ASSERT (! pX3.get());
+          CHECK (pX2);           // both contain indeed a valid pointer....
+          CHECK (pX3);
+          CHECK (! pX2.get());        // but dynamic cast to XX at access fails
+          CHECK (! pX3.get());
         }
-      
-      
+
+
       /** @test equality and ordering operators forwarded to pointee */
       void
       check_ordering ()
         {
           typedef P<X> PX;
           typedef P<XX,PX> PXX;
-          
+
           PX pX1 (new X(3));
           PX pX2 (new XX(5));
           PX pX3, pX4, pX5, pX6;
           PXX pXX (new XX(7));
-          
+
           pX3 = pXX;
           pX4.reset(new X(*pXX));
-          
-          ASSERT ( (pX1 == pX1));    // reflexivity
-          ASSERT (!(pX1 != pX1));
-          ASSERT (!(pX1 <  pX1));
-          ASSERT (!(pX1 >  pX1));
-          ASSERT ( (pX1 <= pX1));
-          ASSERT ( (pX1 >= pX1));
-          
-          ASSERT (!(pX1 == pX2));    // compare to same ptr type with larger pointee of subtype
-          ASSERT ( (pX1 != pX2));
-          ASSERT ( (pX1 <  pX2));
-          ASSERT (!(pX1 >  pX2));
-          ASSERT ( (pX1 <= pX2));
-          ASSERT (!(pX1 >= pX2));
-          
-          ASSERT (!(pX2 == pXX));    // compare to ptr subtype with larger pointee of same subtype
-          ASSERT ( (pX2 != pXX));
-          ASSERT ( (pX2 <  pXX));
-          ASSERT (!(pX2 >  pXX));
-          ASSERT ( (pX2 <= pXX));
-          ASSERT (!(pX2 >= pXX));
-          
-          ASSERT (!(pX1 == pXX));    // transitively compare to ptr subtype with larger pointee of subtype
-          ASSERT ( (pX1 != pXX));
-          ASSERT ( (pX1 <  pXX));
-          ASSERT (!(pX1 >  pXX));
-          ASSERT ( (pX1 <= pXX));
-          ASSERT (!(pX1 >= pXX));
-          
-          ASSERT ( (pX3 == pXX));    // compare ptr to subtype ptr both referring to same pointee
-          ASSERT (!(pX3 != pXX));
-          ASSERT (!(pX3 <  pXX));
-          ASSERT (!(pX3 >  pXX));
-          ASSERT ( (pX3 <= pXX));
-          ASSERT ( (pX3 >= pXX));
-          
-          ASSERT ( (pX4 == pXX));    // compare ptr to subtype ptr both referring to different but equal pointees
-          ASSERT (!(pX4 != pXX));
-          ASSERT (!(pX4 <  pXX));
-          ASSERT (!(pX4 >  pXX));
-          ASSERT ( (pX4 <= pXX));
-          ASSERT ( (pX4 >= pXX));
-          
-          ASSERT (!(pXX == pX5));    // compare subtype ptr to empty ptr: "unequal but not orderable"
-          ASSERT ( (pXX != pX5));
-          
-          ASSERT ( (pX5 == pX6));    // compare two empty ptrs: "equal, equivalent but not orderable"
-          ASSERT (!(pX5 != pX6));
-          
+
+          CHECK ( (pX1 == pX1));    // reflexivity
+          CHECK (!(pX1 != pX1));
+          CHECK (!(pX1 <  pX1));
+          CHECK (!(pX1 >  pX1));
+          CHECK ( (pX1 <= pX1));
+          CHECK ( (pX1 >= pX1));
+
+          CHECK (!(pX1 == pX2));    // compare to same ptr type with larger pointee of subtype
+          CHECK ( (pX1 != pX2));
+          CHECK ( (pX1 <  pX2));
+          CHECK (!(pX1 >  pX2));
+          CHECK ( (pX1 <= pX2));
+          CHECK (!(pX1 >= pX2));
+
+          CHECK (!(pX2 == pXX));    // compare to ptr subtype with larger pointee of same subtype
+          CHECK ( (pX2 != pXX));
+          CHECK ( (pX2 <  pXX));
+          CHECK (!(pX2 >  pXX));
+          CHECK ( (pX2 <= pXX));
+          CHECK (!(pX2 >= pXX));
+
+          CHECK (!(pX1 == pXX));    // transitively compare to ptr subtype with larger pointee of subtype
+          CHECK ( (pX1 != pXX));
+          CHECK ( (pX1 <  pXX));
+          CHECK (!(pX1 >  pXX));
+          CHECK ( (pX1 <= pXX));
+          CHECK (!(pX1 >= pXX));
+
+          CHECK ( (pX3 == pXX));    // compare ptr to subtype ptr both referring to same pointee
+          CHECK (!(pX3 != pXX));
+          CHECK (!(pX3 <  pXX));
+          CHECK (!(pX3 >  pXX));
+          CHECK ( (pX3 <= pXX));
+          CHECK ( (pX3 >= pXX));
+
+          CHECK ( (pX4 == pXX));    // compare ptr to subtype ptr both referring to different but equal pointees
+          CHECK (!(pX4 != pXX));
+          CHECK (!(pX4 <  pXX));
+          CHECK (!(pX4 >  pXX));
+          CHECK ( (pX4 <= pXX));
+          CHECK ( (pX4 >= pXX));
+
+          CHECK (!(pXX == pX5));    // compare subtype ptr to empty ptr: "unequal but not orderable"
+          CHECK ( (pXX != pX5));
+
+          CHECK ( (pX5 == pX6));    // compare two empty ptrs: "equal, equivalent but not orderable"
+          CHECK (!(pX5 != pX6));
+
           // order relations on NIL pointers disallowed
-          
+
 #if false ///////////////////////////////////////////////////////////////////////////////////////////////TICKET #537 : restore throwing ASSERT
           VERIFY_ERROR (ASSERTION, pXX <  pX5 );
           VERIFY_ERROR (ASSERTION, pXX >  pX5 );
           VERIFY_ERROR (ASSERTION, pXX <= pX5 );
           VERIFY_ERROR (ASSERTION, pXX >= pX5 );
-          
+
           VERIFY_ERROR (ASSERTION, pX5 <  pXX );
           VERIFY_ERROR (ASSERTION, pX5 >  pXX );
           VERIFY_ERROR (ASSERTION, pX5 <= pXX );
           VERIFY_ERROR (ASSERTION, pX5 >= pXX );
-          
+
           VERIFY_ERROR (ASSERTION, pX5 <  pX6 );
           VERIFY_ERROR (ASSERTION, pX5 >  pX6 );
           VERIFY_ERROR (ASSERTION, pX5 <= pX6 );
@@ -315,11 +315,11 @@ namespace test{
 #endif    ///////////////////////////////////////////////////////////////////////////////////////////////TICKET #537 : restore throwing ASSERT
         }
     };
-  
-  
+
+
   /** Register this test class... */
   LAUNCHER (CustomSharedPtr_test, "unit common");
-  
-  
-  
+
+
+
 }} // namespace lib::test
diff --git a/tests/lib/exceptionerrortest.cpp b/tests/lib/exceptionerrortest.cpp
index 802b6953f..2de614293 100644
--- a/tests/lib/exceptionerrortest.cpp
+++ b/tests/lib/exceptionerrortest.cpp
@@ -138,20 +138,20 @@ namespace lumiera {
         void checkErrorIntegration()
         {
           lumiera_error ();
-          ASSERT (!lumiera_error ());
+          CHECK (!lumiera_error ());
           
           Error err1;
           Error err2("boo",LUMIERA_ERROR_DERIVED);
-          ASSERT (err1.getID () == lumiera_error ()); // (we didn't clear the first one!)
+          CHECK (err1.getID () == lumiera_error ()); // (we didn't clear the first one!)
           
           Error err3("boooo",LUMIERA_ERROR_DERIVED);
-          ASSERT (err3.getID () == lumiera_error ());
+          CHECK (err3.getID () == lumiera_error ());
           
           SpecificError err4;
-          ASSERT (err4.getID () == LUMIERA_ERROR_LIFE_AND_UNIVERSE);
-          ASSERT (err4.getID () == lumiera_error ());
+          CHECK (err4.getID () == LUMIERA_ERROR_LIFE_AND_UNIVERSE);
+          CHECK (err4.getID () == lumiera_error ());
           
-          ASSERT (!lumiera_error ());
+          CHECK (!lumiera_error ());
         }
         
         
@@ -165,13 +165,13 @@ namespace lumiera {
         void checkErrorFlagPropagation()
         {
           lumiera_error_set(LUMIERA_ERROR_LIFE_AND_UNIVERSE, "what is the answer?");
-          ASSERT (lumiera_error_peek());
+          CHECK (lumiera_error_peek());
           
           catcher (&test::detectErrorflag, "");
-          ASSERT (LUMIERA_ERROR_LIFE_AND_UNIVERSE == lumiera_error_peek());
+          CHECK (LUMIERA_ERROR_LIFE_AND_UNIVERSE == lumiera_error_peek());
           
           catcher (&test::detectErrorflagChained, "the big bang");
-          ASSERT (LUMIERA_ERROR_LIFE_AND_UNIVERSE == lumiera_error());
+          CHECK (LUMIERA_ERROR_LIFE_AND_UNIVERSE == lumiera_error());
         }
         
         
@@ -189,12 +189,12 @@ namespace lumiera {
           error::External err5(rerr);
           Error err6(err5);
           
-          ASSERT (err2.rootCause() == err1.what());
-          ASSERT (err3.rootCause() == err1.what());
-          ASSERT (err4.rootCause() == err1.what());
+          CHECK (err2.rootCause() == err1.what());
+          CHECK (err3.rootCause() == err1.what());
+          CHECK (err4.rootCause() == err1.what());
           
-          ASSERT (err5.rootCause() == rerr.what());
-          ASSERT (err6.rootCause() == rerr.what());
+          CHECK (err5.rootCause() == rerr.what());
+          CHECK (err6.rootCause() == rerr.what());
         }
         
         
diff --git a/tests/lib/factory-special-test.cpp b/tests/lib/factory-special-test.cpp
index 9e205b5ff..4c912e284 100644
--- a/tests/lib/factory-special-test.cpp
+++ b/tests/lib/factory-special-test.cpp
@@ -215,7 +215,7 @@ namespace test{
           format msg ("created %d shared_ptrs to Object placed in static buffer.\n");
           void* raw (0);
           P pX;
-          ASSERT (0 == pX.use_count());
+          CHECK (0 == pX.use_count());
           
             {
               P p1 (placement_fac (cnt));
@@ -228,7 +228,7 @@ namespace test{
               raw = p1.get(); // remember raw mem address
             }
             
-          ASSERT (0 == pX.use_count());
+          CHECK (0 == pX.use_count());
           
             {
               P p1 (placement_fac (cnt+1));
@@ -238,10 +238,10 @@ namespace test{
               
               cout << msg % p2.use_count();
               
-              ASSERT (raw == p1.get(), "explicit object placement at fixed buffer doesn't work.");
+              CHECK (raw == p1.get(), "explicit object placement at fixed buffer doesn't work.");
             }
             
-          ASSERT (0 == pX.use_count());
+          CHECK (0 == pX.use_count());
         } 
       
       
@@ -258,7 +258,7 @@ namespace test{
           format msg ("created %d shared_ptrs to paranoid Object.\n");
           P pX;
           
-          ASSERT (0 == pX.use_count());
+          CHECK (0 == pX.use_count());
             {
               P p1 (paranoid_fac (cnt));
               P p2 (p1);
@@ -267,7 +267,7 @@ namespace test{
               cout << msg % p2.use_count() 
                    << string (*pX) << "\n";
             }
-          ASSERT (0 == pX.use_count());
+          CHECK (0 == pX.use_count());
         }
       
       
@@ -288,7 +288,7 @@ namespace test{
           cout << ("created auto_ptr to malloc-ed Object.\n")
                << string (*p2) << "\n";
           
-          ASSERT (!p1.get());
+          CHECK (!p1.get());
         }
       
       
@@ -309,7 +309,7 @@ namespace test{
           cout << ("created auto_ptr to Interface Object.\n");
           p2->funky(); // call a Interface function
           
-          ASSERT (!p1.get());
+          CHECK (!p1.get());
         }
     };
   
diff --git a/tests/lib/functor-util-test.cpp b/tests/lib/functor-util-test.cpp
index 4d7d8ad53..045583234 100644
--- a/tests/lib/functor-util-test.cpp
+++ b/tests/lib/functor-util-test.cpp
@@ -80,21 +80,21 @@ namespace test {
           Fvi f1 (fun1);
           Fvi f2 (fun2);
           
-          ASSERT (!rawComparison(f0, f1));
-          ASSERT (!rawComparison(f1, f2));
-          ASSERT (!rawComparison(f0, f2));
+          CHECK (!rawComparison(f0, f1));
+          CHECK (!rawComparison(f1, f2));
+          CHECK (!rawComparison(f0, f2));
           
           Fvi f22 (f2);
-          ASSERT ( rawComparison(f2, f22));
+          CHECK ( rawComparison(f2, f22));
           
           f1 = f2;
-          ASSERT ( rawComparison(f1, f2));
+          CHECK ( rawComparison(f1, f2));
           
-          ASSERT (!rawComparison(f0, Fvi()));   // note: can't detect they are equivalent
-          ASSERT (!rawComparison(f0, Fiv()));
+          CHECK (!rawComparison(f0, Fvi()));   // note: can't detect they are equivalent
+          CHECK (!rawComparison(f0, Fiv()));
           
           f1 = bind (fun2, _1);
-          ASSERT (!rawComparison(f1, f2));
+          CHECK (!rawComparison(f1, f2));
           
           Dummy dum1, dum2;
           Fvi fm1 = bind (&Dummy::gummi, dum1, _1);
@@ -104,23 +104,23 @@ namespace test {
           Fvv fm5 = bind (&Dummy::gummi, dum2, 24);
           Fvv fm6 = bind (&Dummy::gummi, dum2, 24);
           
-          ASSERT (!rawComparison(f1, fm1));
+          CHECK (!rawComparison(f1, fm1));
           
-          ASSERT (!rawComparison(fm1, fm2));
-          ASSERT (!rawComparison(fm1, fm3));
-          ASSERT (!rawComparison(fm1, fm4));
-          ASSERT (!rawComparison(fm1, fm5));
-          ASSERT (!rawComparison(fm1, fm6));
-          ASSERT (!rawComparison(fm2, fm3));
-          ASSERT (!rawComparison(fm2, fm4));
-          ASSERT (!rawComparison(fm2, fm5));
-          ASSERT (!rawComparison(fm2, fm6));
-          ASSERT (!rawComparison(fm3, fm4));
-          ASSERT (!rawComparison(fm3, fm5));
-          ASSERT (!rawComparison(fm3, fm6));
-          ASSERT (!rawComparison(fm4, fm5));
-          ASSERT (!rawComparison(fm4, fm6));
-          ASSERT (!rawComparison(fm5, fm6));   // again: can't detect they are equivalent
+          CHECK (!rawComparison(fm1, fm2));
+          CHECK (!rawComparison(fm1, fm3));
+          CHECK (!rawComparison(fm1, fm4));
+          CHECK (!rawComparison(fm1, fm5));
+          CHECK (!rawComparison(fm1, fm6));
+          CHECK (!rawComparison(fm2, fm3));
+          CHECK (!rawComparison(fm2, fm4));
+          CHECK (!rawComparison(fm2, fm5));
+          CHECK (!rawComparison(fm2, fm6));
+          CHECK (!rawComparison(fm3, fm4));
+          CHECK (!rawComparison(fm3, fm5));
+          CHECK (!rawComparison(fm3, fm6));
+          CHECK (!rawComparison(fm4, fm5));
+          CHECK (!rawComparison(fm4, fm6));
+          CHECK (!rawComparison(fm5, fm6));   // again: can't detect they are equivalent
         }
     };
   
diff --git a/tests/lib/hash-indexed-test.cpp b/tests/lib/hash-indexed-test.cpp
index 82578715a..a9791e0dd 100644
--- a/tests/lib/hash-indexed-test.cpp
+++ b/tests/lib/hash-indexed-test.cpp
@@ -94,19 +94,19 @@ namespace test{
           TestB::Id<TestDB> idDB1 ;
           TestB::Id<TestDB> idDB2 (idDB1);
           
-          ASSERT (sizeof (idDB1)     == sizeof (idDA) );
-          ASSERT (sizeof (TestB::ID) == sizeof (hash::LuidH));
-          ASSERT (sizeof (TestDA)    == sizeof (hash::LuidH) + sizeof (DummyAncestor));
+          CHECK (sizeof (idDB1)     == sizeof (idDA) );
+          CHECK (sizeof (TestB::ID) == sizeof (hash::LuidH));
+          CHECK (sizeof (TestDA)    == sizeof (hash::LuidH) + sizeof (DummyAncestor));
           
-          ASSERT (idDA  == bb.getID() );
-          ASSERT (idDB1 == idDB2 );            // equality handled by the hash impl (here LuidH)
+          CHECK (idDA  == bb.getID() );
+          CHECK (idDB1 == idDB2 );            // equality handled by the hash impl (here LuidH)
           
           TestDA d1;
           TestDA d2;
-          ASSERT (d1.getID() != d2.getID());   // should be different because LUIDs are random
+          CHECK (d1.getID() != d2.getID());   // should be different because LUIDs are random
           
           d2 = d1; 
-          ASSERT (d1.getID() == d2.getID());   // default assignment operator works as expected
+          CHECK (d1.getID() == d2.getID());   // default assignment operator works as expected
         }
       
       
@@ -121,7 +121,7 @@ namespace test{
           // now, maybe after passing it through a Layer barrier...
           TestB::ID const& idCopy = reinterpret_cast<TestB::ID & > (plainLUID);
           
-          ASSERT (idOrig == idCopy);
+          CHECK (idOrig == idCopy);
         }
       
       
@@ -141,17 +141,17 @@ namespace test{
           tab[key2] = o2;
           tab[key3] = o3;
           
-          ASSERT (!isSameObject (o1, tab[key1]));     // indeed a copy...
-          ASSERT (!isSameObject (o2, tab[key2]));
-          ASSERT (!isSameObject (o3, tab[key3]));
+          CHECK (!isSameObject (o1, tab[key1]));     // indeed a copy...
+          CHECK (!isSameObject (o2, tab[key2]));
+          CHECK (!isSameObject (o3, tab[key3]));
           
-          ASSERT (o1.getID() == tab[key1].getID());   // but "equal" by ID
-          ASSERT (o2.getID() == tab[key2].getID());
-          ASSERT (o3.getID() == tab[key3].getID());
+          CHECK (o1.getID() == tab[key1].getID());   // but "equal" by ID
+          CHECK (o2.getID() == tab[key2].getID());
+          CHECK (o3.getID() == tab[key3].getID());
           
-          ASSERT (o1.getID() != tab[key2].getID());
-          ASSERT (o1.getID() != tab[key3].getID());
-          ASSERT (o2.getID() != tab[key3].getID());
+          CHECK (o1.getID() != tab[key2].getID());
+          CHECK (o1.getID() != tab[key3].getID());
+          CHECK (o2.getID() != tab[key3].getID());
         }
       
     };
diff --git a/tests/lib/item-wrapper-test.cpp b/tests/lib/item-wrapper-test.cpp
index 7eb343bf8..746d910bc 100644
--- a/tests/lib/item-wrapper-test.cpp
+++ b/tests/lib/item-wrapper-test.cpp
@@ -1,23 +1,23 @@
 /*
   ItemWrapper(Test)  -  wrapping and holding arbitrary values, pointers and references
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2 of the
   License, or (at your option) any later version.
- 
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
@@ -39,12 +39,12 @@
 namespace lib {
 namespace wrapper {
 namespace test{
-  
+
   using ::Test;
   using lib::test::randStr;
   using lib::test::showSizeof;
   using util::isSameObject;
-  
+
   using std::tr1::placeholders::_1;
   using std::tr1::ref;
   using std::vector;
@@ -52,59 +52,59 @@ namespace test{
   using std::rand;
   using std::cout;
   using std::endl;
-  
-  
-  
+
+
+
   namespace { // Test helper: yet another ctor/dtor counting class
-    
+
     long cntTracker = 0;
-    
+
     struct Tracker
       {
         uint i_;
-        
+
         Tracker()                  : i_(rand() % 500) { ++cntTracker; }
         Tracker(Tracker const& ot) : i_(ot.i_)        { ++cntTracker; }
        ~Tracker()                                     { --cntTracker; }
       };
-    
+
     bool operator== (Tracker const& t1, Tracker const& t2) { return t1.i_ == t2.i_; }
     bool operator!= (Tracker const& t1, Tracker const& t2) { return t1.i_ != t2.i_; }
-    
-    
+
+
     /// to be bound as test function....
     int&
     pickElement (vector<int>& vec, size_t idx)
     {
       return vec[idx];
     }
-    
+
     function<int&(size_t)>
     pickElement_ofVector (vector<int>& vec)
     {
       return std::tr1::bind (pickElement, ref(vec), _1 );
     }
-    
-    
+
+
   } // (END) Test helpers
-  
-  
-  
-  
-  
-  
-  
+
+
+
+
+
+
+
   /*******************************************************************************
    * @test use the ItemWrapper to define inline-storage holding values,
    *       pointers and references. Verify correct behaviour in each case,
    *       including (self)assignment, empty check, invalid dereferentiation.
-   *       
+   *
    * @see  wrapper.hpp
    */
   class ItemWrapper_test : public Test
     {
-      
-      
+
+
       virtual void
       run (Arg)
         {
@@ -113,92 +113,92 @@ namespace test{
           string s1 (randStr(50));
           string s2 (randStr(50));
           const char* cp (s1.c_str());
-          
+
           verifyWrapper<ulong> (l1, l2);
           verifyWrapper<ulong&> (l1, l2);
           verifyWrapper<ulong*> (&l1, &l2);
           verifyWrapper<ulong*> ((0), &l2);
           verifyWrapper<ulong*> (&l1, (0));
           verifyWrapper<ulong const&> (l1, l2);
-          
+
           verifyWrapper<string> (s1, s2);
           verifyWrapper<string&> (s1, s2);
           verifyWrapper<string*> (&s1, &s2);
-          
+
           verifyWrapper<const char*> (cp, "Lumiera");
-          
-          
+
+
           verifySaneInstanceHandling();
           verifyWrappedRef ();
-          
+
           verifyFunctionResult ();
           verifyFunctionRefResult ();
         }
-      
-      
+
+
       template<typename X>
       void
       verifyWrapper (X val, X otherVal)
         {
           const ItemWrapper<X> wrap(val);
-          ASSERT (wrap);
-          
+          CHECK (wrap);
+
           cout << "ItemWrapper: " << showSizeof(wrap) << endl;
-          
+
           ItemWrapper<X> copy1 (wrap);
           ItemWrapper<X> copy2;
           ItemWrapper<X> empty;
-          
-          ASSERT (copy1);
-          ASSERT (!copy2);
-          ASSERT (false == bool(empty));
-          
-          ASSERT (wrap == copy1);
-          ASSERT (wrap != copy2);
-          ASSERT (wrap != empty);
-          
+
+          CHECK (copy1);
+          CHECK (!copy2);
+          CHECK (false == bool(empty));
+
+          CHECK (wrap == copy1);
+          CHECK (wrap != copy2);
+          CHECK (wrap != empty);
+
           copy2 = copy1;
-          ASSERT (copy2);
-          ASSERT (wrap == copy2);
-          ASSERT (wrap != empty);
-          
+          CHECK (copy2);
+          CHECK (wrap == copy2);
+          CHECK (wrap != empty);
+
           copy2 = otherVal;
-          ASSERT (copy2);
-          ASSERT (wrap != copy2);
-          ASSERT (wrap != empty);
-          
-          ASSERT (val == *wrap);
-          ASSERT (val == *copy1);
-          ASSERT (val != *copy2);
+          CHECK (copy2);
+          CHECK (wrap != copy2);
+          CHECK (wrap != empty);
+
+          CHECK (val == *wrap);
+          CHECK (val == *copy1);
+          CHECK (val != *copy2);
           VERIFY_ERROR (BOTTOM_VALUE, *empty );
-          
-          ASSERT (otherVal == *copy2);
+
+          CHECK (otherVal == *copy2);
           copy1 = copy2;
-          ASSERT (otherVal == *copy1);
-          ASSERT (otherVal == *copy2);
-          ASSERT (wrap != copy1);
-          ASSERT (wrap != copy2);
-          
+          CHECK (otherVal == *copy1);
+          CHECK (otherVal == *copy2);
+          CHECK (wrap != copy1);
+          CHECK (wrap != copy2);
+
           copy1 = empty;                   // assign empty to discard value
           copy1 = copy1;                   // self-assign empty value
-          ASSERT (!copy1);
-          
+          CHECK (!copy1);
+
           copy1 = copy2;
-          ASSERT (otherVal == *copy1);
+          CHECK (otherVal == *copy1);
           copy1 = copy1;                   // self-assign (will be suppressed)
-          ASSERT (otherVal == *copy1);
+          CHECK (otherVal == *copy1);
           copy1 = *copy1;                  // self-assign also detected in this case
-          ASSERT (otherVal == *copy2);
-          
-          ASSERT (copy1);
+          CHECK (otherVal == *copy2);
+
+          CHECK (copy1);
           copy1.reset();
-          ASSERT (!copy1);
-          ASSERT (empty == copy1);
-          ASSERT (copy2 != copy1);
+          CHECK (!copy1);
+          CHECK (empty == copy1);
+          CHECK (copy2 != copy1);
           VERIFY_ERROR (BOTTOM_VALUE, *copy1 );
         };
-      
-      
+
+
       /** @test verify that ctor and dtor calls are balanced,
        *        even when assigning and self-assigning.
        */
@@ -209,16 +209,16 @@ namespace test{
           {
             Tracker t1;
             Tracker t2;
-            
+
             verifyWrapper<Tracker> (t1, t2);
             verifyWrapper<Tracker&> (t1, t2);
             verifyWrapper<Tracker*> (&t1, &t2);
-              
+
           }
-          ASSERT (0 == cntTracker);  
+          CHECK (0 == cntTracker);
         }
-      
-      
+
+
       /** @test verify especially that we can wrap and handle
        *        a reference "value" in a pointer-like manner
        */
@@ -227,24 +227,24 @@ namespace test{
         {
           int x = 5;
           ItemWrapper<int&> refWrap;
-          ASSERT (!refWrap);
-          
+          CHECK (!refWrap);
+
           refWrap = x;
-          ASSERT (refWrap);
-          ASSERT (5 == *refWrap);
-          ASSERT (x == *refWrap);
-          
+          CHECK (refWrap);
+          CHECK (5 == *refWrap);
+          CHECK (x == *refWrap);
+
           *refWrap += 5;
-          ASSERT (x == 10);
-          
+          CHECK (x == 10);
+
           ItemWrapper<int*> ptrWrap (& *refWrap);
-          ASSERT ( isSameObject (**ptrWrap,  x));
-          ASSERT (!isSameObject ( *ptrWrap, &x));
+          CHECK ( isSameObject (**ptrWrap,  x));
+          CHECK (!isSameObject ( *ptrWrap, &x));
           **ptrWrap += 13;
-          ASSERT (x == 23);
+          CHECK (x == 23);
         }
-      
-      
+
+
       /** @test verify an extension built on top of the ItemWrapper:
        *        a function which remembers the last result. As a simple test,
        *        we bind the \c rand() standard lib function and remember the
@@ -254,26 +254,26 @@ namespace test{
       verifyFunctionResult()
         {
           FunctionResult<int(void)> randomVal (std::rand);
-          
+
           // function was never invoked, thus the remembered result is NIL
-          ASSERT (!randomVal);
+          CHECK (!randomVal);
           VERIFY_ERROR (BOTTOM_VALUE, *randomVal );
-          
+
           int v1 = randomVal();
-          ASSERT (v1 == *randomVal);
-          ASSERT (v1 == *randomVal);
-          ASSERT (v1 == *randomVal);
-          ASSERT (randomVal);
-          
+          CHECK (v1 == *randomVal);
+          CHECK (v1 == *randomVal);
+          CHECK (v1 == *randomVal);
+          CHECK (randomVal);
+
           int v2;
           do v2 = randomVal();
           while (v1 == v2);
-          ASSERT (v2 == *randomVal);
-          ASSERT (v2 == *randomVal);
-          ASSERT (v1 != *randomVal);
+          CHECK (v2 == *randomVal);
+          CHECK (v2 == *randomVal);
+          CHECK (v1 != *randomVal);
         }
-      
-      
+
+
       /** @test verify an extension built on top of the ItemWrapper:
        *        a function which remembers the last result. Here we use
        *        a test function, which picks a member of an vector and
@@ -288,37 +288,37 @@ namespace test{
           vector<int> testVec;
           for (uint i=0; i<10; ++i)
             testVec.push_back(i);
-          
+
           FunctionResult<int&(size_t)> funRes (pickElement_ofVector(testVec));
-          
+
           // function was never invoked, thus the remembered result is NIL
-          ASSERT (!funRes);
+          CHECK (!funRes);
           VERIFY_ERROR (BOTTOM_VALUE, *funRes );
-          
+
           int& r5 = funRes (5);
-          ASSERT (funRes); // indicates existence of cached result
-          
-          ASSERT (5 == r5);
-          ASSERT (isSameObject (r5, testVec[5]));
-          
+          CHECK (funRes); // indicates existence of cached result
+
+          CHECK (5 == r5);
+          CHECK (isSameObject (r5, testVec[5]));
+
           int& r5x = *funRes;
-          ASSERT (isSameObject (r5, r5x));
-          
-          ASSERT ( isSameObject (r5, *funRes));
+          CHECK (isSameObject (r5, r5x));
+
+          CHECK ( isSameObject (r5, *funRes));
           int& r7 = funRes (7);
-          ASSERT (!isSameObject (r5, *funRes));
-          ASSERT ( isSameObject (r7, *funRes));
-          
+          CHECK (!isSameObject (r5, *funRes));
+          CHECK ( isSameObject (r7, *funRes));
+
           -- r5x;
           ++ *funRes;
-          ASSERT (5-1 == testVec[5]);
-          ASSERT (7+1 == testVec[7]);
-          ASSERT (7+1 == r7);
+          CHECK (5-1 == testVec[5]);
+          CHECK (7+1 == testVec[7]);
+          CHECK (7+1 == r7);
         }
     };
-  
+
   LAUNCHER (ItemWrapper_test, "unit common");
-  
-  
+
+
 }}} // namespace lib::wrapper::test
 
diff --git a/tests/lib/iter-adapter-test.cpp b/tests/lib/iter-adapter-test.cpp
index 123adb426..5ed333787 100644
--- a/tests/lib/iter-adapter-test.cpp
+++ b/tests/lib/iter-adapter-test.cpp
@@ -211,15 +211,15 @@ namespace test{
           typedef RangeIter<I> Range;
           
           Range range (iVec.begin(), iVec.end());
-          ASSERT (!isnil (range) || !NUM_ELMS);
+          CHECK (!isnil (range) || !NUM_ELMS);
           
           // now for example the client could....
           while ( range )
             cout << "::" << *range++;
           
           cout << endl;
-          ASSERT (isnil (range));
-          ASSERT (range == Range());
+          CHECK (isnil (range));
+          CHECK (range == Range());
         }
       
       
@@ -263,11 +263,11 @@ namespace test{
                iter; ++iter, ++i
               )
             {
-              ASSERT (iter);
-              ASSERT (iter != elms.end());
-              ASSERT (**iter == i);
+              CHECK (iter);
+              CHECK (iter != elms.end());
+              CHECK (**iter == i);
               --(**iter);
-              ASSERT (**iter == i-1);
+              CHECK (**iter == i-1);
             }
           
           i = 0;
@@ -275,9 +275,9 @@ namespace test{
                iter; ++iter, ++i
               )
             {
-              ASSERT (iter);
-              ASSERT (iter != elms.end());
-              ASSERT (**iter == i-1);
+              CHECK (iter);
+              CHECK (iter != elms.end());
+              CHECK (**iter == i-1);
               
               // note: the previous run indeed modified
               // the element within the container.
@@ -290,10 +290,10 @@ namespace test{
                iter; ++iter, ++i
               )
             {
-              ASSERT (iter);
-              ASSERT ((*iter) == i-1);
+              CHECK (iter);
+              CHECK ((*iter) == i-1);
               ++(*iter);
-              ASSERT ((*iter) == i);
+              CHECK ((*iter) == i);
             }
           
           i = 0;
@@ -301,8 +301,8 @@ namespace test{
                iter; ++iter, ++i
               )
             {
-              ASSERT (iter);
-              ASSERT ((*iter) == i);
+              CHECK (iter);
+              CHECK ((*iter) == i);
               
              // *iter = i+1;   ///////////TODO this should be const, but it isn't
             }
@@ -316,31 +316,31 @@ namespace test{
         {
           TestContainer::ref_iterator rI (elms.begin_ref());
           
-          ASSERT (0 == *rI );
-          ASSERT (0 == *rI++);
-          ASSERT (1 == *rI  );
-          ASSERT (2 == *++rI);
+          CHECK (0 == *rI );
+          CHECK (0 == *rI++);
+          CHECK (1 == *rI  );
+          CHECK (2 == *++rI);
           
           TestContainer const& const_elms (elms);
           TestContainer::const_ref_iter rI2 (const_elms.begin_ref());
           
-          ASSERT (rI2 != rI);
-          ASSERT (rI2 == elms.begin_ref());
-          ASSERT (rI2 == const_elms.begin_ref());
+          CHECK (rI2 != rI);
+          CHECK (rI2 == elms.begin_ref());
+          CHECK (rI2 == const_elms.begin_ref());
           
           ++++rI2;
           
-          ASSERT (rI2 == rI);
-          ASSERT (rI2 != ++rI);
-          ASSERT (!isnil (rI2));
+          CHECK (rI2 == rI);
+          CHECK (rI2 != ++rI);
+          CHECK (!isnil (rI2));
           
-          ASSERT (TestContainer::iterator() == elms.end());
-          ASSERT (!(TestContainer::iterator()));
-          ASSERT (!(elms.end()));
-          ASSERT (isnil (elms.end()));
+          CHECK (TestContainer::iterator() == elms.end());
+          CHECK (!(TestContainer::iterator()));
+          CHECK (!(elms.end()));
+          CHECK (isnil (elms.end()));
           
-          ASSERT (elms.begin());
-          ASSERT (!isnil (elms.begin()));
+          CHECK (elms.begin());
+          CHECK (!isnil (elms.begin()));
         }
       
       
diff --git a/tests/lib/iter-source-test.cpp b/tests/lib/iter-source-test.cpp
index 0021d80f3..8257852a8 100644
--- a/tests/lib/iter-source-test.cpp
+++ b/tests/lib/iter-source-test.cpp
@@ -189,17 +189,17 @@ namespace test{
           IntIter isi (eachEntry (rawList.begin(), rawList.end()));
           StrIter cii (IterSource<CStr>::build(dedicatedSource));
           
-          ASSERT (!isnil (iii));
-          ASSERT (!isnil (isi));
-          ASSERT (!isnil (cii));
+          CHECK (!isnil (iii));
+          CHECK (!isnil (isi));
+          CHECK (!isnil (cii));
           
           pullOut (iii);
           pullOut (isi);
           pullOut (cii);
           
-          ASSERT (!iii);
-          ASSERT (!isi);
-          ASSERT (!cii);
+          CHECK (!iii);
+          CHECK (!isi);
+          CHECK (!cii);
         }
       
       
@@ -225,11 +225,11 @@ namespace test{
           StringIter sIter = eachMapKey (testMap);
           TimeIter   tIter = eachMapVal (testMap);
           
-          ASSERT (sIter && tIter);
+          CHECK (sIter && tIter);
           pullOut (sIter);
           pullOut (tIter);
           
-          ASSERT (!sIter && !tIter);
+          CHECK (!sIter && !tIter);
           
           
           // The each-value-for-given-key-Iterator can be used for a map or multimap.
@@ -239,16 +239,16 @@ namespace test{
           TimeIter correspondingVal = eachMapVal (testMap);
           ++justSomeKey;
           ++correspondingVal;
-          ASSERT (justSomeKey);
+          CHECK (justSomeKey);
           
           TimeIter value4key = eachValForKey (testMap, "nonexistent key");
-          ASSERT (!value4key);
+          CHECK (!value4key);
           
           value4key = eachValForKey (testMap, *justSomeKey);
-          ASSERT (value4key);
-          ASSERT (*value4key == *correspondingVal);
+          CHECK (value4key);
+          CHECK (*value4key == *correspondingVal);
           ++value4key;
-          ASSERT (!value4key);
+          CHECK (!value4key);
         }
       
       
@@ -263,23 +263,23 @@ namespace test{
               do testMap.insert (make_pair (i,n));
               while (--n);
             }
-          ASSERT (NUM_ELMS < testMap.size(), "no repetition in test data??");
+          CHECK (NUM_ELMS < testMap.size(), "no repetition in test data??");
           
           IntIter keys = eachDistinctKey (testMap);
           
           cout << "distinct_keys";
-          ASSERT (keys);
+          CHECK (keys);
           pullOut (keys);
-          ASSERT (!keys);
+          CHECK (!keys);
           
           cout << "values_4_key";
           IntIter vals = eachValForKey (testMap, NUM_ELMS); // non-existent key
-          ASSERT (!vals);
+          CHECK (!vals);
           
           vals = eachValForKey (testMap, 0);
-          ASSERT (vals);
+          CHECK (vals);
           pullOut (vals); // should produce anything between 1 and 100 entries
-          ASSERT (!vals);
+          CHECK (!vals);
           
         }
     };
diff --git a/tests/lib/itertools-test.cpp b/tests/lib/itertools-test.cpp
index 22aea64e1..945a33de7 100644
--- a/tests/lib/itertools-test.cpp
+++ b/tests/lib/itertools-test.cpp
@@ -1,23 +1,23 @@
 /*
   IterTools(Test)  -  building combined and filtering iterators based on the Iterator tools
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2 of the
   License, or (at your option) any later version.
- 
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
@@ -37,7 +37,7 @@
 
 namespace lib {
 namespace test{
-  
+
   using ::Test;
   using boost::lexical_cast;
   using util::for_each;
@@ -46,74 +46,74 @@ namespace test{
   using std::cout;
   using std::endl;
   using std::rand;
-  
-  
-  
+
+
+
   namespace { // Test data
-  
+
     uint NUM_ELMS = 10;
-    
+
     struct TestSource
       {
         vector<int> data_;
-        
+
         TestSource(uint num)
           {
             while (num)
               data_.push_back(num--);
           }
-        
+
         typedef vector<int>::iterator sourceIter;
         typedef RangeIter<sourceIter> iterator;
-        
+
         iterator begin() { return iterator(data_.begin(),data_.end()); }
         iterator end()   { return iterator();                          }
-        
+
       };
-    
+
   } // (END) Test data
-  
-  
-  
-  
-  
-  
-  
+
+
+
+
+
+
+
   /*******************************************************************************
    *  @test build combined and filtering iterators with the help of lib::IterTool.
-   *        Check correct behaviour of the resulting iterators and 
+   *        Check correct behaviour of the resulting iterators and
    *        verify they fulfil the Lumiera Forward Iterator concept
-   *        
+   *
    * @todo implement more iterator tools.... see Ticket #347
    */
   class IterTools_test : public Test
     {
-      
+
       typedef TestSource::iterator Iter;
-      
-      
+
+
       virtual void
       run (Arg arg)
         {
           if (0 < arg.size()) NUM_ELMS = lexical_cast<uint> (arg[0]);
-          
+
           TestSource source(NUM_ELMS);
-          
+
           pullOut (source.begin());
           verifyComparisons (source.begin());
-          
-          
+
+
           buildFilterIterator (source.begin());
           Iter ii (source.begin());
           ++++++ii;
           buildFilterIterator (ii);
           verify_filterRepetitions();
-          
+
           buildTransformingIterator (source.begin());
         }
-      
-      
-      
+
+
+
       template<class IT>
       void
       pullOut (IT const& ii)
@@ -122,34 +122,34 @@ namespace test{
             cout << "::" << *iter;
           cout << endl;
         }
-      
-      
-      
+
+
+
       static bool takeAll (int)   { return true; }
       static bool takeOdd (int i) { return 0 != i % 2; }
       static bool takeEve (int i) { return 0 == i % 2; }
-      
+
       void
       buildFilterIterator (Iter const& ii)
         {
-          pullOut (filterIterator (ii, takeAll));  // note: using the convenient builder function 
+          pullOut (filterIterator (ii, takeAll));  // note: using the convenient builder function
           pullOut (filterIterator (ii, takeEve));
           pullOut (filterIterator (ii, takeOdd));
-          
+
           FilterIter<Iter> all (ii, takeAll);
           FilterIter<Iter> odd (ii, takeOdd);
           verifyComparisons (all);
           verifyComparisons (odd);
-          
+
           while (++all && ++odd)
-            ASSERT (all != odd);
-          
+            CHECK (all != odd);
+
           while (++all) { }
-          ASSERT (isnil (odd));
-          ASSERT (all == odd);
+          CHECK (isnil (odd));
+          CHECK (all == odd);
         }
-      
-      
+
+
       /** @test verify the helper to filter duplicate elements
        *        emitted by an source iterator. This test creates
        *        a sequence of numbers with random repetitions.
@@ -164,57 +164,57 @@ namespace test{
               do numberz.push_back(i);
               while (--n);
             }
-          ASSERT (NUM_ELMS < numberz.size(), "no repetition in test data??");
-          
+          CHECK (NUM_ELMS < numberz.size(), "no repetition in test data??");
+
           typedef vector<uint>::iterator SrcIter;
           typedef RangeIter<SrcIter> SeqIter;
           typedef FilterIter<SeqIter> FilteredSeq;
-          
+
           SeqIter completeSequence (numberz.begin(), numberz.end());
           FilteredSeq filtered = filterRepetitions (completeSequence);
-          
+
           uint num=0;
           for (; num<NUM_ELMS && !isnil(filtered);
                ++num,
                ++filtered
               )
-            ASSERT (num == *filtered);
-          
-          ASSERT (num == NUM_ELMS && isnil(filtered));
+            CHECK (num == *filtered);
+
+          CHECK (num == NUM_ELMS && isnil(filtered));
         }
-      
-      
-      
+
+
+
       static ulong addTwo (int i) { return i+2; }
       static int   negate (int i) { return -i; }
       static int   idFunc (int i) { return i; }
-      
+
       void
       buildTransformingIterator (Iter const& ii)
         {
           pullOut (transformIterator(ii, idFunc));
           pullOut (transformIterator(ii, negate));
           pullOut (transformIterator(ii, addTwo));  // note: changing output type to unsigned
-          
+
           TransformIter<Iter, int> idi (ii, idFunc);
           TransformIter<Iter, int> neg (ii, negate);
           verifyComparisons (idi);
           verifyComparisons (neg);
-          
-          ASSERT (idi);
-          ASSERT (neg);
+
+          CHECK (idi);
+          CHECK (neg);
           for ( ;idi&&neg;
               ++idi,++neg)
-            ASSERT (idi != neg);
-          
-          ASSERT (!idi && !neg);
-          ASSERT (idi == neg);
+            CHECK (idi != neg);
+
+          CHECK (!idi && !neg);
+          CHECK (idi == neg);
         }
-      
-      
-      
-      
-      
+
+
+
+
+
       /** @test verify equality handling and NIL detection
        *        for the given iterator/wrapper handed in */
       template<class IT>
@@ -224,39 +224,39 @@ namespace test{
           IT i1(ii);
           IT i2(ii);
           IT iN;
-          ASSERT ( isnil (iN));
-          ASSERT (!isnil (i1));
-          ASSERT (!isnil (i2));
-          
-          ASSERT (i1 == i2); ASSERT (i2 == i1);
-          ASSERT (i1 != iN); ASSERT (iN != i1); 
-          ASSERT (i2 != iN); ASSERT (iN != i2);
-          
+          CHECK ( isnil (iN));
+          CHECK (!isnil (i1));
+          CHECK (!isnil (i2));
+
+          CHECK (i1 == i2); CHECK (i2 == i1);
+          CHECK (i1 != iN); CHECK (iN != i1);
+          CHECK (i2 != iN); CHECK (iN != i2);
+
           ++i1;
-          ASSERT (i1 != i2);
-          ASSERT (i1 != iN);
-          
+          CHECK (i1 != i2);
+          CHECK (i1 != iN);
+
           ++i2;
-          ASSERT (i1 == i2);
-          ASSERT (i1 != iN); 
-          ASSERT (i2 != iN);
-          
+          CHECK (i1 == i2);
+          CHECK (i1 != iN);
+          CHECK (i2 != iN);
+
           while (++i1) { }
-          ASSERT (isnil(i1));
-          ASSERT (i1 != i2);
-          ASSERT (i1 == iN);
-          
+          CHECK (isnil(i1));
+          CHECK (i1 != i2);
+          CHECK (i1 == iN);
+
           while (++i2) { }
-          ASSERT (isnil(i2));
-          ASSERT (i2 == i1);
-          ASSERT (i2 == iN);
+          CHECK (isnil(i2));
+          CHECK (i2 == i1);
+          CHECK (i2 == iN);
         }
-      
-      
+
+
     };
-  
+
   LAUNCHER (IterTools_test, "unit common");
-  
-  
+
+
 }} // namespace lib::test
 
diff --git a/tests/lib/lifecycletest.cpp b/tests/lib/lifecycletest.cpp
index 00b43fd36..432ba79ef 100644
--- a/tests/lib/lifecycletest.cpp
+++ b/tests/lib/lifecycletest.cpp
@@ -58,12 +58,12 @@ namespace test   {
       virtual void 
       run (Arg)
         {
-          ASSERT (basicInit, "the basic-init callback hasn't been invoked automatically");
-          ASSERT (1 == basicInit, "the basic-init callback has been invoked more than once");
+          CHECK (basicInit, "the basic-init callback hasn't been invoked automatically");
+          CHECK (1 == basicInit, "the basic-init callback has been invoked more than once");
           
-          ASSERT (!customCallback);
+          CHECK (!customCallback);
           LifecycleHook::trigger  (MY_DEADLY_EVENT);
-          ASSERT ( 1 == customCallback);
+          CHECK ( 1 == customCallback);
         }
       
     };
diff --git a/tests/lib/meta/config-flags-test.cpp b/tests/lib/meta/config-flags-test.cpp
index a0ace5922..5159a21cf 100644
--- a/tests/lib/meta/config-flags-test.cpp
+++ b/tests/lib/meta/config-flags-test.cpp
@@ -167,8 +167,8 @@ namespace test {
               // should denote the same type
               Flags1::Flags flags1 = Flags2::Tuple();
               Flags2::Tuple flags2 = flags1;
-              ASSERT (1==sizeof(flags1));   // pure marker-type without content
-              ASSERT (1==sizeof(flags2));
+              CHECK (1==sizeof(flags1));   // pure marker-type without content
+              CHECK (1==sizeof(flags2));
               
               typedef DefineConfigByFlags<Node<Flag<ONE>,NullType> >::Config SimpleConfig_defined_by_Typelist;
               DISPLAY (SimpleConfig_defined_by_Typelist);
diff --git a/tests/lib/meta/function-closure-test.cpp b/tests/lib/meta/function-closure-test.cpp
index faa998fae..3f9714b7c 100644
--- a/tests/lib/meta/function-closure-test.cpp
+++ b/tests/lib/meta/function-closure-test.cpp
@@ -133,8 +133,8 @@ namespace test    {
           DISPLAY (List1);
           DISPLAY (List2);
           ;
-          ASSERT (6 == (getNumberz<1,2,3> (Num<1>(), Num<2>(), Num<3>())));
-          ASSERT (6 == (getNumberz<1,1,1> (Num<1>(), Num<1>(2), Num<1>(3))));
+          CHECK (6 == (getNumberz<1,2,3> (Num<1>(), Num<2>(), Num<3>())));
+          CHECK (6 == (getNumberz<1,1,1> (Num<1>(), Num<1>(2), Num<1>(3))));
         }
       
       
@@ -153,7 +153,7 @@ namespace test    {
           
           NewSig& fun =  getNumberz<1,5,9>;                    //...which is compatible to an existing real function signature!
           
-          ASSERT (1+5+9 == fun(Num<1>(), Num<5>(), Num<9>()));
+          CHECK (1+5+9 == fun(Num<1>(), Num<5>(), Num<9>()));
         }
       
       
@@ -171,20 +171,20 @@ namespace test    {
           DUMPVAL (tup2);
           DUMPVAL (tup3);
           
-          ASSERT (-1       == Apply<0>::invoke<int> (fun0, tup0) );
-          ASSERT (11       == Apply<1>::invoke<int> (fun1, tup1) );
-          ASSERT (11+12    == Apply<2>::invoke<int> (fun2, tup2) );
-          ASSERT (11+12+13 == Apply<3>::invoke<int> (fun3, tup3) );
+          CHECK (-1       == Apply<0>::invoke<int> (fun0, tup0) );
+          CHECK (11       == Apply<1>::invoke<int> (fun1, tup1) );
+          CHECK (11+12    == Apply<2>::invoke<int> (fun2, tup2) );
+          CHECK (11+12+13 == Apply<3>::invoke<int> (fun3, tup3) );
           
-          ASSERT (-1       == TupleApplicator<int()>            (tup0) (fun0) );
-          ASSERT (11       == TupleApplicator<int(int)>         (tup1) (fun1) );
-          ASSERT (11+12    == TupleApplicator<int(int,int)>     (tup2) (fun2) );
-          ASSERT (11+12+13 == TupleApplicator<int(int,int,int)> (tup3) (fun3) );
+          CHECK (-1       == TupleApplicator<int()>            (tup0) (fun0) );
+          CHECK (11       == TupleApplicator<int(int)>         (tup1) (fun1) );
+          CHECK (11+12    == TupleApplicator<int(int,int)>     (tup2) (fun2) );
+          CHECK (11+12+13 == TupleApplicator<int(int,int,int)> (tup3) (fun3) );
           
-          ASSERT (-1       == apply(fun0, tup0) );
-          ASSERT (11       == apply(fun1, tup1) );
-          ASSERT (11+12    == apply(fun2, tup2) );
-          ASSERT (11+12+13 == apply(fun3, tup3) );
+          CHECK (-1       == apply(fun0, tup0) );
+          CHECK (11       == apply(fun1, tup1) );
+          CHECK (11+12    == apply(fun2, tup2) );
+          CHECK (11+12+13 == apply(fun3, tup3) );
         
         }
       
@@ -201,20 +201,20 @@ namespace test    {
           function<int(int,int)>     functor2 (fun2);
           function<int(int,int,int)> functor3 (fun3);
           
-          ASSERT (-1       == Apply<0>::invoke<int> (functor0, tup0) );
-          ASSERT (11       == Apply<1>::invoke<int> (functor1, tup1) );
-          ASSERT (11+12    == Apply<2>::invoke<int> (functor2, tup2) );
-          ASSERT (11+12+13 == Apply<3>::invoke<int> (functor3, tup3) );
+          CHECK (-1       == Apply<0>::invoke<int> (functor0, tup0) );
+          CHECK (11       == Apply<1>::invoke<int> (functor1, tup1) );
+          CHECK (11+12    == Apply<2>::invoke<int> (functor2, tup2) );
+          CHECK (11+12+13 == Apply<3>::invoke<int> (functor3, tup3) );
           
-          ASSERT (-1       == TupleApplicator<int()>            (tup0) (functor0) );
-          ASSERT (11       == TupleApplicator<int(int)>         (tup1) (functor1) );
-          ASSERT (11+12    == TupleApplicator<int(int,int)>     (tup2) (functor2) );
-          ASSERT (11+12+13 == TupleApplicator<int(int,int,int)> (tup3) (functor3) );
+          CHECK (-1       == TupleApplicator<int()>            (tup0) (functor0) );
+          CHECK (11       == TupleApplicator<int(int)>         (tup1) (functor1) );
+          CHECK (11+12    == TupleApplicator<int(int,int)>     (tup2) (functor2) );
+          CHECK (11+12+13 == TupleApplicator<int(int,int,int)> (tup3) (functor3) );
           
-          ASSERT (-1       == apply(functor0, tup0) );
-          ASSERT (11       == apply(functor1, tup1) );
-          ASSERT (11+12    == apply(functor2, tup2) );
-          ASSERT (11+12+13 == apply(functor3, tup3) );
+          CHECK (-1       == apply(functor0, tup0) );
+          CHECK (11       == apply(functor1, tup1) );
+          CHECK (11+12    == apply(functor2, tup2) );
+          CHECK (11+12+13 == apply(functor3, tup3) );
           
         }
       
@@ -236,20 +236,20 @@ namespace test    {
           BoundFun functor2 = Apply<2>::bind<BoundFun> (fun2, tup3);
           BoundFun functor3 = Apply<3>::bind<BoundFun> (fun3, tup3);
           
-          ASSERT (-1       == functor0() );
-          ASSERT (11       == functor1() );
-          ASSERT (11+12    == functor2() );
-          ASSERT (11+12+13 == functor3() );
+          CHECK (-1       == functor0() );
+          CHECK (11       == functor1() );
+          CHECK (11+12    == functor2() );
+          CHECK (11+12+13 == functor3() );
           
           functor0 = TupleApplicator<int()>            (tup0).bind (fun0);
           functor1 = TupleApplicator<int(int)>         (tup1).bind (fun1);
           functor2 = TupleApplicator<int(int,int)>     (tup2).bind (fun2);
           functor3 = TupleApplicator<int(int,int,int)> (tup3).bind (fun3);
           
-          ASSERT (-1       == functor0() );
-          ASSERT (11       == functor1() );
-          ASSERT (11+12    == functor2() );
-          ASSERT (11+12+13 == functor3() );
+          CHECK (-1       == functor0() );
+          CHECK (11       == functor1() );
+          CHECK (11+12    == functor2() );
+          CHECK (11+12+13 == functor3() );
           
         }
       
@@ -273,20 +273,20 @@ namespace test    {
           BoundFun functor2 = Apply<2>::bind<BoundFun> (unbound_functor2, tup3);
           BoundFun functor3 = Apply<3>::bind<BoundFun> (unbound_functor3, tup3);
           
-          ASSERT (-1       == functor0() );
-          ASSERT (11       == functor1() );
-          ASSERT (11+12    == functor2() );
-          ASSERT (11+12+13 == functor3() );
+          CHECK (-1       == functor0() );
+          CHECK (11       == functor1() );
+          CHECK (11+12    == functor2() );
+          CHECK (11+12+13 == functor3() );
           
           functor0 = TupleApplicator<int()>            (tup0).bind (unbound_functor0);
           functor1 = TupleApplicator<int(int)>         (tup1).bind (unbound_functor1);
           functor2 = TupleApplicator<int(int,int)>     (tup2).bind (unbound_functor2);
           functor3 = TupleApplicator<int(int,int,int)> (tup3).bind (unbound_functor3);
           
-          ASSERT (-1       == functor0() );
-          ASSERT (11       == functor1() );
-          ASSERT (11+12    == functor2() );
-          ASSERT (11+12+13 == functor3() );
+          CHECK (-1       == functor0() );
+          CHECK (11       == functor1() );
+          CHECK (11+12    == functor2() );
+          CHECK (11+12+13 == functor3() );
           
         }
       
@@ -304,10 +304,10 @@ namespace test    {
           FunctionClosure<int(int,int)>     clo2 (fun2,tup2);
           FunctionClosure<int(int,int,int)> clo3 (fun3,tup3);
           
-          ASSERT (-1       == clo0() );
-          ASSERT (11       == clo1() );
-          ASSERT (11+12    == clo2() );
-          ASSERT (11+12+13 == clo3() );
+          CHECK (-1       == clo0() );
+          CHECK (11       == clo1() );
+          CHECK (11+12    == clo2() );
+          CHECK (11+12+13 == clo3() );
           
           function<int()>            unbound_functor0 (fun0);
           function<int(int)>         unbound_functor1 (fun1);
@@ -319,20 +319,20 @@ namespace test    {
           clo2 = FunctionClosure<int(int,int)>     (unbound_functor2,tup2);
           clo3 = FunctionClosure<int(int,int,int)> (unbound_functor3,tup3);
           
-          ASSERT (-1       == clo0() );
-          ASSERT (11       == clo1() );
-          ASSERT (11+12    == clo2() );
-          ASSERT (11+12+13 == clo3() );
+          CHECK (-1       == clo0() );
+          CHECK (11       == clo1() );
+          CHECK (11+12    == clo2() );
+          CHECK (11+12+13 == clo3() );
           
-          ASSERT (-1       == closure(fun0,tup0) () );
-          ASSERT (11       == closure(fun1,tup1) () );
-          ASSERT (11+12    == closure(fun2,tup2) () );
-          ASSERT (11+12+13 == closure(fun3,tup3) () );
+          CHECK (-1       == closure(fun0,tup0) () );
+          CHECK (11       == closure(fun1,tup1) () );
+          CHECK (11+12    == closure(fun2,tup2) () );
+          CHECK (11+12+13 == closure(fun3,tup3) () );
           
-          ASSERT (-1       == closure(unbound_functor0,tup0) () );
-          ASSERT (11       == closure(unbound_functor1,tup1) () );
-          ASSERT (11+12    == closure(unbound_functor2,tup2) () );
-          ASSERT (11+12+13 == closure(unbound_functor3,tup3) () );
+          CHECK (-1       == closure(unbound_functor0,tup0) () );
+          CHECK (11       == closure(unbound_functor1,tup1) () );
+          CHECK (11+12    == closure(unbound_functor2,tup2) () );
+          CHECK (11+12+13 == closure(unbound_functor3,tup3) () );
           
           
           // finally combine all techniques....
@@ -342,7 +342,7 @@ namespace test    {
           
           FunctionClosure<NumberzSig> numClo (getNumberz<5,6,7>, numberzTup );
           
-          ASSERT (22+33+44 == numClo() );
+          CHECK (22+33+44 == numClo() );
         }
     };
   
diff --git a/tests/lib/meta/function-composition-test.cpp b/tests/lib/meta/function-composition-test.cpp
index e6cec1f41..050c43053 100644
--- a/tests/lib/meta/function-composition-test.cpp
+++ b/tests/lib/meta/function-composition-test.cpp
@@ -1,23 +1,23 @@
 /*
   FunctionComposition(Test)  -  functional composition and partial application
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2 of the
   License, or (at your option) any later version.
- 
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
@@ -32,38 +32,38 @@
 namespace lumiera {
 namespace typelist{
 namespace test    {
-  
+
   using ::test::Test;
   using func::applyFirst;
   using func::applyLast;
   using func::bindLast;
   using func::PApply;
   using func::BindToArgument;
-  
-  
+
+
       namespace { // test functions
-        
-        Num<1> _1_;                     
-        Num<2> _2_;                     
-        Num<3> _3_;                     
-        Num<4> _4_;                     
-        Num<5> _5_;                     
-        Num<6> _6_;                     
-        Num<7> _7_;                     
-        Num<8> _8_;                     
-        Num<9> _9_;                     
-        
+
+        Num<1> _1_;
+        Num<2> _2_;
+        Num<3> _3_;
+        Num<4> _4_;
+        Num<5> _5_;
+        Num<6> _6_;
+        Num<7> _7_;
+        Num<8> _8_;
+        Num<9> _9_;
+
         /** "Function-1" will be used at the front side, accepting a tuple of values */
         template<uint i>
-        Num<i> 
+        Num<i>
         fun11 ( Num<i>   val1
               )
           {
             return val1;
           }
-        
+
         template<uint i, uint ii>
-        Num<i> 
+        Num<i>
         fun12 ( Num<i>   val1
               , Num<ii>  val2
               )
@@ -71,9 +71,9 @@ namespace test    {
             val1.o_ += val2.o_;
             return val1;
           }
-        
+
         template<uint i, uint ii, uint iii>
-        Num<i> 
+        Num<i>
         fun13 ( Num<i>   val1
               , Num<ii>  val2
               , Num<iii> val3
@@ -82,9 +82,9 @@ namespace test    {
             val1.o_ += val2.o_ + val3.o_;
             return val1;
           }
-        
+
         template<uint i, uint ii, uint iii, uint iv>
-        Num<i> 
+        Num<i>
         fun14 ( Num<i>   val1
               , Num<ii>  val2
               , Num<iii> val3
@@ -94,9 +94,9 @@ namespace test    {
             val1.o_ += val2.o_ + val3.o_ + val4.o_;
             return val1;
           }
-        
+
         template<uint i, uint ii, uint iii, uint iv, uint v>
-        Num<i> 
+        Num<i>
         fun15 ( Num<i>   val1
               , Num<ii>  val2
               , Num<iii> val3
@@ -107,8 +107,8 @@ namespace test    {
             val1.o_ += val2.o_ + val3.o_ + val4.o_ + val5.o_;
             return val1;
           }
-        
-        
+
+
         /** "Function-2" can be chained behind fun1 */
         template<class II>
         int
@@ -116,14 +116,14 @@ namespace test    {
           {
             return val.o_;
           }
-        
+
       } // (End) test data
-  
-  
-  
-  
-  
-  
+
+
+
+
+
+
   /******************************************************************************
    * @test this test covers some extensions and variations on function closures:
    *       - partial application of a function, returning a partial closure
@@ -133,15 +133,15 @@ namespace test    {
   class FunctionComposition_test : public Test
     {
       virtual void
-      run (Arg) 
+      run (Arg)
         {
           check_diagnostics ();
           check_partialApplication ();
           check_functionalComposition ();
           check_bindToArbitraryParameter ();
         }
-      
-      
+
+
       /** verify the test input data
        *  @see TypeListManipl_test#check_diagnostics()
        *       for an explanation of the DISPLAY macro
@@ -149,152 +149,152 @@ namespace test    {
       void
       check_diagnostics ()
         {
-          ASSERT (6 == (fun13<1,2,3> (_1_, _2_, _3_)).o_ );
-          ASSERT (6 == (fun13<1,1,1> (Num<1>(3), Num<1>(2), Num<1>(1))).o_ );
-          
-          ASSERT ( 1 == fun2 (fun11<1> (_1_)) );
-          ASSERT ( 3 == fun2 (fun12<1,2> (_1_, _2_)) );
-          ASSERT ( 6 == fun2 (fun13<1,2,3> (_1_, _2_, _3_)) );
-          ASSERT (10 == fun2 (fun14<1,2,3,4> (_1_, _2_, _3_, _4_)) );
-          ASSERT (15 == fun2 (fun15<1,2,3,4,5> (_1_, _2_, _3_, _4_, _5_)) );
-          
-          ASSERT ( 9 == fun2 (fun13<2,3,4> (_2_, _3_, _4_)) );
-          ASSERT (18 == fun2 (fun13<5,6,7> (_5_, _6_, _7_)) );
-          ASSERT (24 == fun2 (fun13<9,8,7> (_9_, _8_, _7_)) );
+          CHECK (6 == (fun13<1,2,3> (_1_, _2_, _3_)).o_ );
+          CHECK (6 == (fun13<1,1,1> (Num<1>(3), Num<1>(2), Num<1>(1))).o_ );
+
+          CHECK ( 1 == fun2 (fun11<1> (_1_)) );
+          CHECK ( 3 == fun2 (fun12<1,2> (_1_, _2_)) );
+          CHECK ( 6 == fun2 (fun13<1,2,3> (_1_, _2_, _3_)) );
+          CHECK (10 == fun2 (fun14<1,2,3,4> (_1_, _2_, _3_, _4_)) );
+          CHECK (15 == fun2 (fun15<1,2,3,4,5> (_1_, _2_, _3_, _4_, _5_)) );
+
+          CHECK ( 9 == fun2 (fun13<2,3,4> (_2_, _3_, _4_)) );
+          CHECK (18 == fun2 (fun13<5,6,7> (_5_, _6_, _7_)) );
+          CHECK (24 == fun2 (fun13<9,8,7> (_9_, _8_, _7_)) );
         }
-      
-      
+
+
       void
       check_partialApplication ()
         {
           // Because the code of the partial function application is very technical,
           // the following might serve as explanation what actually happens....
           // (and actually it's a leftover from initial debugging)
-          
+
           typedef Num<1> Sig123(Num<1>, Num<2>, Num<3>);             // signature of the original function
-          
+
           typedef Num<1> Sig23(Num<2>, Num<3>);                      // signature after having closed over the first argument
           typedef function<Sig23> F23;                               // and a tr1::function object to hold such a function
-          
+
           Sig123& f =fun13<1,2,3>;                                   // the actual input: a reference to the bare function
-          
-          
+
+
           // Version1: do a direct argument binding----------------- //
-          
+
           typedef std::tr1::_Placeholder<1> PH1;                     // tr1::function argument placeholders
           typedef std::tr1::_Placeholder<2> PH2;
-          
+
           PH1 ph1;                                                   // these empty structs are used to mark the arguments to be kept "open"
           PH2 ph2;
           Num<1> num18 (18);                                         // ...and this value is for closing the first function argument
-          
+
           F23 fun_23 = std::tr1::bind (f, num18                      // do the actual binding (i.e. close the first argument with a constant value)
                                         , ph1
                                         , ph2
                                       );
-          
+
           int res = 0;
           res = fun_23 (_2_,_3_).o_;                                 // and invoke the resulting functor ("closure"), providing the remaining arguments
-          ASSERT (23 == res);
-          
-          
-          
+          CHECK (23 == res);
+
+
+
           // Version2: extract the binding arguments from a tuple--- //
-          
+
           typedef Tuple<Types<Num<1>, PH1, PH2> > PartialArg;        // Tuple type to hold the binding values. Note the placeholder types
           PartialArg arg(num18);                                     // Value for partial application (the placeholders are default constructed)
-          
+
           fun_23 = std::tr1::bind (f, tuple::element<0>(arg)         // now extract the values to bind from this tuple
                                     , tuple::element<1>(arg)
                                     , tuple::element<2>(arg)
                                   );
           res = 0;
           res = fun_23 (_2_,_3_).o_;                                 // and invoke the resulting functor....
-          ASSERT (23 == res);
-          
-          
-          
-          
+          CHECK (23 == res);
+
+
+
+
           // Version3: let the PApply-template do the work for us--- //
-          
+
           typedef Types<Num<1> > ArgTypes;                           // now package just the argument(s) to be applied into a tuple
           Tuple<ArgTypes> args_to_bind (Num<1>(18));
-          
+
           fun_23 = PApply<Sig123, ArgTypes>::bindFront (f , args_to_bind);
                                                                      // "bindFront" will close the parameters starting from left....
           res = 0;
           res = fun_23 (_2_,_3_).o_;                                 // invoke the resulting functor...
-          ASSERT (23 == res);
-          
-          
-          
-          
-          
-          
+          CHECK (23 == res);
+
+
+
+
+
+
           // Version4: as you'd typically do it in real life-------- //
-          
+
           fun_23 = func::applyFirst (f, Num<1>(18));                 // use the convenience function API to close over a single value
-          
+
           res = 0;
           res = fun_23 (_2_,_3_).o_;                                 // invoke the resulting functor...
-          ASSERT (23 == res);
-          
-          
-          
+          CHECK (23 == res);
+
+
+
           // what follows is the real unit test...
           function<Sig123> func123 (f);                              // alternatively do it with an tr1::function object
           fun_23 = func::applyFirst (func123, Num<1>(19));
           res = fun_23 (_2_,_3_).o_;
-          ASSERT (24 == res);
-          
+          CHECK (24 == res);
+
           typedef function<Num<1>(Num<1>, Num<2>)> F12;
           F12 fun_12 = func::applyLast(f, Num<3>(20));               // close the *last* argument of a function
           res = fun_12 (_1_,_2_).o_;
-          ASSERT (23 == res);
-          
+          CHECK (23 == res);
+
           fun_12 = func::applyLast(func123, Num<3>(21));             // alternatively use a function object
           res = fun_12 (_1_,_2_).o_;
-          ASSERT (24 == res);
-          
-          Sig123 *fP = &f;                                           // a function pointer works too 
+          CHECK (24 == res);
+
+          Sig123 *fP = &f;                                           // a function pointer works too
           fun_12 = func::applyLast( fP, Num<3>(22));
           res = fun_12 (_1_,_2_).o_;
-          ASSERT (25 == res);
+          CHECK (25 == res);
                                                                      // cover more cases....
-          
-          ASSERT (1         == (func::applyLast (fun11<1>        , _1_) ( )              ).o_);
-          ASSERT (1+3       == (func::applyLast (fun12<1,3>      , _3_) (_1_)            ).o_);
-          ASSERT (1+3+5     == (func::applyLast (fun13<1,3,5>    , _5_) (_1_,_3_)        ).o_);
-          ASSERT (1+3+5+7   == (func::applyLast (fun14<1,3,5,7>  , _7_) (_1_,_3_,_5_)    ).o_);
-          ASSERT (1+3+5+7+9 == (func::applyLast (fun15<1,3,5,7,9>, _9_) (_1_,_3_,_5_,_7_)).o_);
-          
-          ASSERT (9+8+7+6+5 == (func::applyFirst(fun15<9,8,7,6,5>, _9_) (_8_,_7_,_6_,_5_)).o_);
-          ASSERT (  8+7+6+5 == (func::applyFirst(  fun14<8,7,6,5>, _8_)     (_7_,_6_,_5_)).o_);
-          ASSERT (    7+6+5 == (func::applyFirst(    fun13<7,6,5>, _7_)         (_6_,_5_)).o_);
-          ASSERT (      6+5 == (func::applyFirst(      fun12<6,5>, _6_)             (_5_)).o_);
-          ASSERT (        5 == (func::applyFirst(        fun11<5>, _5_)               ( )).o_);
-          
-          
-          
+
+          CHECK (1         == (func::applyLast (fun11<1>        , _1_) ( )              ).o_);
+          CHECK (1+3       == (func::applyLast (fun12<1,3>      , _3_) (_1_)            ).o_);
+          CHECK (1+3+5     == (func::applyLast (fun13<1,3,5>    , _5_) (_1_,_3_)        ).o_);
+          CHECK (1+3+5+7   == (func::applyLast (fun14<1,3,5,7>  , _7_) (_1_,_3_,_5_)    ).o_);
+          CHECK (1+3+5+7+9 == (func::applyLast (fun15<1,3,5,7,9>, _9_) (_1_,_3_,_5_,_7_)).o_);
+
+          CHECK (9+8+7+6+5 == (func::applyFirst(fun15<9,8,7,6,5>, _9_) (_8_,_7_,_6_,_5_)).o_);
+          CHECK (  8+7+6+5 == (func::applyFirst(  fun14<8,7,6,5>, _8_)     (_7_,_6_,_5_)).o_);
+          CHECK (    7+6+5 == (func::applyFirst(    fun13<7,6,5>, _7_)         (_6_,_5_)).o_);
+          CHECK (      6+5 == (func::applyFirst(      fun12<6,5>, _6_)             (_5_)).o_);
+          CHECK (        5 == (func::applyFirst(        fun11<5>, _5_)               ( )).o_);
+
+
+
           // Finally a more convoluted example
           // covering the general case of partial function closure:
           typedef Num<5> Sig54321(Num<5>, Num<4>, Num<3>, Num<2>, Num<1>);   // Signature of the 5-argument function
           typedef Num<5> Sig54   (Num<5>, Num<4>);                           // ...closing the last 3 arguments should yield this 2-argument function
           typedef Types<Num<3>,Num<2>,Num<1> > Args2Close;                   // Tuple type to hold the 3 argument values used for the closure
-          
+
           // Close the trailing 3 arguments of the 5-argument function...
-          function<Sig54> fun_54 = PApply<Sig54321, Args2Close>::bindBack(fun15<5,4,3,2,1>, 
+          function<Sig54> fun_54 = PApply<Sig54321, Args2Close>::bindBack(fun15<5,4,3,2,1>,
                                                                           tuple::make(_3_,_2_,_1_)
                                                                          );
-          
+
           // apply the remaining argument values
           Num<5> resN5 = fun_54 (_5_,_4_);
-          ASSERT (5+4+3+2+1 == resN5.o_);
+          CHECK (5+4+3+2+1 == resN5.o_);
         }
-      
-      
-      
-      
+
+
+
+
       void
       check_functionalComposition ()
         {
@@ -304,87 +304,87 @@ namespace test    {
           typedef Num<1> Sig13(Num<1>,Num<2>,Num<3>);
           typedef Num<1> Sig14(Num<1>,Num<2>,Num<3>,Num<4>);
           typedef Num<1> Sig15(Num<1>,Num<2>,Num<3>,Num<4>,Num<5>);
-          
+
           Sig2 & ff = fun2< Num<1> >;
           Sig11& f1 = fun11<1>;
           Sig12& f2 = fun12<1,2>;
           Sig13& f3 = fun13<1,2,3>;
           Sig14& f4 = fun14<1,2,3,4>;
           Sig15& f5 = fun15<1,2,3,4,5>;
-          
-          ASSERT (1         == func::chained(f1, ff) (_1_)                 );
-          ASSERT (1+2       == func::chained(f2, ff) (_1_,_2_)             );
-          ASSERT (1+2+3     == func::chained(f3, ff) (_1_,_2_,_3_)         );
-          ASSERT (1+2+3+4   == func::chained(f4, ff) (_1_,_2_,_3_,_4_)     );
-          ASSERT (1+2+3+4+5 == func::chained(f5, ff) (_1_,_2_,_3_,_4_,_5_) );
-          
-          
+
+          CHECK (1         == func::chained(f1, ff) (_1_)                 );
+          CHECK (1+2       == func::chained(f2, ff) (_1_,_2_)             );
+          CHECK (1+2+3     == func::chained(f3, ff) (_1_,_2_,_3_)         );
+          CHECK (1+2+3+4   == func::chained(f4, ff) (_1_,_2_,_3_,_4_)     );
+          CHECK (1+2+3+4+5 == func::chained(f5, ff) (_1_,_2_,_3_,_4_,_5_) );
+
+
           function<Sig15> f5_fun = f5;     // also works with function objects...
           function<Sig2>  ff_fun = ff;
-          ASSERT (1+2+3+4+5 == func::chained(f5_fun, ff    ) (_1_,_2_,_3_,_4_,_5_) );
-          ASSERT (1+2+3+4+5 == func::chained(f5,     ff_fun) (_1_,_2_,_3_,_4_,_5_) );
-          ASSERT (1+2+3+4+5 == func::chained(f5_fun, ff_fun) (_1_,_2_,_3_,_4_,_5_) );
+          CHECK (1+2+3+4+5 == func::chained(f5_fun, ff    ) (_1_,_2_,_3_,_4_,_5_) );
+          CHECK (1+2+3+4+5 == func::chained(f5,     ff_fun) (_1_,_2_,_3_,_4_,_5_) );
+          CHECK (1+2+3+4+5 == func::chained(f5_fun, ff_fun) (_1_,_2_,_3_,_4_,_5_) );
         }
-      
-      
-      
+
+
+
       void
       check_bindToArbitraryParameter ()
         {
           typedef Num<1> Sig15(Num<1>,Num<2>,Num<3>,Num<4>,Num<5>);
-          
+
           typedef Num<1> SigR1(       Num<2>,Num<3>,Num<4>,Num<5>);
           typedef Num<1> SigR2(Num<1>,       Num<3>,Num<4>,Num<5>);
           typedef Num<1> SigR3(Num<1>,Num<2>,       Num<4>,Num<5>);
           typedef Num<1> SigR4(Num<1>,Num<2>,Num<3>,       Num<5>);
           typedef Num<1> SigR5(Num<1>,Num<2>,Num<3>,Num<4>       );
-          
+
           typedef Num<5> SigA5(Num<5>);
-          
+
           Sig15& f = fun15<1,2,3,4,5>;
           SigA5& f5 = fun11<5>;
           Tuple<Types<char> > argT(55);
-          
+
           function<SigR1> f_bound_1 = BindToArgument<Sig15,char,0>::reduced (f, argT);
           function<SigR2> f_bound_2 = BindToArgument<Sig15,char,1>::reduced (f, argT);
           function<SigR3> f_bound_3 = BindToArgument<Sig15,char,2>::reduced (f, argT);
           function<SigR4> f_bound_4 = BindToArgument<Sig15,char,3>::reduced (f, argT);
           function<SigR5> f_bound_5 = BindToArgument<Sig15,char,4>::reduced (f, argT);
-          
-          ASSERT (55+2+3+4+5 == f_bound_1 (    _2_,_3_,_4_,_5_) );
-          ASSERT (1+55+3+4+5 == f_bound_2 (_1_,    _3_,_4_,_5_) );
-          ASSERT (1+2+55+4+5 == f_bound_3 (_1_,_2_,    _4_,_5_) );
-          ASSERT (1+2+3+55+5 == f_bound_4 (_1_,_2_,_3_,    _5_) );
-          ASSERT (1+2+3+4+55 == f_bound_5 (_1_,_2_,_3_,_4_    ) );
-          
-          
+
+          CHECK (55+2+3+4+5 == f_bound_1 (    _2_,_3_,_4_,_5_) );
+          CHECK (1+55+3+4+5 == f_bound_2 (_1_,    _3_,_4_,_5_) );
+          CHECK (1+2+55+4+5 == f_bound_3 (_1_,_2_,    _4_,_5_) );
+          CHECK (1+2+3+55+5 == f_bound_4 (_1_,_2_,_3_,    _5_) );
+          CHECK (1+2+3+4+55 == f_bound_5 (_1_,_2_,_3_,_4_    ) );
+
+
           // degenerate case: specify wrong argument position (behind end of argument list)
           // causes the argument to be simply ignored and no binding to happen
           function<Sig15> f_bound_X = BindToArgument<Sig15,char,5>::reduced (f, argT);
-          ASSERT (1+2+3+4+5  == f_bound_X (_1_,_2_,_3_,_4_,_5_) );
-          
-          
+          CHECK (1+2+3+4+5  == f_bound_X (_1_,_2_,_3_,_4_,_5_) );
+
+
           /* check the convenient function-style API */
-          
+
           using std::tr1::bind;
-          
+
           f_bound_5 = bindLast (f, bind(f5, Num<5>(99)));
-          ASSERT (1+2+3+4+99 == f_bound_5 (_1_,_2_,_3_,_4_   ) );
-          
+          CHECK (1+2+3+4+99 == f_bound_5 (_1_,_2_,_3_,_4_   ) );
+
           f_bound_5 = bindLast (f, bind(&f5, Num<5>(99)));        // can bind function pointer
-          ASSERT (1+2+3+4+99 == f_bound_5 (_1_,_2_,_3_,_4_   ) );
-          
+          CHECK (1+2+3+4+99 == f_bound_5 (_1_,_2_,_3_,_4_   ) );
+
           function<Sig15> asFunctor(f);
           f_bound_5 = bindLast (asFunctor, bind(f5, Num<5>(88))); // use functor instead of direct ref
-          ASSERT (1+2+3+4+88 == f_bound_5 (_1_,_2_,_3_,_4_   ) );
+          CHECK (1+2+3+4+88 == f_bound_5 (_1_,_2_,_3_,_4_   ) );
         }
-      
+
     };
-  
-  
+
+
   /** Register this test class... */
   LAUNCHER (FunctionComposition_test, "unit common");
-  
-  
-  
+
+
+
 }}} // namespace lumiera::typelist::test
diff --git a/tests/lib/meta/function-erasure-test.cpp b/tests/lib/meta/function-erasure-test.cpp
index 1b4fb733e..96bf9f50f 100644
--- a/tests/lib/meta/function-erasure-test.cpp
+++ b/tests/lib/meta/function-erasure-test.cpp
@@ -98,12 +98,12 @@ namespace test {
           check_Comparisons (Efp(testFunc),   Efp(returnIt));
           check_Comparisons (Evoid(testFunc), Evoid(returnIt));
           
-          ASSERT ( detect_Clone (Efun(testFunc)));
-          ASSERT (!detect_Clone (Efun(bindFunc)));  //note equality not detected when cloning a bind term
-          ASSERT (!detect_Clone (Efun(pAplFunc)));  //similarly
-          ASSERT (!detect_Clone (Efun(membFunc)));  //analogous for bound member function
-          ASSERT ( detect_Clone (Efp(testFunc) ));
-          ASSERT ( detect_Clone (Evoid(testFunc)));
+          CHECK ( detect_Clone (Efun(testFunc)));
+          CHECK (!detect_Clone (Efun(bindFunc)));  //note equality not detected when cloning a bind term
+          CHECK (!detect_Clone (Efun(pAplFunc)));  //similarly
+          CHECK (!detect_Clone (Efun(membFunc)));  //analogous for bound member function
+          CHECK ( detect_Clone (Efp(testFunc) ));
+          CHECK ( detect_Clone (Evoid(testFunc)));
           
           detect_unboundFunctor(Efun(testFunc), Efun(getterFunc), Efun(membFunc));
           detect_unboundFunctor(Efp(testFunc),Efp(&testFunc), Efp(returnIt));
@@ -127,22 +127,22 @@ namespace test {
           
           _sum_ = 0;
           f1.getFun<Sig1>() (-11,'M');                // invoke stored tr1::function...
-          ASSERT (_sum_ == 'M'-11);
+          CHECK (_sum_ == 'M'-11);
           
           _sum_ = 0;
           f2.getFun<Sig1>() (-22,'M');
-          ASSERT (_sum_ == 'M'-22);
+          CHECK (_sum_ == 'M'-22);
           
           _sum_ = 0;
           f3.getFun<Sig2>() (-33);
-          ASSERT (_sum_ == 'x'-33);
+          CHECK (_sum_ == 'x'-33);
           
           _sum_ = 0;
           f4.getFun<Sig3>() ('U');
-          ASSERT (_sum_ == 'u');
+          CHECK (_sum_ == 'u');
           
-          ASSERT ( 'u' == f5.getFun<Sig4>() () );
-          ASSERT (INSTANCEOF (function<Sig4>, &f5.getFun<Sig4>()));
+          CHECK ( 'u' == f5.getFun<Sig4>() () );
+          CHECK (INSTANCEOF (function<Sig4>, &f5.getFun<Sig4>()));
           
           
 #if false ///////////////////////////////////////////////////////////////////////////////////////////////TICKET #537 : restore throwing ASSERT
@@ -181,15 +181,15 @@ namespace test {
           
           _sum_ = 0;
           (*fun1) (10, 'a');                          // invoke retrieved function pointer
-          ASSERT (_sum_ == 10+'a');
+          CHECK (_sum_ == 10+'a');
           
           (*fun2) (20, 'b');
-          ASSERT (_sum_ == 10+'a'+20+'b');
+          CHECK (_sum_ == 10+'a'+20+'b');
           
           fun2r (30, 'c');
-          ASSERT (_sum_ == 10+'a'+20+'b'+30+'c');
+          CHECK (_sum_ == 10+'a'+20+'b'+30+'c');
           
-          ASSERT (_sum_ == (f3.getFun<int(void)>()) () );
+          CHECK (_sum_ == (f3.getFun<int(void)>()) () );
           
 #if false ////////////////////////////////////////////////////////TODO: restore throwing ASSERT
           VERIFY_ERROR (ASSERTION, f1.getFun<int(int)>() );
@@ -210,18 +210,18 @@ namespace test {
           
           _sum_ = 0;
           (*fun1) (10, 'a');
-          ASSERT (_sum_ == 10+'a');
+          CHECK (_sum_ == 10+'a');
           
           (*fun2) (20, 'b');
-          ASSERT (_sum_ == 10+'a'+20+'b');
+          CHECK (_sum_ == 10+'a'+20+'b');
           
           fun2r (30, 'c');
-          ASSERT (_sum_ == 10+'a'+20+'b'+30+'c');
+          CHECK (_sum_ == 10+'a'+20+'b'+30+'c');
           
-          ASSERT (_sum_ == (f3.getFun<int(void)>()) () );
+          CHECK (_sum_ == (f3.getFun<int(void)>()) () );
           
           FP bad_fun = &f3.getFun<void(int,char)>();
-          ASSERT ((void*)bad_fun == &returnIt);   // got wrong function!
+          CHECK ((void*)bad_fun == &returnIt);   // got wrong function!
           
         //(*bad_fun) (11, 'x');  // The compiler would accept this line!
         }                       //  likely to result in heap corruption or SEGV
@@ -231,11 +231,11 @@ namespace test {
       void
       check_Comparisons (HOL h1, HOL h2)
         {
-          ASSERT (h1 == h1); ASSERT (!(h1 != h1));
-          ASSERT (h2 == h2); ASSERT (!(h2 != h2));
+          CHECK (h1 == h1); CHECK (!(h1 != h1));
+          CHECK (h2 == h2); CHECK (!(h2 != h2));
           
-          ASSERT (h1 != h2);
-          ASSERT (h2 != h1);
+          CHECK (h1 != h2);
+          CHECK (h2 != h1);
         }
       
       
@@ -257,11 +257,11 @@ namespace test {
           typedef typename BuildEmptyFunctor<HOL>::Type NoFunc;
           NoFunc noFunction = NoFunc();
           HOL emptyHolder (noFunction);
-          ASSERT (!emptyHolder);
+          CHECK (!emptyHolder);
           
-          ASSERT ( h1 );
-          ASSERT ( h2 );
-          ASSERT ( h3 );
+          CHECK ( h1 );
+          CHECK ( h2 );
+          CHECK ( h3 );
         }
       
       
diff --git a/tests/lib/meta/generator-test.cpp b/tests/lib/meta/generator-test.cpp
index 1726fc8ee..61580eaea 100644
--- a/tests/lib/meta/generator-test.cpp
+++ b/tests/lib/meta/generator-test.cpp
@@ -1,23 +1,23 @@
 /*
   Generator(Test)  -  build an interface + implementation directed by a typelis
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2 of the
   License, or (at your option) any later version.
- 
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
@@ -26,7 +26,7 @@
  **
  ** the following test composes both an interface and the corresponding implementation
  ** by instantiating "building block" templates over a collection of types. The resulting
- ** class ends up inheriting a \e virtual function instantiated for each of the types 
+ ** class ends up inheriting a \e virtual function instantiated for each of the types
  ** in the list. (remember: normally the number and signature of all virtual functions
  ** need to be absolutely fixed in the class definition)
  **
@@ -50,23 +50,23 @@ using std::cout;
 namespace lumiera {
 namespace typelist{
 namespace test {
-      
+
       /** template for generating lots of different test types */
       template<int I>
       struct Block
         {
           static string name;
-          string talk()   { return "__"+name+"__"; }  
+          string talk()   { return "__"+name+"__"; }
         };
-      
-      
+
+
       boost::format fmt ("Block<%2i>");
-        
+
       template<int I>
       string Block<I>::name = str (fmt % I);
-      
-      
-      
+
+
+
       /** Use this building block for assembling an abstract interface */
       template<class X>
       class TakeIt
@@ -75,7 +75,7 @@ namespace test {
           virtual void eat (X& x) = 0;
           virtual ~TakeIt() { }
         };
-      
+
       /** Use this building block for chaining corresponding implementation classes. */
       template<class X, class BASE>
       class DoIt
@@ -88,7 +88,7 @@ namespace test {
           void eat (X& x) { cout << "devouring" << x.talk() << "\n";}
           using BASE::eat; // prevent shadowing
         };
-      
+
       typedef Types< Block<1>
                    , Block<2>
                    , Block<3>
@@ -96,53 +96,53 @@ namespace test {
                    , Block<8>
                    , Block<13>
                    >::List TheTypes;
-      
+
       typedef InstantiateForEach<TheTypes,TakeIt>  TheInterface;
-      
-      
+
+
       struct BaseImpl : public TheInterface
         {
           void eat() { cout << "gulp!\n"; }
         };
-      
+
       typedef InstantiateChained<TheTypes,DoIt, BaseImpl>  NumberBabbler;
-      
-      
+
+
       /*************************************************************************
        * @test check the helpers for dealing with lists-of-types.
-       *       <ul><li>build an interface and an implementation class 
-       *               by inheriting template instantiations 
+       *       <ul><li>build an interface and an implementation class
+       *               by inheriting template instantiations
        *               for a collection of classes</li>
        *       </ul>
        */
       class TypeListGenerator_test : public Test
         {
-          virtual void run(Arg) 
+          virtual void run(Arg)
             {
               NumberBabbler me_can_has_more_numberz;
-              
-              ASSERT (INSTANCEOF (TheInterface, &me_can_has_more_numberz));  
-              
+
+              CHECK (INSTANCEOF (TheInterface, &me_can_has_more_numberz));
+
               TheTypes::Tail::Head                          b2;   //  Block<2>
               TheTypes::Tail::Tail::Tail::Head              b5;   //  Block<5>
               TheTypes::Tail::Tail::Tail::Tail::Tail::Head  b13;  //  Block<13>
 
               me_can_has_more_numberz.eat (b2);
               me_can_has_more_numberz.eat (b5);
-              
+
               TakeIt<Block<13> >& subInterface = me_can_has_more_numberz;
-              
+
               subInterface.eat (b13);
               me_can_has_more_numberz.eat();
-              
+
               INFO (test, "SizeOf = %u", sizeof(me_can_has_more_numberz));
-            } 
+            }
         };
-      
-      
+
+
       /** Register this test class... */
       LAUNCHER (TypeListGenerator_test, "unit common");
-      
-      
-      
+
+
+
 }}} // namespace lumiera::typelist::test
diff --git a/tests/lib/meta/type-tuple-test.cpp b/tests/lib/meta/type-tuple-test.cpp
index 932f56572..f5cf2d5f9 100644
--- a/tests/lib/meta/type-tuple-test.cpp
+++ b/tests/lib/meta/type-tuple-test.cpp
@@ -1,23 +1,23 @@
 /*
   TypeTuple(Test)  -  checking type tuples and records based on them
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2 of the
   License, or (at your option) any later version.
- 
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
@@ -48,12 +48,12 @@ using std::endl;
 namespace lumiera {
 namespace typelist{
 namespace test {
-      
-      
-      
+
+
+
       namespace { // test data
-        
-        
+
+
         typedef Types< Num<1>
                      , Num<3>
                      , Num<5>
@@ -62,17 +62,17 @@ namespace test {
                      , Num<4>
                      >          Types2;
         typedef Types< Num<7> > Types3;
-        
-        
-        
+
+
+
       } // (End) test data
-  
-  
-  
-  
+
+
+
+
   /*************************************************************************
-   * @test Cover various aspects of the type tuple. 
-   *       Check the metaprogramming behaviour... 
+   * @test Cover various aspects of the type tuple.
+   *       Check the metaprogramming behaviour...
    *       - build a tuple type from an existing typelist
    *       - create sub tuple types and types with shifted parameters
    *       Additionally, check the behaviour when creating tuple instances
@@ -83,12 +83,12 @@ namespace test {
    *       - creating tuples partially from an existing sub-argument tuple
    *       - copy and copy construct
    *       - access the "head" and access values by numeric index
-   *       - create a tuple with shifted values 
+   *       - create a tuple with shifted values
    */
   class TypeTuple_test : public Test
     {
       virtual void
-      run (Arg) 
+      run (Arg)
         {
           check_diagnostics();
           check_tuple_from_Typelist();
@@ -99,8 +99,8 @@ namespace test {
           check_tuple_copy();
           check_value_access();
         }
-      
-      
+
+
       /** verify the test input data
        *  @see TypeListManipl_test#check_diagnostics()
        *       for an explanation of the DISPLAY macro
@@ -111,156 +111,156 @@ namespace test {
           typedef Types1::List L1;
           typedef Types2::List L2;
           typedef Types3::List L3;
-          
+
           DISPLAY (L1);
           DISPLAY (L2);
           DISPLAY (L3);
-          
+
           typedef Tuple<Types1> Tup1;
           Tup1 tup1x (Num<1>(11));
-          
+
           DISPLAY (Tup1);     // prints the type
           DUMPVAL (Tup1());   // prints the contents
           DUMPVAL (tup1x);
         }
-      
-      
+
+
       void
       check_tuple_from_Typelist()
         {
           typedef Types1::List L1; // starting from an existing Typelist...
-          
+
           typedef Tuple<L1> T_L1;           // ListType based tuple type
           typedef Tuple<L1>::TupleType T1;  // corresponding plain tuple type
           typedef Tuple<L1>::Type Type1;    // extract the underlying type sequence
-          
+
           DISPLAY (Type1);
           DISPLAY (T_L1);
           DISPLAY (T1);
-          
+
           T_L1 tup1 (Num<1>(8));            // both flavours can be created at runtime
           T1   tup2 (Num<1>(9));            // (and we provide an explicit value for the 1st element)
           DUMPVAL (tup1);
           DUMPVAL (tup2);
-          
+
           typedef Tuple<Node<int, L1> > Prepend;
           DISPLAY (Prepend);                // another ListType based tuple created by prepending
-          
+
           Prepend prepend (22, tup2);       // but note: the ListType based tuple has an "(head,tail)" style ctor
           DUMPVAL (prepend);                // ... and in construction, tup2 has been copied and coerced to ListType style
-          
+
           typedef Tuple<Types<> > NulT;     // plain-flat empty Tuple
           typedef Tuple<NullType> NulL;     // list-style empty Tuple
-          
-          ASSERT (            is_Tuple<T1>::value);
-          ASSERT (       is_TuplePlain<T1>::value);
-          ASSERT (!   is_TupleListType<T1>::value);
-          ASSERT (!       is_NullTuple<T1>::value);
-          
-          ASSERT (          is_Tuple<T_L1>::value);
-          ASSERT (!    is_TuplePlain<T_L1>::value);
-          ASSERT (  is_TupleListType<T_L1>::value);
-          ASSERT (!     is_NullTuple<T_L1>::value);
-          
-          ASSERT (          is_Tuple<NulT>::value);
-          ASSERT (     is_TuplePlain<NulT>::value);
-          ASSERT (! is_TupleListType<NulT>::value);
-          ASSERT (      is_NullTuple<NulT>::value);
-          
-          ASSERT (          is_Tuple<NulL>::value);
-          ASSERT (!    is_TuplePlain<NulL>::value);
-          ASSERT (  is_TupleListType<NulL>::value);
-          ASSERT (      is_NullTuple<NulL>::value);
-          
-          ASSERT (!        is_Tuple<Type1>::value);
-          ASSERT (!   is_TuplePlain<Type1>::value);
-          ASSERT (!is_TupleListType<Type1>::value);
-          ASSERT (!    is_NullTuple<Type1>::value);
-          
-          ASSERT (!        is_Tuple<Types1::List>::value);
-          ASSERT (!   is_TuplePlain<Types1::List>::value);
-          ASSERT (!is_TupleListType<Types1::List>::value);
-          ASSERT (!    is_NullTuple<Types1::List>::value);
-          
+
+          CHECK (            is_Tuple<T1>::value);
+          CHECK (       is_TuplePlain<T1>::value);
+          CHECK (!   is_TupleListType<T1>::value);
+          CHECK (!       is_NullTuple<T1>::value);
+
+          CHECK (          is_Tuple<T_L1>::value);
+          CHECK (!    is_TuplePlain<T_L1>::value);
+          CHECK (  is_TupleListType<T_L1>::value);
+          CHECK (!     is_NullTuple<T_L1>::value);
+
+          CHECK (          is_Tuple<NulT>::value);
+          CHECK (     is_TuplePlain<NulT>::value);
+          CHECK (! is_TupleListType<NulT>::value);
+          CHECK (      is_NullTuple<NulT>::value);
+
+          CHECK (          is_Tuple<NulL>::value);
+          CHECK (!    is_TuplePlain<NulL>::value);
+          CHECK (  is_TupleListType<NulL>::value);
+          CHECK (      is_NullTuple<NulL>::value);
+
+          CHECK (!        is_Tuple<Type1>::value);
+          CHECK (!   is_TuplePlain<Type1>::value);
+          CHECK (!is_TupleListType<Type1>::value);
+          CHECK (!    is_NullTuple<Type1>::value);
+
+          CHECK (!        is_Tuple<Types1::List>::value);
+          CHECK (!   is_TuplePlain<Types1::List>::value);
+          CHECK (!is_TupleListType<Types1::List>::value);
+          CHECK (!    is_NullTuple<Types1::List>::value);
+
         }
-      
-      
+
+
       void
       check_sub_tuple_types()
         {
           cout << "\t:\n\t: ---Sub-Tuple-Types----\n";
-          
+
           typedef Append<Types2::List, Types1::List>::List L2;
-          
+
           typedef Tuple<L2> T_L2;              // list-style Tuple
           typedef Types<T_L2::HeadType> Head;
           typedef T_L2::TailType Tail;
           DISPLAY (T_L2);
           DISPLAY (Head);
           DISPLAY (Tail);
-          
+
           typedef T_L2::TupleType T2;          // plain-flat Tuple
           typedef Types<T2::HeadType> Head2;
           typedef T2::TailType Tail2;
           DISPLAY (T2);
           DISPLAY (Head2);
           DISPLAY (Tail2);
-          
+
           typedef Tuple<Types<> > NulT;        // plain-flat empty Tuple
           typedef Tuple<NullType> NulL;        // list-style empty Tuple
-          
+
           DISPLAY (T2::Type);                  // irrespective of the flavour,
-          DISPLAY (T2::TailType);              // a basic set of typedefs is 
+          DISPLAY (T2::TailType);              // a basic set of typedefs is
           DISPLAY (T2::TupleType);             // always available
           DISPLAY (T2::ThisType);
           DISPLAY (T2::Tail);
           DISPLAY (T2::ArgList);
-          
+
           DISPLAY (T_L2::Type);                // the element types as type sequence
           DISPLAY (T_L2::TailType);            // the element types of the "tail" tuple
           DISPLAY (T_L2::TupleType);           // corresponding plain-flat tuple type
           DISPLAY (T_L2::ThisType);            // "type_of(this)"
           DISPLAY (T_L2::Tail);                // tail tuple
           DISPLAY (T_L2::ArgList);             // typelist comprised of the element types
-          
+
           DISPLAY (NulT::Type);
           DISPLAY (NulT::TailType);
           DISPLAY (NulT::TupleType);
           DISPLAY (NulT::ThisType);
           DISPLAY (NulT::Tail);
           DISPLAY (NulT::ArgList);
-          
+
           DISPLAY (NulL::Type);
           DISPLAY (NulL::TailType);
           DISPLAY (NulL::TupleType);
           DISPLAY (NulL::ThisType);
           DISPLAY (NulL::Tail);
           DISPLAY (NulL::ArgList);
-          
+
         }
-      
-      
+
+
       void
       check_shiftedTuple()
         {
           cout << "\t:\n\t: ---Shifted-Tuple---\n";
-          
+
           typedef Append<Types2::List, Types3::List>::List L3;
           typedef Tuple<L3>::Type Ty3;
           typedef Tuple<Ty3>      T3;
-          
+
           typedef Shifted<Ty3,0>::Type Ty_0;  DISPLAY (Ty_0);
           typedef Shifted<Ty3,1>::Type Ty_1;  DISPLAY (Ty_1);
           typedef Shifted<Ty3,2>::Type Ty_2;  DISPLAY (Ty_2);
           typedef Shifted<Ty3,3>::Type Ty_3;  DISPLAY (Ty_3);
           typedef Shifted<Ty3,4>::Type Ty_4;  DISPLAY (Ty_4);
-          
+
           typedef T3::ShiftedTuple<0>::Type T_0; DISPLAY (T_0);
           typedef T3::ShiftedTuple<1>::Type T_1; DISPLAY (T_1);
           typedef T3::ShiftedTuple<2>::Type T_2; DISPLAY (T_2);
           typedef T3::ShiftedTuple<3>::Type T_3; DISPLAY (T_3);
           typedef T3::ShiftedTuple<4>::Type T_4; DISPLAY (T_4);
-          
+
           T3 tu3;                                DUMPVAL (tu3);
           T_0 tu3_0 = tu3.getShifted<0>();       DUMPVAL (tu3_0);
           T_1 tu3_1 = tu3.getShifted<1>();       DUMPVAL (tu3_1);
@@ -268,13 +268,13 @@ namespace test {
           T_3 tu3_3 = tu3.getShifted<3>();       DUMPVAL (tu3_3);
           T_4 tu3_4 = tu3.getShifted<4>();       DUMPVAL (tu3_4);
         }
-      
-      
+
+
       void
       check_tuple_creation()
         {
           cout << "\t:\n\t: ---creating-Tuples---\n";
-          
+
           Tuple<Types1> tup1  ;
           Tuple<Types1> tup11 (Num<1>(11) );
           Tuple<Types1> tup12 (Num<1>(),   Num<3>(33) );
@@ -283,22 +283,22 @@ namespace test {
           DUMPVAL (tup11);
           DUMPVAL (tup12);
           DUMPVAL (tup13);
-          
+
           typedef Tuple<Types<int,int,Num<11> > > Tup2;
           Tup2 tup2 = tuple::make(41,42, Num<11>(43));   // build tuple from given values
           DISPLAY (Tup2);
           DUMPVAL (tup2);
-          
+
           typedef Tup2::Tail Tup22;
           Tup22 tup22 = tup2.getTail();
           DISPLAY (Tup22);
           DUMPVAL (tup22);
-          
+
           typedef Tup2::Tail::Tail Tup222;
           Tup222 tup222 = tup22.getTail();
           DISPLAY (Tup222);
           DUMPVAL (tup222);
-          
+
           typedef Tuple<Types<> > T0T;
           typedef Tuple<NullType> T0L;
           T0T nullT = tuple::makeNullTuple();
@@ -312,31 +312,31 @@ namespace test {
           DUMPVAL (nulTcpy);
           DUMPVAL (nulTref);
         }
-      
-      
+
+
       void
       check_build_from_subTuple()
         {
           cout << "\t:\n\t: ---build-from-sub-Tuples---\n";
-          
+
           typedef Append<Types1::List, Types3::List>::List TL;
           typedef Tuple<TL>::Type                          TT;
           typedef Tuple<TL> T1357L;
           typedef Tuple<TT> T1357T;
           DISPLAY (T1357L);
           DISPLAY (T1357T);
-          
+
           typedef Tuple<Types1::List> T135L;
           typedef Tuple<Types<Num<5>,Num<7> > > T57T;
           typedef Tuple<Types<Num<3>,Num<5> > > T35T;
           DISPLAY (T135L);
           DISPLAY (T57T);
           DISPLAY (T35T);
-          
+
           T135L sub135;
           T57T sub57;
           T35T sub35 (Num<3>(8),Num<5>(8));
-          
+
           DUMPVAL (sub135);
           T1357T   b_135  = tuple::BuildTuple<T1357T,T135L>::create(sub135);
           DUMPVAL (b_135);
@@ -346,113 +346,113 @@ namespace test {
           DUMPVAL (b_135);
                    b_135  = tuple::BuildTuple<TT,Types1::List>::create(sub135);
           DUMPVAL (b_135);                              // all variations of type specification lead to the same result
-          
+
           DUMPVAL (sub57);
           T1357T   b_57   = tuple::BuildTuple<T1357T,T57T,2>::create(sub57);
           DUMPVAL (b_57);
-          
+
           DUMPVAL (sub35);
           T1357T   b_35   = tuple::BuildTuple<T1357T,T35T,1>::create(sub35);
           DUMPVAL (b_35);
-          
+
                    b_35   = tuple::BuildTuple<T1357T,T35T,2>::create(sub35);
           DUMPVAL (b_35);                               // note: wrong start position, argument tuple ignored completely
                    b_35   = tuple::BuildTuple<T1357T,T35T,4>::create(sub35);
           DUMPVAL (b_35);
-          
-          // use an argument tuple beyond the last argument of the target tuple... 
+
+          // use an argument tuple beyond the last argument of the target tuple...
           typedef  Tuple<Types<Num<7>,Num<8> > >  T78T;
           T78T     sub78 (Num<7>(77),Num<8>(88));
           DUMPVAL (sub78);
           T1357T   b_78   = tuple::BuildTuple<T1357T,T78T,3>::create(sub78);
           DUMPVAL (b_78);                              // note: superfluous arguments ignored
-          
+
           typedef Tuple<Types<> > NulT;
           NulT     nult;
           T1357T   b_nul  = tuple::BuildTuple<T1357T,NulT,1>::create(nult);
           DUMPVAL (b_nul);
                    b_nul  = tuple::BuildTuple<T1357T,NulT,4>::create(nult);
           DUMPVAL (b_nul);
-          
+
           NulT     b_nul2 = tuple::BuildTuple<NulT,T78T>::create(sub78);
           DUMPVAL (b_nul2)
                    b_nul2 = tuple::BuildTuple<NulT,T78T,1>::create(sub78);
           DUMPVAL (b_nul2)
         }
-      
-      
+
+
       void
       check_tuple_copy()
         {
           cout << "\t:\n\t: ---copy-operations---\n";
-          
+
           Tuple<Types1> tup1 (Num<1>(11), Num<3>(33), Num<5>() );
-          
+
           Tuple<Types1> tup11 (tup1);
           tup11.getAt<2>().o_ = 44;
           DUMPVAL (tup1);
           DUMPVAL (tup11);
-          
+
           tup1 = tup11;
           DUMPVAL (tup1);
-          
+
           Tuple<Types1::List> tupL = tup11.getShifted<0>();
           Tuple<Types1> tup1L (tupL);      // create plain tuple from list-style tuple
           DUMPVAL (tupL);
           DUMPVAL (tup1L);
         }
-      
-      
+
+
       void
       check_value_access()
         {
           cout << "\t:\n\t: ---value-access---\n";
-          
+
           typedef Append<Types2::List, Types2::List>::List T2424;
           typedef Tuple<T2424> TupX;
           TupX tupX;
           DISPLAY (TupX);
           DUMPVAL (tupX);
-          
+
           Tuple<Types2> tu2;
           DUMPVAL (tu2);
           tuple::element<1>(tu2).o_ = 5;
           tu2.getHead() = Num<2> (tu2.getAt<1>().o_);
           DUMPVAL (tu2);
-          
-          
+
+
           tupX.getShifted<2>() = tu2;
           DUMPVAL (tupX);
-          
+
           typedef Shifted<TupX::TupleType,2>::TupleType T4;
           T4 t4 (tupX.getShifted<2>());
           DISPLAY (T4);
           DUMPVAL (t4);
-          
+
           DISPLAY (TupX::Type)
           DISPLAY (TupX::TailType)
           DISPLAY (TupX::ThisType)
           DISPLAY (TupX::TupleType)
-          
+
           typedef TupX::TupleType TupT;
           DISPLAY (TupT::Type)
           DISPLAY (TupT::TailType)
           DISPLAY (TupT::ThisType)
           DISPLAY (TupT::TupleType)
-          
+
           TupT tupXcopy (tupX);
           DUMPVAL (tupXcopy);
-          
+
           TupT& tupXcast (tupX.tupleCast());   // (down)cast list-style to plain tuple
           DUMPVAL (tupXcast);
         }
-      
+
     };
-  
-  
+
+
   /** Register this test class... */
   LAUNCHER (TypeTuple_test, "unit common");
-  
-  
-  
+
+
+
 }}} // namespace lumiera::typelist::test
diff --git a/tests/lib/multifact-argument-test.cpp b/tests/lib/multifact-argument-test.cpp
index 14131e887..1957a2499 100644
--- a/tests/lib/multifact-argument-test.cpp
+++ b/tests/lib/multifact-argument-test.cpp
@@ -103,14 +103,14 @@ namespace test{
           theFact.defineProduction (TWO, bind (&fabricateNumberz, 2, _1 ));
           
           cout << showSizeof (theFact) << endl;
-          ASSERT (sizeof(theFact) == sizeof(DispatcherMap));
+          CHECK (sizeof(theFact) == sizeof(DispatcherMap));
           
           typedef TestFactory::Product PP;
           
           PP p1 = theFact(ONE, 2);
           PP p2 = theFact(TWO, 3);
-          ASSERT (1*2 == p1->n_);
-          ASSERT (2*3 == p2->n_);
+          CHECK (1*2 == p1->n_);
+          CHECK (2*3 == p2->n_);
         }
     };
   
diff --git a/tests/lib/multifact-test.cpp b/tests/lib/multifact-test.cpp
index 2850c0ea0..2f39deaf8 100644
--- a/tests/lib/multifact-test.cpp
+++ b/tests/lib/multifact-test.cpp
@@ -116,15 +116,15 @@ namespace test{
           
           Interface & o1 = theFact(ONE);
           Interface & o2 = theFact(ONE);
-          ASSERT (isSameObject(o1,o2));
+          CHECK (isSameObject(o1,o2));
           
           TestFactory anotherFact;
-          ASSERT (isnil (anotherFact));
+          CHECK (isnil (anotherFact));
           VERIFY_ERROR (INVALID, anotherFact(ONE) );
           
           TestFactory::Singleton<Implementation<ONE> > anotherSingletonHolder (anotherFact,ONE);
           Interface & o3 = anotherFact(ONE);
-          ASSERT (isSameObject(o2,o3));
+          CHECK (isSameObject(o2,o3));
         } 
     };
   
diff --git a/tests/lib/opaque-holder-test.cpp b/tests/lib/opaque-holder-test.cpp
index 5eae7ebb8..29f3fa125 100644
--- a/tests/lib/opaque-holder-test.cpp
+++ b/tests/lib/opaque-holder-test.cpp
@@ -129,7 +129,7 @@ namespace test{
             checkHandling (objs);
             checkSpecialSubclass ();
           }
-          ASSERT (0 == _checksum); // all dead
+          CHECK (0 == _checksum); // all dead
         }
       
       
@@ -159,63 +159,63 @@ namespace test{
       checkHandling (TestList& objs)
         {
           Opaque oo;
-          ASSERT (!oo);
-          ASSERT (isnil(oo));
+          CHECK (!oo);
+          CHECK (isnil(oo));
           
           oo = objs[1];
-          ASSERT (oo);
-          ASSERT (!isnil(oo));
+          CHECK (oo);
+          CHECK (!isnil(oo));
           
           typedef DD<3> D3;
           typedef DD<5> D5;
           D3 d3 (oo.get<D3>() );
-          ASSERT (3 == oo->getIt());    // re-access through Base interface
-          ASSERT (!isSameObject (d3, *oo));
+          CHECK (3 == oo->getIt());    // re-access through Base interface
+          CHECK (!isSameObject (d3, *oo));
           VERIFY_ERROR (WRONG_TYPE, oo.get<D5>() );
           
           // direct assignment of target into Buffer
           oo = D5();
-          ASSERT (oo);
-          ASSERT (5 == oo->getIt());
+          CHECK (oo);
+          CHECK (5 == oo->getIt());
           VERIFY_ERROR (WRONG_TYPE, oo.get<D3>() );
           
           // can get a direct reference to contained object
           D5 &rd5 (oo.get<D5>()); 
-          ASSERT (isSameObject (rd5, *oo));
+          CHECK (isSameObject (rd5, *oo));
           
-          ASSERT (!isnil(oo));
+          CHECK (!isnil(oo));
           oo = objs[3];     // copy construction also works on non-empty object
-          ASSERT (7 == oo->getIt());
+          CHECK (7 == oo->getIt());
           
           // WARNING: direct ref has been messed up through the backdoor!
-          ASSERT (7 == rd5.getIt());
-          ASSERT (isSameObject (rd5, *oo));
+          CHECK (7 == rd5.getIt());
+          CHECK (isSameObject (rd5, *oo));
           
           uint cnt_before = _create_count;
           
           oo.clear();
-          ASSERT (!oo);
+          CHECK (!oo);
           oo = D5();        // direct assignment also works on empty object
-          ASSERT (oo);
-          ASSERT (5 == oo->getIt());
-          ASSERT (_create_count == 2 + cnt_before);
+          CHECK (oo);
+          CHECK (5 == oo->getIt());
+          CHECK (_create_count == 2 + cnt_before);
           // one within buff and one for the anonymous temporary D5()
           
           
           // verify that self-assignment is properly detected...
           cnt_before = _create_count;
           oo = oo;
-          ASSERT (oo);
-          ASSERT (_create_count == cnt_before);
+          CHECK (oo);
+          CHECK (_create_count == cnt_before);
           oo = oo.get<D5>();
-          ASSERT (_create_count == cnt_before);
+          CHECK (_create_count == cnt_before);
           oo = *oo;
-          ASSERT (_create_count == cnt_before);
-          ASSERT (oo);
+          CHECK (_create_count == cnt_before);
+          CHECK (oo);
           
           oo.clear();
-          ASSERT (!oo);
-          ASSERT (isnil(oo));
+          CHECK (!oo);
+          CHECK (isnil(oo));
           VERIFY_ERROR (INVALID, oo.get<D5>() );
 #if false ///////////////////////////////////////////////////////////////////////////////////////////////TICKET #537 : restore throwing ASSERT
           VERIFY_ERROR (ASSERTION, oo->getIt() );
@@ -223,13 +223,13 @@ namespace test{
           // can't access empty holder...
           
           Opaque o1 (oo);
-          ASSERT (!o1);
+          CHECK (!o1);
           
           Opaque o2 (d3);
-          ASSERT (!isSameObject (d3, *o2));
-          ASSERT (3 == o2->getIt());
+          CHECK (!isSameObject (d3, *o2));
+          CHECK (3 == o2->getIt());
           
-          ASSERT (sizeof(Opaque) <= sizeof(Base) + sizeof(void*) + _ALIGN_);
+          CHECK (sizeof(Opaque) <= sizeof(Base) + sizeof(void*) + _ALIGN_);
         }
       
       
@@ -254,40 +254,40 @@ namespace test{
           cout << showSizeof<Opaque>() << endl;
           cout << showSizeof<SpecialOpaque>() << endl;
           
-          ASSERT (sizeof(Special) > sizeof(Base));
-          ASSERT (sizeof(SpecialOpaque) > sizeof(Opaque));
-          ASSERT (sizeof(SpecialOpaque) <= sizeof(Special) + sizeof(void*) + _ALIGN_);
+          CHECK (sizeof(Special) > sizeof(Base));
+          CHECK (sizeof(SpecialOpaque) > sizeof(Opaque));
+          CHECK (sizeof(SpecialOpaque) <= sizeof(Special) + sizeof(void*) + _ALIGN_);
           
           Special s1 (6);
           Special s2 (3);
-          ASSERT (!s1);               // even value
-          ASSERT (s2);                // odd value
-          ASSERT (7 == s1.getIt());   // indeed subclass of DD<7>
-          ASSERT (7 == s2.getIt());
+          CHECK (!s1);               // even value
+          CHECK (s2);                // odd value
+          CHECK (7 == s1.getIt());   // indeed subclass of DD<7>
+          CHECK (7 == s2.getIt());
           
           SpecialOpaque ospe0;
           SpecialOpaque ospe1 (s1);
           SpecialOpaque ospe2 (s2);
           
-          ASSERT (!ospe0);            // note: bool test (isValid)
-          ASSERT (!ospe1);            // also forwarded to contained object (myVal_==6 is even)
-          ASSERT ( ospe2);
-          ASSERT ( isnil(ospe0));     // while isnil just checks the empty state
-          ASSERT (!isnil(ospe1));
-          ASSERT (!isnil(ospe2));
+          CHECK (!ospe0);            // note: bool test (isValid)
+          CHECK (!ospe1);            // also forwarded to contained object (myVal_==6 is even)
+          CHECK ( ospe2);
+          CHECK ( isnil(ospe0));     // while isnil just checks the empty state
+          CHECK (!isnil(ospe1));
+          CHECK (!isnil(ospe2));
           
-          ASSERT (7 == ospe1->getIt());
-          ASSERT (6 == ospe1.get<Special>().myVal_);
-          ASSERT (3 == ospe2.get<Special>().myVal_);
+          CHECK (7 == ospe1->getIt());
+          CHECK (6 == ospe1.get<Special>().myVal_);
+          CHECK (3 == ospe2.get<Special>().myVal_);
           
           ospe1 = DD<5>();            // but can be reassigned like any normal Opaque
-          ASSERT (ospe1);
-          ASSERT (5 == ospe1->getIt());
+          CHECK (ospe1);
+          CHECK (5 == ospe1->getIt());
           VERIFY_ERROR (WRONG_TYPE, ospe1.get<Special>() );
           
           Opaque normal = DD<5>();
-          ASSERT (normal);
-          ASSERT (5 == normal->getIt());
+          CHECK (normal);
+          CHECK (5 == normal->getIt());
 #if false ////////////////////////////////////////////////////////TODO: restore throwing ASSERT
           // Assertion protects against SEGV
           VERIFY_ERROR (ASSERTION, normal = s1 );
diff --git a/tests/lib/opaque-unchecked-buffer-test.cpp b/tests/lib/opaque-unchecked-buffer-test.cpp
index d905ddfde..222b719e4 100644
--- a/tests/lib/opaque-unchecked-buffer-test.cpp
+++ b/tests/lib/opaque-unchecked-buffer-test.cpp
@@ -140,9 +140,9 @@ namespace test{
             typedef InPlaceBuffer<Base, sizeof(DD<42>), DD<0> > Buffer;
             
             Buffer buff;
-            ASSERT (sizeof(buff) <= sizeof(DD<42>) + _ALIGN_);
-            ASSERT (1 == _create_count);
-            ASSERT (0 == _checksum);
+            CHECK (sizeof(buff) <= sizeof(DD<42>) + _ALIGN_);
+            CHECK (1 == _create_count);
+            CHECK (0 == _checksum);
             buff->confess();          // one default object of type DD<0> has been created
             
             buff.create<DD<5> > ();
@@ -153,15 +153,15 @@ namespace test{
             
             VERIFY_ERROR( FATAL, buff.create<Killer> () );
             
-            ASSERT(0 == buff->id_);   // default object was created, due to exception...
+            CHECK(0 == buff->id_);   // default object was created, due to exception...
             
             buff.create<D42Sub> ("what the f**","is going on here?");
             buff->confess();
             
-            ASSERT (6 == _create_count);
-            ASSERT (42 == _checksum); // No.42 is alive
+            CHECK (6 == _create_count);
+            CHECK (42 == _checksum); // No.42 is alive
           }
-          ASSERT (0 == _checksum);  // all dead
+          CHECK (0 == _checksum);  // all dead
         }
     };
   
diff --git a/tests/lib/query/query-utils-test.cpp b/tests/lib/query/query-utils-test.cpp
index b631d6f8a..a05b46c5f 100644
--- a/tests/lib/query/query-utils-test.cpp
+++ b/tests/lib/query/query-utils-test.cpp
@@ -110,15 +110,15 @@ namespace test{
       void
       check_extractID ()
         {
-          ASSERT ("tok" == extractID ("pred", "pred(tok)." ));
-          ASSERT ("tok" == extractID ("pred", "    pred( tok )" ));
-          ASSERT ("tok" == extractID ("pred", "pred(tok), pred(tux)." ));
-          ASSERT ("tok" == extractID ("pred", "other(xyz) pred(tok) pred(tux)" ));
-          ASSERT ("tok" == extractID ("pred", "some( pred(tok)" ));
+          CHECK ("tok" == extractID ("pred", "pred(tok)." ));
+          CHECK ("tok" == extractID ("pred", "    pred( tok )" ));
+          CHECK ("tok" == extractID ("pred", "pred(tok), pred(tux)." ));
+          CHECK ("tok" == extractID ("pred", "other(xyz) pred(tok) pred(tux)" ));
+          CHECK ("tok" == extractID ("pred", "some( pred(tok)" ));
           
-          ASSERT (isnil (extractID ("pred", "pred (tok)")));
-          ASSERT (isnil (extractID ("pred", "pred tok)" )));
-          ASSERT (isnil (extractID ("pred", "pred(tok " )));
+          CHECK (isnil (extractID ("pred", "pred (tok)")));
+          CHECK (isnil (extractID ("pred", "pred tok)" )));
+          CHECK (isnil (extractID ("pred", "pred(tok " )));
         }
       
       
@@ -128,23 +128,23 @@ namespace test{
       check_removeTerm ()
         {
           // successful------Symbol---input-string----------------------extracted------remaining-------------
-          ASSERT_removeTerm ("pred", "pred(tok).",                     "pred(tok)",   "."                    );
-          ASSERT_removeTerm ("pred", "    pred( tok )",                "pred(tok)",   "    "                 );
-          ASSERT_removeTerm ("pred", "pred(tok), pred(tux).",          "pred(tok)",   "pred(tux)."           );
-          ASSERT_removeTerm ("pred", "other(xyz) pred(tok) pred(tux)", "pred(tok)",   "other(xyz) pred(tux)" );
-          ASSERT_removeTerm ("pred", "some( pred(tok)",                "pred(tok)",   "some( "               );
+          CHECK_removeTerm ("pred", "pred(tok).",                     "pred(tok)",   "."                    );
+          CHECK_removeTerm ("pred", "    pred( tok )",                "pred(tok)",   "    "                 );
+          CHECK_removeTerm ("pred", "pred(tok), pred(tux).",          "pred(tok)",   "pred(tux)."           );
+          CHECK_removeTerm ("pred", "other(xyz) pred(tok) pred(tux)", "pred(tok)",   "other(xyz) pred(tux)" );
+          CHECK_removeTerm ("pred", "some( pred(tok)",                "pred(tok)",   "some( "               );
           
           // not successful
-          ASSERT_removeTerm ("pred", "pred (tok",                      "",            "pred (tok" );
-          ASSERT_removeTerm ("pred", "pred tok)",                      "",            "pred tok)" );
-          ASSERT_removeTerm ("pred", "pred(tok",                       "",            "pred(tok"  );
+          CHECK_removeTerm ("pred", "pred (tok",                      "",            "pred (tok" );
+          CHECK_removeTerm ("pred", "pred tok)",                      "",            "pred tok)" );
+          CHECK_removeTerm ("pred", "pred(tok",                       "",            "pred(tok"  );
         }
       
       void
-      ASSERT_removeTerm (Symbol sym, string input, string extracted, string modified)
+      CHECK_removeTerm (Symbol sym, string input, string extracted, string modified)
         {
-          ASSERT (extracted == removeTerm (sym, input));
-          ASSERT (modified  == input);
+          CHECK (extracted == removeTerm (sym, input));
+          CHECK (modified  == input);
         }
       
       
@@ -156,7 +156,7 @@ namespace test{
       check_countPred ()
         {
           for (uint i=1; i <= 30; ++i)
-              ASSERT ( i == countPred (garbage_query (i)));
+              CHECK ( i == countPred (garbage_query (i)));
         }
     };
   
diff --git a/tests/lib/scoped-holder-test.cpp b/tests/lib/scoped-holder-test.cpp
index 918e7416b..382aa477b 100644
--- a/tests/lib/scoped-holder-test.cpp
+++ b/tests/lib/scoped-holder-test.cpp
@@ -82,33 +82,33 @@ namespace test{
       void
       checkAllocation()
         {
-          ASSERT (0==checksum);
+          CHECK (0==checksum);
           {
             HO holder;
-            ASSERT (!holder);
-            ASSERT (0==checksum);
+            CHECK (!holder);
+            CHECK (0==checksum);
             
             create_contained_object (holder);
-            ASSERT (holder);
-            ASSERT (false!=holder);
-            ASSERT (holder!=false);
+            CHECK (holder);
+            CHECK (false!=holder);
+            CHECK (holder!=false);
             
-            ASSERT (0!=checksum);
-            ASSERT ( &(*holder));
-            ASSERT (holder->add(2) == checksum+2);
+            CHECK (0!=checksum);
+            CHECK ( &(*holder));
+            CHECK (holder->add(2) == checksum+2);
             
             Dummy *rawP = holder.get();
-            ASSERT (rawP);
-            ASSERT (holder);
-            ASSERT (rawP == &(*holder));
-            ASSERT (rawP->add(-5) == holder->add(-5));
+            CHECK (rawP);
+            CHECK (holder);
+            CHECK (rawP == &(*holder));
+            CHECK (rawP->add(-5) == holder->add(-5));
             
             TRACE (test, "holder at %p", &holder);
             TRACE (test, "object at %p", holder.get() );
             TRACE (test, "size(object) = %u", sizeof(*holder));
             TRACE (test, "size(holder) = %u", sizeof(holder));
           }
-          ASSERT (0==checksum);
+          CHECK (0==checksum);
         }
       
       
@@ -116,7 +116,7 @@ namespace test{
       void
       checkErrorHandling()
         {
-          ASSERT (0==checksum);
+          CHECK (0==checksum);
           {
             HO holder;
             
@@ -128,15 +128,15 @@ namespace test{
               }
             catch (int val)
               {
-                ASSERT (0!=checksum);
+                CHECK (0!=checksum);
                 checksum -= val;
-                ASSERT (0==checksum);
+                CHECK (0==checksum);
               }
-            ASSERT (!holder); /* because the exception happens in ctor
+            CHECK (!holder); /* because the exception happens in ctor
                                  object doesn't count as "created" */
             throw_in_ctor = false;
           }
-          ASSERT (0==checksum);
+          CHECK (0==checksum);
         }
       
       
@@ -144,7 +144,7 @@ namespace test{
       void
       checkCopyProtocol()
         {
-          ASSERT (0==checksum);
+          CHECK (0==checksum);
           {
             HO holder;
             HO holder2 (holder);
@@ -152,9 +152,9 @@ namespace test{
             // copy and assignment of empty holders is tolerated
             
             // but after enclosing an object it will be copy protected...
-            ASSERT (!holder);
+            CHECK (!holder);
             create_contained_object (holder);
-            ASSERT (holder);
+            CHECK (holder);
             long currSum = checksum;
             void* adr = holder.get();
             try
@@ -164,10 +164,10 @@ namespace test{
               }
             catch (lumiera::error::Logic&)
               {
-                ASSERT (holder);
-                ASSERT (!holder2);
-                ASSERT (holder.get()==adr);
-                ASSERT (checksum==currSum);
+                CHECK (holder);
+                CHECK (!holder2);
+                CHECK (holder.get()==adr);
+                CHECK (checksum==currSum);
               }
             
             try
@@ -177,15 +177,15 @@ namespace test{
               }
             catch (lumiera::error::Logic&)
               {
-                ASSERT (holder);
-                ASSERT (!holder2);
-                ASSERT (holder.get()==adr);
-                ASSERT (checksum==currSum);
+                CHECK (holder);
+                CHECK (!holder2);
+                CHECK (holder.get()==adr);
+                CHECK (checksum==currSum);
               }
             
             create_contained_object (holder2);
-            ASSERT (holder2);
-            ASSERT (checksum != currSum);
+            CHECK (holder2);
+            CHECK (checksum != currSum);
             currSum = checksum;
             try
               {
@@ -194,10 +194,10 @@ namespace test{
               }
             catch (lumiera::error::Logic&)
               {
-                ASSERT (holder);
-                ASSERT (holder2);
-                ASSERT (holder.get()==adr);
-                ASSERT (checksum==currSum);
+                CHECK (holder);
+                CHECK (holder2);
+                CHECK (holder.get()==adr);
+                CHECK (checksum==currSum);
               }
             
             try
@@ -207,12 +207,12 @@ namespace test{
               }
             catch (lumiera::error::Logic&)
               {
-                ASSERT (holder);
-                ASSERT (holder2);
-                ASSERT (checksum==currSum);
+                CHECK (holder);
+                CHECK (holder2);
+                CHECK (checksum==currSum);
               }
           }
-          ASSERT (0==checksum);
+          CHECK (0==checksum);
         }
       
       
@@ -225,44 +225,44 @@ namespace test{
         {
           typedef std::map<int,HO> MapHO;
           
-          ASSERT (0==checksum);
+          CHECK (0==checksum);
           {
             MapHO maph;
-            ASSERT (isnil (maph));
+            CHECK (isnil (maph));
             
             for (uint i=0; i<100; ++i)
               {
                 HO & contained = maph[i];
-                ASSERT (!contained);
+                CHECK (!contained);
               }                      // 100 holder objects created by sideeffect
                                     
-            ASSERT (0==checksum);  // ..... without creating any contained object!
-            ASSERT (!isnil (maph));
-            ASSERT (100==maph.size());
+            CHECK (0==checksum);  // ..... without creating any contained object!
+            CHECK (!isnil (maph));
+            CHECK (100==maph.size());
             
             for (uint i=0; i<100; ++i)
               {
                 create_contained_object (maph[i]);
-                ASSERT (maph[i]);
-                ASSERT (0 < maph[i]->add(12));
+                CHECK (maph[i]);
+                CHECK (0 < maph[i]->add(12));
               }
-            ASSERT (100==maph.size());
-            ASSERT (0!=checksum);
+            CHECK (100==maph.size());
+            CHECK (0!=checksum);
             
             
             long value55 = maph[55]->add(0); 
             long currSum = checksum;
             
-            ASSERT (1 == maph.erase(55));
-            ASSERT (checksum == currSum - value55); // proves object#55's dtor has been invoked
-            ASSERT (maph.size() == 99);
+            CHECK (1 == maph.erase(55));
+            CHECK (checksum == currSum - value55); // proves object#55's dtor has been invoked
+            CHECK (maph.size() == 99);
             
             maph[55];                            // create new empty holder by sideeffect...
-            ASSERT (&maph[55]);
-            ASSERT (!maph[55]);
-            ASSERT (maph.size() == 100);
+            CHECK (&maph[55]);
+            CHECK (!maph[55]);
+            CHECK (maph.size() == 100);
           }
-          ASSERT (0==checksum);
+          CHECK (0==checksum);
         }
       
       
diff --git a/tests/lib/scoped-ptrvect-test.cpp b/tests/lib/scoped-ptrvect-test.cpp
index ed414aee2..26c8719b5 100644
--- a/tests/lib/scoped-ptrvect-test.cpp
+++ b/tests/lib/scoped-ptrvect-test.cpp
@@ -61,25 +61,25 @@ namespace test{
       void
       simpleUsage()
         {
-          ASSERT (0==checksum);
+          CHECK (0==checksum);
           {
             VectD holder;
-            ASSERT (isnil (holder));
-            ASSERT (0==checksum);
+            CHECK (isnil (holder));
+            CHECK (0==checksum);
             
             Dummy* ptr = new Dummy();
             Dummy& ref = holder.manage (ptr);
-            ASSERT (!isnil (holder));
-            ASSERT (0!=checksum);
-            ASSERT (&ref==ptr);
+            CHECK (!isnil (holder));
+            CHECK (0!=checksum);
+            CHECK (&ref==ptr);
             
             holder.manage (new Dummy);
             holder.manage (new Dummy);
-            ASSERT (3 == holder.size());
+            CHECK (3 == holder.size());
             
             holder.clear();
-            ASSERT (0==checksum);
-            ASSERT (isnil (holder));
+            CHECK (0==checksum);
+            CHECK (isnil (holder));
             
             holder.manage (new Dummy);
             holder.manage (new Dummy);
@@ -90,17 +90,17 @@ namespace test{
             holder.manage (new Dummy);
             holder.manage (new Dummy);
             holder.manage (new Dummy);
-            ASSERT (9 == holder.size());
-            ASSERT (0!=checksum);
+            CHECK (9 == holder.size());
+            CHECK (0!=checksum);
           }
-          ASSERT (0==checksum);
+          CHECK (0==checksum);
         }
       
       
       void
       iterating()
         {
-          ASSERT (0==checksum);
+          CHECK (0==checksum);
           {
             VectD holder;
             for (int i=0; i<16; ++i)
@@ -110,7 +110,7 @@ namespace test{
             VectD::iterator ii = holder.begin();
             while (ii)
               {
-                ASSERT (check == ii->getVal());
+                CHECK (check == ii->getVal());
                 ++check;
                 ++ii;
               }
@@ -121,26 +121,26 @@ namespace test{
             VectD::const_iterator cii = holder.begin();
             while (cii)
               {
-                ASSERT (check == cii->getVal());
+                CHECK (check == cii->getVal());
                 ++check;
                 ++cii;
               }
             
             
             // Verify correct behaviour of iteration end
-            ASSERT (! (holder.end()));
-            ASSERT (isnil (holder.end()));
+            CHECK (! (holder.end()));
+            CHECK (isnil (holder.end()));
             
             VERIFY_ERROR (ITER_EXHAUST, *holder.end() );
             VERIFY_ERROR (ITER_EXHAUST, ++holder.end() );
             
-            ASSERT (ii == holder.end());
-            ASSERT (cii == holder.end());
+            CHECK (ii == holder.end());
+            CHECK (cii == holder.end());
             VERIFY_ERROR (ITER_EXHAUST, ++ii );
             VERIFY_ERROR (ITER_EXHAUST, ++cii );
             
           }
-          ASSERT (0==checksum);
+          CHECK (0==checksum);
         }
       
     };
diff --git a/tests/lib/scopedholdertransfertest.cpp b/tests/lib/scopedholdertransfertest.cpp
index c47cd2a76..7aca8165a 100644
--- a/tests/lib/scopedholdertransfertest.cpp
+++ b/tests/lib/scopedholdertransfertest.cpp
@@ -1,23 +1,23 @@
 /*
   ScopedHolderTransfer(Test)  -  managing noncopyable objects within a growing vector
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2 of the
   License, or (at your option) any later version.
- 
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
@@ -35,17 +35,17 @@
 
 namespace lib {
   namespace test {
-    
+
     using ::Test;
     using util::isnil;
-    
+
     using std::vector;
     using std::cout;
-    
+
     namespace { // extending the Dummy for our special purpose....
-      
+
       bool throw_in_transfer = false;
-    
+
       class FixedDummy
         : public Dummy
         {
@@ -54,146 +54,146 @@ namespace lib {
             {
               TRACE  (test, "CTOR      FixedDummy() --> this=%p val=%d", this, getVal());
             }
-          
+
           ~FixedDummy()
             {
               TRACE  (test, "DTOR     ~FixedDummy()  this=%p val=%d", this, getVal());
             }
-          
+
           friend void
           transfer_control (FixedDummy& from, FixedDummy& to)
           {
             TRACE  (test, "TRANSFER  target=%p   <-- source=%p  (%d,%d)", &to,&from, to.getVal(),from.getVal());
-            
+
             if (throw_in_transfer)
               throw to.getVal();
-            
+
             to.setVal (from.getVal());
             from.setVal(0);
           }
-          
+
         };
-      
-      
+
+
       typedef ScopedHolder<FixedDummy>    HolderD;
       typedef ScopedPtrHolder<FixedDummy> PtrHolderD;
-      
+
       template<class HOL>
       struct Table
         {
-          typedef Allocator_TransferNoncopyable<HOL> Allo; 
+          typedef Allocator_TransferNoncopyable<HOL> Allo;
           typedef typename std::vector<HOL,Allo> Type;
-          
+
         };
     }
-      
-      
-    
-    
+
+
+
+
     /**********************************************************************************
      *  @test growing a vector containing noncopyable objects wrapped into ScopedHolder
-     *        instances. This requires the use of a custom allocator, invoking a 
+     *        instances. This requires the use of a custom allocator, invoking a
      *        \c transfer_control() function to be provided for the concrete
      *        noncopyable class type, being invoked when the vector
      *        needs to reallocate.
      */
     class ScopedHolderTransfer_test : public Test
       {
-        
-        virtual void 
+
+        virtual void
         run (Arg)
           {
-            
+
             cout << "checking ScopedHolder<Dummy>...\n";
             buildVector<HolderD>();
             growVector<HolderD>();
             checkErrorHandling<HolderD>();
-            
+
             cout << "checking ScopedPtrHolder<Dummy>...\n";
             buildVector<PtrHolderD>();
             growVector<PtrHolderD>();
             checkErrorHandling<PtrHolderD>();
           }
-        
+
         void create_contained_object (HolderD&    holder) { holder.create();                }
         void create_contained_object (PtrHolderD& holder) { holder.reset(new FixedDummy()); }
-        
-        
+
+
         template<class HO>
         void
         buildVector()
           {
-            ASSERT (0==checksum);
+            CHECK (0==checksum);
             {
               typedef typename Table<HO>::Type Vect;
-              
+
               Vect table(50);
-              ASSERT (0==checksum);
-              
+              CHECK (0==checksum);
+
               for (uint i=0; i<10; ++i)
                 create_contained_object (table[i]);
-              
-              ASSERT (0 < checksum);
-              ASSERT ( table[9]);
-              ASSERT (!table[10]);
-              
+
+              CHECK (0 < checksum);
+              CHECK ( table[9]);
+              CHECK (!table[10]);
+
               Dummy *rawP = table[5].get();
-              ASSERT (rawP);
-              ASSERT (table[5]);
-              ASSERT (rawP == &(*table[5]));
-              ASSERT (rawP->add(-555) == table[5]->add(-555));
+              CHECK (rawP);
+              CHECK (table[5]);
+              CHECK (rawP == &(*table[5]));
+              CHECK (rawP->add(-555) == table[5]->add(-555));
             }
-            ASSERT (0==checksum);
+            CHECK (0==checksum);
           }
-        
-        
+
+
         template<class HO>
         void
         growVector()
           {
-            ASSERT (0==checksum);
+            CHECK (0==checksum);
             {
               typedef typename Table<HO>::Type Vect;
-              
+
               Vect table;
               table.reserve(2);
-              ASSERT (0==checksum);
-              
+              CHECK (0==checksum);
+
               cout << ".\n..install one element at index[0]\n";
               table.push_back(HO());
-              ASSERT (0==checksum);
-              
+              CHECK (0==checksum);
+
               create_contained_object (table[0]); // switches into "managed" state
-              ASSERT (0 < checksum);
+              CHECK (0 < checksum);
               int theSum = checksum;
-              
+
               cout << ".\n..*** resize table to 16 elements\n";
               for (uint i=0; i<15; ++i)
                 table.push_back(HO());
-              
-              ASSERT (theSum==checksum);
+
+              CHECK (theSum==checksum);
             }
-            ASSERT (0==checksum);
+            CHECK (0==checksum);
           }
-        
-        
+
+
         template<class HO>
         void
         checkErrorHandling()
           {
-            ASSERT (0==checksum);
+            CHECK (0==checksum);
             {
               typedef typename Table<HO>::Type Vect;
-              
+
               Vect table(5);
               table.reserve(5);
-              ASSERT (0==checksum);
-              
+              CHECK (0==checksum);
+
               create_contained_object (table[2]);
               create_contained_object (table[4]);
-              ASSERT (0 < checksum);
+              CHECK (0 < checksum);
               int theSum = checksum;
-              
+
               cout << ".\n.throw some exceptions...\n";
               throw_in_ctor = true;
               try
@@ -203,14 +203,14 @@ namespace lib {
                 }
               catch (int val)
                 {
-                  ASSERT (theSum < checksum);
+                  CHECK (theSum < checksum);
                   checksum -= val;
-                  ASSERT (theSum==checksum);
+                  CHECK (theSum==checksum);
                 }
-              ASSERT ( table[2]); 
-              ASSERT (!table[3]); // not created because of exception 
-              ASSERT ( table[4]); 
-              
+              CHECK ( table[2]);
+              CHECK (!table[3]); // not created because of exception
+              CHECK ( table[4]);
+
               throw_in_ctor = false;
               throw_in_transfer=true;  // can do this only when using ScopedHolder
               try
@@ -219,19 +219,19 @@ namespace lib {
                 }
               catch (int val)
                 {
-                  ASSERT ( table.size() < 10);
+                  CHECK ( table.size() < 10);
                 }
-              ASSERT (theSum == checksum);
+              CHECK (theSum == checksum);
               throw_in_transfer=false;
             }
-            ASSERT (0==checksum);
+            CHECK (0==checksum);
           }
-        
+
       };
-    
+
     LAUNCHER (ScopedHolderTransfer_test, "unit common");
-    
-    
+
+
   }// namespace test
 
 } // namespace lib
diff --git a/tests/lib/singleton-subclass-test.cpp b/tests/lib/singleton-subclass-test.cpp
index 7fb274784..f46f24e7f 100644
--- a/tests/lib/singleton-subclass-test.cpp
+++ b/tests/lib/singleton-subclass-test.cpp
@@ -1,23 +1,23 @@
 /*
   SingletonSubclass(Test)  -  actually creating a subclass of the Singleton Type
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2 of the
   License, or (at your option) any later version.
- 
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
@@ -41,9 +41,9 @@ using std::cout;
 
 namespace lib {
 namespace test{
-  
+
   using lumiera::error::LUMIERA_ERROR_ASSERTION;
-  
+
   /**
    * Target object to be instantiated as Singleton
    * Allocates a variable amount of additional heap memory
@@ -54,37 +54,37 @@ namespace test{
     public:
       static int cnt;
       static void setCountParam (uint c) { Interface::cnt = c; }
-      
+
       virtual string identify()          { return "Interface"; }
-      
+
     protected:
       Interface () : TestTargetObj(cnt) {}
       virtual ~Interface() {}
-      
+
       friend class singleton::StaticCreate<Interface>;
       friend class singleton::HeapCreate<Interface>;
     };
-  
+
   int Interface::cnt = 0;
-  
-  
+
+
   class Impl : public Interface
     {
     public:
       virtual string identify() { return "Implementation"; }
     };
-  
-  
+
+
   // for checking the safety.....
   class Impl_XXX : public Impl { };
   class Unrelated { };
-  
-  
-  
-  
+
+
+
+
   /*******************************************************************
    * @test specialised variant of the Singleton Factory, for creating
-   *       subclasses (implementation classes) without coupling the 
+   *       subclasses (implementation classes) without coupling the
    *       caller to the concrete class type.
    * Expected results: an instance of the subclass is created.
    * @see  lib::Singleton
@@ -93,66 +93,66 @@ namespace test{
    */
   class SingletonSubclass_test : public Test
     {
-      
-      virtual void run(Arg arg) 
+
+      virtual void run(Arg arg)
         {
           uint num= isnil(arg)? 1 : lexical_cast<uint>(arg[1]);
-          
+
           cout << format("using the Singleton should create TargetObj(%d)...\n") % num;
-          
+
           Interface::setCountParam(num);
-          
+
           // marker to declare the concrete type to be created
-          singleton::UseSubclass<Impl> typeinfo;                       
-          
+          singleton::UseSubclass<Impl> typeinfo;
+
           // define an instance of the Singleton factory,
           // Specialised to create the concrete Type passed in
           SingletonSubclassFactory<Interface> instance (typeinfo);
-          
+
           // Now use the Singleton factory...
           // Note: we get the Base type
           Interface& t1 = instance();
           Interface& t2 = instance();
-          
-          ASSERT ( &t1 == &t2, "not a Singleton, got two different instances." ); 
-          
-          cout << "calling a non-static method on the Singleton-" 
+
+          CHECK ( &t1 == &t2, "not a Singleton, got two different instances." );
+
+          cout << "calling a non-static method on the Singleton-"
                << t1.identify() << "\n"
                << string (t1)   << "\n";
-          
+
 ///////////////////////////////////////////////////////////////////////////////TODO: find a way to configure NoBug to throw in case of assertion
 ///////////////////////////////////////////////////////////////////////////////TODO: just for the proc tests. Also find a better way to configure
 ///////////////////////////////////////////////////////////////////////////////TODO: the non-release check. Then re-enable these checks...
 //#ifdef DEBUG
 //        verify_error_detection ();
 //#endif
-        } 
-      
-      
-      
+        }
+
+
+
       void verify_error_detection ()
         {
-          
+
           singleton::UseSubclass<Impl_XXX> more_special_type;
-          
+
           VERIFY_ERROR (ASSERTION, SingletonSubclassFactory<Interface> instance (more_special_type) );
               /* in debug mode, an attempt to re-configure an already
                * configured SingletonSubclassFactory with another type
                * should be detected and spotted by assertion failure */
-          
-          
+
+
           // Note: the following won't compile, because the "subclass" isn't a subclass...
           //
-          // singleton::UseSubclass<Unrelated> yet_another_type;                       
+          // singleton::UseSubclass<Unrelated> yet_another_type;
           // SingletonSubclassFactory<Interface> instance (yet_another_type);
         }
     };
-  
-  
-  
+
+
+
   /** Register this test class... */
   LAUNCHER (SingletonSubclass_test, "unit common");
-  
-  
-  
+
+
+
 }} // namespace lib::test
diff --git a/tests/lib/singleton-test.cpp b/tests/lib/singleton-test.cpp
index e734ff275..eaebc100d 100644
--- a/tests/lib/singleton-test.cpp
+++ b/tests/lib/singleton-test.cpp
@@ -120,7 +120,7 @@ namespace test{
           TargetObj& t1 = instance();
           TargetObj& t2 = instance();
           
-          ASSERT ( &t1 == &t2, "not a Singleton, got two different instances." );
+          CHECK ( &t1 == &t2, "not a Singleton, got two different instances." );
           
           cout << "calling a non-static method on the Singleton instance\n"
                << string (t1) << "\n";
diff --git a/tests/lib/singletontestmocktest.cpp b/tests/lib/singletontestmocktest.cpp
index ba4aade39..66b9b0244 100644
--- a/tests/lib/singletontestmocktest.cpp
+++ b/tests/lib/singletontestmocktest.cpp
@@ -143,7 +143,7 @@ namespace test{
           TestSingletonO* sing = &instance();
           sing->doIt();
           sing->doIt();
-          ASSERT (sing->getCnt() == 2);
+          CHECK (sing->getCnt() == 2);
           
           instance.injectSubclass (new Mock_1);
           sing = &instance();
@@ -152,18 +152,18 @@ namespace test{
           sing->doIt();
           sing->doIt();
           sing->doIt();
-          ASSERT (sing->getCnt() == 5);
+          CHECK (sing->getCnt() == 5);
           
           instance.injectSubclass (new Mock_2);
           sing = &instance();
           sing->doIt();
-          ASSERT (sing->getCnt() == 1);
+          CHECK (sing->getCnt() == 1);
           
           instance.injectSubclass (0); // un-shadowing original instance
           sing = &instance();
-          ASSERT (sing->getCnt() == 2);
+          CHECK (sing->getCnt() == 2);
           sing->doIt();
-          ASSERT (sing->getCnt() == 3);
+          CHECK (sing->getCnt() == 3);
         }
       
       
@@ -198,12 +198,12 @@ namespace test{
           TestSingletonO* sing = &instance();
           sing->doIt();
           sing->doIt();
-          ASSERT (sing->getCnt() == 2);
+          CHECK (sing->getCnt() == 2);
           
           instance.injectSubclass (0);
           sing = &instance();
           sing->doIt();
-          ASSERT (sing->getCnt() == 1);
+          CHECK (sing->getCnt() == 1);
         }
     };
   
diff --git a/tests/lib/streamtypebasicstest.cpp b/tests/lib/streamtypebasicstest.cpp
index 3ddea1deb..069afa3ab 100644
--- a/tests/lib/streamtypebasicstest.cpp
+++ b/tests/lib/streamtypebasicstest.cpp
@@ -70,7 +70,7 @@ namespace lumiera {
             UNIMPLEMENTED ("at least preliminary implementation of the MediaImplLib interface for lib GAVL");
             
             TODO ("how to do a simple consistency check on the returned ImplFacade? can we re-create the GAVL frame type?");
-            ASSERT (GAVL==iTy.libraryID);
+            CHECK (GAVL==iTy.libraryID);
             return iTy;
           }
         
@@ -78,11 +78,11 @@ namespace lumiera {
         basicImplTypeProperties (ImplType refType)
           {
             ImplType iTy2 = test_createImplType ();
-            ASSERT (iTy2==refType);
-            ASSERT (refType==iTy2);
+            CHECK (iTy2==refType);
+            CHECK (refType==iTy2);
             TODO ("add equality comparable concept to the ImplType class");
             
-            ASSERT (StreamType::VIDEO==refType.getKind());
+            CHECK (StreamType::VIDEO==refType.getKind());
             UNIMPLEMENTED ("get a lib descriptor"); 
             UNIMPLEMENTED ("check the lib of the type"); 
             UNIMPLEMENTED ("compare two types"); 
@@ -97,18 +97,18 @@ namespace lumiera {
         void
         basicStreamTypeProperties (SType type, ImplType iTy)
           {
-            ASSERT (type.implType);
-            ASSERT (iTy==(*type.implType));  /////////////TODO: really by ptr???
-            ASSERT (&iTy==type.implType);   // actually using the same object (in the registry)
+            CHECK (type.implType);
+            CHECK (iTy==(*type.implType));  /////////////TODO: really by ptr???
+            CHECK (&iTy==type.implType);   // actually using the same object (in the registry)
             
-            ASSERT (!isnil (type.prototype.id));
-            ASSERT (StreamType::VIDEO==type.prototype.kind);
-            ASSERT (StreamType::VIDEO==type.implType->getKind());
+            CHECK (!isnil (type.prototype.id));
+            CHECK (StreamType::VIDEO==type.prototype.kind);
+            CHECK (StreamType::VIDEO==type.implType->getKind());
             
-            ASSERT (type.implType->canConvert(iTy));  // of course... they are actually the same
-            ASSERT (iTy.canConvert(type));           // because it's based on the same impl type
+            CHECK (type.implType->canConvert(iTy));  // of course... they are actually the same
+            CHECK (iTy.canConvert(type));           // because it's based on the same impl type
             
-            ASSERT (StreamType::RAW==type.intentionTag);
+            CHECK (StreamType::RAW==type.intentionTag);
           }
       };
     
diff --git a/tests/lib/sub-id-test.cpp b/tests/lib/sub-id-test.cpp
index b52778c21..56b8170b9 100644
--- a/tests/lib/sub-id-test.cpp
+++ b/tests/lib/sub-id-test.cpp
@@ -156,7 +156,7 @@ namespace test{
           verify (KEY key)
             {
               cout << "verify....." << key << endl;
-              ASSERT (string(key) == (*this)[key]);
+              CHECK (string(key) == (*this)[key]);
             }
         };
       
diff --git a/tests/lib/subsystem-runner-test.cpp b/tests/lib/subsystem-runner-test.cpp
index 8e1ecb0be..ec827dffc 100644
--- a/tests/lib/subsystem-runner-test.cpp
+++ b/tests/lib/subsystem-runner-test.cpp
@@ -115,7 +115,7 @@ namespace test  {
               REQUIRE (!(isUp_|started_|didRun_), "attempt to start %s twice!", cStr(*this));
               
               string startSpec (extractID ("start",spec_));
-              ASSERT (!isnil (startSpec));
+              CHECK (!isnil (startSpec));
               
               if ("true"==startSpec) //----simulate successful subsystem start
                 {
@@ -124,7 +124,7 @@ namespace test  {
                   Thread (id_, bind (&MockSys::run, this, termination))
                         .sync();     // run-status handshake
                   
-                  ASSERT (started_);
+                  CHECK (started_);
                 }
               else
               if ("fail"==startSpec) //----not starting, incorrectly reporting success
@@ -165,7 +165,7 @@ namespace test  {
           run (Subsys::SigTerm termination)
             {
               string runSpec (extractID ("run",spec_));
-              ASSERT (!isnil (runSpec));
+              CHECK (!isnil (runSpec));
               
               // run-status handshake
               started_ = true;
@@ -287,9 +287,9 @@ namespace test  {
             runner.maybeRun (unit);
             bool emergency = runner.wait();
             
-            ASSERT (!emergency);
-            ASSERT (!unit.isRunning());
-            ASSERT (unit.didRun());
+            CHECK (!emergency);
+            CHECK (!unit.isRunning());
+            CHECK (unit.didRun());
           }
         
         
@@ -322,14 +322,14 @@ namespace test  {
             usleep (DELAY_FOR_FLOUNDERING_THRAD_ms * 1000);     // preempt to allow unit4 to go away
             runner.wait();
             
-            ASSERT (!unit1.isRunning());
-            ASSERT (!unit2.isRunning());
-            ASSERT (!unit3.isRunning());
-            ASSERT (!unit4.isRunning());
-            ASSERT (!unit1.didRun());
-            ASSERT (!unit2.didRun());
-            ASSERT (!unit3.didRun());
-            ASSERT ( unit4.didRun()); // ...but it failed immediately
+            CHECK (!unit1.isRunning());
+            CHECK (!unit2.isRunning());
+            CHECK (!unit3.isRunning());
+            CHECK (!unit4.isRunning());
+            CHECK (!unit1.didRun());
+            CHECK (!unit2.didRun());
+            CHECK (!unit3.didRun());
+            CHECK ( unit4.didRun()); // ...but it failed immediately
           }
         
         
@@ -344,9 +344,9 @@ namespace test  {
             runner.maybeRun (unit);
             bool emergency = runner.wait();
             
-            ASSERT (emergency);      // emergency state got propagated
-            ASSERT (!unit.isRunning());
-            ASSERT (unit.didRun());
+            CHECK (emergency);      // emergency state got propagated
+            CHECK (!unit.isRunning());
+            CHECK (unit.didRun());
           }
         
         
@@ -366,22 +366,22 @@ namespace test  {
             SubsystemRunner runner(dummyOpt);
             
             runner.maybeRun (unit4);
-            ASSERT (unit1.isRunning());
-            ASSERT (unit2.isRunning());
-            ASSERT (unit3.isRunning());
-            ASSERT (unit4.isRunning());
+            CHECK (unit1.isRunning());
+            CHECK (unit2.isRunning());
+            CHECK (unit3.isRunning());
+            CHECK (unit4.isRunning());
             
             bool emergency = runner.wait();
             
-            ASSERT (!emergency);
-            ASSERT (!unit1.isRunning());
-            ASSERT (!unit2.isRunning());
-            ASSERT (!unit3.isRunning());
-            ASSERT (!unit4.isRunning());
-            ASSERT (unit1.didRun());
-            ASSERT (unit2.didRun());
-            ASSERT (unit3.didRun());
-            ASSERT (unit4.didRun());
+            CHECK (!emergency);
+            CHECK (!unit1.isRunning());
+            CHECK (!unit2.isRunning());
+            CHECK (!unit3.isRunning());
+            CHECK (!unit4.isRunning());
+            CHECK (unit1.didRun());
+            CHECK (unit2.didRun());
+            CHECK (unit3.didRun());
+            CHECK (unit4.didRun());
           }
         
         
@@ -401,21 +401,21 @@ namespace test  {
             SubsystemRunner runner(dummyOpt);
             
             VERIFY_ERROR (LOGIC, runner.maybeRun (unit4) );   // failure to bring up prerequisites is detected
-            ASSERT ( unit1.isRunning());
-            ASSERT ( unit2.isRunning());
-            ASSERT (!unit3.isRunning());
+            CHECK ( unit1.isRunning());
+            CHECK ( unit2.isRunning());
+            CHECK (!unit3.isRunning());
             // shutdown has been triggered for unit4, but may require some time
             
             bool emergency = runner.wait();
             
-            ASSERT (!emergency);     // no problems with the subsystems actually running...
-            ASSERT (!unit1.isRunning());
-            ASSERT (!unit2.isRunning());
-            ASSERT (!unit3.isRunning());
-            ASSERT (!unit4.isRunning());
-            ASSERT ( unit1.didRun());
-            ASSERT ( unit2.didRun());
-            ASSERT (!unit3.didRun());
+            CHECK (!emergency);     // no problems with the subsystems actually running...
+            CHECK (!unit1.isRunning());
+            CHECK (!unit2.isRunning());
+            CHECK (!unit3.isRunning());
+            CHECK (!unit4.isRunning());
+            CHECK ( unit1.didRun());
+            CHECK ( unit2.didRun());
+            CHECK (!unit3.didRun());
             // can't say for sure if unit4 actually did run
           }
       };
diff --git a/tests/lib/symbol-hashtable-test.cpp b/tests/lib/symbol-hashtable-test.cpp
index 2e74f7b3c..92e7a38a2 100644
--- a/tests/lib/symbol-hashtable-test.cpp
+++ b/tests/lib/symbol-hashtable-test.cpp
@@ -1,23 +1,23 @@
 /*
   SymbolHashtable(Test)  -  building a hashtable with Symbol (id) keys
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2 of the
   License, or (at your option) any later version.
- 
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
@@ -40,23 +40,23 @@ using util::isnil;
 
 namespace lib {
 namespace test{
-  
+
   using std::string;
   using boost::hash;
-  
-  
+
+
   namespace { // test data
     Symbol KEY1 ("Key1");
     Symbol KEY2 ("Key2");
     Symbol KEY3 ("Key3");
     Symbol KEY4 ("Key4");
     Symbol KEY5 ("Key5");
-    
+
   }
-  
+
   typedef std::tr1::unordered_map< Symbol, string, hash<Symbol> > HTable;
-  
-  
+
+
   /*************************************************************
    * @test build a hashtable using Symbol objects as Keys.
    *       Especially this verifies picking up a customised
@@ -65,101 +65,101 @@ namespace test{
    */
   class SymbolHashtable_test : public Test
     {
-      
+
       void
       run (Arg)
         {
           checkHashFunction();
-          
+
           HTable table;
-          ASSERT (isnil(table));
-          
+          CHECK (isnil(table));
+
           table[KEY1] = string (KEY1);
           table[KEY2] = string (KEY2);
           table[KEY3] = string (KEY3);
           table[KEY4] = string (KEY4);
-          
-          ASSERT (!isnil(table));
-          ASSERT (4 == table.size());
-          ASSERT (contains (table, KEY1));
-          ASSERT (contains (table, KEY2));
-          ASSERT (contains (table, KEY3));
-          ASSERT (contains (table, KEY4));
-          ASSERT (!contains (table, KEY5));
-          
-          ASSERT (string (KEY1) == table[KEY1]);
-          ASSERT (string (KEY2) == table[KEY2]);
-          ASSERT (string (KEY3) == table[KEY3]);
-          ASSERT (string (KEY4) == table[KEY4]);
-          
-          table[KEY3] += "..."; 
-          ASSERT (string(KEY3)       != table[KEY3]);
-          ASSERT (string(KEY3)+"..." == table[KEY3]);
-          
-          ASSERT (isnil (table[KEY5])); // adds a new empty value object as side effect
-          ASSERT (5 == table.size());
+
+          CHECK (!isnil(table));
+          CHECK (4 == table.size());
+          CHECK (contains (table, KEY1));
+          CHECK (contains (table, KEY2));
+          CHECK (contains (table, KEY3));
+          CHECK (contains (table, KEY4));
+          CHECK (!contains (table, KEY5));
+
+          CHECK (string (KEY1) == table[KEY1]);
+          CHECK (string (KEY2) == table[KEY2]);
+          CHECK (string (KEY3) == table[KEY3]);
+          CHECK (string (KEY4) == table[KEY4]);
+
+          table[KEY3] += "...";
+          CHECK (string(KEY3)       != table[KEY3]);
+          CHECK (string(KEY3)+"..." == table[KEY3]);
+
+          CHECK (isnil (table[KEY5])); // adds a new empty value object as side effect
+          CHECK (5 == table.size());
         }
-      
-      
+
+
       void
       checkHashFunction()
         {
           string random = randStr(STRING_MAX_RELEVANT+1);
-          
+
           string copy1(random);
           copy1[5] = '\0';      // truncate the c-String to 5 chars
-          
-          string copy2(random);           
+
+          string copy2(random);
           copy2[rand() % STRING_MAX_RELEVANT] = '*';  // modify a random position
-          
+
           string copy3(copy2);
           copy3[STRING_MAX_RELEVANT]          = '*';  // modify behind observation limit
-          
+
           Symbol  l0;
           Literal l51 (copy1.c_str());
           Literal l52 (random.substr(0,5).c_str());
-          
+
           Literal l_1 (random.c_str());
           Literal l_2 (copy2.c_str());
           Literal l_3 (copy3.c_str());
-          
-          ASSERT (isnil (l0));
-          ASSERT (l0  != l51);
-          ASSERT (l51 == l52);
-          
-          ASSERT (l51 != l_1);
-          ASSERT (l_1 != l_2);
-          ASSERT (l_2 == l_3);  // difference not detected due to observation limit...
-          ASSERT (!std::strncmp (l_2, l_3, STRING_MAX_RELEVANT  ));
-          ASSERT ( std::strncmp (l_2, l_3, STRING_MAX_RELEVANT+1));
-          
+
+          CHECK (isnil (l0));
+          CHECK (l0  != l51);
+          CHECK (l51 == l52);
+
+          CHECK (l51 != l_1);
+          CHECK (l_1 != l_2);
+          CHECK (l_2 == l_3);  // difference not detected due to observation limit...
+          CHECK (!std::strncmp (l_2, l_3, STRING_MAX_RELEVANT  ));
+          CHECK ( std::strncmp (l_2, l_3, STRING_MAX_RELEVANT+1));
+
           size_t h0   = hash_value (l0);
           size_t h51  = hash_value (l51);
           size_t h52  = hash_value (l52);
           size_t h_1  = hash_value (l_1);
           size_t h_2  = hash_value (l_2);
           size_t h_3  = hash_value (l_3);
-          
-          ASSERT (h0  == 0);
-          ASSERT (h51 != 0);
-          ASSERT (h52 != 0);
-          ASSERT (h_1 != 0);
-          ASSERT (h_2 != 0);
-          ASSERT (h_3 != 0);
-          
-          ASSERT (h51 == h52);    // verify the hash function indeed stops at '\0'
-          ASSERT (h51 != h_1);    // share a common prefix, but the hash differs
-          ASSERT (h_1 != h_2);    // the single random modification is detected
-          ASSERT (h_2 == h_3);    // because l_2 and l_3 differ behind the fixed observation limit
-          
-          ASSERT (h_1 == hash_value (l_1)); //reproducible
-          ASSERT (h_2 == hash_value (l_2));
-          ASSERT (h_3 == hash_value (l_3));
+
+          CHECK (h0  == 0);
+          CHECK (h51 != 0);
+          CHECK (h52 != 0);
+          CHECK (h_1 != 0);
+          CHECK (h_2 != 0);
+          CHECK (h_3 != 0);
+
+          CHECK (h51 == h52);    // verify the hash function indeed stops at '\0'
+          CHECK (h51 != h_1);    // share a common prefix, but the hash differs
+          CHECK (h_1 != h_2);    // the single random modification is detected
+          CHECK (h_2 == h_3);    // because l_2 and l_3 differ behind the fixed observation limit
+
+          CHECK (h_1 == hash_value (l_1)); //reproducible
+          CHECK (h_2 == hash_value (l_2));
+          CHECK (h_3 == hash_value (l_3));
         }
     };
-  
+
   LAUNCHER (SymbolHashtable_test, "function common");
-  
-  
+
+
 }} // namespace lib::test
 
diff --git a/tests/lib/symbol-test.cpp b/tests/lib/symbol-test.cpp
index 0da7699fa..cedf77ca4 100644
--- a/tests/lib/symbol-test.cpp
+++ b/tests/lib/symbol-test.cpp
@@ -68,20 +68,20 @@ namespace test{
           
           cout << li1 << endl;
           cout << showSizeof(li1) << endl;
-          ASSERT (sizeof(Literal) == sizeof(char*));
+          CHECK (sizeof(Literal) == sizeof(char*));
           
-          ASSERT (li1 == li2);
-          ASSERT (!isSameObject (li1,li2));
-          ASSERT (li1 != li3);
-          ASSERT (li2 != li3);
-          ASSERT (li3 != li2);
+          CHECK (li1 == li2);
+          CHECK (!isSameObject (li1,li2));
+          CHECK (li1 != li3);
+          CHECK (li2 != li3);
+          CHECK (li3 != li2);
           
           cout << showType(li1 + string("ce"))         << endl;
           cout << showType(string("minus " +li1))      << endl;
           cout << li2+string("..") << string("..")+li2 << endl;
           
-          ASSERT (hash_value(li1) == hash_value(li2));
-          ASSERT (hash_value(li2) != hash_value(li3));
+          CHECK (hash_value(li1) == hash_value(li2));
+          CHECK (hash_value(li2) != hash_value(li3));
         }
       
       
@@ -91,11 +91,11 @@ namespace test{
           Literal nn1 (0);
           Literal nn2 ("");
           
-          ASSERT (isnil (nn1));
-          ASSERT (isnil (nn2));
+          CHECK (isnil (nn1));
+          CHECK (isnil (nn2));
           
           Literal nnn (" ");
-          ASSERT (!isnil (nnn));
+          CHECK (!isnil (nnn));
         }
       
       
@@ -106,17 +106,17 @@ namespace test{
           Symbol sy1("1");
           Symbol sy2(l1);
           
-          ASSERT (sy1 == sy2);
-          ASSERT (!isSameObject (l1,sy1));
-          ASSERT (!isSameObject (sy1,sy2));
+          CHECK (sy1 == sy2);
+          CHECK (!isSameObject (l1,sy1));
+          CHECK (!isSameObject (sy1,sy2));
           
           Symbol sy3;
-          ASSERT (isnil(sy3));
-          ASSERT (sy1 != sy3);
+          CHECK (isnil(sy3));
+          CHECK (sy1 != sy3);
           
           sy3 = l1;
-          ASSERT (!isnil(sy3));
-          ASSERT (sy1 == sy3);
+          CHECK (!isnil(sy3));
+          CHECK (sy1 == sy3);
           
           TODO ("real functionality of Symbol data type");
         }
diff --git a/tests/lib/sync-classlock-test.cpp b/tests/lib/sync-classlock-test.cpp
index 585fff8d9..24430d7a4 100644
--- a/tests/lib/sync-classlock-test.cpp
+++ b/tests/lib/sync-classlock-test.cpp
@@ -81,11 +81,11 @@ namespace test {
           {
             Probe objs[NUM_INSTANCES];
             
-            ASSERT (1 == objs[0].shared_lock_.use_count());
+            CHECK (1 == objs[0].shared_lock_.use_count());
           }
           
           ClassLock<Probe> get_class_lock;
-          ASSERT ( 1 ==  get_class_lock.use_count()); // embedded PerClassMonitor<Probe> got created exactly once
+          CHECK ( 1 ==  get_class_lock.use_count()); // embedded PerClassMonitor<Probe> got created exactly once
         }                                            //  and stays alive until static dtors are called....
       
     };
diff --git a/tests/lib/sync-locking-test.cpp b/tests/lib/sync-locking-test.cpp
index 9b4de03f9..8ed1d9bbc 100644
--- a/tests/lib/sync-locking-test.cpp
+++ b/tests/lib/sync-locking-test.cpp
@@ -138,7 +138,7 @@ namespace test{
                    , bind (&HavocThread::doIt, this)
                    )
           {
-            ASSERT (thread_);
+            CHECK (thread_);
           }
         
         ~HavocThread ()
diff --git a/tests/lib/sync-timedwait-test.cpp b/tests/lib/sync-timedwait-test.cpp
index b204689ab..cb1565d37 100644
--- a/tests/lib/sync-timedwait-test.cpp
+++ b/tests/lib/sync-timedwait-test.cpp
@@ -1,23 +1,23 @@
 /*
   SyncTimedwait(Test)  -  check the monitor object based timed condition wait
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2 of the
   License, or (at your option) any later version.
- 
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
@@ -34,105 +34,105 @@ using test::Test;
 
 namespace lib {
 namespace test{
-  
+
   namespace { // private test classes and data...
-    
+
     const uint WAIT_mSec = 200;   ///< milliseconds to wait before timeout
-    
+
   } // (End) test classes and data....
-  
-  
-  
-  
-  
-  
-  
-  
-  
-  
+
+
+
+
+
+
+
+
+
+
   /********************************************************************************
    * @test timeout feature on condition wait as provided by pthread and accessible
    *       via the object monitor based locking/waiting mechanism. Without creating
    *       multiple threads, we engage into a blocking wait, which aborts due to
    *       setting a timeout. (Note it is discouraged to use the timed wait feature;
    *       when possible, you should prefer relying on the Lumiera scheduler)
-   * 
+   *
    * @see SyncWaiting_test
    * @see sync::Timeout
    * @see sync.hpp
    */
-  class SyncTimedwait_test 
+  class SyncTimedwait_test
     : public Test,
       Sync<RecursiveLock_Waitable>
     {
-      
+
       friend class Lock; // allows inheriting privately from Sync
-      
-      
+
+
       virtual void
       run (Arg)
         {
           checkTimeoutStruct();
-          
+
           Lock block(this, &SyncTimedwait_test::neverHappens);
-          
+
           cout << "back from LaLaLand, alive and thriving!\n";
-          ASSERT (block.isTimedWait());
+          CHECK (block.isTimedWait());
         }
-      
-      
+
+
       bool
       neverHappens()                              ///< the "condition test" used for waiting....
         {
           Lock currentLock(this);                 // get the Lock recursively
           if (!currentLock.isTimedWait())         // right from within the condition test:
             currentLock.setTimeout(WAIT_mSec);    // switch waiting mode to timed wait and set timeout
-          
-          return false; 
+
+          return false;
         }
-      
-      
-      
+
+
+
       void
       checkTimeoutStruct()
         {
           sync::Timeout tout;
-          
-          ASSERT (!tout);
-          ASSERT (0 == tout.tv_sec);
-          ASSERT (0 == tout.tv_nsec);
-          
+
+          CHECK (!tout);
+          CHECK (0 == tout.tv_sec);
+          CHECK (0 == tout.tv_nsec);
+
           tout.setOffset (0);
-          ASSERT (!tout);
-          ASSERT (0 == tout.tv_sec);
-          ASSERT (0 == tout.tv_nsec);
-          
+          CHECK (!tout);
+          CHECK (0 == tout.tv_sec);
+          CHECK (0 == tout.tv_nsec);
+
           timespec ref;
           clock_gettime(CLOCK_REALTIME, &ref);
           tout.setOffset (1);
-          ASSERT (tout);
-          ASSERT (0 < tout.tv_sec);
-          ASSERT (ref.tv_sec <= tout.tv_sec);
-          ASSERT (ref.tv_nsec <= 1000000 + tout.tv_nsec || ref.tv_nsec > 1000000000-100000);
-          
+          CHECK (tout);
+          CHECK (0 < tout.tv_sec);
+          CHECK (ref.tv_sec <= tout.tv_sec);
+          CHECK (ref.tv_nsec <= 1000000 + tout.tv_nsec || ref.tv_nsec > 1000000000-100000);
+
           clock_gettime(CLOCK_REALTIME, &ref);
           tout.setOffset (1000);
-          ASSERT (tout);
+          CHECK (tout);
           if (ref.tv_nsec!=0) // should have gotten an overflow to the seconds part
             {
-              ASSERT (ref.tv_sec <= 2 + tout.tv_sec );
-              ASSERT ((ref.tv_nsec +  1000000 * 999) % 1000000000 
+              CHECK (ref.tv_sec <= 2 + tout.tv_sec );
+              CHECK ((ref.tv_nsec +  1000000 * 999) % 1000000000
                                  <= tout.tv_nsec);
             }
         }
-      
+
     };
-  
-  
-  
+
+
+
   /** Register this test class... */
   LAUNCHER (SyncTimedwait_test, "unit common");
-  
-  
-  
+
+
+
 }} // namespace lib::test
diff --git a/tests/lib/sync-waiting-test.cpp b/tests/lib/sync-waiting-test.cpp
index 154b54979..2a16ae02b 100644
--- a/tests/lib/sync-waiting-test.cpp
+++ b/tests/lib/sync-waiting-test.cpp
@@ -157,9 +157,9 @@ namespace test{
           Thread ping ("SyncWaiting ping", bind (&Token::getIt, &tok));
           Thread pong ("SyncWaiting pong", bind (&Token::getIt, &tok));
           
-          ASSERT (ping);
-          ASSERT (pong);
-          ASSERT (0 == tok.result());
+          CHECK (ping);
+          CHECK (pong);
+          CHECK (0 == tok.result());
           
           usleep (100000); // if the threads don't block correctly, they've missed their chance by now... 
           
@@ -171,7 +171,7 @@ namespace test{
           pong.join();
           ping.join();
           
-          ASSERT (2*val == tok.result());
+          CHECK (2*val == tok.result());
         }
     };
   
diff --git a/tests/lib/test/test-helper-test.cpp b/tests/lib/test/test-helper-test.cpp
index 6b782a76d..e78ef316d 100644
--- a/tests/lib/test/test-helper-test.cpp
+++ b/tests/lib/test/test-helper-test.cpp
@@ -92,9 +92,9 @@ namespace test{
           Wrmpf3 rmpf3;
           Murpf murpf;
           
-          ASSERT (1 == sizeof (rmpf1));
-          ASSERT (2 == sizeof (rmpf2));
-          ASSERT (3 == sizeof (rmpf3));
+          CHECK (1 == sizeof (rmpf1));
+          CHECK (2 == sizeof (rmpf2));
+          CHECK (3 == sizeof (rmpf3));
           
           cout << showSizeof((size_t)42, "theUniverse") << endl;
           cout << showSizeof<char>("just a char")       << endl;
@@ -116,7 +116,7 @@ namespace test{
       checkGarbageStr()
         {
           string garN = randStr(0);
-          ASSERT (0 == garN.size());
+          CHECK (0 == garN.size());
           
           typedef function<bool(string::value_type)> ChPredicate;
           ChPredicate is_OK (is_lower() || is_digit());
diff --git a/tests/lib/thread-wrapper-join-test.cpp b/tests/lib/thread-wrapper-join-test.cpp
index 0c207f930..2a5a62f8b 100644
--- a/tests/lib/thread-wrapper-join-test.cpp
+++ b/tests/lib/thread-wrapper-join-test.cpp
@@ -126,7 +126,7 @@ namespace test {
                                 , bind (&ThreadWrapperJoin_test::theAction, this, DESTRUCTION_CODE)
                                 );
           
-          ASSERT (!thread2.join().isValid() ); // can check success without throwing
+          CHECK (!thread2.join().isValid() ); // can check success without throwing
         }
     };
   
diff --git a/tests/lib/thread-wrapper-test.cpp b/tests/lib/thread-wrapper-test.cpp
index 9049fc45c..498175e4c 100644
--- a/tests/lib/thread-wrapper-test.cpp
+++ b/tests/lib/thread-wrapper-test.cpp
@@ -130,7 +130,7 @@ namespace backend {
             
             usleep (200000);  // pause 200ms for the threads to terminate.....
             
-            ASSERT (checksum.verify());
+            CHECK (checksum.verify());
           }
       };
     
diff --git a/tests/lib/time-wrapper-test.cpp b/tests/lib/time-wrapper-test.cpp
index cec91bd79..cb5d4b5e5 100644
--- a/tests/lib/time-wrapper-test.cpp
+++ b/tests/lib/time-wrapper-test.cpp
@@ -74,10 +74,10 @@ namespace test   {
           
           val += Time(2);
           val *= 2;
-          ASSERT (zero == (val - 2*(ref + Time(2))) );
+          CHECK (zero == (val - 2*(ref + Time(2))) );
           
           val = ref;
-          ASSERT (zero == (val - ref));
+          CHECK (zero == (val - ref));
         }
       
       
@@ -88,40 +88,40 @@ namespace test   {
           Time max (Time::MAX);
           Time min (Time::MIN);
           
-          ASSERT (zero == Time(0));
-          ASSERT (min < zero);
-          ASSERT (max > zero);
+          CHECK (zero == Time(0));
+          CHECK (min < zero);
+          CHECK (max > zero);
           
           Time val (ref);
-          ASSERT ( (val == ref) );
-          ASSERT (!(val != ref) );
-          ASSERT ( (val >= ref) );
-          ASSERT ( (val <= ref) );
-          ASSERT (!(val <  ref) );
-          ASSERT (!(val >  ref) );
+          CHECK ( (val == ref) );
+          CHECK (!(val != ref) );
+          CHECK ( (val >= ref) );
+          CHECK ( (val <= ref) );
+          CHECK (!(val <  ref) );
+          CHECK (!(val >  ref) );
           
           val += Time(2);
-          ASSERT (!(val == ref) );
-          ASSERT ( (val != ref) );
-          ASSERT ( (val >= ref) );
-          ASSERT (!(val <= ref) );
-          ASSERT (!(val <  ref) );
-          ASSERT ( (val >  ref) );
+          CHECK (!(val == ref) );
+          CHECK ( (val != ref) );
+          CHECK ( (val >= ref) );
+          CHECK (!(val <= ref) );
+          CHECK (!(val <  ref) );
+          CHECK ( (val >  ref) );
           
           gavl_time_t gat(val);
-          ASSERT (!(gat == ref) );
-          ASSERT ( (gat != ref) );
-          ASSERT ( (gat >= ref) );
-          ASSERT (!(gat <= ref) );
-          ASSERT (!(gat <  ref) );
-          ASSERT ( (gat >  ref) );
+          CHECK (!(gat == ref) );
+          CHECK ( (gat != ref) );
+          CHECK ( (gat >= ref) );
+          CHECK (!(gat <= ref) );
+          CHECK (!(gat <  ref) );
+          CHECK ( (gat >  ref) );
           
-          ASSERT ( (val == gat) );
-          ASSERT (!(val != gat) );
-          ASSERT ( (val >= gat) );
-          ASSERT ( (val <= gat) );
-          ASSERT (!(val <  gat) );
-          ASSERT (!(val >  gat) );
+          CHECK ( (val == gat) );
+          CHECK (!(val != gat) );
+          CHECK ( (val >= gat) );
+          CHECK ( (val <= gat) );
+          CHECK (!(val <  gat) );
+          CHECK (!(val >  gat) );
         }
       
       
@@ -134,32 +134,32 @@ namespace test   {
           int hours  = rand() % 100;
           
           Time time(millis,secs,mins,hours);
-          ASSERT (millis == time.getMillis());
-          ASSERT (secs   == time.getSecs());
-          ASSERT (mins   == time.getMins());
-          ASSERT (hours  == time.getHours());
+          CHECK (millis == time.getMillis());
+          CHECK (secs   == time.getSecs());
+          CHECK (mins   == time.getMins());
+          CHECK (hours  == time.getHours());
           cout << time << endl;
           
           Time t2(2008,0);
           cout << t2 << endl;
-          ASSERT ( 8 == t2.getMillis());
-          ASSERT ( 2 == t2.getSecs());
-          ASSERT ( 0 == t2.getMins());
-          ASSERT ( 0 == t2.getHours());
+          CHECK ( 8 == t2.getMillis());
+          CHECK ( 2 == t2.getSecs());
+          CHECK ( 0 == t2.getMins());
+          CHECK ( 0 == t2.getHours());
           
           Time t3(2008,88);
           cout << t3 << endl;
-          ASSERT ( 8 == t3.getMillis());
-          ASSERT (30 == t3.getSecs());
-          ASSERT ( 1 == t3.getMins());
-          ASSERT ( 0 == t3.getHours());
+          CHECK ( 8 == t3.getMillis());
+          CHECK (30 == t3.getSecs());
+          CHECK ( 1 == t3.getMins());
+          CHECK ( 0 == t3.getHours());
           
           Time t4(2008,118,58);
           cout << t4 << endl;
-          ASSERT ( 8 == t4.getMillis());
-          ASSERT ( 0 == t4.getSecs());
-          ASSERT ( 0 == t4.getMins());
-          ASSERT ( 1 == t4.getHours());
+          CHECK ( 8 == t4.getMillis());
+          CHECK ( 0 == t4.getSecs());
+          CHECK ( 0 == t4.getMins());
+          CHECK ( 1 == t4.getHours());
         }
       
     };
diff --git a/tests/lib/typed-allocation-manager-test.cpp b/tests/lib/typed-allocation-manager-test.cpp
index 10e32b9b7..f0e701504 100644
--- a/tests/lib/typed-allocation-manager-test.cpp
+++ b/tests/lib/typed-allocation-manager-test.cpp
@@ -92,43 +92,43 @@ namespace test{
           
           typedef shared_ptr<DummyObj<1> >  PD1;
           typedef shared_ptr<DummyObj<22> > PD22;
-          ASSERT (sizeof(DummyObj<1>) != sizeof(DummyObj<22>));
+          CHECK (sizeof(DummyObj<1>) != sizeof(DummyObj<22>));
           
             {
               PD1  pD11 = allocator.create<DummyObj<1> >();
               PD1  pD12 = allocator.create<DummyObj<1> >();
               PD22 pD21 = allocator.create<DummyObj<22> >();
               PD22 pD22 = allocator.create<DummyObj<22> >();
-              ASSERT (pD11);
-              ASSERT (pD12);
-              ASSERT (pD21);
-              ASSERT (pD22);
-              ASSERT (1 == pD11.use_count());
-              ASSERT (1 == pD12.use_count());
-              ASSERT (1 == pD21.use_count());
-              ASSERT (1 == pD22.use_count());
-              ASSERT (!isSameObject (*pD11, *pD12));
-              ASSERT (!isSameObject (*pD11, *pD21));
-              ASSERT (!isSameObject (*pD11, *pD22));
-              ASSERT (!isSameObject (*pD12, *pD21));
-              ASSERT (!isSameObject (*pD12, *pD22));
-              ASSERT (!isSameObject (*pD21, *pD22));
+              CHECK (pD11);
+              CHECK (pD12);
+              CHECK (pD21);
+              CHECK (pD22);
+              CHECK (1 == pD11.use_count());
+              CHECK (1 == pD12.use_count());
+              CHECK (1 == pD21.use_count());
+              CHECK (1 == pD22.use_count());
+              CHECK (!isSameObject (*pD11, *pD12));
+              CHECK (!isSameObject (*pD11, *pD21));
+              CHECK (!isSameObject (*pD11, *pD22));
+              CHECK (!isSameObject (*pD12, *pD21));
+              CHECK (!isSameObject (*pD12, *pD22));
+              CHECK (!isSameObject (*pD21, *pD22));
               
               PD22 pD2x = pD21;
-              ASSERT (pD2x);
-              ASSERT (2 == pD21.use_count());
-              ASSERT (2 == pD2x.use_count());
-              ASSERT (isSameObject (*pD21, *pD2x));
+              CHECK (pD2x);
+              CHECK (2 == pD21.use_count());
+              CHECK (2 == pD2x.use_count());
+              CHECK (isSameObject (*pD21, *pD2x));
               
-              ASSERT (2 == allocator.numSlots<DummyObj<1> >());
-              ASSERT (2 == allocator.numSlots<DummyObj<22> >());
+              CHECK (2 == allocator.numSlots<DummyObj<1> >());
+              CHECK (2 == allocator.numSlots<DummyObj<22> >());
               
-              ASSERT (0 == allocator.numSlots<long>()); // query just some unrelated type...
+              CHECK (0 == allocator.numSlots<long>()); // query just some unrelated type...
             }
           
-          ASSERT (0 == allocator.numSlots<DummyObj<1> >());
-          ASSERT (0 == allocator.numSlots<DummyObj<22> >());
-          ASSERT (0 == checksum_);
+          CHECK (0 == allocator.numSlots<DummyObj<1> >());
+          CHECK (0 == allocator.numSlots<DummyObj<22> >());
+          CHECK (0 == checksum_);
         }
     };
   
diff --git a/tests/lib/typed-counter-test.cpp b/tests/lib/typed-counter-test.cpp
index 576bce3c3..e5bcd3e6b 100644
--- a/tests/lib/typed-counter-test.cpp
+++ b/tests/lib/typed-counter-test.cpp
@@ -321,26 +321,26 @@ namespace test{
       simpleUsageTest ()
         {
           TypedCounter myCounter;
-          ASSERT (isnil (myCounter));
-          ASSERT (0==myCounter.size());
+          CHECK (isnil (myCounter));
+          CHECK (0==myCounter.size());
           
-          ASSERT (0 == myCounter.get<short>());
-          ASSERT (1 == myCounter.size());
+          CHECK (0 == myCounter.get<short>());
+          CHECK (1 == myCounter.size());
           
-          ASSERT (0 == myCounter.get<long>());
-          ASSERT (2 == myCounter.size());
+          CHECK (0 == myCounter.get<long>());
+          CHECK (2 == myCounter.size());
           
-          ASSERT (-1 == myCounter.dec<short>());
-          ASSERT (-2 == myCounter.dec<short>());
-          ASSERT (+1 == myCounter.inc<long>());
+          CHECK (-1 == myCounter.dec<short>());
+          CHECK (-2 == myCounter.dec<short>());
+          CHECK (+1 == myCounter.inc<long>());
           
-          ASSERT (-2 == myCounter.get<short>());
-          ASSERT (+1 == myCounter.get<long>());
+          CHECK (-2 == myCounter.get<short>());
+          CHECK (+1 == myCounter.get<long>());
           
           
-          ASSERT (1 == TypedContext<TypedCounter>::ID<short>::get());
-          ASSERT (2 == TypedContext<TypedCounter>::ID<long>::get());
-          ASSERT (2 == myCounter.size());
+          CHECK (1 == TypedContext<TypedCounter>::ID<short>::get());
+          CHECK (2 == TypedContext<TypedCounter>::ID<long>::get());
+          CHECK (2 == myCounter.size());
         }
       
       
@@ -360,7 +360,7 @@ namespace test{
           testFamilies.clear(); // blocks until all threads have terminated
           
           for_each (targetCollection, accountInternal);
-          ASSERT (sum_TypedCounter_ == sum_internal_);
+          CHECK (sum_TypedCounter_ == sum_internal_);
         }
     };
   
diff --git a/tests/lib/util-foreach-test.cpp b/tests/lib/util-foreach-test.cpp
index 44ed644fd..9ffa6b790 100644
--- a/tests/lib/util-foreach-test.cpp
+++ b/tests/lib/util-foreach-test.cpp
@@ -150,13 +150,13 @@ namespace test {
           check_existence_quant (container);
           check_existence_quant (iterator);
           
-          ASSERT (int(NUM_ELMS) ==container[0]);
+          CHECK (int(NUM_ELMS) ==container[0]);
           
           check_ref_argument_bind (container);
-          ASSERT (int(NUM_ELMS) ==container[0]);
+          CHECK (int(NUM_ELMS) ==container[0]);
           
           check_ref_argument_bind (iterator);
-          ASSERT (60+int(NUM_ELMS) ==container[0]);
+          CHECK (60+int(NUM_ELMS) ==container[0]);
           // changes got propagated through the iterator
           
           check_wrapped_container_passing(container);
@@ -354,10 +354,10 @@ namespace test {
           
           for_each (coll, var(sum) += _1_ );
           
-          ASSERT (sum == (NUM_ELMS+1) * NUM_ELMS/2);
+          CHECK (sum == (NUM_ELMS+1) * NUM_ELMS/2);
           
-          ASSERT (!and_all  (coll, _1_ - 1 ));
-          ASSERT ( has_any  (coll, _1_ + 1 ));
+          CHECK (!and_all  (coll, _1_ - 1 ));
+          CHECK ( has_any  (coll, _1_ + 1 ));
         }
       
       
@@ -369,12 +369,12 @@ namespace test {
         {
           ANNOUNCE (check_existence_quant);
           
-          ASSERT ( and_all (coll, 0 < _1_ ));
-          ASSERT (!and_all (coll, 1 < _1_ ));
+          CHECK ( and_all (coll, 0 < _1_ ));
+          CHECK (!and_all (coll, 1 < _1_ ));
           
-          ASSERT ( has_any (coll, 0 < _1_ ));
-          ASSERT ( has_any (coll, _1_ >= NUM_ELMS ));
-          ASSERT (!has_any (coll, _1_ >  NUM_ELMS ));
+          CHECK ( has_any (coll, 0 < _1_ ));
+          CHECK ( has_any (coll, _1_ >= NUM_ELMS ));
+          CHECK (!has_any (coll, _1_ >  NUM_ELMS ));
         }
       
       
@@ -443,7 +443,7 @@ namespace test {
           
           SHOW_CONTAINER
           // indeed got modifications into the original container!
-          ASSERT (0 == counter);
+          CHECK (0 == counter);
           
           // passing anonymous temporary
           for_each (buildTestNumberz(NUM_ELMS), _1_ = var(counter)-- );
@@ -455,8 +455,8 @@ namespace test {
           
           // both didn't influence the original container
           SHOW_CONTAINER
-          ASSERT (-2*int(NUM_ELMS)   == counter);
-          ASSERT (bySmartPtr->back() == counter+1);
+          CHECK (-2*int(NUM_ELMS)   == counter);
+          CHECK (bySmartPtr->back() == counter+1);
           
           // passing by pointer is also possible
           const VecI * const passByConstPointer (&coll);
diff --git a/tests/lib/vectortransfertest.cpp b/tests/lib/vectortransfertest.cpp
index f165f2ece..59a35b0c2 100644
--- a/tests/lib/vectortransfertest.cpp
+++ b/tests/lib/vectortransfertest.cpp
@@ -1,23 +1,23 @@
 /*
   VectorTransfer(Test)  -  intercept object copying when a STL vector grows
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2 of the
   License, or (at your option) any later version.
- 
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
@@ -33,13 +33,13 @@
 
 namespace lib {
   namespace test {
-    
+
     using ::Test;
     using std::vector;
     using std::cout;
-    
+
     namespace { // extending the Dummy for our special purpose....
-    
+
       class TransDummy
         : public Dummy
         {
@@ -47,72 +47,72 @@ namespace lib {
           TransDummy()
             {
               TRACE  (test, "CTOR      TransDummy() --> this=%p", this);
-              setVal(0); // we use val_==0 to mark the "empty" state 
+              setVal(0); // we use val_==0 to mark the "empty" state
             }
-          
+
           ~TransDummy()
             {
               TRACE  (test, "DTOR     ~TransDummy()  this=%p", this);
             }
-          
+
           /* to make Dummy usable within vector, we need to provide
            * \em special copy operations, an operator bool() and
            * a transfer_control friend function to be used by
            * our special allocator.
            */
-          
+
           TransDummy (const TransDummy& o)
             : Dummy()
             {
               TRACE  (test, "COPY-ctor TransDummy( ref=%p ) --> this=%p", &o,this);
-              ASSERT (!o, "protocol violation: real copy operations inhibited");
+              CHECK (!o, "protocol violation: real copy operations inhibited");
             }
-          
+
           TransDummy&
           operator= (TransDummy const& ref)
             {
               TRACE  (test, "COPY      target=%p   <-- source=%p", this,&ref);
-              ASSERT (!(*this));
-              ASSERT (!ref, "protocol violation: real copy operations inhibited");
+              CHECK (!(*this));
+              CHECK (!ref, "protocol violation: real copy operations inhibited");
               return *this;
             }
-          
+
           void
           setup (int x=0)
             {
               setVal (x? x : (rand() % 10000));
               TRACE  (test, "CREATE    val=%d ---> this=%p", getVal(),this);
             }
-          
-          
+
+
           // define implicit conversion to "bool" the naive way...
           operator bool()  const
             {
               return 0!=getVal();
             }
-          
-          
+
+
           friend void transfer_control (TransDummy& from, TransDummy& to);
-          
+
         };
-      
-      
+
+
       void
       transfer_control (TransDummy& from, TransDummy& to)
       {
         TRACE  (test, "TRANSFER  target=%p   <-- source=%p", &to,&from);
-        ASSERT (!to, "protocol violation: target already manages another object");
+        CHECK (!to, "protocol violation: target already manages another object");
         to.setVal (from.getVal());
         from.setVal(0);
       }
-      
-      typedef Allocator_TransferNoncopyable<TransDummy> Allo; 
+
+      typedef Allocator_TransferNoncopyable<TransDummy> Allo;
       typedef vector<TransDummy, Allo> TransDummyVector;
     }
-    
-    
-    
-    
+
+
+
+
     /**********************************************************************************
      *  @test growing (re-allocating) a vector with noncopyable objects, with the
      *        help of a special Allocator and a custom \c transfer_control operation
@@ -122,41 +122,41 @@ namespace lib {
      */
     class VectorTransfer_test : public Test
       {
-        
-        virtual void 
+
+        virtual void
         run (Arg)
           {
             cout << "\n..setup table space for 2 elements\n";
             TransDummyVector table;
             table.reserve(2);
-            ASSERT (0==checksum);
-            
+            CHECK (0==checksum);
+
             cout << "\n..install one element at index[0]\n";
             table.push_back(TransDummy());
-            ASSERT (0==checksum);
-            
+            CHECK (0==checksum);
+
             table[0].setup(); // switches into "managed" state
-            ASSERT (0 < checksum);
+            CHECK (0 < checksum);
             int theSum = checksum;
-            
+
             cout << "\n..*** resize table to 5 elements\n";
             table.resize(5);
-            ASSERT (theSum==checksum);
-            
+            CHECK (theSum==checksum);
+
             cout << "\n..install another element\n";
             table[3].setup(375);
-            ASSERT (theSum+375==checksum);
-            
+            CHECK (theSum+375==checksum);
+
             cout << "\n..kill all elements....\n";
             table.clear();
-            ASSERT (0==checksum); 
+            CHECK (0==checksum);
           }
-        
+
       };
-    
+
     LAUNCHER (VectorTransfer_test, "unit common");
-    
-    
+
+
   }// namespace test
 
 } // namespace lib

From 518f4bac1a303cbdee49d6222c835f2069afb2cc Mon Sep 17 00:00:00 2001
From: Stefan Kangas <skangas@skangas.se>
Date: Fri, 10 Dec 2010 03:00:17 +0100
Subject: [PATCH 23/28] Use CHECK instead of REQUIRE in test suite.  (Ticket
 #250)

---
 tests/backend/test-fileheader.c               |  2 +-
 tests/backend/test-resourcecollector.c        |  2 +-
 tests/common/test-config.c                    | 72 +++++++++----------
 .../session/session-element-tracker-test.cpp  |  2 +-
 tests/lib/del-stash-test.cpp                  |  2 +-
 tests/lib/subsystem-runner-test.cpp           |  8 +--
 tests/lib/sync-locking-test.cpp               |  2 +-
 tests/lib/typed-allocation-manager-test.cpp   |  2 +-
 tests/lib/visitingtoolconcept.cpp             |  2 +-
 9 files changed, 47 insertions(+), 47 deletions(-)

diff --git a/tests/backend/test-fileheader.c b/tests/backend/test-fileheader.c
index 5b206c7da..ca14b545a 100644
--- a/tests/backend/test-fileheader.c
+++ b/tests/backend/test-fileheader.c
@@ -56,7 +56,7 @@ TEST (create_nowrite)
 {
   lumiera_backend_init ();
   LumieraFile file = lumiera_file_new (",tmp-fileheader", LUMIERA_FILE_READONLY);
-  REQUIRE(file);
+  CHECK(file);
 
   LUMIERA_FILE_RDLOCK_SECTION (NOBUG_ON, file)
     {
diff --git a/tests/backend/test-resourcecollector.c b/tests/backend/test-resourcecollector.c
index f0d0f5dda..d555eb282 100644
--- a/tests/backend/test-resourcecollector.c
+++ b/tests/backend/test-resourcecollector.c
@@ -57,7 +57,7 @@ TEST (basic)
 
 TEST (memory_collection_mockup)
 {
-  REQUIRE (argv[2]);
+  CHECK (argv[2]);
   lumiera_resourcecollector_init ();
 
   lumiera_resourcecollector_register_handler (LUMIERA_RESOURCE_MEMORY, test_memory_handler, NULL);
diff --git a/tests/common/test-config.c b/tests/common/test-config.c
index f90441a8e..d89f09216 100644
--- a/tests/common/test-config.c
+++ b/tests/common/test-config.c
@@ -39,7 +39,7 @@ TEST (init)
 
 TEST (configitem_simple)
 {
-  REQUIRE (argv[2]);
+  CHECK (argv[2]);
 
   LumieraConfigitem item;
 
@@ -83,9 +83,9 @@ TEST (lookup)
 
 TEST (change_value)
 {
-  REQUIRE (argv[2]);
-  REQUIRE (argv[3]);
-  REQUIRE (argv[4]);
+  CHECK (argv[2]);
+  CHECK (argv[3]);
+  CHECK (argv[4]);
 
   const char* value;
 
@@ -112,8 +112,8 @@ TEST (change_value)
 
 TEST (basic_set_get)
 {
-  REQUIRE (argv[2]);
-  REQUIRE (argv[3]);
+  CHECK (argv[2]);
+  CHECK (argv[3]);
 
   if (!lumiera_config_set (argv[2], argv[3]))
     printf ("failure setting first time '%s%s': %s\n", argv[2], argv[3], lumiera_error ());
@@ -135,8 +135,8 @@ TEST (basic_set_get)
 
 TEST (number_get)
 {
-  REQUIRE (argv[2]);
-  REQUIRE (argv[3]);
+  CHECK (argv[2]);
+  CHECK (argv[3]);
 
   long long number = 0;
 
@@ -153,7 +153,7 @@ TEST (number_get)
 
 TEST (number_get_nodefault)
 {
-  REQUIRE (argv[2]);
+  CHECK (argv[2]);
 
   long long number = 0;
 
@@ -168,8 +168,8 @@ TEST (number_get_nodefault)
 
 TEST (number_set)
 {
-  REQUIRE (argv[2]);
-  REQUIRE (argv[3]);
+  CHECK (argv[2]);
+  CHECK (argv[3]);
 
   signed long long number = atoll (argv[3]);
 
@@ -187,8 +187,8 @@ TEST (number_set)
 
 TEST (string_get)
 {
-  REQUIRE (argv[2]);
-  REQUIRE (argv[3]);
+  CHECK (argv[2]);
+  CHECK (argv[3]);
 
   const char* string;
 
@@ -205,8 +205,8 @@ TEST (string_get)
 
 TEST (string_set)
 {
-  REQUIRE (argv[2]);
-  REQUIRE (argv[3]);
+  CHECK (argv[2]);
+  CHECK (argv[3]);
 
   if (!lumiera_config_string_set (argv[2], &argv[3]))
     printf ("failed setting string '%s=%s': %s\n", argv[2], argv[3], lumiera_error ());
@@ -223,8 +223,8 @@ TEST (string_set)
 
 TEST (word_get)
 {
-  REQUIRE (argv[2]);
-  REQUIRE (argv[3]);
+  CHECK (argv[2]);
+  CHECK (argv[3]);
 
   const char* word;
 
@@ -241,8 +241,8 @@ TEST (word_get)
 
 TEST (word_set)
 {
-  REQUIRE (argv[2]);
-  REQUIRE (argv[3]);
+  CHECK (argv[2]);
+  CHECK (argv[3]);
 
   if (!lumiera_config_word_set (argv[2], &argv[3]))
     printf ("failed setting word '%s=%s': %s\n", argv[2], argv[3], lumiera_error ());
@@ -259,7 +259,7 @@ TEST (word_set)
 
 TEST (configitem_simple_ctor_dtor)
 {
-  REQUIRE (argv[2]);
+  CHECK (argv[2]);
 
   LumieraConfigitem item;
 
@@ -271,7 +271,7 @@ TEST (configitem_simple_ctor_dtor)
 
 TEST (configitem_simple_content_check)
 {
-  REQUIRE (argv[2]);
+  CHECK (argv[2]);
 
   LumieraConfigitem item;
 
@@ -300,9 +300,9 @@ TEST (configitem_simple_content_check)
 
 TEST (wordlist_get_nth)
 {
-  REQUIRE (argv[2]);
-  REQUIRE (argv[3]);
-  REQUIRE (argv[4]);
+  CHECK (argv[2]);
+  CHECK (argv[3]);
+  CHECK (argv[4]);
 
   if (!lumiera_config_wordlist_set (argv[2], &argv[3]))
     printf ("failed setting word '%s=%s': %s\n", argv[2], argv[3], lumiera_error ());
@@ -317,9 +317,9 @@ TEST (wordlist_get_nth)
 
 TEST (wordlist_find)
 {
-  REQUIRE (argv[2]);
-  REQUIRE (argv[3]);
-  REQUIRE (argv[4]);
+  CHECK (argv[2]);
+  CHECK (argv[3]);
+  CHECK (argv[4]);
 
   if (!lumiera_config_wordlist_set (argv[2], &argv[3]))
     printf ("failed setting word '%s=%s': %s\n", argv[2], argv[3], lumiera_error ());
@@ -334,11 +334,11 @@ TEST (wordlist_find)
 
 TEST (wordlist_replace)
 {
-  REQUIRE (argv[2]);
-  REQUIRE (argv[3]);
-  REQUIRE (argv[4]);
-  REQUIRE (argv[5]);
-  REQUIRE (argv[6]);
+  CHECK (argv[2]);
+  CHECK (argv[3]);
+  CHECK (argv[4]);
+  CHECK (argv[5]);
+  CHECK (argv[6]);
 
   if (!lumiera_config_wordlist_set (argv[2], &argv[3]))
     printf ("failed setting word '%s=%s': %s\n", argv[2], argv[3], lumiera_error ());
@@ -356,10 +356,10 @@ TEST (wordlist_replace)
 
 TEST (wordlist_add)
 {
-  REQUIRE (argv[2]);
-  REQUIRE (argv[3]);
-  REQUIRE (argv[4]);
-  REQUIRE (argv[5]);
+  CHECK (argv[2]);
+  CHECK (argv[3]);
+  CHECK (argv[4]);
+  CHECK (argv[5]);
 
   if (!lumiera_config_wordlist_set (argv[2], &argv[3]))
     printf ("failed setting word '%s=%s': %s\n", argv[2], argv[3], lumiera_error ());
diff --git a/tests/components/proc/mobject/session/session-element-tracker-test.cpp b/tests/components/proc/mobject/session/session-element-tracker-test.cpp
index c7e90b96b..7561f40d4 100644
--- a/tests/components/proc/mobject/session/session-element-tracker-test.cpp
+++ b/tests/components/proc/mobject/session/session-element-tracker-test.cpp
@@ -210,7 +210,7 @@ namespace test    {
       void
       verify_cleanup (PTimeline aTimeline_in_session)
         {
-          REQUIRE (1 < aTimeline_in_session.use_count(), "test object should still be attached to session");
+          CHECK (1 < aTimeline_in_session.use_count(), "test object should still be attached to session");
           Session::current.reset();
           aTimeline_in_session->detach();              // should be a no-op and not cause any invalid access
         }
diff --git a/tests/lib/del-stash-test.cpp b/tests/lib/del-stash-test.cpp
index f09500b98..dbe325be2 100644
--- a/tests/lib/del-stash-test.cpp
+++ b/tests/lib/del-stash-test.cpp
@@ -63,7 +63,7 @@ namespace test{
         
        ~Probe()
           {
-            REQUIRE (siz == mySiz_, "using wrong type information for de-allocation");
+            CHECK (siz == mySiz_, "using wrong type information for de-allocation");
             for (uint i=0; i<siz; ++i)
               checksum -= myCrap_[i];
           }
diff --git a/tests/lib/subsystem-runner-test.cpp b/tests/lib/subsystem-runner-test.cpp
index ec827dffc..10da60ac7 100644
--- a/tests/lib/subsystem-runner-test.cpp
+++ b/tests/lib/subsystem-runner-test.cpp
@@ -112,14 +112,14 @@ namespace test  {
           bool
           start (lumiera::Option&, Subsys::SigTerm termination)
             {
-              REQUIRE (!(isUp_|started_|didRun_), "attempt to start %s twice!", cStr(*this));
+              CHECK (!(isUp_|started_|didRun_), "attempt to start %s twice!", cStr(*this));
               
               string startSpec (extractID ("start",spec_));
               CHECK (!isnil (startSpec));
               
               if ("true"==startSpec) //----simulate successful subsystem start
                 {
-                  REQUIRE (!started_);
+                  CHECK (!started_);
                    
                   Thread (id_, bind (&MockSys::run, this, termination))
                         .sync();     // run-status handshake
@@ -281,8 +281,8 @@ namespace test  {
             
             MockSys unit ("one", "start(true), run(true).");
             SubsystemRunner runner(dummyOpt);
-            REQUIRE (!unit.isRunning());
-            REQUIRE (!unit.didRun());
+            CHECK (!unit.isRunning());
+            CHECK (!unit.didRun());
             
             runner.maybeRun (unit);
             bool emergency = runner.wait();
diff --git a/tests/lib/sync-locking-test.cpp b/tests/lib/sync-locking-test.cpp
index 8ed1d9bbc..30734a759 100644
--- a/tests/lib/sync-locking-test.cpp
+++ b/tests/lib/sync-locking-test.cpp
@@ -176,7 +176,7 @@ namespace test{
       virtual void
       run (Arg)
         {
-          REQUIRE (ourVictim.checkAllEqual());
+          CHECK (ourVictim.checkAllEqual());
           {
             HavocThread threads[NUM_THREADS]   SIDEEFFECT;
           } 
diff --git a/tests/lib/typed-allocation-manager-test.cpp b/tests/lib/typed-allocation-manager-test.cpp
index f0e701504..8593c3a98 100644
--- a/tests/lib/typed-allocation-manager-test.cpp
+++ b/tests/lib/typed-allocation-manager-test.cpp
@@ -86,7 +86,7 @@ namespace test{
       virtual void
       run (Arg) 
         {
-          REQUIRE (0 == checksum_);
+          CHECK (0 == checksum_);
           
           TypedAllocationManager allocator;
           
diff --git a/tests/lib/visitingtoolconcept.cpp b/tests/lib/visitingtoolconcept.cpp
index 21effbf41..302bd3a6d 100644
--- a/tests/lib/visitingtoolconcept.cpp
+++ b/tests/lib/visitingtoolconcept.cpp
@@ -175,7 +175,7 @@ namespace lumiera
         callTrampoline (TAR& obj, TOOL& tool)
           {
             // cast down to real implementation type
-            REQUIRE (INSTANCEOF (TOOLImpl, &tool));  
+            CHECK (INSTANCEOF (TOOLImpl, &tool));  
             TOOLImpl& toolObj = static_cast<TOOLImpl&> (tool);
             
             // trigger (compile time) overload resolution

From 0fac2b6569554cb374537102eaadb8a1aa1c6f9f Mon Sep 17 00:00:00 2001
From: Stefan Kangas <skangas@skangas.se>
Date: Fri, 10 Dec 2010 03:01:38 +0100
Subject: [PATCH 24/28] Use CHECK instead of ENSURE in test suite.  (Ticket
 #250)

---
 tests/backend/test-filehandles.c      |  4 ++--
 tests/backend/test-filemmap.c         | 12 ++++++------
 tests/common/test-config.c            |  6 +++---
 tests/lib/test/cmdlinewrappertest.cpp |  4 ++--
 tests/library/test-llist.c            |  2 +-
 tests/library/test-psplay.c           |  8 ++++----
 tests/library/test-safeclib.c         |  2 +-
 7 files changed, 19 insertions(+), 19 deletions(-)

diff --git a/tests/backend/test-filehandles.c b/tests/backend/test-filehandles.c
index 351a07e4b..285fb5a2e 100644
--- a/tests/backend/test-filehandles.c
+++ b/tests/backend/test-filehandles.c
@@ -38,7 +38,7 @@ TEST ("basic")
   int fd = lumiera_file_handle_acquire (file);
 
   /* we now 'own'it and can use it */
-  ENSURE (fd > -1);
+  CHECK (fd > -1);
   printf ("got filehandle #%d\n", fd);
 
   /* put it into aging, can't use anymore */
@@ -67,7 +67,7 @@ TEST ("more")
   for (int i=0; i<100; ++i)
     {
       fds[i] = lumiera_file_handle_acquire (files[i]);
-      ENSURE (fds[i] > -1);
+      CHECK (fds[i] > -1);
       printf ("got filehandle #%d\n", fds[i]);
     }
 
diff --git a/tests/backend/test-filemmap.c b/tests/backend/test-filemmap.c
index c93e2543c..0c64d0382 100644
--- a/tests/backend/test-filemmap.c
+++ b/tests/backend/test-filemmap.c
@@ -159,7 +159,7 @@ TEST (mmap_simple)
   /* check that the file got truncated to the desired size */
   struct stat st;
   stat (",tmp-filemmap", &st);
-  ENSURE (st.st_size == 100);
+  CHECK (st.st_size == 100);
 
   lumiera_backend_destroy ();
   lumiera_config_destroy ();
@@ -179,7 +179,7 @@ TEST (mmap_checkout_twice)
 
   LumieraMMap map2 = lumiera_mmapings_mmap_acquire (mmaps, file, 0, 100);
 
-  ENSURE (map->address == map2->address);
+  CHECK (map->address == map2->address);
 
   lumiera_mmapings_release_mmap (mmaps, map);
 
@@ -190,7 +190,7 @@ TEST (mmap_checkout_twice)
   /* check that the file got truncated to the desired size */
   struct stat st;
   stat (",tmp-filemmap", &st);
-  ENSURE (st.st_size == 100);
+  CHECK (st.st_size == 100);
 
   lumiera_backend_destroy ();
   lumiera_config_destroy ();
@@ -217,7 +217,7 @@ TEST (mmap_checkout_again)
   /* check that the file got truncated to the desired size */
   struct stat st;
   stat (",tmp-filemmap", &st);
-  ENSURE (st.st_size == 100);
+  CHECK (st.st_size == 100);
 
   lumiera_backend_destroy ();
   lumiera_config_destroy ();
@@ -242,7 +242,7 @@ TEST (mmap_grow_existing_file)
   /* check that the file got truncated to the desired size */
   struct stat st;
   stat (",tmp-filemmap", &st);
-  ENSURE (st.st_size == 100);
+  CHECK (st.st_size == 100);
 
   lumiera_backend_destroy ();
   lumiera_config_destroy ();
@@ -266,7 +266,7 @@ TEST (mmap_readonly_file)
   /* check that the file got truncated to the desired size */
   struct stat st;
   stat (",tmp-filemmap", &st);
-  ENSURE (st.st_size == 100);
+  CHECK (st.st_size == 100);
 
   lumiera_backend_destroy ();
   lumiera_config_destroy ();
diff --git a/tests/common/test-config.c b/tests/common/test-config.c
index d89f09216..522eb5fee 100644
--- a/tests/common/test-config.c
+++ b/tests/common/test-config.c
@@ -44,7 +44,7 @@ TEST (configitem_simple)
   LumieraConfigitem item;
 
   item = lumiera_configitem_new (argv[2]);
-  ENSURE (item);
+  CHECK (item);
 
   printf ("line = '%s'\n", item->line);
   if (item->key)
@@ -71,10 +71,10 @@ TEST (lookup)
   lumiera_config_lookup_insert (&lookup, item);
 
   LumieraConfigitem found = lumiera_config_lookup_item_find (&lookup, "foo.bar");
-  ENSURE (found == item);
+  CHECK (found == item);
 
   lumiera_config_lookup_remove (&lookup, found);
-  ENSURE (!lumiera_config_lookup_item_find (&lookup, "foo.bar"));
+  CHECK (!lumiera_config_lookup_item_find (&lookup, "foo.bar"));
 
   lumiera_config_lookup_destroy (&lookup);
   lumiera_config_destroy ();
diff --git a/tests/lib/test/cmdlinewrappertest.cpp b/tests/lib/test/cmdlinewrappertest.cpp
index 00a016d9f..81434839a 100644
--- a/tests/lib/test/cmdlinewrappertest.cpp
+++ b/tests/lib/test/cmdlinewrappertest.cpp
@@ -71,13 +71,13 @@ namespace test {
           // consistency checks
           std::ostringstream output;
           output << theCmdline;
-          ENSURE (output.str() == string(theCmdline));
+          CHECK (output.str() == string(theCmdline));
           
           i=0;
           string token;
           std::istringstream input(theCmdline);
           while (input >> token)
-            ENSURE (token == theCmdline[i++]);
+            CHECK (token == theCmdline[i++]);
         }
       
       /** @test wrapping a (albeit faked) standard commandline
diff --git a/tests/library/test-llist.c b/tests/library/test-llist.c
index 144b77412..b9ef45a84 100644
--- a/tests/library/test-llist.c
+++ b/tests/library/test-llist.c
@@ -199,7 +199,7 @@ TEST (relocate)
   target = source;
 
   llist_relocate (&target);
-  ENSURE (llist_is_head (&target, &something));
+  CHECK (llist_is_head (&target, &something));
 }
 
 
diff --git a/tests/library/test-psplay.c b/tests/library/test-psplay.c
index 06659679d..54199f9d9 100644
--- a/tests/library/test-psplay.c
+++ b/tests/library/test-psplay.c
@@ -241,22 +241,22 @@ TEST ("insert_find")
 
   //TestItem f = (TestItem) psplay_find (&splay_tree, "baz", 100);
   TestItem f = (TestItem) psplay_find (&splay_tree, "baz", 100);
-  ENSURE (f);
+  CHECK (f);
   printf ("found %p (%.4s)\n", &f->node, f->key);
   psplay_dump (&splay_tree, stdout);
 
   f = (TestItem) psplay_find (&splay_tree, "test", 100);
-  ENSURE (f);
+  CHECK (f);
   printf ("found %p (%.4s)\n", &f->node, f->key);
   psplay_dump (&splay_tree, stdout);
 
   f = (TestItem) psplay_find (&splay_tree, "test", 100);
-  ENSURE (f);
+  CHECK (f);
   printf ("found %p (%.4s)\n", &f->node, f->key);
   psplay_dump (&splay_tree, stdout);
 
   f = (TestItem) psplay_find (&splay_tree, "foo", 100);
-  ENSURE (f);
+  CHECK (f);
   printf ("found %p (%.4s)\n", &f->node, f->key);
   psplay_dump (&splay_tree, stdout);
 
diff --git a/tests/library/test-safeclib.c b/tests/library/test-safeclib.c
index a14a73c33..ba46b172e 100644
--- a/tests/library/test-safeclib.c
+++ b/tests/library/test-safeclib.c
@@ -37,7 +37,7 @@ TEST (allocation1024)
   for (int i = 0; i < 1024; ++i)
     {
       data[i] = lumiera_malloc (1024);
-      ENSURE (data[i]);
+      CHECK (data[i]);
     }
   for (int i = 0; i < 1024; ++i)
     {

From 3f1b7651e97296ca42b07d1a8faffecf35d134dd Mon Sep 17 00:00:00 2001
From: Ichthyostega <prg@ichthyostega.de>
Date: Fri, 17 Dec 2010 23:28:49 +0100
Subject: [PATCH 25/28] GPL header whitespace

---
 src/backend/backend.c                              |  4 ++--
 src/backend/backend.h                              |  4 ++--
 src/backend/enginefacade.cpp                       | 14 +++++++-------
 src/backend/enginefacade.hpp                       | 14 +++++++-------
 src/backend/file.c                                 |  4 ++--
 src/backend/file.h                                 |  4 ++--
 src/backend/filedescriptor.c                       |  4 ++--
 src/backend/filedescriptor.h                       |  4 ++--
 src/backend/filedescriptorregistry.c               |  4 ++--
 src/backend/filedescriptorregistry.h               |  4 ++--
 src/backend/filehandle.c                           |  4 ++--
 src/backend/filehandle.h                           |  4 ++--
 src/backend/filehandlecache.c                      |  4 ++--
 src/backend/filehandlecache.h                      |  4 ++--
 src/backend/fileheader.c                           |  4 ++--
 src/backend/fileheader.h                           |  4 ++--
 src/backend/mediaaccessfacade.cpp                  | 14 +++++++-------
 src/backend/mediaaccessfacade.hpp                  | 14 +++++++-------
 src/backend/mmap.c                                 |  4 ++--
 src/backend/mmap.h                                 |  4 ++--
 src/backend/mmapcache.c                            |  4 ++--
 src/backend/mmapcache.h                            |  4 ++--
 src/backend/mmapings.c                             |  4 ++--
 src/backend/mmapings.h                             |  4 ++--
 src/backend/netnodefacade.cpp                      | 14 +++++++-------
 src/backend/netnodefacade.hpp                      | 14 +++++++-------
 src/backend/resourcecollector.c                    |  4 ++--
 src/backend/resourcecollector.h                    |  4 ++--
 src/backend/scriptrunnerfacade.cpp                 | 14 +++++++-------
 src/backend/scriptrunnerfacade.hpp                 | 14 +++++++-------
 src/backend/thread-wrapper.hpp                     | 14 +++++++-------
 src/backend/threadpool-init.cpp                    | 14 +++++++-------
 src/backend/threadpool-init.hpp                    | 14 +++++++-------
 src/backend/threadpool.c                           |  4 ++--
 src/backend/threadpool.h                           |  4 ++--
 src/backend/threads.c                              |  4 ++--
 src/backend/threads.h                              |  4 ++--
 src/common/appstate.cpp                            | 14 +++++++-------
 src/common/appstate.hpp                            | 14 +++++++-------
 src/common/config.c                                |  4 ++--
 src/common/config.h                                |  4 ++--
 src/common/config_interface.c                      |  4 ++--
 src/common/config_interface.h                      |  4 ++--
 src/common/config_lookup.c                         |  4 ++--
 src/common/config_lookup.h                         |  4 ++--
 src/common/config_typed.c                          |  4 ++--
 src/common/config_wordlist.c                       |  4 ++--
 src/common/configentry.c                           |  4 ++--
 src/common/configentry.h                           |  4 ++--
 src/common/configfacade.cpp                        | 14 +++++++-------
 src/common/configitem.c                            |  4 ++--
 src/common/configitem.h                            |  4 ++--
 src/common/configrules.cpp                         | 14 +++++++-------
 src/common/configrules.hpp                         | 14 +++++++-------
 src/common/external/libgavl.cpp                    | 14 +++++++-------
 src/common/external/libgavl.hpp                    | 14 +++++++-------
 src/common/guifacade.cpp                           | 14 +++++++-------
 src/common/instancehandle.hpp                      | 14 +++++++-------
 src/common/interface.c                             |  4 ++--
 src/common/interface.h                             |  4 ++--
 src/common/interfacedescriptor.h                   |  4 ++--
 src/common/interfaceproxy.cpp                      | 14 +++++++-------
 src/common/interfaceregistry.c                     |  4 ++--
 src/common/interfaceregistry.h                     |  4 ++--
 src/common/option.cpp                              | 14 +++++++-------
 src/common/option.hpp                              | 14 +++++++-------
 src/common/plugin.c                                |  4 ++--
 src/common/plugin.h                                |  4 ++--
 src/common/plugin_dynlib.c                         |  4 ++--
 src/common/query/fake-configrules.cpp              | 14 +++++++-------
 src/common/query/fake-configrules.hpp              | 14 +++++++-------
 src/common/subsys.cpp                              | 14 +++++++-------
 src/common/subsys.hpp                              | 14 +++++++-------
 src/common/subsystem-runner.hpp                    | 14 +++++++-------
 src/gui/controller/controller.cpp                  | 14 +++++++-------
 src/gui/controller/controller.hpp                  | 14 +++++++-------
 src/gui/controller/playback-controller.cpp         | 14 +++++++-------
 src/gui/controller/playback-controller.hpp         | 14 +++++++-------
 src/gui/dialogs/dialog.hpp                         | 14 +++++++-------
 src/gui/dialogs/name-chooser.cpp                   | 14 +++++++-------
 src/gui/dialogs/name-chooser.hpp                   | 14 +++++++-------
 src/gui/dialogs/preferences-dialog.cpp             | 14 +++++++-------
 src/gui/dialogs/preferences-dialog.hpp             | 14 +++++++-------
 src/gui/dialogs/render.cpp                         | 14 +++++++-------
 src/gui/dialogs/render.hpp                         | 14 +++++++-------
 src/gui/display-interface-proxy.hpp                | 14 +++++++-------
 src/gui/display-service.cpp                        | 14 +++++++-------
 src/gui/display-service.hpp                        | 14 +++++++-------
 src/gui/gtk-lumiera.cpp                            | 14 +++++++-------
 src/gui/gtk-lumiera.hpp                            | 14 +++++++-------
 src/gui/guifacade.hpp                              | 14 +++++++-------
 src/gui/guistart.cpp                               | 14 +++++++-------
 src/gui/model/clip-track.cpp                       | 14 +++++++-------
 src/gui/model/clip-track.hpp                       | 14 +++++++-------
 src/gui/model/clip.cpp                             | 14 +++++++-------
 src/gui/model/clip.hpp                             | 14 +++++++-------
 src/gui/model/group-track.cpp                      | 14 +++++++-------
 src/gui/model/group-track.hpp                      | 14 +++++++-------
 src/gui/model/parent-track.cpp                     | 14 +++++++-------
 src/gui/model/parent-track.hpp                     | 14 +++++++-------
 src/gui/model/project.cpp                          | 14 +++++++-------
 src/gui/model/project.hpp                          | 14 +++++++-------
 src/gui/model/sequence.cpp                         | 14 +++++++-------
 src/gui/model/sequence.hpp                         | 14 +++++++-------
 src/gui/model/track.cpp                            | 14 +++++++-------
 src/gui/model/track.hpp                            | 14 +++++++-------
 src/gui/notification-interface-proxy.hpp           | 14 +++++++-------
 src/gui/notification-service.cpp                   | 14 +++++++-------
 src/gui/notification-service.hpp                   | 14 +++++++-------
 src/gui/output/displayer.cpp                       | 14 +++++++-------
 src/gui/output/displayer.hpp                       | 14 +++++++-------
 src/gui/output/gdkdisplayer.cpp                    | 14 +++++++-------
 src/gui/output/gdkdisplayer.hpp                    | 14 +++++++-------
 src/gui/output/xvdisplayer.cpp                     | 14 +++++++-------
 src/gui/output/xvdisplayer.hpp                     | 14 +++++++-------
 src/gui/panels/panel.cpp                           | 14 +++++++-------
 src/gui/panels/panel.hpp                           | 14 +++++++-------
 src/gui/panels/resources-panel.cpp                 | 14 +++++++-------
 src/gui/panels/resources-panel.hpp                 | 14 +++++++-------
 src/gui/panels/timeline-panel.cpp                  | 14 +++++++-------
 src/gui/panels/timeline-panel.hpp                  | 14 +++++++-------
 src/gui/panels/viewer-panel.cpp                    | 14 +++++++-------
 src/gui/panels/viewer-panel.hpp                    | 14 +++++++-------
 src/gui/util/rectangle.cpp                         | 14 +++++++-------
 src/gui/util/rectangle.hpp                         | 14 +++++++-------
 src/gui/widgets/button-bar.cpp                     | 14 +++++++-------
 src/gui/widgets/button-bar.hpp                     | 14 +++++++-------
 src/gui/widgets/menu-button.cpp                    | 14 +++++++-------
 src/gui/widgets/menu-button.hpp                    | 14 +++++++-------
 src/gui/widgets/mini-button.hpp                    | 14 +++++++-------
 src/gui/widgets/panel-bar.cpp                      | 14 +++++++-------
 src/gui/widgets/panel-bar.hpp                      | 14 +++++++-------
 src/gui/widgets/timeline-widget.cpp                | 14 +++++++-------
 src/gui/widgets/timeline-widget.hpp                | 14 +++++++-------
 src/gui/widgets/timeline/timeline-arrow-tool.cpp   | 14 +++++++-------
 src/gui/widgets/timeline/timeline-arrow-tool.hpp   | 14 +++++++-------
 src/gui/widgets/timeline/timeline-body.cpp         | 14 +++++++-------
 src/gui/widgets/timeline/timeline-body.hpp         | 14 +++++++-------
 src/gui/widgets/timeline/timeline-clip-track.cpp   | 14 +++++++-------
 src/gui/widgets/timeline/timeline-clip-track.hpp   | 14 +++++++-------
 src/gui/widgets/timeline/timeline-clip.cpp         | 14 +++++++-------
 src/gui/widgets/timeline/timeline-clip.hpp         | 14 +++++++-------
 src/gui/widgets/timeline/timeline-group-track.cpp  | 14 +++++++-------
 src/gui/widgets/timeline/timeline-group-track.hpp  | 14 +++++++-------
 .../widgets/timeline/timeline-header-container.cpp | 14 +++++++-------
 .../widgets/timeline/timeline-header-container.hpp | 14 +++++++-------
 .../widgets/timeline/timeline-header-widget.cpp    | 14 +++++++-------
 .../widgets/timeline/timeline-header-widget.hpp    | 14 +++++++-------
 src/gui/widgets/timeline/timeline-ibeam-tool.cpp   | 14 +++++++-------
 src/gui/widgets/timeline/timeline-ibeam-tool.hpp   | 14 +++++++-------
 .../widgets/timeline/timeline-layout-helper.cpp    | 14 +++++++-------
 .../widgets/timeline/timeline-layout-helper.hpp    | 14 +++++++-------
 src/gui/widgets/timeline/timeline-ruler.cpp        | 14 +++++++-------
 src/gui/widgets/timeline/timeline-ruler.hpp        | 14 +++++++-------
 src/gui/widgets/timeline/timeline-state.cpp        | 14 +++++++-------
 src/gui/widgets/timeline/timeline-state.hpp        | 14 +++++++-------
 src/gui/widgets/timeline/timeline-tool.cpp         | 14 +++++++-------
 src/gui/widgets/timeline/timeline-tool.hpp         | 14 +++++++-------
 src/gui/widgets/timeline/timeline-track.cpp        | 14 +++++++-------
 src/gui/widgets/timeline/timeline-track.hpp        | 14 +++++++-------
 src/gui/widgets/timeline/timeline-view-window.cpp  | 14 +++++++-------
 src/gui/widgets/timeline/timeline-view-window.hpp  | 14 +++++++-------
 src/gui/widgets/video-display-widget.cpp           | 14 +++++++-------
 src/gui/widgets/video-display-widget.hpp           | 14 +++++++-------
 src/gui/window-manager.cpp                         | 14 +++++++-------
 src/gui/window-manager.hpp                         | 14 +++++++-------
 src/gui/workspace/actions.cpp                      | 14 +++++++-------
 src/gui/workspace/actions.hpp                      | 14 +++++++-------
 src/gui/workspace/panel-manager.cpp                | 14 +++++++-------
 src/gui/workspace/panel-manager.hpp                | 14 +++++++-------
 src/gui/workspace/workspace-window.cpp             | 14 +++++++-------
 src/gui/workspace/workspace-window.hpp             | 14 +++++++-------
 src/include/configfacade.hpp                       | 14 +++++++-------
 src/include/display-facade.h                       | 14 +++++++-------
 src/include/display-handles.h                      | 14 +++++++-------
 src/include/dummy-player-facade.h                  | 14 +++++++-------
 src/include/guinotification-facade.h               | 14 +++++++-------
 src/include/interfaceproxy.hpp                     | 14 +++++++-------
 src/include/lifecycle.h                            | 14 +++++++-------
 src/include/logging.h                              |  4 ++--
 src/lib/access-casted.hpp                          | 14 +++++++-------
 src/lib/advice.hpp                                 | 14 +++++++-------
 src/lib/advice/advice.cpp                          | 14 +++++++-------
 src/lib/advice/binding.cpp                         | 14 +++++++-------
 src/lib/advice/binding.hpp                         | 14 +++++++-------
 src/lib/advice/index.hpp                           | 14 +++++++-------
 src/lib/allocationcluster.cpp                      | 14 +++++++-------
 src/lib/allocationcluster.hpp                      | 14 +++++++-------
 src/lib/bool-checkable.hpp                         | 14 +++++++-------
 src/lib/cmdline.cpp                                | 14 +++++++-------
 src/lib/cmdline.hpp                                | 14 +++++++-------
 src/lib/condition.c                                |  4 ++--
 src/lib/condition.h                                |  4 ++--
 src/lib/cuckoo.c                                   |  4 ++--
 src/lib/cuckoo.h                                   |  4 ++--
 src/lib/del-stash.hpp                              | 14 +++++++-------
 src/lib/diagnostic-context.hpp                     | 10 +++++-----
 src/lib/element-tracker.hpp                        | 14 +++++++-------
 src/lib/error.c                                    |  4 ++--
 src/lib/error.h                                    |  4 ++--
 src/lib/error.hpp                                  | 14 +++++++-------
 src/lib/exception.cpp                              | 14 +++++++-------
 src/lib/factory.hpp                                | 14 +++++++-------
 src/lib/format.hpp                                 | 14 +++++++-------
 src/lib/frameid.hpp                                | 14 +++++++-------
 src/lib/functor-util.hpp                           | 14 +++++++-------
 src/lib/handle.hpp                                 | 10 +++++-----
 src/lib/hash-indexed.hpp                           | 14 +++++++-------
 src/lib/iter-adapter-stl.hpp                       | 14 +++++++-------
 src/lib/iter-adapter.hpp                           | 14 +++++++-------
 src/lib/iter-source.hpp                            | 14 +++++++-------
 src/lib/iter-type-binding.hpp                      | 14 +++++++-------
 src/lib/itertools.hpp                              | 14 +++++++-------
 src/lib/lifecycle.cpp                              | 14 +++++++-------
 src/lib/lifecycleregistry.hpp                      | 14 +++++++-------
 src/lib/llist.h                                    |  4 ++--
 src/lib/lockerror.c                                |  4 ++--
 src/lib/lockerror.h                                |  4 ++--
 src/lib/logging.cpp                                |  4 ++--
 src/lib/luid.c                                     |  4 ++--
 src/lib/luid.h                                     |  4 ++--
 src/lib/lumitime-fmt.hpp                           | 14 +++++++-------
 src/lib/lumitime.cpp                               | 14 +++++++-------
 src/lib/lumitime.hpp                               | 14 +++++++-------
 src/lib/meta/configflags.hpp                       | 14 +++++++-------
 src/lib/meta/duck-detector.hpp                     | 14 +++++++-------
 src/lib/meta/function-closure.hpp                  | 14 +++++++-------
 src/lib/meta/function-erasure.hpp                  | 14 +++++++-------
 src/lib/meta/function.hpp                          | 14 +++++++-------
 src/lib/meta/generator.hpp                         | 10 +++++-----
 src/lib/meta/maybe-compare.hpp                     | 14 +++++++-------
 src/lib/meta/trait-special.hpp                     | 14 +++++++-------
 src/lib/meta/trait.hpp                             | 14 +++++++-------
 src/lib/meta/tuple.hpp                             | 14 +++++++-------
 src/lib/meta/typelist-util.hpp                     | 14 +++++++-------
 src/lib/meta/typelist.hpp                          | 10 +++++-----
 src/lib/meta/typeseq-util.hpp                      | 14 +++++++-------
 src/lib/meta/util.hpp                              | 14 +++++++-------
 src/lib/mpool.c                                    |  4 ++--
 src/lib/mpool.h                                    |  4 ++--
 src/lib/mrucache.c                                 |  4 ++--
 src/lib/mrucache.h                                 |  4 ++--
 src/lib/multifact-arg.hpp                          | 14 +++++++-------
 src/lib/multifact.hpp                              | 14 +++++++-------
 src/lib/mutex.c                                    |  4 ++--
 src/lib/mutex.h                                    |  4 ++--
 src/lib/nobug-init.cpp                             | 14 +++++++-------
 src/lib/nobug-init.hpp                             | 14 +++++++-------
 src/lib/null-value.hpp                             | 14 +++++++-------
 src/lib/observable-list.hpp                        | 14 +++++++-------
 src/lib/opaque-holder.hpp                          | 14 +++++++-------
 src/lib/optional-ref.hpp                           | 10 +++++-----
 src/lib/p.hpp                                      | 14 +++++++-------
 src/lib/ppmpl.h                                    |  4 ++--
 src/lib/psplay.c                                   |  4 ++--
 src/lib/psplay.h                                   |  4 ++--
 src/lib/query.cpp                                  | 14 +++++++-------
 src/lib/query.hpp                                  | 14 +++++++-------
 src/lib/reccondition.c                             |  4 ++--
 src/lib/reccondition.h                             |  4 ++--
 src/lib/recmutex.c                                 |  4 ++--
 src/lib/recmutex.h                                 |  4 ++--
 src/lib/ref-array-impl.hpp                         | 14 +++++++-------
 src/lib/ref-array.hpp                              | 14 +++++++-------
 src/lib/result.hpp                                 | 14 +++++++-------
 src/lib/rwlock.c                                   |  4 ++--
 src/lib/rwlock.h                                   |  4 ++--
 src/lib/safeclib.c                                 |  4 ++--
 src/lib/safeclib.h                                 |  4 ++--
 src/lib/scoped-holder-transfer.hpp                 | 14 +++++++-------
 src/lib/scoped-holder.hpp                          | 14 +++++++-------
 src/lib/scoped-ptrvect.hpp                         | 14 +++++++-------
 src/lib/sectionlock.h                              |  4 ++--
 src/lib/singleton-ref.hpp                          | 14 +++++++-------
 src/lib/singleton-subclass.hpp                     | 14 +++++++-------
 src/lib/singleton.hpp                              | 14 +++++++-------
 src/lib/singletonfactory.hpp                       | 10 +++++-----
 src/lib/singletonpolicies.hpp                      | 10 +++++-----
 src/lib/singletonpreconfigure.hpp                  | 14 +++++++-------
 src/lib/streamtype.cpp                             | 14 +++++++-------
 src/lib/streamtype.hpp                             | 14 +++++++-------
 src/lib/sub-id.hpp                                 | 14 +++++++-------
 src/lib/symbol-impl.cpp                            | 14 +++++++-------
 src/lib/symbol.hpp                                 | 14 +++++++-------
 src/lib/sync-classlock.hpp                         | 10 +++++-----
 src/lib/sync.hpp                                   | 10 +++++-----
 src/lib/test/mockinjector.hpp                      | 14 +++++++-------
 src/lib/test/run.hpp                               | 14 +++++++-------
 src/lib/test/suite.cpp                             | 14 +++++++-------
 src/lib/test/suite.hpp                             | 14 +++++++-------
 src/lib/test/test-coll.hpp                         | 14 +++++++-------
 src/lib/test/test-helper.cpp                       | 14 +++++++-------
 src/lib/test/test-helper.hpp                       | 14 +++++++-------
 src/lib/test/testoption.cpp                        | 14 +++++++-------
 src/lib/test/testoption.hpp                        | 14 +++++++-------
 src/lib/thread-local.hpp                           | 10 +++++-----
 src/lib/time.c                                     |  4 ++--
 src/lib/time.h                                     |  4 ++--
 src/lib/tmpbuf.c                                   |  4 ++--
 src/lib/tmpbuf.h                                   |  4 ++--
 src/lib/typed-allocation-manager.hpp               | 14 +++++++-------
 src/lib/typed-counter.hpp                          | 14 +++++++-------
 src/lib/util-foreach.hpp                           | 14 +++++++-------
 src/lib/util.cpp                                   | 14 +++++++-------
 src/lib/util.hpp                                   | 14 +++++++-------
 src/lib/variant.hpp                                | 14 +++++++-------
 src/lib/vcall.h                                    |  4 ++--
 src/lib/visitor-dispatcher.hpp                     | 14 +++++++-------
 src/lib/visitor-policies.hpp                       | 14 +++++++-------
 src/lib/visitor.hpp                                | 10 +++++-----
 src/lib/wrapper.hpp                                | 10 +++++-----
 src/lib/wrapperptr.hpp                             | 14 +++++++-------
 src/lumiera/main.cpp                               |  4 ++--
 src/pre.hpp                                        | 14 +++++++-------
 src/pre_a.hpp                                      | 14 +++++++-------
 src/proc/asset.cpp                                 | 14 +++++++-------
 src/proc/asset.hpp                                 | 14 +++++++-------
 src/proc/asset/buildinstruct.hpp                   | 14 +++++++-------
 src/proc/asset/category.cpp                        | 14 +++++++-------
 src/proc/asset/category.hpp                        | 14 +++++++-------
 src/proc/asset/clip.cpp                            | 14 +++++++-------
 src/proc/asset/clip.hpp                            | 14 +++++++-------
 src/proc/asset/codec.cpp                           | 14 +++++++-------
 src/proc/asset/codec.hpp                           | 14 +++++++-------
 src/proc/asset/compoundmedia.cpp                   | 14 +++++++-------
 src/proc/asset/compoundmedia.hpp                   | 14 +++++++-------
 src/proc/asset/dataset.hpp                         | 14 +++++++-------
 src/proc/asset/db.hpp                              | 14 +++++++-------
 src/proc/asset/effect.cpp                          | 14 +++++++-------
 src/proc/asset/effect.hpp                          | 14 +++++++-------
 src/proc/asset/entry-id.hpp                        | 14 +++++++-------
 src/proc/asset/inventory.hpp                       | 14 +++++++-------
 src/proc/asset/media.cpp                           | 14 +++++++-------
 src/proc/asset/media.hpp                           | 14 +++++++-------
 src/proc/asset/meta.cpp                            | 14 +++++++-------
 src/proc/asset/meta.hpp                            | 14 +++++++-------
 src/proc/asset/pipe.cpp                            | 14 +++++++-------
 src/proc/asset/pipe.hpp                            | 14 +++++++-------
 src/proc/asset/preview.cpp                         | 14 +++++++-------
 src/proc/asset/preview.hpp                         | 14 +++++++-------
 src/proc/asset/proc.cpp                            | 14 +++++++-------
 src/proc/asset/proc.hpp                            | 14 +++++++-------
 src/proc/asset/procpatt.cpp                        | 14 +++++++-------
 src/proc/asset/procpatt.hpp                        | 14 +++++++-------
 src/proc/asset/sequence.cpp                        | 14 +++++++-------
 src/proc/asset/sequence.hpp                        | 14 +++++++-------
 src/proc/asset/struct-factory-impl.hpp             | 14 +++++++-------
 src/proc/asset/struct-scheme.hpp                   | 14 +++++++-------
 src/proc/asset/struct.cpp                          | 14 +++++++-------
 src/proc/asset/struct.hpp                          | 14 +++++++-------
 src/proc/asset/timeline.cpp                        | 14 +++++++-------
 src/proc/asset/timeline.hpp                        | 14 +++++++-------
 src/proc/asset/typed-id.hpp                        | 14 +++++++-------
 src/proc/asset/typed-lookup.cpp                    | 14 +++++++-------
 src/proc/asset/unknown.cpp                         | 14 +++++++-------
 src/proc/asset/unknown.hpp                         | 14 +++++++-------
 src/proc/assetmanager.cpp                          | 14 +++++++-------
 src/proc/assetmanager.hpp                          | 14 +++++++-------
 src/proc/common.hpp                                | 14 +++++++-------
 src/proc/control/argument-erasure.hpp              | 14 +++++++-------
 src/proc/control/argument-tuple-accept.hpp         | 14 +++++++-------
 src/proc/control/command-argument-holder.hpp       | 14 +++++++-------
 src/proc/control/command-closure.hpp               | 14 +++++++-------
 src/proc/control/command-def.hpp                   | 14 +++++++-------
 src/proc/control/command-impl-clone-builder.hpp    | 14 +++++++-------
 src/proc/control/command-impl.cpp                  | 14 +++++++-------
 src/proc/control/command-impl.hpp                  | 14 +++++++-------
 src/proc/control/command-invocation.hpp            | 14 +++++++-------
 src/proc/control/command-mutation.hpp              | 14 +++++++-------
 src/proc/control/command-registry.hpp              | 14 +++++++-------
 src/proc/control/command-signature.hpp             | 14 +++++++-------
 src/proc/control/command.cpp                       | 14 +++++++-------
 src/proc/control/command.hpp                       | 14 +++++++-------
 src/proc/control/handling-pattern.cpp              | 14 +++++++-------
 src/proc/control/handling-pattern.hpp              | 14 +++++++-------
 src/proc/control/handling-patterns.hpp             | 14 +++++++-------
 src/proc/control/mediaimpllib.hpp                  | 14 +++++++-------
 src/proc/control/memento-tie.hpp                   | 14 +++++++-------
 src/proc/control/pathmanager.cpp                   | 14 +++++++-------
 src/proc/control/pathmanager.hpp                   | 14 +++++++-------
 src/proc/control/proc-dispatcher.cpp               | 14 +++++++-------
 src/proc/control/proc-dispatcher.hpp               | 14 +++++++-------
 src/proc/control/stypemanager.cpp                  | 14 +++++++-------
 src/proc/control/stypemanager.hpp                  | 14 +++++++-------
 src/proc/control/styperegistry.hpp                 | 14 +++++++-------
 src/proc/controllerfacade.cpp                      | 14 +++++++-------
 src/proc/controllerfacade.hpp                      | 14 +++++++-------
 src/proc/engine/buffhandle.cpp                     | 14 +++++++-------
 src/proc/engine/buffhandle.hpp                     | 14 +++++++-------
 src/proc/engine/bufftable.hpp                      | 14 +++++++-------
 src/proc/engine/link.cpp                           | 14 +++++++-------
 src/proc/engine/link.hpp                           | 14 +++++++-------
 src/proc/engine/mask.cpp                           | 14 +++++++-------
 src/proc/engine/mask.hpp                           | 14 +++++++-------
 src/proc/engine/nodefactory.cpp                    | 14 +++++++-------
 src/proc/engine/nodefactory.hpp                    | 14 +++++++-------
 src/proc/engine/nodeinvocation.hpp                 | 14 +++++++-------
 src/proc/engine/nodeoperation.hpp                  | 14 +++++++-------
 src/proc/engine/nodewiring-config.hpp              | 14 +++++++-------
 src/proc/engine/nodewiring-def.hpp                 | 14 +++++++-------
 src/proc/engine/nodewiring.cpp                     | 14 +++++++-------
 src/proc/engine/nodewiring.hpp                     | 14 +++++++-------
 src/proc/engine/pluginadapter.cpp                  | 14 +++++++-------
 src/proc/engine/pluginadapter.hpp                  | 14 +++++++-------
 src/proc/engine/procnode.hpp                       | 14 +++++++-------
 src/proc/engine/projector.cpp                      | 14 +++++++-------
 src/proc/engine/projector.hpp                      | 14 +++++++-------
 src/proc/engine/render-invocation.cpp              | 14 +++++++-------
 src/proc/engine/render-invocation.hpp              | 14 +++++++-------
 src/proc/engine/renderengine.cpp                   | 14 +++++++-------
 src/proc/engine/renderengine.hpp                   | 14 +++++++-------
 src/proc/engine/rendergraph.cpp                    | 14 +++++++-------
 src/proc/engine/rendergraph.hpp                    | 14 +++++++-------
 src/proc/engine/source.cpp                         | 14 +++++++-------
 src/proc/engine/source.hpp                         | 14 +++++++-------
 src/proc/engine/stateproxy.cpp                     | 14 +++++++-------
 src/proc/engine/stateproxy.hpp                     | 14 +++++++-------
 src/proc/engine/trafo.cpp                          | 14 +++++++-------
 src/proc/engine/trafo.hpp                          | 14 +++++++-------
 src/proc/facade.cpp                                | 14 +++++++-------
 src/proc/facade.hpp                                | 14 +++++++-------
 .../builder/applicable-builder-target-types.hpp    | 14 +++++++-------
 src/proc/mobject/builder/assembler.cpp             | 14 +++++++-------
 src/proc/mobject/builder/assembler.hpp             | 14 +++++++-------
 src/proc/mobject/builder/buildertool.hpp           | 14 +++++++-------
 src/proc/mobject/builder/common.hpp                | 14 +++++++-------
 src/proc/mobject/builder/conmanager.cpp            | 14 +++++++-------
 src/proc/mobject/builder/conmanager.hpp            | 14 +++++++-------
 .../mobject/builder/fixture-change-detector.hpp    | 14 +++++++-------
 src/proc/mobject/builder/model-port-registry.cpp   | 14 +++++++-------
 src/proc/mobject/builder/model-port-registry.hpp   | 14 +++++++-------
 src/proc/mobject/builder/mould.hpp                 | 14 +++++++-------
 src/proc/mobject/builder/nodecreatortool.cpp       | 14 +++++++-------
 src/proc/mobject/builder/nodecreatortool.hpp       | 14 +++++++-------
 src/proc/mobject/builder/operationpoint.cpp        | 14 +++++++-------
 src/proc/mobject/builder/operationpoint.hpp        | 14 +++++++-------
 src/proc/mobject/builder/renderstate.hpp           | 14 +++++++-------
 src/proc/mobject/builder/segmentation-tool.cpp     | 14 +++++++-------
 src/proc/mobject/builder/segmentation-tool.hpp     | 14 +++++++-------
 src/proc/mobject/builder/segmentation.cpp          | 14 +++++++-------
 src/proc/mobject/builder/segmentation.hpp          | 14 +++++++-------
 src/proc/mobject/builder/toolfactory.cpp           | 14 +++++++-------
 src/proc/mobject/builder/toolfactory.hpp           | 14 +++++++-------
 src/proc/mobject/builder/wiringrequest.hpp         | 14 +++++++-------
 src/proc/mobject/builderfacade.cpp                 | 14 +++++++-------
 src/proc/mobject/builderfacade.hpp                 | 14 +++++++-------
 src/proc/mobject/explicitplacement.hpp             | 14 +++++++-------
 src/proc/mobject/interpolator.cpp                  | 14 +++++++-------
 src/proc/mobject/interpolator.hpp                  | 14 +++++++-------
 src/proc/mobject/mobject-ref.cpp                   | 14 +++++++-------
 src/proc/mobject/mobject-ref.hpp                   | 14 +++++++-------
 src/proc/mobject/mobject.cpp                       | 14 +++++++-------
 src/proc/mobject/mobject.hpp                       | 14 +++++++-------
 src/proc/mobject/model-port.hpp                    | 14 +++++++-------
 src/proc/mobject/output-designation.cpp            | 14 +++++++-------
 src/proc/mobject/output-designation.hpp            | 14 +++++++-------
 src/proc/mobject/output-mapping.hpp                | 14 +++++++-------
 src/proc/mobject/parameter.cpp                     | 14 +++++++-------
 src/proc/mobject/parameter.hpp                     | 14 +++++++-------
 src/proc/mobject/paramprovider.cpp                 | 14 +++++++-------
 src/proc/mobject/paramprovider.hpp                 | 14 +++++++-------
 src/proc/mobject/placement-ref.hpp                 | 14 +++++++-------
 src/proc/mobject/placement.cpp                     | 14 +++++++-------
 src/proc/mobject/placement.hpp                     | 14 +++++++-------
 src/proc/mobject/session.hpp                       | 14 +++++++-------
 src/proc/mobject/session/abstractmo.cpp            | 14 +++++++-------
 src/proc/mobject/session/abstractmo.hpp            | 14 +++++++-------
 src/proc/mobject/session/allocation.cpp            | 14 +++++++-------
 src/proc/mobject/session/allocation.hpp            | 14 +++++++-------
 src/proc/mobject/session/auto.cpp                  | 14 +++++++-------
 src/proc/mobject/session/auto.hpp                  | 14 +++++++-------
 src/proc/mobject/session/binding.cpp               | 14 +++++++-------
 src/proc/mobject/session/binding.hpp               | 14 +++++++-------
 src/proc/mobject/session/bus-mo.cpp                | 14 +++++++-------
 src/proc/mobject/session/bus-mo.hpp                | 14 +++++++-------
 src/proc/mobject/session/clip.cpp                  | 14 +++++++-------
 src/proc/mobject/session/clip.hpp                  | 14 +++++++-------
 src/proc/mobject/session/compoundclip.cpp          | 14 +++++++-------
 src/proc/mobject/session/compoundclip.hpp          | 14 +++++++-------
 src/proc/mobject/session/constraint.cpp            | 14 +++++++-------
 src/proc/mobject/session/constraint.hpp            | 14 +++++++-------
 src/proc/mobject/session/defsmanager.cpp           | 14 +++++++-------
 src/proc/mobject/session/defsmanager.hpp           | 14 +++++++-------
 src/proc/mobject/session/defsregistry.hpp          | 14 +++++++-------
 src/proc/mobject/session/effect.cpp                | 14 +++++++-------
 src/proc/mobject/session/effect.hpp                | 14 +++++++-------
 src/proc/mobject/session/element-query.hpp         | 14 +++++++-------
 src/proc/mobject/session/fixedlocation.cpp         | 14 +++++++-------
 src/proc/mobject/session/fixedlocation.hpp         | 14 +++++++-------
 src/proc/mobject/session/fixture.cpp               | 14 +++++++-------
 src/proc/mobject/session/fixture.hpp               | 14 +++++++-------
 src/proc/mobject/session/label.cpp                 | 14 +++++++-------
 src/proc/mobject/session/label.hpp                 | 14 +++++++-------
 src/proc/mobject/session/lifecycle-advisor.hpp     | 14 +++++++-------
 src/proc/mobject/session/locatingpin.cpp           | 14 +++++++-------
 src/proc/mobject/session/locatingpin.hpp           | 14 +++++++-------
 src/proc/mobject/session/meta.cpp                  | 14 +++++++-------
 src/proc/mobject/session/meta.hpp                  | 14 +++++++-------
 src/proc/mobject/session/mobjectfactory.cpp        | 14 +++++++-------
 src/proc/mobject/session/mobjectfactory.hpp        | 14 +++++++-------
 .../session/placement-index-query-resolver.cpp     | 14 +++++++-------
 .../session/placement-index-query-resolver.hpp     | 14 +++++++-------
 src/proc/mobject/session/placement-index.cpp       | 14 +++++++-------
 src/proc/mobject/session/placement-index.hpp       | 14 +++++++-------
 src/proc/mobject/session/plug.cpp                  | 14 +++++++-------
 src/proc/mobject/session/plug.hpp                  | 14 +++++++-------
 src/proc/mobject/session/query-focus-stack.hpp     | 14 +++++++-------
 src/proc/mobject/session/query-focus.cpp           | 14 +++++++-------
 src/proc/mobject/session/query-focus.hpp           | 14 +++++++-------
 src/proc/mobject/session/query-resolver.cpp        | 14 +++++++-------
 src/proc/mobject/session/query-resolver.hpp        | 14 +++++++-------
 src/proc/mobject/session/relativelocation.cpp      | 14 +++++++-------
 src/proc/mobject/session/relativelocation.hpp      | 14 +++++++-------
 src/proc/mobject/session/root.cpp                  | 14 +++++++-------
 src/proc/mobject/session/root.hpp                  | 12 ++++++------
 src/proc/mobject/session/scope-locator.hpp         | 14 +++++++-------
 src/proc/mobject/session/scope-path.cpp            | 14 +++++++-------
 src/proc/mobject/session/scope-path.hpp            | 14 +++++++-------
 src/proc/mobject/session/scope-query.hpp           | 14 +++++++-------
 src/proc/mobject/session/scope.cpp                 | 14 +++++++-------
 src/proc/mobject/session/scope.hpp                 | 14 +++++++-------
 src/proc/mobject/session/segment.cpp               | 14 +++++++-------
 src/proc/mobject/session/segment.hpp               | 14 +++++++-------
 src/proc/mobject/session/segmentation.cpp          | 14 +++++++-------
 src/proc/mobject/session/segmentation.hpp          | 14 +++++++-------
 src/proc/mobject/session/sess-manager-impl.cpp     | 14 +++++++-------
 src/proc/mobject/session/sess-manager-impl.hpp     | 14 +++++++-------
 src/proc/mobject/session/session-impl.cpp          | 14 +++++++-------
 src/proc/mobject/session/session-impl.hpp          | 14 +++++++-------
 .../mobject/session/session-interface-modules.hpp  | 14 +++++++-------
 src/proc/mobject/session/session-query.hpp         | 14 +++++++-------
 .../mobject/session/session-service-defaults.hpp   | 14 +++++++-------
 .../session/session-service-explore-scope.hpp      | 14 +++++++-------
 src/proc/mobject/session/session-service-fetch.hpp | 14 +++++++-------
 .../mobject/session/session-service-mock-index.hpp | 14 +++++++-------
 .../mobject/session/session-service-mutate.hpp     | 14 +++++++-------
 src/proc/mobject/session/session-services.cpp      | 14 +++++++-------
 src/proc/mobject/session/session-services.hpp      | 14 +++++++-------
 src/proc/mobject/session/session.cpp               | 14 +++++++-------
 src/proc/mobject/session/simpleclip.cpp            | 14 +++++++-------
 src/proc/mobject/session/simpleclip.hpp            | 14 +++++++-------
 .../mobject/session/specific-contents-query.hpp    | 14 +++++++-------
 src/proc/mobject/session/track.cpp                 | 14 +++++++-------
 src/proc/mobject/session/track.hpp                 | 14 +++++++-------
 src/proc/mobject/session/wish.cpp                  | 14 +++++++-------
 src/proc/mobject/session/wish.hpp                  | 14 +++++++-------
 src/proc/mobject/test-dummy-mobject.hpp            | 14 +++++++-------
 src/proc/play/dummy-image-generator.cpp            | 14 +++++++-------
 src/proc/play/dummy-image-generator.hpp            | 14 +++++++-------
 src/proc/play/dummy-player-interface-proxy.hpp     | 14 +++++++-------
 src/proc/play/dummy-player-service.cpp             | 14 +++++++-------
 src/proc/play/dummy-player-service.hpp             | 14 +++++++-------
 src/proc/play/tick-service.hpp                     | 14 +++++++-------
 src/proc/state.cpp                                 | 14 +++++++-------
 src/proc/state.hpp                                 | 14 +++++++-------
 src/tool/luidgen.c                                 |  4 ++--
 tests/backend/test-filedescriptors.c               |  4 ++--
 tests/backend/test-filehandles.c                   |  4 ++--
 tests/backend/test-fileheader.c                    |  4 ++--
 tests/backend/test-filemmap.c                      |  4 ++--
 tests/backend/test-resourcecollector.c             |  4 ++--
 tests/backend/test-threadpool.c                    |  4 ++--
 tests/backend/test-threads.c                       |  4 ++--
 tests/bugs/bugmain.c                               |  4 ++--
 tests/common/ref-array-test.cpp                    | 14 +++++++-------
 tests/common/test-config.c                         |  4 ++--
 tests/common/test-interfaces.c                     |  4 ++--
 tests/components/backend/mediaaccessmock.cpp       | 14 +++++++-------
 tests/components/backend/mediaaccessmock.hpp       | 14 +++++++-------
 tests/components/backend/mediaaccessmocktest.cpp   | 14 +++++++-------
 .../components/proc/asset/asset-category-test.cpp  | 14 +++++++-------
 tests/components/proc/asset/asset-diagnostics.hpp  | 14 +++++++-------
 tests/components/proc/asset/basicpipetest.cpp      | 14 +++++++-------
 tests/components/proc/asset/compoundmediatest.cpp  | 14 +++++++-------
 tests/components/proc/asset/create-asset-test.cpp  |  4 ++--
 tests/components/proc/asset/deleteassettest.cpp    | 14 +++++++-------
 .../proc/asset/dependent-assets-test.cpp           |  4 ++--
 tests/components/proc/asset/entry-id-test.cpp      | 14 +++++++-------
 .../components/proc/asset/identityofassetstest.cpp | 14 +++++++-------
 tests/components/proc/asset/makecliptest.cpp       | 14 +++++++-------
 .../proc/asset/mediastructurequerytest.cpp         | 14 +++++++-------
 .../components/proc/asset/orderingofassetstest.cpp | 14 +++++++-------
 tests/components/proc/asset/testasset.cpp          | 14 +++++++-------
 tests/components/proc/asset/testasset.hpp          | 14 +++++++-------
 tests/components/proc/asset/testclipasset.hpp      | 14 +++++++-------
 tests/components/proc/asset/typed-id-test.cpp      | 14 +++++++-------
 .../proc/control/argument-tuple-accept-test.cpp    | 14 +++++++-------
 .../proc/control/command-argument-test.cpp         |  4 ++--
 .../components/proc/control/command-basic-test.cpp | 14 +++++++-------
 .../proc/control/command-binding-test.cpp          | 14 +++++++-------
 .../proc/control/command-clone-builder-test.cpp    | 14 +++++++-------
 .../proc/control/command-equality-test.cpp         | 14 +++++++-------
 .../proc/control/command-mutation-test.cpp         | 14 +++++++-------
 .../proc/control/command-registry-test.cpp         | 14 +++++++-------
 .../components/proc/control/command-use1-test.cpp  | 14 +++++++-------
 .../components/proc/control/command-use2-test.cpp  | 14 +++++++-------
 .../components/proc/control/command-use3-test.cpp  | 14 +++++++-------
 .../proc/control/handling-pattern-basics-test.cpp  |  4 ++--
 .../handling-pattern-standard-impl-test.cpp        | 14 +++++++-------
 tests/components/proc/control/memento-tie-test.cpp | 14 +++++++-------
 .../proc/control/test-dummy-commands.cpp           | 14 +++++++-------
 .../proc/control/test-dummy-commands.hpp           | 14 +++++++-------
 tests/components/proc/engine/buff-table-test.cpp   | 14 +++++++-------
 tests/components/proc/engine/node-basic-test.cpp   | 14 +++++++-------
 .../proc/engine/node-fabrication-test.cpp          | 14 +++++++-------
 .../components/proc/engine/node-operation-test.cpp | 14 +++++++-------
 tests/components/proc/engine/node-source-test.cpp  | 14 +++++++-------
 .../proc/mobject/builder/buildertooltest.cpp       | 14 +++++++-------
 .../proc/mobject/builder/buildsegmenttest.cpp      | 14 +++++++-------
 .../builder/fixture-change-detector-test.cpp       | 14 +++++++-------
 .../mobject/builder/model-port-registry-test.cpp   | 14 +++++++-------
 .../builder/segmentation-datastructure-test.cpp    | 14 +++++++-------
 .../proc/mobject/controller/rendersegmenttest.cpp  | 14 +++++++-------
 .../proc/mobject/mobject-interface-test.cpp        | 14 +++++++-------
 tests/components/proc/mobject/mobject-ref-test.cpp |  4 ++--
 .../proc/mobject/output-mapping-test.cpp           | 14 +++++++-------
 .../proc/mobject/placement-basic-test.cpp          |  4 ++--
 .../proc/mobject/placement-hierarchy-test.cpp      | 14 +++++++-------
 .../mobject/placement-object-identity-test.cpp     | 14 +++++++-------
 .../components/proc/mobject/placement-ref-test.cpp |  4 ++--
 .../proc/mobject/session/addcliptest.cpp           | 14 +++++++-------
 .../proc/mobject/session/defsmanagerimpltest.cpp   |  4 ++--
 .../proc/mobject/session/defsmanagertest.cpp       |  4 ++--
 .../proc/mobject/session/defsregistryimpltest.cpp  |  4 ++--
 .../proc/mobject/session/deletecliptest.cpp        | 14 +++++++-------
 .../mobject/session/placement-index-query-test.cpp | 14 +++++++-------
 .../proc/mobject/session/placement-index-test.cpp  |  4 ++--
 .../proc/mobject/session/placement-scope-test.cpp  | 14 +++++++-------
 .../mobject/session/query-focus-stack-test.cpp     | 14 +++++++-------
 .../proc/mobject/session/query-focus-test.cpp      | 14 +++++++-------
 .../proc/mobject/session/query-resolver-test.cpp   | 14 +++++++-------
 .../proc/mobject/session/rebuildfixturetest.cpp    | 14 +++++++-------
 .../proc/mobject/session/scope-path-test.cpp       | 14 +++++++-------
 .../proc/mobject/session/scope-query-test.cpp      | 14 +++++++-------
 .../mobject/session/session-element-query-test.cpp | 14 +++++++-------
 .../session/session-element-tracker-test.cpp       | 14 +++++++-------
 .../mobject/session/session-modify-parts-test.cpp  | 14 +++++++-------
 .../session/session-service-access-test.cpp        | 14 +++++++-------
 .../mobject/session/session-structure-test.cpp     | 14 +++++++-------
 .../proc/mobject/session/sessionmanagertest.cpp    | 14 +++++++-------
 .../proc/mobject/session/test-scope-invalid.hpp    | 14 +++++++-------
 .../proc/mobject/session/test-scopes.cpp           | 14 +++++++-------
 .../proc/mobject/session/test-scopes.hpp           | 14 +++++++-------
 tests/components/proc/mobject/session/testclip.cpp | 14 +++++++-------
 tests/components/proc/mobject/session/testclip.hpp | 14 +++++++-------
 tests/components/proc/mobject/session/testroot.hpp | 14 +++++++-------
 .../proc/mobject/session/testsession1.hpp          | 14 +++++++-------
 .../session/timeline-sequence-handling-test.cpp    | 14 +++++++-------
 tests/lib/advice/advice-basics-test.cpp            | 14 +++++++-------
 tests/lib/advice/advice-binding-pattern-test.cpp   | 14 +++++++-------
 tests/lib/advice/advice-configuration-test.cpp     | 14 +++++++-------
 tests/lib/advice/advice-index-test.cpp             | 14 +++++++-------
 tests/lib/advice/advice-multiplicity-test.cpp      | 14 +++++++-------
 tests/lib/advice/advice-situations-test.cpp        | 14 +++++++-------
 tests/lib/allocationclustertest.cpp                | 14 +++++++-------
 tests/lib/appconfigtest.cpp                        | 14 +++++++-------
 tests/lib/bool-checkable-test.cpp                  | 14 +++++++-------
 tests/lib/custom-shared-ptr-test.cpp               |  4 ++--
 tests/lib/del-stash-test.cpp                       | 14 +++++++-------
 tests/lib/exceptionerrortest.cpp                   | 14 +++++++-------
 tests/lib/factory-special-test.cpp                 | 14 +++++++-------
 tests/lib/factorytest.cpp                          | 14 +++++++-------
 tests/lib/format-helper-test.cpp                   | 14 +++++++-------
 tests/lib/functor-util-test.cpp                    | 14 +++++++-------
 tests/lib/hash-indexed-test.cpp                    | 14 +++++++-------
 tests/lib/helloworldtest.cpp                       | 14 +++++++-------
 tests/lib/item-wrapper-test.cpp                    |  4 ++--
 tests/lib/iter-adapter-stl-test.cpp                | 14 +++++++-------
 tests/lib/iter-adapter-test.cpp                    | 14 +++++++-------
 tests/lib/iter-source-test.cpp                     | 14 +++++++-------
 tests/lib/itertools-test.cpp                       |  4 ++--
 tests/lib/lifecycletest.cpp                        | 14 +++++++-------
 tests/lib/mainsuite.cpp                            |  4 ++--
 tests/lib/meta/config-flags-test.cpp               | 14 +++++++-------
 tests/lib/meta/duck-detector-test.cpp              | 14 +++++++-------
 tests/lib/meta/dummy-functions.hpp                 | 14 +++++++-------
 tests/lib/meta/function-closure-test.cpp           | 14 +++++++-------
 tests/lib/meta/function-composition-test.cpp       |  4 ++--
 tests/lib/meta/function-erasure-test.cpp           | 14 +++++++-------
 tests/lib/meta/generator-test.cpp                  |  4 ++--
 tests/lib/meta/iterable-classification-test.cpp    | 14 +++++++-------
 tests/lib/meta/tuple-diagnostics.hpp               | 14 +++++++-------
 tests/lib/meta/type-tuple-test.cpp                 |  4 ++--
 tests/lib/meta/typelist-diagnostics.hpp            | 14 +++++++-------
 tests/lib/meta/typelist-manip-test.cpp             | 14 +++++++-------
 tests/lib/meta/typelist-test.cpp                   | 14 +++++++-------
 tests/lib/meta/typeseq-manip-test.cpp              | 14 +++++++-------
 tests/lib/multifact-argument-test.cpp              | 14 +++++++-------
 tests/lib/multifact-test.cpp                       | 14 +++++++-------
 tests/lib/null-value-test.cpp                      | 14 +++++++-------
 tests/lib/opaque-holder-test.cpp                   | 14 +++++++-------
 tests/lib/opaque-unchecked-buffer-test.cpp         | 14 +++++++-------
 tests/lib/optional-ref-test.cpp                    | 14 +++++++-------
 tests/lib/query/query-utils-test.cpp               | 14 +++++++-------
 tests/lib/query/querydiagnostics.hpp               | 14 +++++++-------
 tests/lib/removefromsettest.cpp                    | 14 +++++++-------
 tests/lib/sanitised-identifier-test.cpp            | 14 +++++++-------
 tests/lib/scoped-holder-test.cpp                   | 14 +++++++-------
 tests/lib/scoped-holder-transfer-test.cpp          |  4 ++--
 tests/lib/scoped-ptrvect-test.cpp                  | 14 +++++++-------
 tests/lib/singleton-subclass-test.cpp              |  4 ++--
 tests/lib/singleton-test.cpp                       | 14 +++++++-------
 tests/lib/singletontestmocktest.cpp                | 14 +++++++-------
 tests/lib/streamtypebasicstest.cpp                 | 14 +++++++-------
 tests/lib/streamtypelifecycletest.cpp              | 14 +++++++-------
 tests/lib/sub-id-test.cpp                          | 14 +++++++-------
 tests/lib/subsystem-runner-test.cpp                | 14 +++++++-------
 tests/lib/symbol-hashtable-test.cpp                |  4 ++--
 tests/lib/symbol-test.cpp                          | 14 +++++++-------
 tests/lib/sync-classlock-test.cpp                  | 14 +++++++-------
 tests/lib/sync-locking-test.cpp                    | 14 +++++++-------
 tests/lib/sync-timedwait-test.cpp                  |  4 ++--
 tests/lib/sync-waiting-test.cpp                    | 14 +++++++-------
 tests/lib/test/cmdlinewrappertest.cpp              | 14 +++++++-------
 tests/lib/test/test-helper-test.cpp                | 14 +++++++-------
 tests/lib/test/testoptiontest.cpp                  | 14 +++++++-------
 tests/lib/testdummy.hpp                            | 14 +++++++-------
 tests/lib/teststreamtypes.hpp                      | 14 +++++++-------
 tests/lib/testtargetobj.hpp                        | 14 +++++++-------
 tests/lib/thread-wrapper-join-test.cpp             | 14 +++++++-------
 tests/lib/thread-wrapper-test.cpp                  | 14 +++++++-------
 tests/lib/time-wrapper-test.cpp                    | 14 +++++++-------
 tests/lib/typed-allocation-manager-test.cpp        | 14 +++++++-------
 tests/lib/typed-counter-test.cpp                   | 14 +++++++-------
 tests/lib/util-foreach-test.cpp                    | 14 +++++++-------
 tests/lib/vector-transfer-test.cpp                 |  4 ++--
 tests/lib/visitingtoolconcept.cpp                  | 14 +++++++-------
 tests/lib/visitingtoolextendedtest.cpp             | 14 +++++++-------
 tests/lib/visitingtooltest.cpp                     | 14 +++++++-------
 tests/library/test-error.c                         |  4 ++--
 tests/library/test-llist.c                         |  4 ++--
 tests/library/test-locking.c                       |  4 ++--
 tests/library/test-luid.c                          |  4 ++--
 tests/library/test-mpool.c                         |  4 ++--
 tests/library/test-psplay.c                        |  4 ++--
 tests/library/test-safeclib.c                      |  4 ++--
 tests/plugin/examplepluginc/example_plugin.c       | 14 +++++++-------
 tests/plugin/test-cpp-plugin/example_plugin.cpp    | 14 +++++++-------
 tests/test.h                                       |  4 ++--
 tests/tool/vgsuppression.c                         |  4 ++--
 740 files changed, 4525 insertions(+), 4525 deletions(-)

diff --git a/src/backend/backend.c b/src/backend/backend.c
index fa007c404..0f2c62b8a 100644
--- a/src/backend/backend.c
+++ b/src/backend/backend.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/backend/backend.h b/src/backend/backend.h
index f1e68c85b..163c8fc7c 100644
--- a/src/backend/backend.h
+++ b/src/backend/backend.h
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/backend/enginefacade.cpp b/src/backend/enginefacade.cpp
index 93b2dedc8..d99ad83fa 100644
--- a/src/backend/enginefacade.cpp
+++ b/src/backend/enginefacade.cpp
@@ -1,23 +1,23 @@
 /*
   EngineFacade  -  access point for communicating with the render engine
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/backend/enginefacade.hpp b/src/backend/enginefacade.hpp
index 05680d39b..7cbf698e8 100644
--- a/src/backend/enginefacade.hpp
+++ b/src/backend/enginefacade.hpp
@@ -1,23 +1,23 @@
 /*
   ENGINEFACADE.hpp  -  access point for communicating with the render engine
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/backend/file.c b/src/backend/file.c
index 3303cae5d..b636bdf29 100644
--- a/src/backend/file.c
+++ b/src/backend/file.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/backend/file.h b/src/backend/file.h
index d70525004..8b8b94ca5 100644
--- a/src/backend/file.h
+++ b/src/backend/file.h
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/backend/filedescriptor.c b/src/backend/filedescriptor.c
index ee0366dcb..a1bfcd15f 100644
--- a/src/backend/filedescriptor.c
+++ b/src/backend/filedescriptor.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/backend/filedescriptor.h b/src/backend/filedescriptor.h
index 89306cab8..8f73bfb2c 100644
--- a/src/backend/filedescriptor.h
+++ b/src/backend/filedescriptor.h
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/backend/filedescriptorregistry.c b/src/backend/filedescriptorregistry.c
index 5dc186a3e..c31623a78 100644
--- a/src/backend/filedescriptorregistry.c
+++ b/src/backend/filedescriptorregistry.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/backend/filedescriptorregistry.h b/src/backend/filedescriptorregistry.h
index c3a03da83..2faea51f9 100644
--- a/src/backend/filedescriptorregistry.h
+++ b/src/backend/filedescriptorregistry.h
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/backend/filehandle.c b/src/backend/filehandle.c
index 37944ba26..409d6ed32 100644
--- a/src/backend/filehandle.c
+++ b/src/backend/filehandle.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/backend/filehandle.h b/src/backend/filehandle.h
index 6ad9c5832..1290a52e8 100644
--- a/src/backend/filehandle.h
+++ b/src/backend/filehandle.h
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/backend/filehandlecache.c b/src/backend/filehandlecache.c
index c130fbd39..abf77e49e 100644
--- a/src/backend/filehandlecache.c
+++ b/src/backend/filehandlecache.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/backend/filehandlecache.h b/src/backend/filehandlecache.h
index 29a023b17..ca130cfbd 100644
--- a/src/backend/filehandlecache.h
+++ b/src/backend/filehandlecache.h
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/backend/fileheader.c b/src/backend/fileheader.c
index 5bbe8c4e5..9b7e44959 100644
--- a/src/backend/fileheader.c
+++ b/src/backend/fileheader.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/backend/fileheader.h b/src/backend/fileheader.h
index 03058181c..a14abd97f 100644
--- a/src/backend/fileheader.h
+++ b/src/backend/fileheader.h
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/backend/mediaaccessfacade.cpp b/src/backend/mediaaccessfacade.cpp
index f3308f4a7..e9feab29f 100644
--- a/src/backend/mediaaccessfacade.cpp
+++ b/src/backend/mediaaccessfacade.cpp
@@ -1,23 +1,23 @@
 /*
   MediaAccessFacade  -  functions for querying media file and channels.
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/backend/mediaaccessfacade.hpp b/src/backend/mediaaccessfacade.hpp
index 3d009c6fe..261e84a61 100644
--- a/src/backend/mediaaccessfacade.hpp
+++ b/src/backend/mediaaccessfacade.hpp
@@ -1,23 +1,23 @@
 /*
   MEDIAACCESSFACADE.hpp  -  functions for querying media file and channels.
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/backend/mmap.c b/src/backend/mmap.c
index 37523c9f0..f31c05154 100644
--- a/src/backend/mmap.c
+++ b/src/backend/mmap.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/backend/mmap.h b/src/backend/mmap.h
index 155ec0d06..77f4672d0 100644
--- a/src/backend/mmap.h
+++ b/src/backend/mmap.h
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/backend/mmapcache.c b/src/backend/mmapcache.c
index cda0493c7..dc91b2baa 100644
--- a/src/backend/mmapcache.c
+++ b/src/backend/mmapcache.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/backend/mmapcache.h b/src/backend/mmapcache.h
index 5b3704512..2b5345696 100644
--- a/src/backend/mmapcache.h
+++ b/src/backend/mmapcache.h
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/backend/mmapings.c b/src/backend/mmapings.c
index 376519f9e..a751b1b89 100644
--- a/src/backend/mmapings.c
+++ b/src/backend/mmapings.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/backend/mmapings.h b/src/backend/mmapings.h
index 28b567d93..39cf7aa9f 100644
--- a/src/backend/mmapings.h
+++ b/src/backend/mmapings.h
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/backend/netnodefacade.cpp b/src/backend/netnodefacade.cpp
index 24d97b8b2..99f64e1bb 100644
--- a/src/backend/netnodefacade.cpp
+++ b/src/backend/netnodefacade.cpp
@@ -1,23 +1,23 @@
 /*
   NetNodeFacade  -  access point for maintaining a renderfarm node
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/backend/netnodefacade.hpp b/src/backend/netnodefacade.hpp
index afeee3b59..17ceb60de 100644
--- a/src/backend/netnodefacade.hpp
+++ b/src/backend/netnodefacade.hpp
@@ -1,23 +1,23 @@
 /*
   NETNODEFACADE.hpp  -  access point for maintaining a renderfarm node
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/backend/resourcecollector.c b/src/backend/resourcecollector.c
index 7ef6a48de..ec9dce348 100644
--- a/src/backend/resourcecollector.c
+++ b/src/backend/resourcecollector.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/backend/resourcecollector.h b/src/backend/resourcecollector.h
index 1d41e3e44..6a90ddb7a 100644
--- a/src/backend/resourcecollector.h
+++ b/src/backend/resourcecollector.h
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/backend/scriptrunnerfacade.cpp b/src/backend/scriptrunnerfacade.cpp
index 9ecf4f13f..a36d70fea 100644
--- a/src/backend/scriptrunnerfacade.cpp
+++ b/src/backend/scriptrunnerfacade.cpp
@@ -1,23 +1,23 @@
 /*
   ScriptRunnerFacade  -  access point for running a script within Lumiera application context
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/backend/scriptrunnerfacade.hpp b/src/backend/scriptrunnerfacade.hpp
index b0c1f74ec..d54087497 100644
--- a/src/backend/scriptrunnerfacade.hpp
+++ b/src/backend/scriptrunnerfacade.hpp
@@ -1,23 +1,23 @@
 /*
   SCRIPTRUNNERFACADE.hpp  -  access point for running a script within Lumiera application context
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/backend/thread-wrapper.hpp b/src/backend/thread-wrapper.hpp
index 1a6c4be49..c45fd4e75 100644
--- a/src/backend/thread-wrapper.hpp
+++ b/src/backend/thread-wrapper.hpp
@@ -1,24 +1,24 @@
 /*
   THREADWRAPPER.hpp  -  thin convenience wrapper for starting lumiera threads
- 
+
   Copyright (C)         Lumiera.org
     2008 - 2010         Hermann Vosseler <Ichthyostega@web.de>
                         Christian Thaeter <ct@pipapo.org>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/backend/threadpool-init.cpp b/src/backend/threadpool-init.cpp
index 0f4bdaf90..604a6a8ac 100644
--- a/src/backend/threadpool-init.cpp
+++ b/src/backend/threadpool-init.cpp
@@ -1,23 +1,23 @@
 /*
   ThreadpoolInit  -  pull up the Thread management automagically at application initialisation 
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/backend/threadpool-init.hpp b/src/backend/threadpool-init.hpp
index aebdb00aa..05fe29370 100644
--- a/src/backend/threadpool-init.hpp
+++ b/src/backend/threadpool-init.hpp
@@ -1,24 +1,24 @@
 /*
   THREADPOOL-INIT.hpp  -  pull up the Thread management automagically at application initialisation 
  
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file threadpool-init.hpp
diff --git a/src/backend/threadpool.c b/src/backend/threadpool.c
index 0e144e31c..b0ac7c0b3 100644
--- a/src/backend/threadpool.c
+++ b/src/backend/threadpool.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/backend/threadpool.h b/src/backend/threadpool.h
index 28bb21020..6f80c8bb9 100644
--- a/src/backend/threadpool.h
+++ b/src/backend/threadpool.h
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/backend/threads.c b/src/backend/threads.c
index f4e379354..1261fe134 100644
--- a/src/backend/threads.c
+++ b/src/backend/threads.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/backend/threads.h b/src/backend/threads.h
index 1eee2d536..6e755be48 100644
--- a/src/backend/threads.h
+++ b/src/backend/threads.h
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/common/appstate.cpp b/src/common/appstate.cpp
index dfcab9834..20d2c6e96 100644
--- a/src/common/appstate.cpp
+++ b/src/common/appstate.cpp
@@ -1,23 +1,23 @@
 /*
   AppState  -  application initialisation and behaviour 
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/common/appstate.hpp b/src/common/appstate.hpp
index 1f16f0630..6472b5102 100644
--- a/src/common/appstate.hpp
+++ b/src/common/appstate.hpp
@@ -1,23 +1,23 @@
 /*
   APPSTATE.hpp  -  application initialisation and behaviour 
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file appstate.hpp
diff --git a/src/common/config.c b/src/common/config.c
index 88961ddc6..a767cce96 100644
--- a/src/common/config.c
+++ b/src/common/config.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/common/config.h b/src/common/config.h
index 7cf0ff2df..4fa462f25 100644
--- a/src/common/config.h
+++ b/src/common/config.h
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/common/config_interface.c b/src/common/config_interface.c
index a40a8ab03..9f83b3e56 100644
--- a/src/common/config_interface.c
+++ b/src/common/config_interface.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/common/config_interface.h b/src/common/config_interface.h
index d4eca205a..0e605ca30 100644
--- a/src/common/config_interface.h
+++ b/src/common/config_interface.h
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/common/config_lookup.c b/src/common/config_lookup.c
index f2bca1ff1..0c0a776a4 100644
--- a/src/common/config_lookup.c
+++ b/src/common/config_lookup.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/common/config_lookup.h b/src/common/config_lookup.h
index aa11e8dff..eadf96b39 100644
--- a/src/common/config_lookup.h
+++ b/src/common/config_lookup.h
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/common/config_typed.c b/src/common/config_typed.c
index b916cdb61..68083931f 100644
--- a/src/common/config_typed.c
+++ b/src/common/config_typed.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/common/config_wordlist.c b/src/common/config_wordlist.c
index 0762a74a7..a528286f4 100644
--- a/src/common/config_wordlist.c
+++ b/src/common/config_wordlist.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/common/configentry.c b/src/common/configentry.c
index 0b09f76c3..495690c04 100644
--- a/src/common/configentry.c
+++ b/src/common/configentry.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/common/configentry.h b/src/common/configentry.h
index 92d63ec46..c2c1eadd8 100644
--- a/src/common/configentry.h
+++ b/src/common/configentry.h
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/common/configfacade.cpp b/src/common/configfacade.cpp
index b0860e08e..08aa04903 100644
--- a/src/common/configfacade.cpp
+++ b/src/common/configfacade.cpp
@@ -1,23 +1,23 @@
 /*
   ConfigFacade  -  C++ convenience wrapper and startup of the config system
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/common/configitem.c b/src/common/configitem.c
index c69d804d8..e2a22c98c 100644
--- a/src/common/configitem.c
+++ b/src/common/configitem.c
@@ -7,8 +7,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/common/configitem.h b/src/common/configitem.h
index 942f77ef8..3c3823422 100644
--- a/src/common/configitem.h
+++ b/src/common/configitem.h
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/common/configrules.cpp b/src/common/configrules.cpp
index b4d4ea00a..b42e5591a 100644
--- a/src/common/configrules.cpp
+++ b/src/common/configrules.cpp
@@ -1,24 +1,24 @@
 
 /*
   ConfigRules  -  interface for rule based configuration
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/common/configrules.hpp b/src/common/configrules.hpp
index 473b82155..841858883 100644
--- a/src/common/configrules.hpp
+++ b/src/common/configrules.hpp
@@ -1,23 +1,23 @@
 /*
   CONFIGRULES.hpp  -  interface for rule based configuration
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/common/external/libgavl.cpp b/src/common/external/libgavl.cpp
index 8cb37a12f..b60caecea 100644
--- a/src/common/external/libgavl.cpp
+++ b/src/common/external/libgavl.cpp
@@ -1,23 +1,23 @@
 /*
   ImplFacadeGAVL  -  facade for integrating the GAVL media handling library
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/common/external/libgavl.hpp b/src/common/external/libgavl.hpp
index 505fc4325..ac6a00b03 100644
--- a/src/common/external/libgavl.hpp
+++ b/src/common/external/libgavl.hpp
@@ -1,23 +1,23 @@
 /*
   LILBGAVL.hpp  -  facade for integrating the GAVL media handling library
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/common/guifacade.cpp b/src/common/guifacade.cpp
index e786dba40..aff7febb8 100644
--- a/src/common/guifacade.cpp
+++ b/src/common/guifacade.cpp
@@ -1,23 +1,23 @@
 /*
   GuiFacade  -  access point for communicating with the Lumiera GTK GUI
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/common/instancehandle.hpp b/src/common/instancehandle.hpp
index 9b9a12bd9..d6c98e546 100644
--- a/src/common/instancehandle.hpp
+++ b/src/common/instancehandle.hpp
@@ -1,23 +1,23 @@
 /*
   INSTANCEHANDLE.hpp  -  automatically handling interface lifecycle 
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file instancehandle.hpp
diff --git a/src/common/interface.c b/src/common/interface.c
index a8d91c40f..71cf71e96 100644
--- a/src/common/interface.c
+++ b/src/common/interface.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/common/interface.h b/src/common/interface.h
index d50af3233..3a8e2fb5c 100644
--- a/src/common/interface.h
+++ b/src/common/interface.h
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/common/interfacedescriptor.h b/src/common/interfacedescriptor.h
index 121c0711e..c6aab3043 100644
--- a/src/common/interfacedescriptor.h
+++ b/src/common/interfacedescriptor.h
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/common/interfaceproxy.cpp b/src/common/interfaceproxy.cpp
index 1970cce21..e403e40a5 100644
--- a/src/common/interfaceproxy.cpp
+++ b/src/common/interfaceproxy.cpp
@@ -1,23 +1,23 @@
 /*
   InterfaceProxy  -  definition of forwarding proxies for the facade interfaces
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/common/interfaceregistry.c b/src/common/interfaceregistry.c
index 1637e48df..121bf6408 100644
--- a/src/common/interfaceregistry.c
+++ b/src/common/interfaceregistry.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/common/interfaceregistry.h b/src/common/interfaceregistry.h
index bc4f11440..677ef6c89 100644
--- a/src/common/interfaceregistry.h
+++ b/src/common/interfaceregistry.h
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/common/option.cpp b/src/common/option.cpp
index 84b28b942..d01afc88d 100644
--- a/src/common/option.cpp
+++ b/src/common/option.cpp
@@ -1,23 +1,23 @@
 /*
   Option  -  handle cmdline for starting the Lumiera application
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/common/option.hpp b/src/common/option.hpp
index c44a6b35e..a6ccc4ab9 100644
--- a/src/common/option.hpp
+++ b/src/common/option.hpp
@@ -1,23 +1,23 @@
 /*
   OPTION.hpp  -  handle cmdline for starting the Lumiera application
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/common/plugin.c b/src/common/plugin.c
index 0b9a515a5..2638af5d1 100644
--- a/src/common/plugin.c
+++ b/src/common/plugin.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/common/plugin.h b/src/common/plugin.h
index df75cd012..bd77b3806 100644
--- a/src/common/plugin.h
+++ b/src/common/plugin.h
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/common/plugin_dynlib.c b/src/common/plugin_dynlib.c
index 6c30afe85..7e8618628 100644
--- a/src/common/plugin_dynlib.c
+++ b/src/common/plugin_dynlib.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/common/query/fake-configrules.cpp b/src/common/query/fake-configrules.cpp
index b2f187dea..a095a4acf 100644
--- a/src/common/query/fake-configrules.cpp
+++ b/src/common/query/fake-configrules.cpp
@@ -1,23 +1,23 @@
 /*
   FakeConfigRules  -  dummy implementation of the config rules system
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/common/query/fake-configrules.hpp b/src/common/query/fake-configrules.hpp
index 7cdf1df37..bbc9f91ca 100644
--- a/src/common/query/fake-configrules.hpp
+++ b/src/common/query/fake-configrules.hpp
@@ -1,23 +1,23 @@
 /*
   FAKE-CONFIGRULES.hpp  -  dummy implementation of the config rules system
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/common/subsys.cpp b/src/common/subsys.cpp
index 68850f4c8..2a9b2446c 100644
--- a/src/common/subsys.cpp
+++ b/src/common/subsys.cpp
@@ -1,23 +1,23 @@
 /*
   Subsys  -  interface for describing an application part to be handled by main() 
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/common/subsys.hpp b/src/common/subsys.hpp
index ee0e229ad..363b17e51 100644
--- a/src/common/subsys.hpp
+++ b/src/common/subsys.hpp
@@ -1,23 +1,23 @@
 /*
   SUBSYS.hpp  -  interface for describing an application part to be handled by main() 
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file subsys.hpp
diff --git a/src/common/subsystem-runner.hpp b/src/common/subsystem-runner.hpp
index 8e7edcffc..89a90245d 100644
--- a/src/common/subsystem-runner.hpp
+++ b/src/common/subsystem-runner.hpp
@@ -1,23 +1,23 @@
 /*
   SUBSYSTEMRUNNER.hpp  -  helper for controlling execution of several dependent subsystems 
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/gui/controller/controller.cpp b/src/gui/controller/controller.cpp
index 2d7deefc9..c31ca787d 100644
--- a/src/gui/controller/controller.cpp
+++ b/src/gui/controller/controller.cpp
@@ -1,23 +1,23 @@
 /*
   controllerk.cpp  -  Implementation of the timeline track object
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 #include "controller.hpp"
diff --git a/src/gui/controller/controller.hpp b/src/gui/controller/controller.hpp
index 594f5e19e..29d3684df 100644
--- a/src/gui/controller/controller.hpp
+++ b/src/gui/controller/controller.hpp
@@ -1,23 +1,23 @@
 /*
   controller.hpp  -  Declaration of the controller object
- 
+
   Copyright (C)         Lumiera.org
     2009,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /** @file controller/controller.hpp
  ** This file contains the definition of the controller object
diff --git a/src/gui/controller/playback-controller.cpp b/src/gui/controller/playback-controller.cpp
index bfb623860..12727c86b 100644
--- a/src/gui/controller/playback-controller.cpp
+++ b/src/gui/controller/playback-controller.cpp
@@ -1,23 +1,23 @@
 /*
   playback-controller.cpp  -  Implementation of the playback controller object
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/gui/controller/playback-controller.hpp b/src/gui/controller/playback-controller.hpp
index 7ef5ce4fb..e403bc528 100644
--- a/src/gui/controller/playback-controller.hpp
+++ b/src/gui/controller/playback-controller.hpp
@@ -1,23 +1,23 @@
 /*
   playback-controller.hpp  -  Declaration of the playback controller object
- 
+
   Copyright (C)         Lumiera.org
     2009,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /** @file controller/playback-controller.hpp
  ** This file contains the definition of the playback controller object
diff --git a/src/gui/dialogs/dialog.hpp b/src/gui/dialogs/dialog.hpp
index 454ddee6a..c72949b3b 100644
--- a/src/gui/dialogs/dialog.hpp
+++ b/src/gui/dialogs/dialog.hpp
@@ -1,23 +1,23 @@
 /*
   dialog.hpp  -  Definitions of globals for dialogs
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /** @file render.hpp
  ** This file contains definitions of globals for dialogs
diff --git a/src/gui/dialogs/name-chooser.cpp b/src/gui/dialogs/name-chooser.cpp
index c44c7adad..c61527be8 100644
--- a/src/gui/dialogs/name-chooser.cpp
+++ b/src/gui/dialogs/name-chooser.cpp
@@ -1,23 +1,23 @@
 /*
   name-chooser.cpp  -  Definition of the name chooser dialog object
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 #include "../gtk-lumiera.hpp"
diff --git a/src/gui/dialogs/name-chooser.hpp b/src/gui/dialogs/name-chooser.hpp
index c848820e3..0794e6427 100644
--- a/src/gui/dialogs/name-chooser.hpp
+++ b/src/gui/dialogs/name-chooser.hpp
@@ -1,23 +1,23 @@
 /*
   name-chooser.hpp  -  Definition of the name chooser dialog object
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /** @file name-chooser.hpp
  ** This file contains the definition of the name chooser dialog
diff --git a/src/gui/dialogs/preferences-dialog.cpp b/src/gui/dialogs/preferences-dialog.cpp
index dae928143..4db367360 100644
--- a/src/gui/dialogs/preferences-dialog.cpp
+++ b/src/gui/dialogs/preferences-dialog.cpp
@@ -1,23 +1,23 @@
 /*
   preferences-dialog.cpp  -  Implementation of the application preferences dialog
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 #include "../gtk-lumiera.hpp"
diff --git a/src/gui/dialogs/preferences-dialog.hpp b/src/gui/dialogs/preferences-dialog.hpp
index 6e9ce2087..62a37ed07 100644
--- a/src/gui/dialogs/preferences-dialog.hpp
+++ b/src/gui/dialogs/preferences-dialog.hpp
@@ -1,23 +1,23 @@
 /*
   preferences-dialog.hpp  -  Definition of the application preferences dialog
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /** @file render.hpp
  ** This file contains the definition of the application preferences dialog
diff --git a/src/gui/dialogs/render.cpp b/src/gui/dialogs/render.cpp
index 88a8c41ff..6178c014c 100644
--- a/src/gui/dialogs/render.cpp
+++ b/src/gui/dialogs/render.cpp
@@ -1,23 +1,23 @@
 /*
   render.cpp  -  Definition of the main workspace window object
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 #include "../gtk-lumiera.hpp"
diff --git a/src/gui/dialogs/render.hpp b/src/gui/dialogs/render.hpp
index 51989a25e..8d586c398 100644
--- a/src/gui/dialogs/render.hpp
+++ b/src/gui/dialogs/render.hpp
@@ -1,23 +1,23 @@
 /*
   render.hpp  -  Definition of the render output dialog
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /** @file render.hpp
  ** This file contains the definition of the render output dialog
diff --git a/src/gui/display-interface-proxy.hpp b/src/gui/display-interface-proxy.hpp
index 8ae035124..e0fd15031 100644
--- a/src/gui/display-interface-proxy.hpp
+++ b/src/gui/display-interface-proxy.hpp
@@ -1,23 +1,23 @@
 /*
   Display(Proxy)  -  service providing access to a display for outputting frames
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/gui/display-service.cpp b/src/gui/display-service.cpp
index 1c20dd4de..96600bf3b 100644
--- a/src/gui/display-service.cpp
+++ b/src/gui/display-service.cpp
@@ -1,23 +1,23 @@
 /*
   DisplayService  -  service providing access to a display for outputting frames
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/gui/display-service.hpp b/src/gui/display-service.hpp
index 2a84f9c12..1dec2c192 100644
--- a/src/gui/display-service.hpp
+++ b/src/gui/display-service.hpp
@@ -1,23 +1,23 @@
 /*
   DISPLAY-SERVICE.hpp  -  service providing access to a display for outputting frames
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file display-service.hpp
diff --git a/src/gui/gtk-lumiera.cpp b/src/gui/gtk-lumiera.cpp
index 65b448f40..3b8f34859 100644
--- a/src/gui/gtk-lumiera.cpp
+++ b/src/gui/gtk-lumiera.cpp
@@ -1,23 +1,23 @@
 /*
   gtk-lumiera.cpp  -  The entry point for the GTK GUI application
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 #include <gtkmm.h>
diff --git a/src/gui/gtk-lumiera.hpp b/src/gui/gtk-lumiera.hpp
index c1b5a773a..bc26c1d96 100644
--- a/src/gui/gtk-lumiera.hpp
+++ b/src/gui/gtk-lumiera.hpp
@@ -1,23 +1,23 @@
 /*
   gtk-lumiera.hpp  -  Application wide global definitions
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /** @file gtk-lumiera.hpp
  ** This file contains application wide global definitions
diff --git a/src/gui/guifacade.hpp b/src/gui/guifacade.hpp
index d7bf7f542..27de18a35 100644
--- a/src/gui/guifacade.hpp
+++ b/src/gui/guifacade.hpp
@@ -1,23 +1,23 @@
 /*
   GUIFACADE.hpp  -  access point for communicating with the Lumiera GTK GUI
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file guifacade.hpp
diff --git a/src/gui/guistart.cpp b/src/gui/guistart.cpp
index e345f9047..d8c5513d8 100644
--- a/src/gui/guistart.cpp
+++ b/src/gui/guistart.cpp
@@ -1,25 +1,25 @@
 /*
   GuiStart  -  entry point for the lumiera GUI loaded as shared module
- 
+
   Copyright (C)         Lumiera.org
     2007-2008,          Joel Holdsworth <joel@airwebreathe.org.uk>
                         Christian Thaeter <ct@pipapo.org>
                         Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/gui/model/clip-track.cpp b/src/gui/model/clip-track.cpp
index 5f8907599..30407a1f8 100644
--- a/src/gui/model/clip-track.cpp
+++ b/src/gui/model/clip-track.cpp
@@ -1,23 +1,23 @@
 /*
   clip-track.cpp  -  Implementation of a clip containing track object
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 #include "clip-track.hpp"
diff --git a/src/gui/model/clip-track.hpp b/src/gui/model/clip-track.hpp
index c3c7e0e2f..5e8ea354c 100644
--- a/src/gui/model/clip-track.hpp
+++ b/src/gui/model/clip-track.hpp
@@ -1,23 +1,23 @@
 /*
   clip-track.hpp  -  Declaration of a clip containing track object
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /**
  * @file widgets/timeline/clip-track.hpp
diff --git a/src/gui/model/clip.cpp b/src/gui/model/clip.cpp
index 802543991..2815ea7fe 100644
--- a/src/gui/model/clip.cpp
+++ b/src/gui/model/clip.cpp
@@ -1,23 +1,23 @@
 /*
   timeline-track.cpp  -  Implementation of the timeline clip object
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 #include "clip.hpp"
diff --git a/src/gui/model/clip.hpp b/src/gui/model/clip.hpp
index 89f7d89d7..df9d67d1c 100644
--- a/src/gui/model/clip.hpp
+++ b/src/gui/model/clip.hpp
@@ -1,23 +1,23 @@
 /*
   timeline-clip.hpp  -  Declaration of the timeline clip object
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /** @file widgets/timeline/timeline-clip.hpp
  ** This file contains the definition of timeline clip object
diff --git a/src/gui/model/group-track.cpp b/src/gui/model/group-track.cpp
index 73ac08114..067821d82 100644
--- a/src/gui/model/group-track.cpp
+++ b/src/gui/model/group-track.cpp
@@ -1,23 +1,23 @@
 /*
   group-track.cpp  -  Implementation of the timeline group track object
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 #include "group-track.hpp"
diff --git a/src/gui/model/group-track.hpp b/src/gui/model/group-track.hpp
index ae3f48b63..6dc15db31 100644
--- a/src/gui/model/group-track.hpp
+++ b/src/gui/model/group-track.hpp
@@ -1,23 +1,23 @@
 /*
   group-track.hpp  -  Declaration of the timeline group track object
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /** @file widgets/timeline/group-track.hpp
  ** This file contains the definition of group track timeline objects
diff --git a/src/gui/model/parent-track.cpp b/src/gui/model/parent-track.cpp
index f7122fe46..874c7e9d5 100644
--- a/src/gui/model/parent-track.cpp
+++ b/src/gui/model/parent-track.cpp
@@ -1,23 +1,23 @@
 /*
   parent-track-.cpp  -  Implementation of the ParentTrack class
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 #include "parent-track.hpp"
diff --git a/src/gui/model/parent-track.hpp b/src/gui/model/parent-track.hpp
index bc26be80f..6d5b0481a 100644
--- a/src/gui/model/parent-track.hpp
+++ b/src/gui/model/parent-track.hpp
@@ -1,23 +1,23 @@
 /*
   parent-track.hpp  -  Definition of the ParentTrack class
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /** @file parent-track.hpp
  ** This file contains the definition of ParentTrack, a class which
diff --git a/src/gui/model/project.cpp b/src/gui/model/project.cpp
index cc7dd6b84..92dda0758 100644
--- a/src/gui/model/project.cpp
+++ b/src/gui/model/project.cpp
@@ -1,23 +1,23 @@
 /*
   project.cpp  -  Implementation of the Project class
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 #include <boost/foreach.hpp>
diff --git a/src/gui/model/project.hpp b/src/gui/model/project.hpp
index f70029f88..42fb8d611 100644
--- a/src/gui/model/project.hpp
+++ b/src/gui/model/project.hpp
@@ -1,23 +1,23 @@
 /*
   project.hpp  -  Definition of the Project class
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /** @file project.hpp
  ** This file contains the definition of Project, a class which
diff --git a/src/gui/model/sequence.cpp b/src/gui/model/sequence.cpp
index 361724125..6cb0269a9 100644
--- a/src/gui/model/sequence.cpp
+++ b/src/gui/model/sequence.cpp
@@ -1,23 +1,23 @@
 /*
   sequence.hpp  -  Implementation of the Sequence class
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 #include "sequence.hpp"
diff --git a/src/gui/model/sequence.hpp b/src/gui/model/sequence.hpp
index 717368a9c..ae4f59a2f 100644
--- a/src/gui/model/sequence.hpp
+++ b/src/gui/model/sequence.hpp
@@ -1,23 +1,23 @@
 /*
   sequence.hpp  -  Definition of the Sequence class
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /** @file sequence.hpp
  ** This file contains the definition of Sequence, a class which
diff --git a/src/gui/model/track.cpp b/src/gui/model/track.cpp
index d94926229..6d5cf2a65 100644
--- a/src/gui/model/track.cpp
+++ b/src/gui/model/track.cpp
@@ -1,23 +1,23 @@
 /*
   track.cpp  -  Implementation of the Track class
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 #include "track.hpp"
diff --git a/src/gui/model/track.hpp b/src/gui/model/track.hpp
index c59d06875..6dc5d2b71 100644
--- a/src/gui/model/track.hpp
+++ b/src/gui/model/track.hpp
@@ -1,23 +1,23 @@
 /*
   track.hpp  -  Definition of the Track class
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /** @file track.hpp
  ** This file contains the definition of Track, a class which
diff --git a/src/gui/notification-interface-proxy.hpp b/src/gui/notification-interface-proxy.hpp
index 361e01865..79500e8df 100644
--- a/src/gui/notification-interface-proxy.hpp
+++ b/src/gui/notification-interface-proxy.hpp
@@ -1,23 +1,23 @@
 /*
   Notification(Proxy)  -  public service allowing to push informations into the GUI
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/gui/notification-service.cpp b/src/gui/notification-service.cpp
index 080d1461d..0cfd3c826 100644
--- a/src/gui/notification-service.cpp
+++ b/src/gui/notification-service.cpp
@@ -1,23 +1,23 @@
 /*
   NotificationService  -  public service allowing to push informations into the GUI
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/gui/notification-service.hpp b/src/gui/notification-service.hpp
index c6e862be8..d7e2e218b 100644
--- a/src/gui/notification-service.hpp
+++ b/src/gui/notification-service.hpp
@@ -1,23 +1,23 @@
 /*
   NOTIFICATION-SERVICE.hpp  -  public service allowing to push informations into the GUI
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file notification-service.hpp
diff --git a/src/gui/output/displayer.cpp b/src/gui/output/displayer.cpp
index 482db826e..251279a9a 100644
--- a/src/gui/output/displayer.cpp
+++ b/src/gui/output/displayer.cpp
@@ -1,25 +1,25 @@
 /*
   displayer.cpp  -  Implements the base class for displaying video
- 
+
   Copyright (C)         Lumiera.org
     2000,               Arne Schirmacher <arne@schirmacher.de>
     2001-2007,          Dan Dennedy <dan@dennedy.org>
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 #include "../gtk-lumiera.hpp"
diff --git a/src/gui/output/displayer.hpp b/src/gui/output/displayer.hpp
index 5dc576565..1ec3ed6be 100644
--- a/src/gui/output/displayer.hpp
+++ b/src/gui/output/displayer.hpp
@@ -1,25 +1,25 @@
 /*
   displayer.hpp  -  Defines the base class for displaying video
- 
+
   Copyright (C)         Lumiera.org
     2000,               Arne Schirmacher <arne@schirmacher.de>
     2001-2007,          Dan Dennedy <dan@dennedy.org>
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /** @file displayer.hpp
  ** This file contains the defintion of Displayer; the base class
diff --git a/src/gui/output/gdkdisplayer.cpp b/src/gui/output/gdkdisplayer.cpp
index 523ed2bb5..1d6f96214 100644
--- a/src/gui/output/gdkdisplayer.cpp
+++ b/src/gui/output/gdkdisplayer.cpp
@@ -1,25 +1,25 @@
 /*
   gdkdisplayer.cpp  -  Implements the class for displaying video via GDK
- 
+
   Copyright (C)         Lumiera.org
     2000,               Arne Schirmacher <arne@schirmacher.de>
     2001-2007,          Dan Dennedy <dan@dennedy.org>
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 #include "../gtk-lumiera.hpp"
diff --git a/src/gui/output/gdkdisplayer.hpp b/src/gui/output/gdkdisplayer.hpp
index 76bb66d0f..291a20503 100644
--- a/src/gui/output/gdkdisplayer.hpp
+++ b/src/gui/output/gdkdisplayer.hpp
@@ -1,25 +1,25 @@
 /*
   gdkdisplayer.hpp  -  Defines the class for displaying video via GDK
- 
+
   Copyright (C)         Lumiera.org
     2000,               Arne Schirmacher <arne@schirmacher.de>
     2001-2007,          Dan Dennedy <dan@dennedy.org>
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /** @file gdkdisplayer.hpp
  ** This file contains the definition of XvDisplayer, the XVideo
diff --git a/src/gui/output/xvdisplayer.cpp b/src/gui/output/xvdisplayer.cpp
index 5799f93dc..81ed19188 100644
--- a/src/gui/output/xvdisplayer.cpp
+++ b/src/gui/output/xvdisplayer.cpp
@@ -1,25 +1,25 @@
 /*
   xvdisplayer.cpp  -  Implements the base class for XVideo display
- 
+
   Copyright (C)         Lumiera.org
     2000,               Arne Schirmacher <arne@schirmacher.de>
     2001-2007,          Dan Dennedy <dan@dennedy.org>
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 #include "../gtk-lumiera.hpp"
diff --git a/src/gui/output/xvdisplayer.hpp b/src/gui/output/xvdisplayer.hpp
index afc25c670..9c7e58208 100644
--- a/src/gui/output/xvdisplayer.hpp
+++ b/src/gui/output/xvdisplayer.hpp
@@ -1,25 +1,25 @@
 /*
   xvdisplayer.hpp  -  Defines the base class for XVideo display
- 
+
   Copyright (C)         Lumiera.org
     2000,               Arne Schirmacher <arne@schirmacher.de>
     2001-2007,          Dan Dennedy <dan@dennedy.org>
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /** @file xvdisplayer.hpp
  ** This file contains the definition of XvDisplayer, the XVideo
diff --git a/src/gui/panels/panel.cpp b/src/gui/panels/panel.cpp
index 4d782d619..4db7a2ff2 100644
--- a/src/gui/panels/panel.cpp
+++ b/src/gui/panels/panel.cpp
@@ -1,23 +1,23 @@
 /*
   panel.cpp  -  Implementation of Panel, the base class for docking panels 
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 #include "panel.hpp"
diff --git a/src/gui/panels/panel.hpp b/src/gui/panels/panel.hpp
index a46233169..5b0ed2afe 100644
--- a/src/gui/panels/panel.hpp
+++ b/src/gui/panels/panel.hpp
@@ -1,23 +1,23 @@
 /*
   panel.hpp  -  Definition of Panel, the base class for docking panels            
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /** @file panel.hpp
  ** This file contains the definition of Panel; the base class
diff --git a/src/gui/panels/resources-panel.cpp b/src/gui/panels/resources-panel.cpp
index 1180ddd58..bd37cf195 100644
--- a/src/gui/panels/resources-panel.cpp
+++ b/src/gui/panels/resources-panel.cpp
@@ -1,23 +1,23 @@
 /*
   assets-panel.cpp  -  Implementation of the assets panel
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 #include "../gtk-lumiera.hpp"
diff --git a/src/gui/panels/resources-panel.hpp b/src/gui/panels/resources-panel.hpp
index 5c725dc3c..20021a920 100644
--- a/src/gui/panels/resources-panel.hpp
+++ b/src/gui/panels/resources-panel.hpp
@@ -1,23 +1,23 @@
 /*
   assets-panel.hpp  -  Definition of the assets panel            
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /** @file assets-panel.hpp
  ** This file contains the definition of the assets panel
diff --git a/src/gui/panels/timeline-panel.cpp b/src/gui/panels/timeline-panel.cpp
index a93e49251..756fef16e 100644
--- a/src/gui/panels/timeline-panel.cpp
+++ b/src/gui/panels/timeline-panel.cpp
@@ -1,23 +1,23 @@
 /*
   timeline-panel.cpp  -  Implementation of the timeline panel
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 #include <boost/foreach.hpp>
diff --git a/src/gui/panels/timeline-panel.hpp b/src/gui/panels/timeline-panel.hpp
index eaec9e02b..73c60b7a0 100644
--- a/src/gui/panels/timeline-panel.hpp
+++ b/src/gui/panels/timeline-panel.hpp
@@ -1,23 +1,23 @@
 /*
   timeline-panel.hpp  -  Definition of the timeline panel            
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /** @file timeline-panel.hpp
  ** This file contains the definition of the timeline panel
diff --git a/src/gui/panels/viewer-panel.cpp b/src/gui/panels/viewer-panel.cpp
index 94c055a00..01a94934f 100644
--- a/src/gui/panels/viewer-panel.cpp
+++ b/src/gui/panels/viewer-panel.cpp
@@ -1,23 +1,23 @@
 /*
   viewer-panel.cpp  -  Implementation of the viewer panel
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 #include "../gtk-lumiera.hpp"
diff --git a/src/gui/panels/viewer-panel.hpp b/src/gui/panels/viewer-panel.hpp
index a51b3997f..fd234a823 100644
--- a/src/gui/panels/viewer-panel.hpp
+++ b/src/gui/panels/viewer-panel.hpp
@@ -1,23 +1,23 @@
 /*
   viewer-panel.hpp  -  Definition of the viewer panel            
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /** @file viewer-panel.hpp
  ** This file contains the definition of the viewer panel
diff --git a/src/gui/util/rectangle.cpp b/src/gui/util/rectangle.cpp
index 72c678a2b..e8797784c 100644
--- a/src/gui/util/rectangle.cpp
+++ b/src/gui/util/rectangle.cpp
@@ -1,23 +1,23 @@
 /*
   rectangle.cpp  -  Implements utility functions for GDK rects
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 #include "rectangle.hpp"
diff --git a/src/gui/util/rectangle.hpp b/src/gui/util/rectangle.hpp
index bd72adb2d..ae77d2305 100644
--- a/src/gui/util/rectangle.hpp
+++ b/src/gui/util/rectangle.hpp
@@ -1,23 +1,23 @@
 /*
   rectangle.hpp  -  Declares utility functions for GDK rects
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 /** @file rectangle.hpp
  ** This file contains the declaration of the utility functions for
diff --git a/src/gui/widgets/button-bar.cpp b/src/gui/widgets/button-bar.cpp
index 9e121be48..ccd3c1919 100644
--- a/src/gui/widgets/button-bar.cpp
+++ b/src/gui/widgets/button-bar.cpp
@@ -1,23 +1,23 @@
 /*
   button-bar.cpp  -  Implementation of the button bar widget
- 
+
   Copyright (C)         Lumiera.org
     2009,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 #include "button-bar.hpp"
diff --git a/src/gui/widgets/button-bar.hpp b/src/gui/widgets/button-bar.hpp
index d9a0b2d79..237f0270c 100644
--- a/src/gui/widgets/button-bar.hpp
+++ b/src/gui/widgets/button-bar.hpp
@@ -1,23 +1,23 @@
 /*
   button-bar.hpp  -  Declaration of the button bar widget
- 
+
   Copyright (C)         Lumiera.org
     2009,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /** @file button-bar.hpp
  ** This file contains the definition of the button bar widget
diff --git a/src/gui/widgets/menu-button.cpp b/src/gui/widgets/menu-button.cpp
index 6c78d5c67..a5e7629b6 100644
--- a/src/gui/widgets/menu-button.cpp
+++ b/src/gui/widgets/menu-button.cpp
@@ -1,23 +1,23 @@
 /*
   menu-button.cpp  -  Implementation of the menu button widget
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 #include "menu-button.hpp"
diff --git a/src/gui/widgets/menu-button.hpp b/src/gui/widgets/menu-button.hpp
index 0ebca1b0b..fe32f677d 100644
--- a/src/gui/widgets/menu-button.hpp
+++ b/src/gui/widgets/menu-button.hpp
@@ -1,23 +1,23 @@
 /*
   menu-button.hpp  -  Declaration of the menu button widget
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /** @file menu-button.hpp
  ** This file contains the definition of menu button widget
diff --git a/src/gui/widgets/mini-button.hpp b/src/gui/widgets/mini-button.hpp
index 7edf510ad..9b6c39565 100644
--- a/src/gui/widgets/mini-button.hpp
+++ b/src/gui/widgets/mini-button.hpp
@@ -1,23 +1,23 @@
 /*
   mini-button.hpp  -  Declaration of the mini button widget
- 
+
   Copyright (C)         Lumiera.org
     2009,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /** @file mini-button.hpp
  ** This file contains the definition of mini button widget
diff --git a/src/gui/widgets/panel-bar.cpp b/src/gui/widgets/panel-bar.cpp
index 251c9a7cf..7b41a4d32 100644
--- a/src/gui/widgets/panel-bar.cpp
+++ b/src/gui/widgets/panel-bar.cpp
@@ -1,23 +1,23 @@
 /*
   panel-bar.hpp  -  Declaration of the panel bar widget
- 
+
   Copyright (C)         Lumiera.org
     2009,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 #include "panel-bar.hpp"
diff --git a/src/gui/widgets/panel-bar.hpp b/src/gui/widgets/panel-bar.hpp
index 30e08c91e..d9f9d99e1 100644
--- a/src/gui/widgets/panel-bar.hpp
+++ b/src/gui/widgets/panel-bar.hpp
@@ -1,23 +1,23 @@
 /*
   panel-bar.hpp  -  Declaration of the panel bar widget
- 
+
   Copyright (C)         Lumiera.org
     2009,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /** @file panel-bar.hpp
  ** This file contains the definition of timeline widget
diff --git a/src/gui/widgets/timeline-widget.cpp b/src/gui/widgets/timeline-widget.cpp
index 721467536..eabf25514 100644
--- a/src/gui/widgets/timeline-widget.cpp
+++ b/src/gui/widgets/timeline-widget.cpp
@@ -1,23 +1,23 @@
 /*
   timeline-widget.cpp  -  Implementation of the timeline widget
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 #include "timeline-widget.hpp"
diff --git a/src/gui/widgets/timeline-widget.hpp b/src/gui/widgets/timeline-widget.hpp
index 41e368947..2278f5ca9 100644
--- a/src/gui/widgets/timeline-widget.hpp
+++ b/src/gui/widgets/timeline-widget.hpp
@@ -1,23 +1,23 @@
 /*
   timeline-widget.hpp  -  Declaration of the timeline widget
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /** @file timeline-widget.hpp
  ** This file contains the definition of timeline widget
diff --git a/src/gui/widgets/timeline/timeline-arrow-tool.cpp b/src/gui/widgets/timeline/timeline-arrow-tool.cpp
index c211e3ace..d985cf7bf 100644
--- a/src/gui/widgets/timeline/timeline-arrow-tool.cpp
+++ b/src/gui/widgets/timeline/timeline-arrow-tool.cpp
@@ -1,23 +1,23 @@
 /*
   timeline-arrow-tool.cpp  -  Implementation of the ArrowTool class
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 #include "timeline-arrow-tool.hpp"
diff --git a/src/gui/widgets/timeline/timeline-arrow-tool.hpp b/src/gui/widgets/timeline/timeline-arrow-tool.hpp
index 74d6f8e5c..be21b19c5 100644
--- a/src/gui/widgets/timeline/timeline-arrow-tool.hpp
+++ b/src/gui/widgets/timeline/timeline-arrow-tool.hpp
@@ -1,23 +1,23 @@
 /*
   timeline-arrow-tool.hpp  -  Declaration of the ArrowTool class
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /** @file timeline-arrow-tool.hpp
  ** This file contains the definition of the arrow tool class
diff --git a/src/gui/widgets/timeline/timeline-body.cpp b/src/gui/widgets/timeline/timeline-body.cpp
index 44eb9a472..eac93ba09 100644
--- a/src/gui/widgets/timeline/timeline-body.cpp
+++ b/src/gui/widgets/timeline/timeline-body.cpp
@@ -1,23 +1,23 @@
 /*
   timeline.cpp  -  Implementation of the timeline widget
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 #include <cairomm-1.0/cairomm/cairomm.h>
diff --git a/src/gui/widgets/timeline/timeline-body.hpp b/src/gui/widgets/timeline/timeline-body.hpp
index e218ae3a4..46dfb2303 100644
--- a/src/gui/widgets/timeline/timeline-body.hpp
+++ b/src/gui/widgets/timeline/timeline-body.hpp
@@ -1,23 +1,23 @@
 /*
   timeline-body.hpp  -  Declaration of the timeline body widget
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /** @file timeline-body.hpp
  ** This file contains the definition of timeline body widget
diff --git a/src/gui/widgets/timeline/timeline-clip-track.cpp b/src/gui/widgets/timeline/timeline-clip-track.cpp
index 0f0f2f1f5..2b2bbb875 100644
--- a/src/gui/widgets/timeline/timeline-clip-track.cpp
+++ b/src/gui/widgets/timeline/timeline-clip-track.cpp
@@ -1,23 +1,23 @@
 /*
   timeline-clip-track.cpp  -  Implementation of the timeline clip track object
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 #include "timeline-clip-track.hpp"
diff --git a/src/gui/widgets/timeline/timeline-clip-track.hpp b/src/gui/widgets/timeline/timeline-clip-track.hpp
index 1ac781195..f6947fbe8 100644
--- a/src/gui/widgets/timeline/timeline-clip-track.hpp
+++ b/src/gui/widgets/timeline/timeline-clip-track.hpp
@@ -1,23 +1,23 @@
 /*
   timeline-clip-track.hpp  -  Declaration of the timeline clip track object
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /**
  * @file widgets/timeline/timeline-clip-track.hpp
diff --git a/src/gui/widgets/timeline/timeline-clip.cpp b/src/gui/widgets/timeline/timeline-clip.cpp
index a6b6fb124..e4c031e52 100644
--- a/src/gui/widgets/timeline/timeline-clip.cpp
+++ b/src/gui/widgets/timeline/timeline-clip.cpp
@@ -1,23 +1,23 @@
 /*
   timeline-track.cpp  -  Implementation of the timeline clip object
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 #include "timeline-clip.hpp"
diff --git a/src/gui/widgets/timeline/timeline-clip.hpp b/src/gui/widgets/timeline/timeline-clip.hpp
index 3dd8b0759..46cc751be 100644
--- a/src/gui/widgets/timeline/timeline-clip.hpp
+++ b/src/gui/widgets/timeline/timeline-clip.hpp
@@ -1,23 +1,23 @@
 /*
   timeline-clip.hpp  -  Declaration of the timeline clip object
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /** @file widgets/timeline/timeline-clip.hpp
  ** This file contains the definition of timeline clip object
diff --git a/src/gui/widgets/timeline/timeline-group-track.cpp b/src/gui/widgets/timeline/timeline-group-track.cpp
index 56ad56c0a..6ecc20005 100644
--- a/src/gui/widgets/timeline/timeline-group-track.cpp
+++ b/src/gui/widgets/timeline/timeline-group-track.cpp
@@ -1,23 +1,23 @@
 /*
   timeline-group-track.cpp  -  Implementation of the timeline group track object
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 #include "timeline-group-track.hpp"
diff --git a/src/gui/widgets/timeline/timeline-group-track.hpp b/src/gui/widgets/timeline/timeline-group-track.hpp
index 821acf9a8..62e4d8d53 100644
--- a/src/gui/widgets/timeline/timeline-group-track.hpp
+++ b/src/gui/widgets/timeline/timeline-group-track.hpp
@@ -1,23 +1,23 @@
 /*
   timeline-group-track.hpp  -  Declaration of the timeline group track object
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /** @file widgets/timeline/timeline-group-track.hpp
  ** This file contains the definition of group track timeline objects
diff --git a/src/gui/widgets/timeline/timeline-header-container.cpp b/src/gui/widgets/timeline/timeline-header-container.cpp
index 5b6291ade..93f2e6aee 100644
--- a/src/gui/widgets/timeline/timeline-header-container.cpp
+++ b/src/gui/widgets/timeline/timeline-header-container.cpp
@@ -1,24 +1,24 @@
 /*
   timeline-header-container.cpp  -  Implementation of the timeline
   header container widget
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 #include <boost/foreach.hpp>
diff --git a/src/gui/widgets/timeline/timeline-header-container.hpp b/src/gui/widgets/timeline/timeline-header-container.hpp
index 8243135d2..921394eff 100644
--- a/src/gui/widgets/timeline/timeline-header-container.hpp
+++ b/src/gui/widgets/timeline/timeline-header-container.hpp
@@ -1,24 +1,24 @@
 /*
   timeline-header-container.hpp  -  Declaration of the timeline
   header container widget
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /** @file timeline-header-container.hpp
  ** This file contains the definition of the header container
diff --git a/src/gui/widgets/timeline/timeline-header-widget.cpp b/src/gui/widgets/timeline/timeline-header-widget.cpp
index f51e026cf..ae5e85a98 100644
--- a/src/gui/widgets/timeline/timeline-header-widget.cpp
+++ b/src/gui/widgets/timeline/timeline-header-widget.cpp
@@ -1,24 +1,24 @@
 /*
   timeline-header-widget.cpp  -  Implementation of the timeline
   header widget
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 #include <boost/foreach.hpp>
diff --git a/src/gui/widgets/timeline/timeline-header-widget.hpp b/src/gui/widgets/timeline/timeline-header-widget.hpp
index 3db843738..18dcfb78c 100644
--- a/src/gui/widgets/timeline/timeline-header-widget.hpp
+++ b/src/gui/widgets/timeline/timeline-header-widget.hpp
@@ -1,24 +1,24 @@
 /*
   timeline-header-widget.hpp  -  Declaration of the timeline
   header widget
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /** @file timeline-header-widget.hpp
  ** This file contains the definition of the header widget
diff --git a/src/gui/widgets/timeline/timeline-ibeam-tool.cpp b/src/gui/widgets/timeline/timeline-ibeam-tool.cpp
index 7e243ef7c..5e37d4b4d 100644
--- a/src/gui/widgets/timeline/timeline-ibeam-tool.cpp
+++ b/src/gui/widgets/timeline/timeline-ibeam-tool.cpp
@@ -1,23 +1,23 @@
 /*
   timeline-ibeam-tool.cpp  -  Implementation of the IBeamTool class
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 #include "timeline-ibeam-tool.hpp"
diff --git a/src/gui/widgets/timeline/timeline-ibeam-tool.hpp b/src/gui/widgets/timeline/timeline-ibeam-tool.hpp
index 5d05b14ba..219a6dd49 100644
--- a/src/gui/widgets/timeline/timeline-ibeam-tool.hpp
+++ b/src/gui/widgets/timeline/timeline-ibeam-tool.hpp
@@ -1,23 +1,23 @@
 /*
   timeline-ibeam-tool.hpp  -  Declaration of the ArrowTool class
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /** @file timeline-ibeam-tool.hpp
  ** This file contains the definition of ibeam tool class
diff --git a/src/gui/widgets/timeline/timeline-layout-helper.cpp b/src/gui/widgets/timeline/timeline-layout-helper.cpp
index 93531f800..c9ff0ed03 100644
--- a/src/gui/widgets/timeline/timeline-layout-helper.cpp
+++ b/src/gui/widgets/timeline/timeline-layout-helper.cpp
@@ -1,24 +1,24 @@
 /*
   timeline-layout-helper.cpp  -  Implementation of the timeline
   layout helper class
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 #include <boost/foreach.hpp>
diff --git a/src/gui/widgets/timeline/timeline-layout-helper.hpp b/src/gui/widgets/timeline/timeline-layout-helper.hpp
index 217f35d13..f8ac3f7bd 100644
--- a/src/gui/widgets/timeline/timeline-layout-helper.hpp
+++ b/src/gui/widgets/timeline/timeline-layout-helper.hpp
@@ -1,24 +1,24 @@
 /*
   timeline-layout-helper.hpp  -  Declaration of the timeline
   layout helper class
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /** @file timeline-layout-helper.cpp
  ** This file contains the definition of the layout helpeer class
diff --git a/src/gui/widgets/timeline/timeline-ruler.cpp b/src/gui/widgets/timeline/timeline-ruler.cpp
index cce311007..cd5c9cdd3 100644
--- a/src/gui/widgets/timeline/timeline-ruler.cpp
+++ b/src/gui/widgets/timeline/timeline-ruler.cpp
@@ -1,23 +1,23 @@
 /*
   timeline-ruler.cpp  -  Implementation of the time ruler widget
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 #include <cairomm-1.0/cairomm/cairomm.h>
diff --git a/src/gui/widgets/timeline/timeline-ruler.hpp b/src/gui/widgets/timeline/timeline-ruler.hpp
index e47038ab1..4e8bf2083 100644
--- a/src/gui/widgets/timeline/timeline-ruler.hpp
+++ b/src/gui/widgets/timeline/timeline-ruler.hpp
@@ -1,23 +1,23 @@
 /*
   timeline-ruler.hpp  -  Declaration of the time ruler widget
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /** @file timeline-ruler.hpp
  ** This file contains the declaration of the time ruler widget
diff --git a/src/gui/widgets/timeline/timeline-state.cpp b/src/gui/widgets/timeline/timeline-state.cpp
index e6a6e92c5..f8e712169 100644
--- a/src/gui/widgets/timeline/timeline-state.cpp
+++ b/src/gui/widgets/timeline/timeline-state.cpp
@@ -1,23 +1,23 @@
 /*
   timeline-state.cpp  -  Implementation of the timeline state object
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 #include "timeline-state.hpp"
diff --git a/src/gui/widgets/timeline/timeline-state.hpp b/src/gui/widgets/timeline/timeline-state.hpp
index 431173240..2d9a11ea3 100644
--- a/src/gui/widgets/timeline/timeline-state.hpp
+++ b/src/gui/widgets/timeline/timeline-state.hpp
@@ -1,23 +1,23 @@
 /*
   timeline-state.hpp  -  Declaration of the timeline state object
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /** @file widgets/timeline/timeline-state.hpp
  ** This file contains the definition of the timeline state object
diff --git a/src/gui/widgets/timeline/timeline-tool.cpp b/src/gui/widgets/timeline/timeline-tool.cpp
index 96991ef64..bc1092e53 100644
--- a/src/gui/widgets/timeline/timeline-tool.cpp
+++ b/src/gui/widgets/timeline/timeline-tool.cpp
@@ -1,23 +1,23 @@
 /*
   timeline-tool.hpp  -  Implementation of the Tool class
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 #include "timeline-tool.hpp"
diff --git a/src/gui/widgets/timeline/timeline-tool.hpp b/src/gui/widgets/timeline/timeline-tool.hpp
index 9b5d8ea16..af9e61146 100644
--- a/src/gui/widgets/timeline/timeline-tool.hpp
+++ b/src/gui/widgets/timeline/timeline-tool.hpp
@@ -1,23 +1,23 @@
 /*
   timeline-tool.hpp  -  Declaration of the Tool class
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /** @file timeline-tool.hpp
  ** This file contains the definition of base class for timeline
diff --git a/src/gui/widgets/timeline/timeline-track.cpp b/src/gui/widgets/timeline/timeline-track.cpp
index b6c69a698..810a7d84f 100644
--- a/src/gui/widgets/timeline/timeline-track.cpp
+++ b/src/gui/widgets/timeline/timeline-track.cpp
@@ -1,23 +1,23 @@
 /*
   timeline-track.cpp  -  Implementation of the timeline track object
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 #include "timeline-track.hpp"
diff --git a/src/gui/widgets/timeline/timeline-track.hpp b/src/gui/widgets/timeline/timeline-track.hpp
index fbb6b56cc..8b1ed5099 100644
--- a/src/gui/widgets/timeline/timeline-track.hpp
+++ b/src/gui/widgets/timeline/timeline-track.hpp
@@ -1,23 +1,23 @@
 /*
   timeline-track.hpp  -  Declaration of the timeline group track object
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /** @file widgets/timeline/timeline-track.hpp
  ** This file contains the definition of timeline track object
diff --git a/src/gui/widgets/timeline/timeline-view-window.cpp b/src/gui/widgets/timeline/timeline-view-window.cpp
index e5283a24a..6ea7ff242 100644
--- a/src/gui/widgets/timeline/timeline-view-window.cpp
+++ b/src/gui/widgets/timeline/timeline-view-window.cpp
@@ -1,23 +1,23 @@
 /*
   timeline-window.hpp  -  Implementation of the timeline window object
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 #include "timeline-view-window.hpp"
diff --git a/src/gui/widgets/timeline/timeline-view-window.hpp b/src/gui/widgets/timeline/timeline-view-window.hpp
index 8689b6ce6..972f30edb 100644
--- a/src/gui/widgets/timeline/timeline-view-window.hpp
+++ b/src/gui/widgets/timeline/timeline-view-window.hpp
@@ -1,23 +1,23 @@
 /*
   timeline-view-window.hpp  -  Declaration of the timeline window object
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /** @file widgets/timeline/timeline-view-window.hpp
  ** This file contains the definition of timeline view window helper
diff --git a/src/gui/widgets/video-display-widget.cpp b/src/gui/widgets/video-display-widget.cpp
index 4a31af101..5b6d59b1f 100644
--- a/src/gui/widgets/video-display-widget.cpp
+++ b/src/gui/widgets/video-display-widget.cpp
@@ -1,23 +1,23 @@
 /*
   video-display-widget.cpp  -  Implementation of the video viewer widget
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 #include <gdkmm/drawable.h>
diff --git a/src/gui/widgets/video-display-widget.hpp b/src/gui/widgets/video-display-widget.hpp
index 6587362cf..9eea972f2 100644
--- a/src/gui/widgets/video-display-widget.hpp
+++ b/src/gui/widgets/video-display-widget.hpp
@@ -1,23 +1,23 @@
 /*
   video-display-widget.hpp  -  Declaration of the video viewer widget
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /** @file video-display-widget.hpp
  ** This file contains the definition of video viewer widget
diff --git a/src/gui/window-manager.cpp b/src/gui/window-manager.cpp
index 0e6319816..2ede0c8ba 100644
--- a/src/gui/window-manager.cpp
+++ b/src/gui/window-manager.cpp
@@ -1,23 +1,23 @@
 /*
   window-manager.cpp  -  Defines the global UI Manager class
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 #include "window-manager.hpp"
diff --git a/src/gui/window-manager.hpp b/src/gui/window-manager.hpp
index 341c25fcb..0724c04b3 100644
--- a/src/gui/window-manager.hpp
+++ b/src/gui/window-manager.hpp
@@ -1,23 +1,23 @@
 /*
   window-manager.hpp  -  Defines the global UI Manager class
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /** @file window-manager.hpp
  ** This file contains the defintion of global UI Manager class.
diff --git a/src/gui/workspace/actions.cpp b/src/gui/workspace/actions.cpp
index af8d94952..cf0761964 100644
--- a/src/gui/workspace/actions.cpp
+++ b/src/gui/workspace/actions.cpp
@@ -1,23 +1,23 @@
 /*
   Actions.cpp  -  Definition of the main workspace window object
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 #include "actions.hpp"
diff --git a/src/gui/workspace/actions.hpp b/src/gui/workspace/actions.hpp
index c6e843832..aa25fbee6 100644
--- a/src/gui/workspace/actions.hpp
+++ b/src/gui/workspace/actions.hpp
@@ -1,23 +1,23 @@
 /*
   ACTIONS.hpp  -  Definition of a helper class for user actions
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /** @file actions.hpp
  ** This file contains the definition of a helper class for the
diff --git a/src/gui/workspace/panel-manager.cpp b/src/gui/workspace/panel-manager.cpp
index 357f91860..3cabe8f45 100644
--- a/src/gui/workspace/panel-manager.cpp
+++ b/src/gui/workspace/panel-manager.cpp
@@ -1,23 +1,23 @@
 /*
   panel-manager.cpp  -  Definition of the panel manager object
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 #include "panel-manager.hpp"
diff --git a/src/gui/workspace/panel-manager.hpp b/src/gui/workspace/panel-manager.hpp
index 012826184..9362b66aa 100644
--- a/src/gui/workspace/panel-manager.hpp
+++ b/src/gui/workspace/panel-manager.hpp
@@ -1,23 +1,23 @@
 /*
   panel-manager.hpp  -  Definition of the panel manager object
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /** @file panel-manager.hpp
  ** This file contains the definition of the panel manager object.
diff --git a/src/gui/workspace/workspace-window.cpp b/src/gui/workspace/workspace-window.cpp
index 5a74c526f..e7b91a6a0 100644
--- a/src/gui/workspace/workspace-window.cpp
+++ b/src/gui/workspace/workspace-window.cpp
@@ -1,23 +1,23 @@
 /*
   workspace-window.cpp  -  Definition of the main workspace window object
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 #include <gtkmm/stock.h>
diff --git a/src/gui/workspace/workspace-window.hpp b/src/gui/workspace/workspace-window.hpp
index b00b009a6..a038728f1 100644
--- a/src/gui/workspace/workspace-window.hpp
+++ b/src/gui/workspace/workspace-window.hpp
@@ -1,23 +1,23 @@
 /*
   workspace-window.hpp  -  Definition of the main workspace window object
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /** @file workspace-window.hpp
  ** This file contains the definition of the main workspace window
diff --git a/src/include/configfacade.hpp b/src/include/configfacade.hpp
index 7e6c8307b..90a2528b2 100644
--- a/src/include/configfacade.hpp
+++ b/src/include/configfacade.hpp
@@ -1,23 +1,23 @@
 /*
   CONFIGFACADE  -  C++ convenience wrapper and startup of the config system
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file configfacade.hpp
diff --git a/src/include/display-facade.h b/src/include/display-facade.h
index ef12fdb1d..d226fa6e5 100644
--- a/src/include/display-facade.h
+++ b/src/include/display-facade.h
@@ -1,23 +1,23 @@
 /*
   DISPLAY-FACADE.h  -  accessing a display for outputting frames
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file display-facade.h
diff --git a/src/include/display-handles.h b/src/include/display-handles.h
index 467607427..8efb51ed9 100644
--- a/src/include/display-handles.h
+++ b/src/include/display-handles.h
@@ -1,23 +1,23 @@
 /*
   DISPLAY-HANDLES.h  -  opaque handle types for playback and display
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file display-handles.hpp
diff --git a/src/include/dummy-player-facade.h b/src/include/dummy-player-facade.h
index 0447172d1..403ca2f35 100644
--- a/src/include/dummy-player-facade.h
+++ b/src/include/dummy-player-facade.h
@@ -1,23 +1,23 @@
 /*
   DUMMY-PLAYER-FACADE.h  -  access point to a dummy test player
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/include/guinotification-facade.h b/src/include/guinotification-facade.h
index ea575fb5f..8c0834d2c 100644
--- a/src/include/guinotification-facade.h
+++ b/src/include/guinotification-facade.h
@@ -1,23 +1,23 @@
 /*
   GUINOTIFICATION-FACADE.h  -  access point for pushing informations into the GUI
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file guinotification-facade.h
diff --git a/src/include/interfaceproxy.hpp b/src/include/interfaceproxy.hpp
index 26d1761f1..ea5677042 100644
--- a/src/include/interfaceproxy.hpp
+++ b/src/include/interfaceproxy.hpp
@@ -1,23 +1,23 @@
 /*
   INTERFACEPROXY  -  definition of forwarding proxies for the facade interfaces
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file interfaceproxy.hpp
diff --git a/src/include/lifecycle.h b/src/include/lifecycle.h
index 26e649569..3313e5bee 100644
--- a/src/include/lifecycle.h
+++ b/src/include/lifecycle.h
@@ -1,23 +1,23 @@
 /*
   LIFECYCLE.h  -  interface for registering and triggering lifecycle callbacks 
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file lifecycle.h
diff --git a/src/include/logging.h b/src/include/logging.h
index d5123f48f..e2b9455ea 100644
--- a/src/include/logging.h
+++ b/src/include/logging.h
@@ -7,8 +7,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/lib/access-casted.hpp b/src/lib/access-casted.hpp
index 503262294..9f51110f8 100644
--- a/src/lib/access-casted.hpp
+++ b/src/lib/access-casted.hpp
@@ -1,23 +1,23 @@
 /*
   ACCESS-CASTED.hpp  -  util template to access a value using conversion or cast as appropriate
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lib/advice.hpp b/src/lib/advice.hpp
index dd6e749eb..d83c33aa4 100644
--- a/src/lib/advice.hpp
+++ b/src/lib/advice.hpp
@@ -1,23 +1,23 @@
 /*
   ADVICE.hpp  -  generic loosely coupled interaction guided by symbolic pattern
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lib/advice/advice.cpp b/src/lib/advice/advice.cpp
index cbd70e764..2255de2b6 100644
--- a/src/lib/advice/advice.cpp
+++ b/src/lib/advice/advice.cpp
@@ -1,23 +1,23 @@
 /*
   Advice  -  generic loosely coupled interaction guided by symbolic pattern
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/lib/advice/binding.cpp b/src/lib/advice/binding.cpp
index c123f04d7..82bcc491b 100644
--- a/src/lib/advice/binding.cpp
+++ b/src/lib/advice/binding.cpp
@@ -1,23 +1,23 @@
 /*
   Binding  -  pattern defining a specific attachment to the Advice system
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/lib/advice/binding.hpp b/src/lib/advice/binding.hpp
index 23d2b5ae4..df9715907 100644
--- a/src/lib/advice/binding.hpp
+++ b/src/lib/advice/binding.hpp
@@ -1,23 +1,23 @@
 /*
   BINDING.hpp  -  pattern defining a specific attachment to the Advice system
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lib/advice/index.hpp b/src/lib/advice/index.hpp
index 7d3b07fc0..5f3fa249a 100644
--- a/src/lib/advice/index.hpp
+++ b/src/lib/advice/index.hpp
@@ -1,23 +1,23 @@
 /*
   INDEX.hpp  -  data structure for organising advice solutions and matching
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lib/allocationcluster.cpp b/src/lib/allocationcluster.cpp
index ae283e62f..7e186ec93 100644
--- a/src/lib/allocationcluster.cpp
+++ b/src/lib/allocationcluster.cpp
@@ -1,23 +1,23 @@
 /*
   AllocationCluster  -  allocating and owning a pile of objects
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/lib/allocationcluster.hpp b/src/lib/allocationcluster.hpp
index 1b51e9d5c..638aa0564 100644
--- a/src/lib/allocationcluster.hpp
+++ b/src/lib/allocationcluster.hpp
@@ -1,23 +1,23 @@
 /*
   ALLOCATIONCLUSTER.hpp  -  allocating and owning a pile of objects
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file allocationcluster.hpp
diff --git a/src/lib/bool-checkable.hpp b/src/lib/bool-checkable.hpp
index 8ff9ab063..4f03c2773 100644
--- a/src/lib/bool-checkable.hpp
+++ b/src/lib/bool-checkable.hpp
@@ -1,23 +1,23 @@
 /*
   BOOL-CHECKABLE.hpp  -  mixin template for defining a safe conversion to bool
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lib/cmdline.cpp b/src/lib/cmdline.cpp
index 90335230e..8539909ec 100644
--- a/src/lib/cmdline.cpp
+++ b/src/lib/cmdline.cpp
@@ -1,23 +1,23 @@
 /*
   Cmdline  -  abstraction of the usual commandline, a sequence of strings 
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/lib/cmdline.hpp b/src/lib/cmdline.hpp
index 1353a9d1d..88d6e2d5a 100644
--- a/src/lib/cmdline.hpp
+++ b/src/lib/cmdline.hpp
@@ -1,23 +1,23 @@
 /*
   CMDLINE.hpp  -  abstraction of the usual commandline, a sequence of strings 
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lib/condition.c b/src/lib/condition.c
index 7c2d31d8e..2218f40ce 100644
--- a/src/lib/condition.c
+++ b/src/lib/condition.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/lib/condition.h b/src/lib/condition.h
index db06d5441..70d1a2a03 100644
--- a/src/lib/condition.h
+++ b/src/lib/condition.h
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/lib/cuckoo.c b/src/lib/cuckoo.c
index b2ad064c0..4b3a2cbee 100644
--- a/src/lib/cuckoo.c
+++ b/src/lib/cuckoo.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/lib/cuckoo.h b/src/lib/cuckoo.h
index 84546d002..9fc5c2e75 100644
--- a/src/lib/cuckoo.h
+++ b/src/lib/cuckoo.h
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/lib/del-stash.hpp b/src/lib/del-stash.hpp
index 11dd537c6..92dcef26a 100644
--- a/src/lib/del-stash.hpp
+++ b/src/lib/del-stash.hpp
@@ -1,23 +1,23 @@
 /*
   DEL-STASH.hpp  -  collect and execute deleter functions
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lib/diagnostic-context.hpp b/src/lib/diagnostic-context.hpp
index 0003c0677..28f97c5c1 100644
--- a/src/lib/diagnostic-context.hpp
+++ b/src/lib/diagnostic-context.hpp
@@ -1,14 +1,14 @@
 /*
   DIAGNOSTIC-CONTEXT.hpp  -  thread local stack for explicitly collecting diagnostic context info
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
diff --git a/src/lib/element-tracker.hpp b/src/lib/element-tracker.hpp
index 4513ae379..d7d6c1794 100644
--- a/src/lib/element-tracker.hpp
+++ b/src/lib/element-tracker.hpp
@@ -1,23 +1,23 @@
 /*
   ELEMENT-TRACKER.hpp  -  registry for tracking instances automatically
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lib/error.c b/src/lib/error.c
index 0de5f4b7a..d91a27359 100644
--- a/src/lib/error.c
+++ b/src/lib/error.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/lib/error.h b/src/lib/error.h
index 1449c4fa2..f76a21591 100644
--- a/src/lib/error.h
+++ b/src/lib/error.h
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/lib/error.hpp b/src/lib/error.hpp
index 4a841c629..af911ac7a 100644
--- a/src/lib/error.hpp
+++ b/src/lib/error.hpp
@@ -1,23 +1,23 @@
 /*
   ERROR.hpp  -  Lumiera Exception Interface
- 
+
   Copyright (C)         Lumiera.org
     2008-2010           Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lib/exception.cpp b/src/lib/exception.cpp
index 8d11c8580..bd19d30f6 100644
--- a/src/lib/exception.cpp
+++ b/src/lib/exception.cpp
@@ -1,23 +1,23 @@
 /*
   Error  -  Lumiera Exception Interface
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/lib/factory.hpp b/src/lib/factory.hpp
index 6cefba752..28d37ad1a 100644
--- a/src/lib/factory.hpp
+++ b/src/lib/factory.hpp
@@ -1,23 +1,23 @@
 /*
   FACTORY.hpp  -  template for object/smart-pointer factories
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lib/format.hpp b/src/lib/format.hpp
index 0e75f6da2..4aa0a1743 100644
--- a/src/lib/format.hpp
+++ b/src/lib/format.hpp
@@ -1,23 +1,23 @@
 /*
   FORMAT.hpp  -  helpers for formatting and diagnostics
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lib/frameid.hpp b/src/lib/frameid.hpp
index 1e0f2af78..a8db83077 100644
--- a/src/lib/frameid.hpp
+++ b/src/lib/frameid.hpp
@@ -1,23 +1,23 @@
 /*
   FRAMEID.hpp  -  distinct identification of a single data frame
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lib/functor-util.hpp b/src/lib/functor-util.hpp
index 7efee7060..d47b86a9c 100644
--- a/src/lib/functor-util.hpp
+++ b/src/lib/functor-util.hpp
@@ -1,23 +1,23 @@
 /*
   FUNCTOR-UTIL.hpp  -  collection of helpers for dealing with functors and signals
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lib/handle.hpp b/src/lib/handle.hpp
index cb3b56e55..a1a01a919 100644
--- a/src/lib/handle.hpp
+++ b/src/lib/handle.hpp
@@ -1,14 +1,14 @@
 /*
   HANDLE.hpp  -  opaque handle to an implementation entity, automatically managing lifecycle
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
diff --git a/src/lib/hash-indexed.hpp b/src/lib/hash-indexed.hpp
index 81c0b37fa..d665dac81 100644
--- a/src/lib/hash-indexed.hpp
+++ b/src/lib/hash-indexed.hpp
@@ -1,23 +1,23 @@
 /*
   HASH-INDEXED.hpp  -  generic hash based and typed ID
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lib/iter-adapter-stl.hpp b/src/lib/iter-adapter-stl.hpp
index 13e183113..f974892ec 100644
--- a/src/lib/iter-adapter-stl.hpp
+++ b/src/lib/iter-adapter-stl.hpp
@@ -1,23 +1,23 @@
 /*
   ITER-ADAPTER-STL.hpp  -  helpers for building simple forward iterators 
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file iter-adapter-stl.hpp
diff --git a/src/lib/iter-adapter.hpp b/src/lib/iter-adapter.hpp
index 88968cca5..a8306a774 100644
--- a/src/lib/iter-adapter.hpp
+++ b/src/lib/iter-adapter.hpp
@@ -1,23 +1,23 @@
 /*
   ITER-ADAPTER.hpp  -  helpers for building simple forward iterators 
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file iter-adapter.hpp
diff --git a/src/lib/iter-source.hpp b/src/lib/iter-source.hpp
index ee3ec8228..7910ecd5c 100644
--- a/src/lib/iter-source.hpp
+++ b/src/lib/iter-source.hpp
@@ -1,23 +1,23 @@
 /*
   ITER-SOURCE.hpp  -  an interface to build an opaque iterator-based data source 
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file iter-source.hpp
diff --git a/src/lib/iter-type-binding.hpp b/src/lib/iter-type-binding.hpp
index a370e99fb..4580ac18c 100644
--- a/src/lib/iter-type-binding.hpp
+++ b/src/lib/iter-type-binding.hpp
@@ -1,23 +1,23 @@
 /*
   ITER-TYPE-BINDING.hpp  -  control type variations for IterAdapter
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file iter-type-binding.hpp
diff --git a/src/lib/itertools.hpp b/src/lib/itertools.hpp
index 80092d61b..a4efc4829 100644
--- a/src/lib/itertools.hpp
+++ b/src/lib/itertools.hpp
@@ -1,23 +1,23 @@
 /*
   ITERTOOLS.hpp  -  collection of tools for building and combining iterators 
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file itertools.hpp
diff --git a/src/lib/lifecycle.cpp b/src/lib/lifecycle.cpp
index 939e3e252..2e23081ec 100644
--- a/src/lib/lifecycle.cpp
+++ b/src/lib/lifecycle.cpp
@@ -1,23 +1,23 @@
 /*
   Lifecycle  -  registering and triggering lifecycle callbacks 
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/lib/lifecycleregistry.hpp b/src/lib/lifecycleregistry.hpp
index 4a426e2e6..a52ff65c4 100644
--- a/src/lib/lifecycleregistry.hpp
+++ b/src/lib/lifecycleregistry.hpp
@@ -1,24 +1,24 @@
 /*
   LIFECYCLEREGISTRY.hpp  -  registry for application lifecycle callbacks 
- 
+
   Copyright (C)         Lumiera.org
     2008,               Christian Thaeter <ct@pipapo.org>
                         Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file lifecycleregistry.hpp
diff --git a/src/lib/llist.h b/src/lib/llist.h
index d6511ebaf..d5599a007 100644
--- a/src/lib/llist.h
+++ b/src/lib/llist.h
@@ -8,8 +8,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/lib/lockerror.c b/src/lib/lockerror.c
index bad423698..d115f8d7f 100644
--- a/src/lib/lockerror.c
+++ b/src/lib/lockerror.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/lib/lockerror.h b/src/lib/lockerror.h
index 27ff5dbe3..3c5293272 100644
--- a/src/lib/lockerror.h
+++ b/src/lib/lockerror.h
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/lib/logging.cpp b/src/lib/logging.cpp
index b2a62dfce..91c1af570 100644
--- a/src/lib/logging.cpp
+++ b/src/lib/logging.cpp
@@ -7,8 +7,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/lib/luid.c b/src/lib/luid.c
index c8d766094..2776cda84 100644
--- a/src/lib/luid.c
+++ b/src/lib/luid.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/lib/luid.h b/src/lib/luid.h
index 0986e5580..d24614a37 100644
--- a/src/lib/luid.h
+++ b/src/lib/luid.h
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/lib/lumitime-fmt.hpp b/src/lib/lumitime-fmt.hpp
index bb8066ebe..20b24f951 100644
--- a/src/lib/lumitime-fmt.hpp
+++ b/src/lib/lumitime-fmt.hpp
@@ -1,23 +1,23 @@
 /*
   LUMITIME-FMT.hpp  -  output and formatting of time(code) values
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lib/lumitime.cpp b/src/lib/lumitime.cpp
index bc9812aed..bae855539 100644
--- a/src/lib/lumitime.cpp
+++ b/src/lib/lumitime.cpp
@@ -1,23 +1,23 @@
 /*
   Time  -  convenience wrapper for working with gavl_time in C++
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/lib/lumitime.hpp b/src/lib/lumitime.hpp
index 4f2ab8834..5fe942218 100644
--- a/src/lib/lumitime.hpp
+++ b/src/lib/lumitime.hpp
@@ -1,23 +1,23 @@
 /*
   LUMITIME.hpp  -  convenience wrapper for working with gavl_time in C++
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lib/meta/configflags.hpp b/src/lib/meta/configflags.hpp
index 82d49bfc5..16c81a7bb 100644
--- a/src/lib/meta/configflags.hpp
+++ b/src/lib/meta/configflags.hpp
@@ -1,23 +1,23 @@
 /*
   CONFIGFLAGS.hpp  -  Building classes based on configuration cases
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lib/meta/duck-detector.hpp b/src/lib/meta/duck-detector.hpp
index 9ee864880..0091a894f 100644
--- a/src/lib/meta/duck-detector.hpp
+++ b/src/lib/meta/duck-detector.hpp
@@ -1,23 +1,23 @@
 /*
   DUCK-DETECTOR.hpp  -  helpers for statically detecting properties of a type
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lib/meta/function-closure.hpp b/src/lib/meta/function-closure.hpp
index 936534af9..374c75883 100644
--- a/src/lib/meta/function-closure.hpp
+++ b/src/lib/meta/function-closure.hpp
@@ -1,23 +1,23 @@
 /*
   FUNCTION-CLOSURE.hpp  -  metaprogramming tools for closing a function over given arguments
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lib/meta/function-erasure.hpp b/src/lib/meta/function-erasure.hpp
index 388e799cb..6e04effc2 100644
--- a/src/lib/meta/function-erasure.hpp
+++ b/src/lib/meta/function-erasure.hpp
@@ -1,23 +1,23 @@
 /*
   FUNCTION-ERASURE.hpp  -  wrapping a functor object for inline storage while hiding the signature
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lib/meta/function.hpp b/src/lib/meta/function.hpp
index 57faab310..fa7c38c55 100644
--- a/src/lib/meta/function.hpp
+++ b/src/lib/meta/function.hpp
@@ -1,23 +1,23 @@
 /*
   FUNCTION.hpp  -  metaprogramming utilities for transforming function types
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lib/meta/generator.hpp b/src/lib/meta/generator.hpp
index b248888d2..c3dfa76f4 100644
--- a/src/lib/meta/generator.hpp
+++ b/src/lib/meta/generator.hpp
@@ -1,14 +1,14 @@
 /*
   GENERATOR.hpp  -  metaprogramming utilities for generating classes and interfaces
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
diff --git a/src/lib/meta/maybe-compare.hpp b/src/lib/meta/maybe-compare.hpp
index 385e90bd3..3c96cdf01 100644
--- a/src/lib/meta/maybe-compare.hpp
+++ b/src/lib/meta/maybe-compare.hpp
@@ -1,23 +1,23 @@
 /*
   MAYBE-COMPARE.hpp  -  guarded invocation of comparisons
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lib/meta/trait-special.hpp b/src/lib/meta/trait-special.hpp
index 1fbb4b157..e6a302a7b 100644
--- a/src/lib/meta/trait-special.hpp
+++ b/src/lib/meta/trait-special.hpp
@@ -1,23 +1,23 @@
 /*
   TRAIT-SPECIAL.hpp  -  supplement, not so commonly used definitions and specialisations
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lib/meta/trait.hpp b/src/lib/meta/trait.hpp
index eb6d208ef..84250866f 100644
--- a/src/lib/meta/trait.hpp
+++ b/src/lib/meta/trait.hpp
@@ -1,23 +1,23 @@
 /*
   TRAIT.hpp  -  type handling and type detection helpers
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lib/meta/tuple.hpp b/src/lib/meta/tuple.hpp
index 27f8538c1..39e9e53dd 100644
--- a/src/lib/meta/tuple.hpp
+++ b/src/lib/meta/tuple.hpp
@@ -1,23 +1,23 @@
 /*
   TUPLE.hpp  -  metaprogramming utilities for type tuples and data tuples
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lib/meta/typelist-util.hpp b/src/lib/meta/typelist-util.hpp
index a55ca639f..cf66a791a 100644
--- a/src/lib/meta/typelist-util.hpp
+++ b/src/lib/meta/typelist-util.hpp
@@ -1,23 +1,23 @@
 /*
   TYPELIST-UTIL.hpp  -  Utils for working with lists-of-types
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lib/meta/typelist.hpp b/src/lib/meta/typelist.hpp
index b3e44138d..5d0e11bc0 100644
--- a/src/lib/meta/typelist.hpp
+++ b/src/lib/meta/typelist.hpp
@@ -1,14 +1,14 @@
 /*
   TYPELIST.hpp  -  typelist meta programming facilities
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
diff --git a/src/lib/meta/typeseq-util.hpp b/src/lib/meta/typeseq-util.hpp
index 23ffbdc77..398d09d53 100644
--- a/src/lib/meta/typeseq-util.hpp
+++ b/src/lib/meta/typeseq-util.hpp
@@ -1,23 +1,23 @@
 /*
   TYPESEQ-UTIL.hpp  -  basic metaprogramming utilities for type sequences
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lib/meta/util.hpp b/src/lib/meta/util.hpp
index f824ee6b6..e6bb82209 100644
--- a/src/lib/meta/util.hpp
+++ b/src/lib/meta/util.hpp
@@ -1,23 +1,23 @@
 /*
   UTIL.hpp  -  metaprogramming helpers and utilities
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lib/mpool.c b/src/lib/mpool.c
index b713006c8..abcc8a810 100644
--- a/src/lib/mpool.c
+++ b/src/lib/mpool.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/lib/mpool.h b/src/lib/mpool.h
index f2384bf94..3d9ec4e13 100644
--- a/src/lib/mpool.h
+++ b/src/lib/mpool.h
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/lib/mrucache.c b/src/lib/mrucache.c
index d591d5f56..272d66a3e 100644
--- a/src/lib/mrucache.c
+++ b/src/lib/mrucache.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/lib/mrucache.h b/src/lib/mrucache.h
index 8a8c5fbe9..a96f02282 100644
--- a/src/lib/mrucache.h
+++ b/src/lib/mrucache.h
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/lib/multifact-arg.hpp b/src/lib/multifact-arg.hpp
index dfb452765..c68117c2c 100644
--- a/src/lib/multifact-arg.hpp
+++ b/src/lib/multifact-arg.hpp
@@ -1,23 +1,23 @@
 /*
   MULTIFACT-ARG.hpp  -  variant of family-of-object factory, accepting fabrication arguments
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file multifact.hpp
diff --git a/src/lib/multifact.hpp b/src/lib/multifact.hpp
index 6e77b5d6e..b598a198d 100644
--- a/src/lib/multifact.hpp
+++ b/src/lib/multifact.hpp
@@ -1,23 +1,23 @@
 /*
   MULTIFACT.hpp  -  flexible family-of-object factory template
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file multifact.hpp
diff --git a/src/lib/mutex.c b/src/lib/mutex.c
index baaa39b07..11977c372 100644
--- a/src/lib/mutex.c
+++ b/src/lib/mutex.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/lib/mutex.h b/src/lib/mutex.h
index ec9215e04..cfcba113d 100644
--- a/src/lib/mutex.h
+++ b/src/lib/mutex.h
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/lib/nobug-init.cpp b/src/lib/nobug-init.cpp
index 59c4edf6c..18d1f95d0 100644
--- a/src/lib/nobug-init.cpp
+++ b/src/lib/nobug-init.cpp
@@ -1,23 +1,23 @@
 /*
   NoBugInit  -  pull up NoBug automagically in static initialisation 
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/lib/nobug-init.hpp b/src/lib/nobug-init.hpp
index a34fa8577..8d340b855 100644
--- a/src/lib/nobug-init.hpp
+++ b/src/lib/nobug-init.hpp
@@ -1,24 +1,24 @@
 /*
   NOBUG-INIT.hpp  -  pull up NoBug automagically in static initialisation
  
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file nobug-init.hpp
diff --git a/src/lib/null-value.hpp b/src/lib/null-value.hpp
index 5b102d110..050bd3fcc 100644
--- a/src/lib/null-value.hpp
+++ b/src/lib/null-value.hpp
@@ -1,23 +1,23 @@
 /*
   NULL-VALUE.hpp  -  maintain per-type NIL values in static memory 
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lib/observable-list.hpp b/src/lib/observable-list.hpp
index dd06d0979..467fa7020 100644
--- a/src/lib/observable-list.hpp
+++ b/src/lib/observable-list.hpp
@@ -1,23 +1,23 @@
 /*
   observable-list.hpp  -  Defines the observable std::list class
- 
+
   Copyright (C)         Lumiera.org
     2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 /** @file observable-list.hpp
  ** This file contains the definition of the observable list class
diff --git a/src/lib/opaque-holder.hpp b/src/lib/opaque-holder.hpp
index 407a4c685..3cc52a607 100644
--- a/src/lib/opaque-holder.hpp
+++ b/src/lib/opaque-holder.hpp
@@ -1,23 +1,23 @@
 /*
   OPAQUE-HOLDER.hpp  -  buffer holding an object inline while hiding the concrete type 
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file opaque-holder.hpp
diff --git a/src/lib/optional-ref.hpp b/src/lib/optional-ref.hpp
index 9c4825825..71ce7393d 100644
--- a/src/lib/optional-ref.hpp
+++ b/src/lib/optional-ref.hpp
@@ -1,14 +1,14 @@
 /*
   OPTIONAL-REF.hpp  -  optional and switchable reference
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
diff --git a/src/lib/p.hpp b/src/lib/p.hpp
index 4ac393a18..4fef50a36 100644
--- a/src/lib/p.hpp
+++ b/src/lib/p.hpp
@@ -1,23 +1,23 @@
 /*
   P.hpp  -  customised shared_ptr with ordering and type relationships
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file p.hpp
diff --git a/src/lib/ppmpl.h b/src/lib/ppmpl.h
index f2cf20665..db47b9920 100644
--- a/src/lib/ppmpl.h
+++ b/src/lib/ppmpl.h
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/lib/psplay.c b/src/lib/psplay.c
index 1f788a644..e28840476 100644
--- a/src/lib/psplay.c
+++ b/src/lib/psplay.c
@@ -8,8 +8,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/lib/psplay.h b/src/lib/psplay.h
index 70c450fe3..4858db8cd 100644
--- a/src/lib/psplay.h
+++ b/src/lib/psplay.h
@@ -8,8 +8,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/lib/query.cpp b/src/lib/query.cpp
index ab143cd0b..e6ff8e918 100644
--- a/src/lib/query.cpp
+++ b/src/lib/query.cpp
@@ -1,23 +1,23 @@
 /*
   Query  -  interface for capability queries
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/lib/query.hpp b/src/lib/query.hpp
index 2e3186cc6..a9ef96614 100644
--- a/src/lib/query.hpp
+++ b/src/lib/query.hpp
@@ -1,23 +1,23 @@
 /*
   QUERY.hpp  -  interface for capability queries
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lib/reccondition.c b/src/lib/reccondition.c
index 01feab0ee..b7d0730d5 100644
--- a/src/lib/reccondition.c
+++ b/src/lib/reccondition.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/lib/reccondition.h b/src/lib/reccondition.h
index 418d8556b..a2a734a69 100644
--- a/src/lib/reccondition.h
+++ b/src/lib/reccondition.h
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/lib/recmutex.c b/src/lib/recmutex.c
index ca3c2f37c..dc631f25b 100644
--- a/src/lib/recmutex.c
+++ b/src/lib/recmutex.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/lib/recmutex.h b/src/lib/recmutex.h
index 18dff4acf..0088b8ae6 100644
--- a/src/lib/recmutex.h
+++ b/src/lib/recmutex.h
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/lib/ref-array-impl.hpp b/src/lib/ref-array-impl.hpp
index 02eff2d54..7a8b84c82 100644
--- a/src/lib/ref-array-impl.hpp
+++ b/src/lib/ref-array-impl.hpp
@@ -1,23 +1,23 @@
 /*
   REF-ARRAY-IMPL.hpp  -  some implementations of the ref-array interface
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file ref-array-impl.hpp
diff --git a/src/lib/ref-array.hpp b/src/lib/ref-array.hpp
index ccf565406..ddbc06da1 100644
--- a/src/lib/ref-array.hpp
+++ b/src/lib/ref-array.hpp
@@ -1,23 +1,23 @@
 /*
   REF-ARRAY.hpp  -  abstraction providing array-like access to a list of references
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lib/result.hpp b/src/lib/result.hpp
index 8cc77beb9..ae4f7b187 100644
--- a/src/lib/result.hpp
+++ b/src/lib/result.hpp
@@ -1,23 +1,23 @@
 /*
   RESULT.hpp  -  intermediary token representing the result of an operation
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lib/rwlock.c b/src/lib/rwlock.c
index 03d70b7e3..8e293543f 100644
--- a/src/lib/rwlock.c
+++ b/src/lib/rwlock.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/lib/rwlock.h b/src/lib/rwlock.h
index 79b019660..9890cd1ef 100644
--- a/src/lib/rwlock.h
+++ b/src/lib/rwlock.h
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/lib/safeclib.c b/src/lib/safeclib.c
index ae621501d..980353273 100644
--- a/src/lib/safeclib.c
+++ b/src/lib/safeclib.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/lib/safeclib.h b/src/lib/safeclib.h
index 7a79b5021..60ae3c5ad 100644
--- a/src/lib/safeclib.h
+++ b/src/lib/safeclib.h
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/lib/scoped-holder-transfer.hpp b/src/lib/scoped-holder-transfer.hpp
index e7e78c945..e1ee6d5c9 100644
--- a/src/lib/scoped-holder-transfer.hpp
+++ b/src/lib/scoped-holder-transfer.hpp
@@ -1,23 +1,23 @@
 /*
   SCOPED-HOLDER-TRANSFER.hpp  -  using ScopedHolder within a STL vector 
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lib/scoped-holder.hpp b/src/lib/scoped-holder.hpp
index 83191970f..f8eaf74d2 100644
--- a/src/lib/scoped-holder.hpp
+++ b/src/lib/scoped-holder.hpp
@@ -1,23 +1,23 @@
 /*
   SCOPED-HOLDER.hpp  -  general purpose wrapper for dealing with ownership problems 
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file scoped-holder.hpp
diff --git a/src/lib/scoped-ptrvect.hpp b/src/lib/scoped-ptrvect.hpp
index fa7515c6b..8bb713082 100644
--- a/src/lib/scoped-ptrvect.hpp
+++ b/src/lib/scoped-ptrvect.hpp
@@ -1,23 +1,23 @@
 /*
   SCOPED-PTRVECT.hpp  -  simple noncopyable lifecycle managing collection of pointers 
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file scoped-ptrvect.hpp
diff --git a/src/lib/sectionlock.h b/src/lib/sectionlock.h
index 61225e84b..0eb6cd93b 100644
--- a/src/lib/sectionlock.h
+++ b/src/lib/sectionlock.h
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/lib/singleton-ref.hpp b/src/lib/singleton-ref.hpp
index 8fc9c289c..089ae8579 100644
--- a/src/lib/singleton-ref.hpp
+++ b/src/lib/singleton-ref.hpp
@@ -1,23 +1,23 @@
 /*
   SINGLETON-REF.hpp  -  helper template providing singleton-like access for implementation code
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file singleton-ref.hpp
diff --git a/src/lib/singleton-subclass.hpp b/src/lib/singleton-subclass.hpp
index ce120278a..386fc9f59 100644
--- a/src/lib/singleton-subclass.hpp
+++ b/src/lib/singleton-subclass.hpp
@@ -1,23 +1,23 @@
 /*
   SINGLETON-SUBCLASS.hpp  -  variant of the singleton (factory) creating a subclass
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file singleton-subclass.hpp
diff --git a/src/lib/singleton.hpp b/src/lib/singleton.hpp
index 731c441ac..d2f82bd9e 100644
--- a/src/lib/singleton.hpp
+++ b/src/lib/singleton.hpp
@@ -1,23 +1,23 @@
 /*
   SINGLETON.hpp  -  configuration header for singleton factory
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file singleton.hpp
diff --git a/src/lib/singletonfactory.hpp b/src/lib/singletonfactory.hpp
index 737ebe8b4..65a6a3bd8 100644
--- a/src/lib/singletonfactory.hpp
+++ b/src/lib/singletonfactory.hpp
@@ -1,14 +1,14 @@
 /*
   SINGLETONFACTORY.hpp  -  template for implementing the singleton pattern
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
diff --git a/src/lib/singletonpolicies.hpp b/src/lib/singletonpolicies.hpp
index b8333334d..49cb27223 100644
--- a/src/lib/singletonpolicies.hpp
+++ b/src/lib/singletonpolicies.hpp
@@ -1,14 +1,14 @@
 /*
   SINGLETONPOLICIES.hpp  -  how to manage creation, lifecycle and multithreading
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
diff --git a/src/lib/singletonpreconfigure.hpp b/src/lib/singletonpreconfigure.hpp
index a657a0ec9..b7c39fa83 100644
--- a/src/lib/singletonpreconfigure.hpp
+++ b/src/lib/singletonpreconfigure.hpp
@@ -1,23 +1,23 @@
 /*
   SINGLETONPRECONFIGURE  -  declare the configuration of some Singleton types in advance
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file singletonpreconfigure.hpp
diff --git a/src/lib/streamtype.cpp b/src/lib/streamtype.cpp
index 5d90af0c0..410227567 100644
--- a/src/lib/streamtype.cpp
+++ b/src/lib/streamtype.cpp
@@ -1,23 +1,23 @@
 /*
   StreamType  -  classification of media stream types 
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/lib/streamtype.hpp b/src/lib/streamtype.hpp
index cf45ad59c..745f50d86 100644
--- a/src/lib/streamtype.hpp
+++ b/src/lib/streamtype.hpp
@@ -1,23 +1,23 @@
 /*
   STREAMTYPE.hpp  -  classification of media stream types 
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file streamtype.hpp
diff --git a/src/lib/sub-id.hpp b/src/lib/sub-id.hpp
index 98df7c4e7..fa47f42f5 100644
--- a/src/lib/sub-id.hpp
+++ b/src/lib/sub-id.hpp
@@ -1,23 +1,23 @@
 /*
   SUB-ID.hpp  -  extensible symbolic identifier
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lib/symbol-impl.cpp b/src/lib/symbol-impl.cpp
index 3d06dcc35..9e09b4254 100644
--- a/src/lib/symbol-impl.cpp
+++ b/src/lib/symbol-impl.cpp
@@ -1,23 +1,23 @@
 /*
   Symbol(impl)  -  helpers for working with literal string IDs 
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 /** @file symbol-impl.hpp
diff --git a/src/lib/symbol.hpp b/src/lib/symbol.hpp
index fcc9041ce..5c1f4d298 100644
--- a/src/lib/symbol.hpp
+++ b/src/lib/symbol.hpp
@@ -1,23 +1,23 @@
 /*
   SYMBOL.hpp  -  symbolic constant datatype 
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file symbol.hpp
diff --git a/src/lib/sync-classlock.hpp b/src/lib/sync-classlock.hpp
index cdee70048..350e0c615 100644
--- a/src/lib/sync-classlock.hpp
+++ b/src/lib/sync-classlock.hpp
@@ -1,15 +1,15 @@
 /*
   SYNC-CLASSLOCK.hpp  -  special case of object based locking tied directly to a type
- 
+
   Copyright (C)         Lumiera.org
     2008,               Christian Thaeter <ct@pipapo.org>
                         Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
diff --git a/src/lib/sync.hpp b/src/lib/sync.hpp
index 56d4c29af..c6ceafc40 100644
--- a/src/lib/sync.hpp
+++ b/src/lib/sync.hpp
@@ -1,15 +1,15 @@
 /*
   SYNC.hpp  -  generic helper for object based locking and synchronisation
- 
+
   Copyright (C)         Lumiera.org
     2008,               Christian Thaeter <ct@pipapo.org>
                         Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
diff --git a/src/lib/test/mockinjector.hpp b/src/lib/test/mockinjector.hpp
index 594ac2727..32a647988 100644
--- a/src/lib/test/mockinjector.hpp
+++ b/src/lib/test/mockinjector.hpp
@@ -1,23 +1,23 @@
 /*
   MOCKINJECTOR.hpp  -  replacement singleton factory for injecting Test-Mock objects
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lib/test/run.hpp b/src/lib/test/run.hpp
index ff61cf30c..b47a46e4c 100644
--- a/src/lib/test/run.hpp
+++ b/src/lib/test/run.hpp
@@ -1,24 +1,24 @@
 /*
   RUN.hpp  -  helper class for grouping, registering and invoking testcases
- 
+
   Copyright (C)         Lumiera.org
     2008,               Christian Thaeter <ct@pipapo.org>
                         Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file run.hpp
diff --git a/src/lib/test/suite.cpp b/src/lib/test/suite.cpp
index cef0bda42..b109b755d 100644
--- a/src/lib/test/suite.cpp
+++ b/src/lib/test/suite.cpp
@@ -1,23 +1,23 @@
 /*
   Suite  -  helper class for running collections of tests
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/lib/test/suite.hpp b/src/lib/test/suite.hpp
index d640050f6..953642150 100644
--- a/src/lib/test/suite.hpp
+++ b/src/lib/test/suite.hpp
@@ -1,23 +1,23 @@
 /*
   SUITE.hpp  -  helper class for running collections of tests
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file suite.hpp
diff --git a/src/lib/test/test-coll.hpp b/src/lib/test/test-coll.hpp
index 09578d5fb..907c19309 100644
--- a/src/lib/test/test-coll.hpp
+++ b/src/lib/test/test-coll.hpp
@@ -1,23 +1,23 @@
 /*
   TEST-COLL.hpp  -  containers and collections with test data
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lib/test/test-helper.cpp b/src/lib/test/test-helper.cpp
index 0c67ca7fd..8c8a7dda0 100644
--- a/src/lib/test/test-helper.cpp
+++ b/src/lib/test/test-helper.cpp
@@ -1,23 +1,23 @@
 /*
   Test-Helper  -  collection of functions supporting unit testing
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/lib/test/test-helper.hpp b/src/lib/test/test-helper.hpp
index 5ad305977..a115e3a1f 100644
--- a/src/lib/test/test-helper.hpp
+++ b/src/lib/test/test-helper.hpp
@@ -1,23 +1,23 @@
 /*
   TEST-HELPER.hpp  -  collection of functions supporting unit testing
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lib/test/testoption.cpp b/src/lib/test/testoption.cpp
index b0807ab63..3a84ee4f8 100644
--- a/src/lib/test/testoption.cpp
+++ b/src/lib/test/testoption.cpp
@@ -1,23 +1,23 @@
 /*
   TestOption  -  handle cmdline for invoking Testsuite
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/lib/test/testoption.hpp b/src/lib/test/testoption.hpp
index d9b31521a..efa9ea2cd 100644
--- a/src/lib/test/testoption.hpp
+++ b/src/lib/test/testoption.hpp
@@ -1,23 +1,23 @@
 /*
   TESTOPTION.hpp  -  handle cmdline for invoking Testsuite
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lib/thread-local.hpp b/src/lib/thread-local.hpp
index d0cdb06a4..cfb854ae8 100644
--- a/src/lib/thread-local.hpp
+++ b/src/lib/thread-local.hpp
@@ -1,14 +1,14 @@
 /*
   THREAD-LOCAL.hpp  -  support using thread local data
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
diff --git a/src/lib/time.c b/src/lib/time.c
index c5f497f9d..5af40d640 100644
--- a/src/lib/time.c
+++ b/src/lib/time.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/lib/time.h b/src/lib/time.h
index 688eb91ad..f812c1b9d 100644
--- a/src/lib/time.h
+++ b/src/lib/time.h
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/lib/tmpbuf.c b/src/lib/tmpbuf.c
index 9ac442d2b..d2ef81a7c 100644
--- a/src/lib/tmpbuf.c
+++ b/src/lib/tmpbuf.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/lib/tmpbuf.h b/src/lib/tmpbuf.h
index da1f0f09a..95fc62564 100644
--- a/src/lib/tmpbuf.h
+++ b/src/lib/tmpbuf.h
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/lib/typed-allocation-manager.hpp b/src/lib/typed-allocation-manager.hpp
index 1a4887121..188f120dc 100644
--- a/src/lib/typed-allocation-manager.hpp
+++ b/src/lib/typed-allocation-manager.hpp
@@ -1,23 +1,23 @@
 /*
   TYPED-ALLOCATION-MANAGER.hpp  -  abstract backbone to build custom memory managers 
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lib/typed-counter.hpp b/src/lib/typed-counter.hpp
index 8b7ca90a7..252faaab5 100644
--- a/src/lib/typed-counter.hpp
+++ b/src/lib/typed-counter.hpp
@@ -1,23 +1,23 @@
 /*
   TYPED-COUNTER.hpp  -  maintain a set of type based contexts 
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lib/util-foreach.hpp b/src/lib/util-foreach.hpp
index bfb6f9514..9270c3a06 100644
--- a/src/lib/util-foreach.hpp
+++ b/src/lib/util-foreach.hpp
@@ -1,23 +1,23 @@
 /*
   UTIL-FOREACH.hpp  -  helpers for doing something for each element
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lib/util.cpp b/src/lib/util.cpp
index f5229fc86..b11c232fc 100644
--- a/src/lib/util.cpp
+++ b/src/lib/util.cpp
@@ -1,23 +1,23 @@
 /*
   util.cpp  -  helper functions implementation
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/lib/util.hpp b/src/lib/util.hpp
index 3d3abf038..1383e6244 100644
--- a/src/lib/util.hpp
+++ b/src/lib/util.hpp
@@ -1,23 +1,23 @@
 /*
   UTIL.hpp  -  collection of small helper functions used "everywhere"
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lib/variant.hpp b/src/lib/variant.hpp
index ebaac670a..7a964c5db 100644
--- a/src/lib/variant.hpp
+++ b/src/lib/variant.hpp
@@ -1,23 +1,23 @@
 /*
   VARIANT.hpp  -  simple variant wrapper (typesafe union)
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lib/vcall.h b/src/lib/vcall.h
index bcd3b5190..16bf81b2d 100644
--- a/src/lib/vcall.h
+++ b/src/lib/vcall.h
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/lib/visitor-dispatcher.hpp b/src/lib/visitor-dispatcher.hpp
index 26e99f9aa..35f566193 100644
--- a/src/lib/visitor-dispatcher.hpp
+++ b/src/lib/visitor-dispatcher.hpp
@@ -1,23 +1,23 @@
 /*
   VISITOR-DISPATCHER.hpp  -  visitor implementation details
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lib/visitor-policies.hpp b/src/lib/visitor-policies.hpp
index 63e6324cf..164b7d1b2 100644
--- a/src/lib/visitor-policies.hpp
+++ b/src/lib/visitor-policies.hpp
@@ -1,23 +1,23 @@
 /*
   VISITOR-POLICIES.hpp  -  Acyclic Visitor library
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lib/visitor.hpp b/src/lib/visitor.hpp
index a36ca00e1..b2a67e447 100644
--- a/src/lib/visitor.hpp
+++ b/src/lib/visitor.hpp
@@ -1,14 +1,14 @@
 /*
   VISITOR.hpp  -  Generic Visitor library implementation
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
diff --git a/src/lib/wrapper.hpp b/src/lib/wrapper.hpp
index d31a0983a..8a7761263 100644
--- a/src/lib/wrapper.hpp
+++ b/src/lib/wrapper.hpp
@@ -1,14 +1,14 @@
 /*
   WRAPPER.hpp  -  some smart wrapping and reference managing helper templates
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
diff --git a/src/lib/wrapperptr.hpp b/src/lib/wrapperptr.hpp
index ed4b43b82..1032045b0 100644
--- a/src/lib/wrapperptr.hpp
+++ b/src/lib/wrapperptr.hpp
@@ -1,23 +1,23 @@
 /*
   WRAPPERPTR.hpp  -  variant record able to hold a pointer to some smart-ptr/wrapper types, providing conversions
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/lumiera/main.cpp b/src/lumiera/main.cpp
index f5555e927..a1f73e53e 100644
--- a/src/lumiera/main.cpp
+++ b/src/lumiera/main.cpp
@@ -8,8 +8,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/src/pre.hpp b/src/pre.hpp
index 6b12ea67f..1170769b9 100644
--- a/src/pre.hpp
+++ b/src/pre.hpp
@@ -1,25 +1,25 @@
 /*
   PRE.hpp  -  precompiled header collection
  
- 
+
   Copyright (C)         Lumiera.org
     2008,               Christian Thaeter <ct@pipapo.org>
                         Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file pre.hpp
diff --git a/src/pre_a.hpp b/src/pre_a.hpp
index 1bac10969..153fbb01a 100644
--- a/src/pre_a.hpp
+++ b/src/pre_a.hpp
@@ -1,25 +1,25 @@
 /*
   PRE_A.hpp  -  precompiled header (including assets)
  
- 
+
   Copyright (C)         Lumiera.org
     2008,               Christian Thaeter <ct@pipapo.org>
                         Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file pre.hpp
diff --git a/src/proc/asset.cpp b/src/proc/asset.cpp
index 36a4d7c49..81e5ab5f9 100644
--- a/src/proc/asset.cpp
+++ b/src/proc/asset.cpp
@@ -1,23 +1,23 @@
 /*
   Asset  -  Superinterface: bookkeeping view of "things" present in the session
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/asset.hpp b/src/proc/asset.hpp
index ef56fc632..bef9463ac 100644
--- a/src/proc/asset.hpp
+++ b/src/proc/asset.hpp
@@ -1,23 +1,23 @@
 /*
   ASSET.hpp  -  Superinterface: bookkeeping view of "things" present in the session
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file asset.hpp
diff --git a/src/proc/asset/buildinstruct.hpp b/src/proc/asset/buildinstruct.hpp
index 1b1129762..715e40954 100644
--- a/src/proc/asset/buildinstruct.hpp
+++ b/src/proc/asset/buildinstruct.hpp
@@ -1,23 +1,23 @@
 /*
   BUILDINSTRUCT.hpp  -  Instructions for building some configuration of render nodes.
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/asset/category.cpp b/src/proc/asset/category.cpp
index e285bf011..8e98a68dd 100644
--- a/src/proc/asset/category.cpp
+++ b/src/proc/asset/category.cpp
@@ -1,23 +1,23 @@
 /*
   Category  -  tree like classification of Assets
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/asset/category.hpp b/src/proc/asset/category.hpp
index 71a24eac4..aa263ee7d 100644
--- a/src/proc/asset/category.hpp
+++ b/src/proc/asset/category.hpp
@@ -1,23 +1,23 @@
 /*
   CATEGORY.hpp  -  tree like classification of Assets
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/asset/clip.cpp b/src/proc/asset/clip.cpp
index ebfb2fa8d..aa651de74 100644
--- a/src/proc/asset/clip.cpp
+++ b/src/proc/asset/clip.cpp
@@ -1,23 +1,23 @@
 /*
   Clip(Asset)  -  bookkeeping (asset) view of a media clip.
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/asset/clip.hpp b/src/proc/asset/clip.hpp
index 8534b32ba..d3b1a3aaa 100644
--- a/src/proc/asset/clip.hpp
+++ b/src/proc/asset/clip.hpp
@@ -1,23 +1,23 @@
 /*
   CLIP.hpp  -  bookkeeping (asset) view of a media clip.
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/asset/codec.cpp b/src/proc/asset/codec.cpp
index e98608375..8810ea0da 100644
--- a/src/proc/asset/codec.cpp
+++ b/src/proc/asset/codec.cpp
@@ -1,23 +1,23 @@
 /*
   Codec(Asset)  -  description of some media data decoder or encoder facility
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/asset/codec.hpp b/src/proc/asset/codec.hpp
index e46fcf5dd..b7d7e5e34 100644
--- a/src/proc/asset/codec.hpp
+++ b/src/proc/asset/codec.hpp
@@ -1,23 +1,23 @@
 /*
   CODEC.hpp  -  description of some media data decoder or encoder facility
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/asset/compoundmedia.cpp b/src/proc/asset/compoundmedia.cpp
index 1a00458b6..e77416247 100644
--- a/src/proc/asset/compoundmedia.cpp
+++ b/src/proc/asset/compoundmedia.cpp
@@ -1,23 +1,23 @@
 /*
   CompoundMedia  -  multichannel media
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/asset/compoundmedia.hpp b/src/proc/asset/compoundmedia.hpp
index 987632408..22fdb6922 100644
--- a/src/proc/asset/compoundmedia.hpp
+++ b/src/proc/asset/compoundmedia.hpp
@@ -1,23 +1,23 @@
 /*
   COMPOUNDMEDIA.hpp  -  multichannel media
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/asset/dataset.hpp b/src/proc/asset/dataset.hpp
index 31fcb8982..e488302c2 100644
--- a/src/proc/asset/dataset.hpp
+++ b/src/proc/asset/dataset.hpp
@@ -1,23 +1,23 @@
 /*
   DATASET.hpp  -  meta asset describing a collection of control data
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/asset/db.hpp b/src/proc/asset/db.hpp
index 1676c96da..b2d9b073f 100644
--- a/src/proc/asset/db.hpp
+++ b/src/proc/asset/db.hpp
@@ -1,23 +1,23 @@
 /*
   DB.hpp  -  registry holding known Asset instances.
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/asset/effect.cpp b/src/proc/asset/effect.cpp
index cf795dc08..999b5c118 100644
--- a/src/proc/asset/effect.cpp
+++ b/src/proc/asset/effect.cpp
@@ -1,23 +1,23 @@
 /*
   Effect(Asset)  -  Effect or media processing component
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/asset/effect.hpp b/src/proc/asset/effect.hpp
index a9b470b17..e2e8c3fd4 100644
--- a/src/proc/asset/effect.hpp
+++ b/src/proc/asset/effect.hpp
@@ -1,23 +1,23 @@
 /*
   EFFECT.hpp  -  Effect or media processing component
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/asset/entry-id.hpp b/src/proc/asset/entry-id.hpp
index b16739a02..b7ff98cce 100644
--- a/src/proc/asset/entry-id.hpp
+++ b/src/proc/asset/entry-id.hpp
@@ -1,23 +1,23 @@
 /*
   ENTRY-ID.hpp  -  plain symbolic and hash ID used for accounting
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/asset/inventory.hpp b/src/proc/asset/inventory.hpp
index 7286f3324..2853e2697 100644
--- a/src/proc/asset/inventory.hpp
+++ b/src/proc/asset/inventory.hpp
@@ -1,23 +1,23 @@
 /*
   INVENTORY.hpp  -  viewing an Typed-ID registration group as meta asset
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/asset/media.cpp b/src/proc/asset/media.cpp
index 4f3ffddc4..53cd1f1fd 100644
--- a/src/proc/asset/media.cpp
+++ b/src/proc/asset/media.cpp
@@ -1,23 +1,23 @@
 /*
   Media(Asset)  -  key abstraction: media-like assets
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/asset/media.hpp b/src/proc/asset/media.hpp
index ba6b10558..d3b2c9024 100644
--- a/src/proc/asset/media.hpp
+++ b/src/proc/asset/media.hpp
@@ -1,23 +1,23 @@
 /*
   MEDIA.hpp  -  key abstraction: media-like assets
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/asset/meta.cpp b/src/proc/asset/meta.cpp
index ecb918ed1..795ea0e74 100644
--- a/src/proc/asset/meta.cpp
+++ b/src/proc/asset/meta.cpp
@@ -1,23 +1,23 @@
 /*
   Meta(Asset)  -  key abstraction: metadata and organisational asset
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/asset/meta.hpp b/src/proc/asset/meta.hpp
index 5a5ac592f..cd94b26e5 100644
--- a/src/proc/asset/meta.hpp
+++ b/src/proc/asset/meta.hpp
@@ -1,23 +1,23 @@
 /*
   META.hpp  -  key abstraction: metadata and organisational asset
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/asset/pipe.cpp b/src/proc/asset/pipe.cpp
index 8e823313a..4a766cb36 100644
--- a/src/proc/asset/pipe.cpp
+++ b/src/proc/asset/pipe.cpp
@@ -1,23 +1,23 @@
 /*
   Pipe  -  structural asset denoting a processing pipe to generate media output
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/asset/pipe.hpp b/src/proc/asset/pipe.hpp
index aed616264..c60d310c4 100644
--- a/src/proc/asset/pipe.hpp
+++ b/src/proc/asset/pipe.hpp
@@ -1,23 +1,23 @@
 /*
   PIPE.hpp  -  structural asset denoting a processing pipe generating media output
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/asset/preview.cpp b/src/proc/asset/preview.cpp
index f6aa426d6..d14d54a77 100644
--- a/src/proc/asset/preview.cpp
+++ b/src/proc/asset/preview.cpp
@@ -1,23 +1,23 @@
 /*
   Preview(Asset) -  alternative version of the media data, probably with lower resolution
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/asset/preview.hpp b/src/proc/asset/preview.hpp
index 8aec81b5f..27bacd1b2 100644
--- a/src/proc/asset/preview.hpp
+++ b/src/proc/asset/preview.hpp
@@ -1,23 +1,23 @@
 /*
   PREVIEW.hpp  -  alternative version of the media data, probably with lower resolution
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/asset/proc.cpp b/src/proc/asset/proc.cpp
index fe53bd336..8b6ecb178 100644
--- a/src/proc/asset/proc.cpp
+++ b/src/proc/asset/proc.cpp
@@ -1,23 +1,23 @@
 /*
   Proc(Asset)  -  key abstraction: data-processing assets
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/asset/proc.hpp b/src/proc/asset/proc.hpp
index 35618627b..cced6e638 100644
--- a/src/proc/asset/proc.hpp
+++ b/src/proc/asset/proc.hpp
@@ -1,23 +1,23 @@
 /*
   PROC.hpp  -  key abstraction: data-processing assets
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/asset/procpatt.cpp b/src/proc/asset/procpatt.cpp
index 13d193c2c..8399f6ccb 100644
--- a/src/proc/asset/procpatt.cpp
+++ b/src/proc/asset/procpatt.cpp
@@ -1,23 +1,23 @@
 /*
   ProcPatt  -  template for building some render processing network
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/asset/procpatt.hpp b/src/proc/asset/procpatt.hpp
index bd9b025df..ff714617d 100644
--- a/src/proc/asset/procpatt.hpp
+++ b/src/proc/asset/procpatt.hpp
@@ -1,23 +1,23 @@
 /*
   PROCPATT.hpp  -  template for building some render processing network
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/asset/sequence.cpp b/src/proc/asset/sequence.cpp
index 7d4f375e8..a84e2fd3b 100644
--- a/src/proc/asset/sequence.cpp
+++ b/src/proc/asset/sequence.cpp
@@ -1,23 +1,23 @@
 /*
   Sequence  -  Compound of MObjects placed on a track tree. Building block of the Session
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/asset/sequence.hpp b/src/proc/asset/sequence.hpp
index c1ce02704..91d851d59 100644
--- a/src/proc/asset/sequence.hpp
+++ b/src/proc/asset/sequence.hpp
@@ -1,23 +1,23 @@
 /*
   SEQUENCE.hpp  -  Compound of MObjects placed on a track tree. Building block of the Session
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/asset/struct-factory-impl.hpp b/src/proc/asset/struct-factory-impl.hpp
index 93836e2b2..bfc702d18 100644
--- a/src/proc/asset/struct-factory-impl.hpp
+++ b/src/proc/asset/struct-factory-impl.hpp
@@ -1,23 +1,23 @@
 /*
   STRUCT-FACTORY-IMPL.hpp  -  crating structural assets (impl details)
- 
+
   Copyright (C)         Lumiera.org
     2008-2010,          Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/asset/struct-scheme.hpp b/src/proc/asset/struct-scheme.hpp
index dd6f6f512..f39069101 100644
--- a/src/proc/asset/struct-scheme.hpp
+++ b/src/proc/asset/struct-scheme.hpp
@@ -1,23 +1,23 @@
 /*
   STRUCT-SCHEME.hpp  -  naming and designation scheme for structural assets
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/asset/struct.cpp b/src/proc/asset/struct.cpp
index 70f893149..1eeece4a9 100644
--- a/src/proc/asset/struct.cpp
+++ b/src/proc/asset/struct.cpp
@@ -1,23 +1,23 @@
 /*
   Struct(Asset)  -  key abstraction: structural asset
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/asset/struct.hpp b/src/proc/asset/struct.hpp
index 9a9e84caa..bfd175fae 100644
--- a/src/proc/asset/struct.hpp
+++ b/src/proc/asset/struct.hpp
@@ -1,23 +1,23 @@
 /*
   STRUCT.hpp  -  key abstraction: structural asset
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/asset/timeline.cpp b/src/proc/asset/timeline.cpp
index dbd663b3d..bb2f9e36e 100644
--- a/src/proc/asset/timeline.cpp
+++ b/src/proc/asset/timeline.cpp
@@ -1,23 +1,23 @@
 /*
   Timeline  -  independent top-level element of the Session
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/asset/timeline.hpp b/src/proc/asset/timeline.hpp
index 64fd4af32..7bf168e1e 100644
--- a/src/proc/asset/timeline.hpp
+++ b/src/proc/asset/timeline.hpp
@@ -1,23 +1,23 @@
 /*
   TIMELINE.hpp  -  independent top-level element of the Session
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/asset/typed-id.hpp b/src/proc/asset/typed-id.hpp
index 0c9db1f12..a7edcc732 100644
--- a/src/proc/asset/typed-id.hpp
+++ b/src/proc/asset/typed-id.hpp
@@ -1,23 +1,23 @@
 /*
   TYPED-ID.hpp  -  registration service for ID to type association
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/asset/typed-lookup.cpp b/src/proc/asset/typed-lookup.cpp
index fdfeafd57..a7d9c3368 100644
--- a/src/proc/asset/typed-lookup.cpp
+++ b/src/proc/asset/typed-lookup.cpp
@@ -1,23 +1,23 @@
 /*
   TypedLookup  -  implementing a registration service for ID to type association
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/asset/unknown.cpp b/src/proc/asset/unknown.cpp
index 3fa2e4ae9..ca25adf74 100644
--- a/src/proc/asset/unknown.cpp
+++ b/src/proc/asset/unknown.cpp
@@ -1,23 +1,23 @@
 /*
   Unknown  -  placeholder for unknown or unavailable media source
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/asset/unknown.hpp b/src/proc/asset/unknown.hpp
index 0402f6bc7..fa3f5a291 100644
--- a/src/proc/asset/unknown.hpp
+++ b/src/proc/asset/unknown.hpp
@@ -1,23 +1,23 @@
 /*
   UNKNOWN.hpp  -  placeholder for unknown or unavailable media source
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/assetmanager.cpp b/src/proc/assetmanager.cpp
index ec7421b4a..0cf1a989c 100644
--- a/src/proc/assetmanager.cpp
+++ b/src/proc/assetmanager.cpp
@@ -1,23 +1,23 @@
 /*
   AssetManager  -  Facade for the Asset subsystem
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/assetmanager.hpp b/src/proc/assetmanager.hpp
index 51b7b416b..d5102eeb4 100644
--- a/src/proc/assetmanager.hpp
+++ b/src/proc/assetmanager.hpp
@@ -1,23 +1,23 @@
 /*
   ASSETMANAGER.hpp  -  Facade for the Asset subsystem
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file assetmanager.hpp
diff --git a/src/proc/common.hpp b/src/proc/common.hpp
index 69cbce3e8..ebf5ca48f 100644
--- a/src/proc/common.hpp
+++ b/src/proc/common.hpp
@@ -1,25 +1,25 @@
 /*
   COMMON.hpp  -  global definitions and common types for the Proc-Layer
  
- 
+
   Copyright (C)         Lumiera.org
     2008,               Christian Thaeter <ct@pipapo.org>
                         Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file common.hpp
diff --git a/src/proc/control/argument-erasure.hpp b/src/proc/control/argument-erasure.hpp
index c903605c9..1a9d15b60 100644
--- a/src/proc/control/argument-erasure.hpp
+++ b/src/proc/control/argument-erasure.hpp
@@ -1,23 +1,23 @@
 /*
   ARGUMENT-ERASURE.hpp  -  helper for passing on a dynamic typed argument tuple
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/control/argument-tuple-accept.hpp b/src/proc/control/argument-tuple-accept.hpp
index 189934b9f..5db90d0c8 100644
--- a/src/proc/control/argument-tuple-accept.hpp
+++ b/src/proc/control/argument-tuple-accept.hpp
@@ -1,23 +1,23 @@
 /*
   ARGUMENT-TUPLE-ACCEPT.hpp  -  helper template providing a bind(...) member function
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/control/command-argument-holder.hpp b/src/proc/control/command-argument-holder.hpp
index e4d4adfbe..e71a60a10 100644
--- a/src/proc/control/command-argument-holder.hpp
+++ b/src/proc/control/command-argument-holder.hpp
@@ -1,23 +1,23 @@
 /*
   COMMAND-ARGUMENT-HOLDER.hpp  -  specifically typed container for storage of command arguments
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/control/command-closure.hpp b/src/proc/control/command-closure.hpp
index be82e0649..90b29435c 100644
--- a/src/proc/control/command-closure.hpp
+++ b/src/proc/control/command-closure.hpp
@@ -1,23 +1,23 @@
 /*
   COMMAND-CLOSURE.hpp  -  defining execution targets and parameters for commands
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/control/command-def.hpp b/src/proc/control/command-def.hpp
index 058f06ce9..b3e777c4c 100644
--- a/src/proc/control/command-def.hpp
+++ b/src/proc/control/command-def.hpp
@@ -1,23 +1,23 @@
 /*
   COMMAND-DEF.hpp  -  defining and binding a Proc-Layer command
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/control/command-impl-clone-builder.hpp b/src/proc/control/command-impl-clone-builder.hpp
index 21848f2a8..cbc6ba378 100644
--- a/src/proc/control/command-impl-clone-builder.hpp
+++ b/src/proc/control/command-impl-clone-builder.hpp
@@ -1,23 +1,23 @@
 /*
   COMMAND-IMPL-CLONE-BUILDER.hpp  -  Cloning command implementation without disclosing concrete type
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/control/command-impl.cpp b/src/proc/control/command-impl.cpp
index b73573091..36406ced5 100644
--- a/src/proc/control/command-impl.cpp
+++ b/src/proc/control/command-impl.cpp
@@ -1,23 +1,23 @@
 /*
   CommandImpl  -  Proc-Layer command implementation (top level)
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/control/command-impl.hpp b/src/proc/control/command-impl.hpp
index f796c248a..7d3c18536 100644
--- a/src/proc/control/command-impl.hpp
+++ b/src/proc/control/command-impl.hpp
@@ -1,23 +1,23 @@
 /*
   COMMAND-IMPL.hpp  -  Proc-Layer command implementation (top level)
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/control/command-invocation.hpp b/src/proc/control/command-invocation.hpp
index 64cbbe44f..660814098 100644
--- a/src/proc/control/command-invocation.hpp
+++ b/src/proc/control/command-invocation.hpp
@@ -1,23 +1,23 @@
 /*
   COMMAND-INVOCATION.hpp  -  shortcuts and helpers for calling Proc-Layer commands
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/control/command-mutation.hpp b/src/proc/control/command-mutation.hpp
index 8152f093c..9a4f2d13d 100644
--- a/src/proc/control/command-mutation.hpp
+++ b/src/proc/control/command-mutation.hpp
@@ -1,23 +1,23 @@
 /*
   COMMAND-MUTATION.hpp  -  functor encapsulating the actual operation of proc-Command
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/control/command-registry.hpp b/src/proc/control/command-registry.hpp
index 4dbd225be..1a94ee13f 100644
--- a/src/proc/control/command-registry.hpp
+++ b/src/proc/control/command-registry.hpp
@@ -1,23 +1,23 @@
 /*
   COMMAND-REGISTRY.hpp  -  proc-Command object registration and storage management
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/control/command-signature.hpp b/src/proc/control/command-signature.hpp
index 150e3db0b..3c9df666f 100644
--- a/src/proc/control/command-signature.hpp
+++ b/src/proc/control/command-signature.hpp
@@ -1,23 +1,23 @@
 /*
   COMMAND-SIGNATURE.hpp  -  deriving suitable command function signatures
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/control/command.cpp b/src/proc/control/command.cpp
index 43906c704..291edfb7e 100644
--- a/src/proc/control/command.cpp
+++ b/src/proc/control/command.cpp
@@ -1,23 +1,23 @@
 /*
   Command  -  Key abstraction for proc/edit operations and UNDO management
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/control/command.hpp b/src/proc/control/command.hpp
index b23882863..86632febc 100644
--- a/src/proc/control/command.hpp
+++ b/src/proc/control/command.hpp
@@ -1,23 +1,23 @@
 /*
   COMMAND.hpp  -  Key abstraction for proc/edit operations and UNDO management
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/control/handling-pattern.cpp b/src/proc/control/handling-pattern.cpp
index b3d961418..b71cc6d4c 100644
--- a/src/proc/control/handling-pattern.cpp
+++ b/src/proc/control/handling-pattern.cpp
@@ -1,23 +1,23 @@
 /*
   HandlingPattern  -  A skeleton for executing commands, including standard implementations
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/control/handling-pattern.hpp b/src/proc/control/handling-pattern.hpp
index d4b4ae946..f414e25a1 100644
--- a/src/proc/control/handling-pattern.hpp
+++ b/src/proc/control/handling-pattern.hpp
@@ -1,23 +1,23 @@
 /*
   HANDLILNG-PATTERN.hpp  -  A skeleton for executing commands, including standard implementations
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/control/handling-patterns.hpp b/src/proc/control/handling-patterns.hpp
index d01ad6236..19d3d7d5f 100644
--- a/src/proc/control/handling-patterns.hpp
+++ b/src/proc/control/handling-patterns.hpp
@@ -1,23 +1,23 @@
 /*
   HANDLILNG-PATTERNS.hpp  -  Collection of predefined command handling patterns
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/control/mediaimpllib.hpp b/src/proc/control/mediaimpllib.hpp
index 6150c3f4e..0afa07b8a 100644
--- a/src/proc/control/mediaimpllib.hpp
+++ b/src/proc/control/mediaimpllib.hpp
@@ -1,23 +1,23 @@
 /*
   MEDIAIMPLLIB.hpp  -  interface providing a facade to an media handling library
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/control/memento-tie.hpp b/src/proc/control/memento-tie.hpp
index 3c78b99f7..af63d38d1 100644
--- a/src/proc/control/memento-tie.hpp
+++ b/src/proc/control/memento-tie.hpp
@@ -1,23 +1,23 @@
 /*
   MEMENTO-TIE.hpp  -  capturing and providing state for undoing commands
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/control/pathmanager.cpp b/src/proc/control/pathmanager.cpp
index 6c2288a28..0e3375083 100644
--- a/src/proc/control/pathmanager.cpp
+++ b/src/proc/control/pathmanager.cpp
@@ -1,23 +1,23 @@
 /*
   PathManager  -  Manager for deciding the actual render strategy
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/control/pathmanager.hpp b/src/proc/control/pathmanager.hpp
index c3057944f..63ea761c2 100644
--- a/src/proc/control/pathmanager.hpp
+++ b/src/proc/control/pathmanager.hpp
@@ -1,23 +1,23 @@
 /*
   PATHMANAGER.hpp  -  Manager for deciding the actual render strategy
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/control/proc-dispatcher.cpp b/src/proc/control/proc-dispatcher.cpp
index 2fcb6e251..b7bb53fc4 100644
--- a/src/proc/control/proc-dispatcher.cpp
+++ b/src/proc/control/proc-dispatcher.cpp
@@ -1,23 +1,23 @@
 /*
   ProcDispatcher  -  Proc-Layer command dispatch and execution
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/control/proc-dispatcher.hpp b/src/proc/control/proc-dispatcher.hpp
index d15021523..a4161aa42 100644
--- a/src/proc/control/proc-dispatcher.hpp
+++ b/src/proc/control/proc-dispatcher.hpp
@@ -1,23 +1,23 @@
 /*
   PROC-DISPATCHER.hpp  -  Proc-Layer command dispatch and execution
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/control/stypemanager.cpp b/src/proc/control/stypemanager.cpp
index 4ba2fda19..8c4d50672 100644
--- a/src/proc/control/stypemanager.cpp
+++ b/src/proc/control/stypemanager.cpp
@@ -1,23 +1,23 @@
 /*
   STypeManager  -  entry point for dealing with media stream types
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/control/stypemanager.hpp b/src/proc/control/stypemanager.hpp
index cd6a311df..0f40408cc 100644
--- a/src/proc/control/stypemanager.hpp
+++ b/src/proc/control/stypemanager.hpp
@@ -1,23 +1,23 @@
 /*
   STYPEMANAGER.hpp  -  entry point for dealing with media stream types
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/control/styperegistry.hpp b/src/proc/control/styperegistry.hpp
index 63c33e841..a5593f9c7 100644
--- a/src/proc/control/styperegistry.hpp
+++ b/src/proc/control/styperegistry.hpp
@@ -1,23 +1,23 @@
 /*
   STYPEREGISTRY.hpp  -  implementation of the registry for stream type descriptors
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/controllerfacade.cpp b/src/proc/controllerfacade.cpp
index cff9e43d0..737f85589 100644
--- a/src/proc/controllerfacade.cpp
+++ b/src/proc/controllerfacade.cpp
@@ -1,23 +1,23 @@
 /*
   ControllerFacade  -  Facade and service access point for the Proc Layer Controller
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/controllerfacade.hpp b/src/proc/controllerfacade.hpp
index faa213e9b..e7f2c95c2 100644
--- a/src/proc/controllerfacade.hpp
+++ b/src/proc/controllerfacade.hpp
@@ -1,23 +1,23 @@
 /*
   CONTROLLERFACADE.hpp  -  Facade and service access point for the Proc Layer Controller
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/engine/buffhandle.cpp b/src/proc/engine/buffhandle.cpp
index 30ae603e2..24573990e 100644
--- a/src/proc/engine/buffhandle.cpp
+++ b/src/proc/engine/buffhandle.cpp
@@ -1,23 +1,23 @@
 /*
   BuffHandle  -  Buffer handling support for the render engine
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/engine/buffhandle.hpp b/src/proc/engine/buffhandle.hpp
index cdf1135e6..6cdca586c 100644
--- a/src/proc/engine/buffhandle.hpp
+++ b/src/proc/engine/buffhandle.hpp
@@ -1,23 +1,23 @@
 /*
   BUFFHANDLE.hpp  -  Buffer handling support for the render engine
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file buffhandle.hpp
diff --git a/src/proc/engine/bufftable.hpp b/src/proc/engine/bufftable.hpp
index 7ec679f72..3682b51ff 100644
--- a/src/proc/engine/bufftable.hpp
+++ b/src/proc/engine/bufftable.hpp
@@ -1,23 +1,23 @@
 /*
   BUFFTABLE.hpp  -  Table of buffer pointers to be used by the render nodes
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/engine/link.cpp b/src/proc/engine/link.cpp
index aac01ed41..e3e9096c6 100644
--- a/src/proc/engine/link.cpp
+++ b/src/proc/engine/link.cpp
@@ -1,23 +1,23 @@
 /*
   Link  -  forwarding, adapting or connecting ProcNode
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/engine/link.hpp b/src/proc/engine/link.hpp
index d677fca9c..ac3f70f01 100644
--- a/src/proc/engine/link.hpp
+++ b/src/proc/engine/link.hpp
@@ -1,23 +1,23 @@
 /*
   LINK.hpp  -  forwarding, adapting or connecting ProcNode
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/engine/mask.cpp b/src/proc/engine/mask.cpp
index beecb86d3..e742a9a91 100644
--- a/src/proc/engine/mask.cpp
+++ b/src/proc/engine/mask.cpp
@@ -1,23 +1,23 @@
 /*
   Mask  -  Video ProcNode for masking regions of the image (automatable)
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/engine/mask.hpp b/src/proc/engine/mask.hpp
index ccbac5bcf..d2973550f 100644
--- a/src/proc/engine/mask.hpp
+++ b/src/proc/engine/mask.hpp
@@ -1,23 +1,23 @@
 /*
   MASK.hpp  -  Video ProcNode for masking regions of the image (automatable)
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/engine/nodefactory.cpp b/src/proc/engine/nodefactory.cpp
index d8dbfa01d..52aceb647 100644
--- a/src/proc/engine/nodefactory.cpp
+++ b/src/proc/engine/nodefactory.cpp
@@ -1,23 +1,23 @@
 /*
   NodeFactory  -  Interface for creating processing nodes of various kinds
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/engine/nodefactory.hpp b/src/proc/engine/nodefactory.hpp
index 4c3d9e679..49f605ca4 100644
--- a/src/proc/engine/nodefactory.hpp
+++ b/src/proc/engine/nodefactory.hpp
@@ -1,23 +1,23 @@
 /*
   NODEFACTORY.hpp  -  Interface for creating processing nodes of various kinds
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/engine/nodeinvocation.hpp b/src/proc/engine/nodeinvocation.hpp
index 1d57280f4..dd9b17ea4 100644
--- a/src/proc/engine/nodeinvocation.hpp
+++ b/src/proc/engine/nodeinvocation.hpp
@@ -1,23 +1,23 @@
 /*
   NODEINVOCATION.hpp  -  Organise the invocation state within a single pull() call
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file nodeinvocation.hpp
diff --git a/src/proc/engine/nodeoperation.hpp b/src/proc/engine/nodeoperation.hpp
index cc8a29137..ce587862b 100644
--- a/src/proc/engine/nodeoperation.hpp
+++ b/src/proc/engine/nodeoperation.hpp
@@ -1,23 +1,23 @@
 /*
   NODEOPERATION.hpp  -  Specify how the nodes call each other and how processing is organized
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file nodeoperation.hpp
diff --git a/src/proc/engine/nodewiring-config.hpp b/src/proc/engine/nodewiring-config.hpp
index 6271199fd..62ce24abc 100644
--- a/src/proc/engine/nodewiring-config.hpp
+++ b/src/proc/engine/nodewiring-config.hpp
@@ -1,23 +1,23 @@
 /*
   NODEWIRING-CONFIG.hpp  -  Helper for representing and selecting the wiring case
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file nodewiring-config.hpp
diff --git a/src/proc/engine/nodewiring-def.hpp b/src/proc/engine/nodewiring-def.hpp
index 496195de1..ef0173820 100644
--- a/src/proc/engine/nodewiring-def.hpp
+++ b/src/proc/engine/nodewiring-def.hpp
@@ -1,23 +1,23 @@
 /*
   NODEWIRING-DEF.hpp  -  Implementation of the node network and operation control
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file nodewiring-def.hpp
diff --git a/src/proc/engine/nodewiring.cpp b/src/proc/engine/nodewiring.cpp
index f59d620db..f1e989816 100644
--- a/src/proc/engine/nodewiring.cpp
+++ b/src/proc/engine/nodewiring.cpp
@@ -1,23 +1,23 @@
 /*
   NodeWiring  -  Implementation of the node network and operation control
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/engine/nodewiring.hpp b/src/proc/engine/nodewiring.hpp
index 7d2882d45..79a7cb0d1 100644
--- a/src/proc/engine/nodewiring.hpp
+++ b/src/proc/engine/nodewiring.hpp
@@ -1,23 +1,23 @@
 /*
   NODEWIRING.hpp  -  Implementation of the node network and operation control
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/engine/pluginadapter.cpp b/src/proc/engine/pluginadapter.cpp
index fb57ae58a..7d6a16031 100644
--- a/src/proc/engine/pluginadapter.cpp
+++ b/src/proc/engine/pluginadapter.cpp
@@ -1,23 +1,23 @@
 /*
   PluginAdapter  -  Adapter for integrating various Effect processors in the render pipeline
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/engine/pluginadapter.hpp b/src/proc/engine/pluginadapter.hpp
index b771f1fbc..25dabab66 100644
--- a/src/proc/engine/pluginadapter.hpp
+++ b/src/proc/engine/pluginadapter.hpp
@@ -1,23 +1,23 @@
 /*
   PLUGINADAPTER.hpp  -  Adapter for integrating various Effect processors in the render pipeline
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/engine/procnode.hpp b/src/proc/engine/procnode.hpp
index 536085832..757524914 100644
--- a/src/proc/engine/procnode.hpp
+++ b/src/proc/engine/procnode.hpp
@@ -1,23 +1,23 @@
 /*
   PROCNODE.hpp  -  Key abstraction of the Render Engine: a Processing Node
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file procnode.hpp
diff --git a/src/proc/engine/projector.cpp b/src/proc/engine/projector.cpp
index 14fcecabb..3b75702ed 100644
--- a/src/proc/engine/projector.cpp
+++ b/src/proc/engine/projector.cpp
@@ -1,23 +1,23 @@
 /*
   Projector  -  video ProcNode for scaling and translating image data
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/engine/projector.hpp b/src/proc/engine/projector.hpp
index 4e03c4cc2..b93552e4d 100644
--- a/src/proc/engine/projector.hpp
+++ b/src/proc/engine/projector.hpp
@@ -1,23 +1,23 @@
 /*
   PROJECTOR.hpp  -  video ProcNode for scaling and translating image data
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/engine/render-invocation.cpp b/src/proc/engine/render-invocation.cpp
index abd0ce338..90c9bf147 100644
--- a/src/proc/engine/render-invocation.cpp
+++ b/src/proc/engine/render-invocation.cpp
@@ -1,23 +1,23 @@
 /*
   RenderInvocation  -  Interface for creating processing nodes of various kinds
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/engine/render-invocation.hpp b/src/proc/engine/render-invocation.hpp
index 2138169cf..459eb3f93 100644
--- a/src/proc/engine/render-invocation.hpp
+++ b/src/proc/engine/render-invocation.hpp
@@ -1,23 +1,23 @@
 /*
   RENDER-INVOCATION.hpp  -  initiate the rendering of a single frame
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file render-invocation.hpp
diff --git a/src/proc/engine/renderengine.cpp b/src/proc/engine/renderengine.cpp
index 73af98a72..588d1276b 100644
--- a/src/proc/engine/renderengine.cpp
+++ b/src/proc/engine/renderengine.cpp
@@ -1,23 +1,23 @@
 /*
   RenderEngine  -  a complete network of processing nodes usable for rendering
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/engine/renderengine.hpp b/src/proc/engine/renderengine.hpp
index b64530ed4..c3030271f 100644
--- a/src/proc/engine/renderengine.hpp
+++ b/src/proc/engine/renderengine.hpp
@@ -1,23 +1,23 @@
 /*
   RENDERENGINE.hpp  -  a complete network of processing nodes usable for rendering
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/engine/rendergraph.cpp b/src/proc/engine/rendergraph.cpp
index 0900dde06..fefaf7c63 100644
--- a/src/proc/engine/rendergraph.cpp
+++ b/src/proc/engine/rendergraph.cpp
@@ -1,23 +1,23 @@
 /*
   RenderGraph  -  render network corresponding to one segment of the timeline
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/engine/rendergraph.hpp b/src/proc/engine/rendergraph.hpp
index c994737f5..718d3dfdb 100644
--- a/src/proc/engine/rendergraph.hpp
+++ b/src/proc/engine/rendergraph.hpp
@@ -1,23 +1,23 @@
 /*
   RENDERGRAPH.hpp  -  render network corresponding to one segment of the timeline
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/engine/source.cpp b/src/proc/engine/source.cpp
index 73da9add5..68cad7a62 100644
--- a/src/proc/engine/source.cpp
+++ b/src/proc/engine/source.cpp
@@ -1,23 +1,23 @@
 /*
   Source  -  Representation of a Media source
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/engine/source.hpp b/src/proc/engine/source.hpp
index 3573f3e0b..8587c3d67 100644
--- a/src/proc/engine/source.hpp
+++ b/src/proc/engine/source.hpp
@@ -1,23 +1,23 @@
 /*
   SOURCE.hpp  -  Representation of a Media source
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/engine/stateproxy.cpp b/src/proc/engine/stateproxy.cpp
index c8a07a429..cb32f3b57 100644
--- a/src/proc/engine/stateproxy.cpp
+++ b/src/proc/engine/stateproxy.cpp
@@ -1,23 +1,23 @@
 /*
   StateProxy  -  Encapsulation of the state corresponding to a render calculation
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/engine/stateproxy.hpp b/src/proc/engine/stateproxy.hpp
index 50e961ca1..7125790f7 100644
--- a/src/proc/engine/stateproxy.hpp
+++ b/src/proc/engine/stateproxy.hpp
@@ -1,23 +1,23 @@
 /*
   STATEPROXY.hpp  -  Encapsulation of the state corresponding to a render calculation
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/engine/trafo.cpp b/src/proc/engine/trafo.cpp
index 28c3db772..636e59e4e 100644
--- a/src/proc/engine/trafo.cpp
+++ b/src/proc/engine/trafo.cpp
@@ -1,23 +1,23 @@
 /*
   Trafo  -  transforming processing Node 
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/engine/trafo.hpp b/src/proc/engine/trafo.hpp
index 166154674..cb1933619 100644
--- a/src/proc/engine/trafo.hpp
+++ b/src/proc/engine/trafo.hpp
@@ -1,23 +1,23 @@
 /*
   TRAFO.hpp  -  transforming processing Node 
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/facade.cpp b/src/proc/facade.cpp
index 3c7d6f93b..6b44fbd36 100644
--- a/src/proc/facade.cpp
+++ b/src/proc/facade.cpp
@@ -1,23 +1,23 @@
 /*
   Facade  -  access point for communicating with the Proc-Interface
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/facade.hpp b/src/proc/facade.hpp
index b231359f3..88ac62e56 100644
--- a/src/proc/facade.hpp
+++ b/src/proc/facade.hpp
@@ -1,23 +1,23 @@
 /*
   FACADE.hpp  -  access point for communicating with the Proc-Interface
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/builder/applicable-builder-target-types.hpp b/src/proc/mobject/builder/applicable-builder-target-types.hpp
index 0f0a4d848..57c2e66f9 100644
--- a/src/proc/mobject/builder/applicable-builder-target-types.hpp
+++ b/src/proc/mobject/builder/applicable-builder-target-types.hpp
@@ -1,23 +1,23 @@
 /*
   ApplicableBuilderTargetTypes  -  definition header specifying all types treated by builder tools
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file applicable-builder-target-types.hpp
diff --git a/src/proc/mobject/builder/assembler.cpp b/src/proc/mobject/builder/assembler.cpp
index 8542860f3..b4d05bb07 100644
--- a/src/proc/mobject/builder/assembler.cpp
+++ b/src/proc/mobject/builder/assembler.cpp
@@ -1,23 +1,23 @@
 /*
   Assembler  -  building facility (implementation of the build process)
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/builder/assembler.hpp b/src/proc/mobject/builder/assembler.hpp
index f0274f171..f874b99bd 100644
--- a/src/proc/mobject/builder/assembler.hpp
+++ b/src/proc/mobject/builder/assembler.hpp
@@ -1,23 +1,23 @@
 /*
   ASSEMBLER.hpp  -  building facility (implementation of the build process)
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/builder/buildertool.hpp b/src/proc/mobject/builder/buildertool.hpp
index 2d919a70a..9d51361d4 100644
--- a/src/proc/mobject/builder/buildertool.hpp
+++ b/src/proc/mobject/builder/buildertool.hpp
@@ -1,23 +1,23 @@
 /*
   BUILDERTOOL.hpp  -  Interface, (visiting) tool for processing MObjects
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file buildertool.hpp
diff --git a/src/proc/mobject/builder/common.hpp b/src/proc/mobject/builder/common.hpp
index ed3554c4c..ba09ec9ca 100644
--- a/src/proc/mobject/builder/common.hpp
+++ b/src/proc/mobject/builder/common.hpp
@@ -1,23 +1,23 @@
 /*
   COMMON.hpp  -  common definitions for the Builder subsystem
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/builder/conmanager.cpp b/src/proc/mobject/builder/conmanager.cpp
index 14e20a788..b13c19b67 100644
--- a/src/proc/mobject/builder/conmanager.cpp
+++ b/src/proc/mobject/builder/conmanager.cpp
@@ -1,23 +1,23 @@
 /*
   ConManager  -  manages the creation of data/control connections when building the Renderengine
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/builder/conmanager.hpp b/src/proc/mobject/builder/conmanager.hpp
index c992cbf59..db699d868 100644
--- a/src/proc/mobject/builder/conmanager.hpp
+++ b/src/proc/mobject/builder/conmanager.hpp
@@ -1,23 +1,23 @@
 /*
   CONMANAGER.hpp  -  manages the creation of data/control connections when building the Renderengine
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/builder/fixture-change-detector.hpp b/src/proc/mobject/builder/fixture-change-detector.hpp
index 7d25225f3..bf836d7d1 100644
--- a/src/proc/mobject/builder/fixture-change-detector.hpp
+++ b/src/proc/mobject/builder/fixture-change-detector.hpp
@@ -1,23 +1,23 @@
 /*
     FIXTURE-CHANGE-DETECTOR.hpp  -  isolating changed segments and tainted processes
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file fixture-change-detector.hpp
diff --git a/src/proc/mobject/builder/model-port-registry.cpp b/src/proc/mobject/builder/model-port-registry.cpp
index f674fd912..c3c16d7eb 100644
--- a/src/proc/mobject/builder/model-port-registry.cpp
+++ b/src/proc/mobject/builder/model-port-registry.cpp
@@ -1,23 +1,23 @@
 /*
   ModelPortRegistry  -  creating and organising and accessing model ports
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/builder/model-port-registry.hpp b/src/proc/mobject/builder/model-port-registry.hpp
index be69cac8b..078c1928b 100644
--- a/src/proc/mobject/builder/model-port-registry.hpp
+++ b/src/proc/mobject/builder/model-port-registry.hpp
@@ -1,23 +1,23 @@
 /*
     MODEL-PORT-REGISTRY.hpp  -  creating and organising and accessing model ports
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file model-port-registry.hpp
diff --git a/src/proc/mobject/builder/mould.hpp b/src/proc/mobject/builder/mould.hpp
index 9a0108104..5db2ece7f 100644
--- a/src/proc/mobject/builder/mould.hpp
+++ b/src/proc/mobject/builder/mould.hpp
@@ -1,23 +1,23 @@
 /*
   MOULD.hpp  -  builder tool kit for the basic building situations
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/builder/nodecreatortool.cpp b/src/proc/mobject/builder/nodecreatortool.cpp
index 854d92dbc..9dcb639b7 100644
--- a/src/proc/mobject/builder/nodecreatortool.cpp
+++ b/src/proc/mobject/builder/nodecreatortool.cpp
@@ -1,23 +1,23 @@
 /*
   NodeCreaterTool  -  central Tool implementing the Renderengine building
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/builder/nodecreatortool.hpp b/src/proc/mobject/builder/nodecreatortool.hpp
index 6d2b5e9e8..fda4c95db 100644
--- a/src/proc/mobject/builder/nodecreatortool.hpp
+++ b/src/proc/mobject/builder/nodecreatortool.hpp
@@ -1,23 +1,23 @@
 /*
   NODECREATERTOOL.hpp  -  central Tool implementing the Renderengine building
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/builder/operationpoint.cpp b/src/proc/mobject/builder/operationpoint.cpp
index 5a6bbe3bf..e27ffc5b4 100644
--- a/src/proc/mobject/builder/operationpoint.cpp
+++ b/src/proc/mobject/builder/operationpoint.cpp
@@ -1,23 +1,23 @@
 /*
   OperationPoint  -  abstraction representing the point where to apply a build instruction
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/builder/operationpoint.hpp b/src/proc/mobject/builder/operationpoint.hpp
index 329dbcebc..49b5855bb 100644
--- a/src/proc/mobject/builder/operationpoint.hpp
+++ b/src/proc/mobject/builder/operationpoint.hpp
@@ -1,23 +1,23 @@
 /*
   OPERATIONPOINT.hpp  -  abstraction representing the point where to apply a build instruction
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/builder/renderstate.hpp b/src/proc/mobject/builder/renderstate.hpp
index 6e99a99b1..3da0e094b 100644
--- a/src/proc/mobject/builder/renderstate.hpp
+++ b/src/proc/mobject/builder/renderstate.hpp
@@ -1,23 +1,23 @@
 /*
   RENDERSTATE.hpp  -  renderengine state management
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/builder/segmentation-tool.cpp b/src/proc/mobject/builder/segmentation-tool.cpp
index b87109d68..39b47380f 100644
--- a/src/proc/mobject/builder/segmentation-tool.cpp
+++ b/src/proc/mobject/builder/segmentation-tool.cpp
@@ -1,23 +1,23 @@
 /*
   SegmentationTool  -  Tool for creating a partitioning of the current timeline
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/builder/segmentation-tool.hpp b/src/proc/mobject/builder/segmentation-tool.hpp
index a40f4c8f9..52bb1c5c1 100644
--- a/src/proc/mobject/builder/segmentation-tool.hpp
+++ b/src/proc/mobject/builder/segmentation-tool.hpp
@@ -1,23 +1,23 @@
 /*
   SEGMENTATION-TOOL.hpp  -  Tool for creating a partitioning of the current timeline
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/builder/segmentation.cpp b/src/proc/mobject/builder/segmentation.cpp
index 7231dfd0a..e7cd9cbf1 100644
--- a/src/proc/mobject/builder/segmentation.cpp
+++ b/src/proc/mobject/builder/segmentation.cpp
@@ -1,23 +1,23 @@
 /*
   Segmentation  -  partitioning the effective timeline
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/builder/segmentation.hpp b/src/proc/mobject/builder/segmentation.hpp
index c3c73249c..028e47f26 100644
--- a/src/proc/mobject/builder/segmentation.hpp
+++ b/src/proc/mobject/builder/segmentation.hpp
@@ -1,23 +1,23 @@
 /*
     SEGMENTATION.hpp  -  partitioning the effective timeline
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file segmentation.hpp
diff --git a/src/proc/mobject/builder/toolfactory.cpp b/src/proc/mobject/builder/toolfactory.cpp
index abfa8c83c..ab844f574 100644
--- a/src/proc/mobject/builder/toolfactory.cpp
+++ b/src/proc/mobject/builder/toolfactory.cpp
@@ -1,23 +1,23 @@
 /*
   ToolFactory  -  supply of Tool implementations for the Builder
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/builder/toolfactory.hpp b/src/proc/mobject/builder/toolfactory.hpp
index e17687ad4..201653fde 100644
--- a/src/proc/mobject/builder/toolfactory.hpp
+++ b/src/proc/mobject/builder/toolfactory.hpp
@@ -1,23 +1,23 @@
 /*
   TOOLFACTORY.hpp  -  supply of Tool implementations for the Builder
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/builder/wiringrequest.hpp b/src/proc/mobject/builder/wiringrequest.hpp
index 6e39cb562..1ebb4515c 100644
--- a/src/proc/mobject/builder/wiringrequest.hpp
+++ b/src/proc/mobject/builder/wiringrequest.hpp
@@ -1,23 +1,23 @@
 /*
   WIRINGREQUEST.hpp  -  (interface) the intention to make a data or control connection
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/builderfacade.cpp b/src/proc/mobject/builderfacade.cpp
index cbf73bbbd..b2f1377d5 100644
--- a/src/proc/mobject/builderfacade.cpp
+++ b/src/proc/mobject/builderfacade.cpp
@@ -1,23 +1,23 @@
 /*
   BuilderFacade  -  Facade and service access point for the Builder Subsystem
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/builderfacade.hpp b/src/proc/mobject/builderfacade.hpp
index 31ab936ab..4a27d8b88 100644
--- a/src/proc/mobject/builderfacade.hpp
+++ b/src/proc/mobject/builderfacade.hpp
@@ -1,23 +1,23 @@
 /*
   BUILDERFACADE.hpp  -  Facade and service access point for the Builder Subsystem
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/explicitplacement.hpp b/src/proc/mobject/explicitplacement.hpp
index 7fc3ec5dc..363e8beef 100644
--- a/src/proc/mobject/explicitplacement.hpp
+++ b/src/proc/mobject/explicitplacement.hpp
@@ -1,23 +1,23 @@
 /*
   EXPLICITPLACEMENT.hpp  -  special Placement yielding an absolute location (Time,Track) for a MObject
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/interpolator.cpp b/src/proc/mobject/interpolator.cpp
index 8ceb9ad86..026111b53 100644
--- a/src/proc/mobject/interpolator.cpp
+++ b/src/proc/mobject/interpolator.cpp
@@ -1,23 +1,23 @@
 /*
   Interpolator  -  denotes a facility to get (continuously interpolated) parameter values
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/interpolator.hpp b/src/proc/mobject/interpolator.hpp
index 843cd52bc..2244d7e58 100644
--- a/src/proc/mobject/interpolator.hpp
+++ b/src/proc/mobject/interpolator.hpp
@@ -1,23 +1,23 @@
 /*
   INTERPOLATOR.hpp  -  denotes a facility to get (continuously interpolated) parameter values
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/mobject-ref.cpp b/src/proc/mobject/mobject-ref.cpp
index a66250f1a..4eb98dcfc 100644
--- a/src/proc/mobject/mobject-ref.cpp
+++ b/src/proc/mobject/mobject-ref.cpp
@@ -1,23 +1,23 @@
 /*
   MobjectRef  -  active external reference to an MObject within the Session
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/mobject-ref.hpp b/src/proc/mobject/mobject-ref.hpp
index 737782436..ac03f32a1 100644
--- a/src/proc/mobject/mobject-ref.hpp
+++ b/src/proc/mobject/mobject-ref.hpp
@@ -1,23 +1,23 @@
 /*
   MOBJECT-REF.hpp  -  active external reference to an MObject within the Session
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/mobject.cpp b/src/proc/mobject/mobject.cpp
index 8ac73a1d2..f55c588aa 100644
--- a/src/proc/mobject/mobject.cpp
+++ b/src/proc/mobject/mobject.cpp
@@ -1,23 +1,23 @@
 /*
   MObject  -  Key Abstraction: A Media Object in the Session
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/mobject.hpp b/src/proc/mobject/mobject.hpp
index a1a7c8eab..a8ea73313 100644
--- a/src/proc/mobject/mobject.hpp
+++ b/src/proc/mobject/mobject.hpp
@@ -1,23 +1,23 @@
 /*
   MOBJECT.hpp  -  Key Abstraction: A Media Object in the Session
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/model-port.hpp b/src/proc/mobject/model-port.hpp
index 7b033218b..1ff5a0b3b 100644
--- a/src/proc/mobject/model-port.hpp
+++ b/src/proc/mobject/model-port.hpp
@@ -1,23 +1,23 @@
 /*
   MODEL-PORT.hpp  -  point to pull output data from the model
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file model-port.hpp
diff --git a/src/proc/mobject/output-designation.cpp b/src/proc/mobject/output-designation.cpp
index 0423e5890..3d628150b 100644
--- a/src/proc/mobject/output-designation.cpp
+++ b/src/proc/mobject/output-designation.cpp
@@ -1,23 +1,23 @@
 /*
   OutputDesignation  -  specifying a desired output destination
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/output-designation.hpp b/src/proc/mobject/output-designation.hpp
index 61a7b1c1a..43aa6f5b8 100644
--- a/src/proc/mobject/output-designation.hpp
+++ b/src/proc/mobject/output-designation.hpp
@@ -1,23 +1,23 @@
 /*
   OUTPUT-DESIGNATION.hpp  -  specifying a desired output destination
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/output-mapping.hpp b/src/proc/mobject/output-mapping.hpp
index 45f26ae0a..182c007e1 100644
--- a/src/proc/mobject/output-mapping.hpp
+++ b/src/proc/mobject/output-mapping.hpp
@@ -1,23 +1,23 @@
 /*
   OUTPUT-MAPPING.hpp  -  generic interface for translation of output designations
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/parameter.cpp b/src/proc/mobject/parameter.cpp
index ac826dcdd..854634f49 100644
--- a/src/proc/mobject/parameter.cpp
+++ b/src/proc/mobject/parameter.cpp
@@ -1,23 +1,23 @@
 /*
   Parameter  -  representation of an automatable effect/plugin parameter
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/parameter.hpp b/src/proc/mobject/parameter.hpp
index 634e36851..7a0a852d5 100644
--- a/src/proc/mobject/parameter.hpp
+++ b/src/proc/mobject/parameter.hpp
@@ -1,23 +1,23 @@
 /*
   PARAMETER.hpp  -  representation of an automatable effect/plugin parameter
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/paramprovider.cpp b/src/proc/mobject/paramprovider.cpp
index 8b5da785a..e0fae70a2 100644
--- a/src/proc/mobject/paramprovider.cpp
+++ b/src/proc/mobject/paramprovider.cpp
@@ -1,23 +1,23 @@
 /*
   ParamProvider  -  interface denoting a source for actual Parameter values
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/paramprovider.hpp b/src/proc/mobject/paramprovider.hpp
index fdcaff2a8..cbf44a779 100644
--- a/src/proc/mobject/paramprovider.hpp
+++ b/src/proc/mobject/paramprovider.hpp
@@ -1,23 +1,23 @@
 /*
   PARAMPROVIDER.hpp  -  interface denoting a source for actual Parameter values
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/placement-ref.hpp b/src/proc/mobject/placement-ref.hpp
index 91d246471..d5fb4fa59 100644
--- a/src/proc/mobject/placement-ref.hpp
+++ b/src/proc/mobject/placement-ref.hpp
@@ -1,23 +1,23 @@
 /*
   PLACEMENT-REF.hpp  -  generic reference to an individual placement added to the session
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/placement.cpp b/src/proc/mobject/placement.cpp
index 1b6e4c14d..e0260ef13 100644
--- a/src/proc/mobject/placement.cpp
+++ b/src/proc/mobject/placement.cpp
@@ -1,23 +1,23 @@
 /*
   Placement  -  Key Abstraction: a way to place and locate a Media Object
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/placement.hpp b/src/proc/mobject/placement.hpp
index 46607752d..5cd8206dc 100644
--- a/src/proc/mobject/placement.hpp
+++ b/src/proc/mobject/placement.hpp
@@ -1,23 +1,23 @@
 /*
   PLACEMENT.hpp  -  Key Abstraction: a way to place and locate a Media Object
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session.hpp b/src/proc/mobject/session.hpp
index 4bab5f285..b60821096 100644
--- a/src/proc/mobject/session.hpp
+++ b/src/proc/mobject/session.hpp
@@ -1,23 +1,23 @@
 /*
   SESSION.hpp  -  holds the complete session to be edited by the user
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/abstractmo.cpp b/src/proc/mobject/session/abstractmo.cpp
index bdebb727d..aba3d7b2f 100644
--- a/src/proc/mobject/session/abstractmo.cpp
+++ b/src/proc/mobject/session/abstractmo.cpp
@@ -1,23 +1,23 @@
 /*
   AbstractMO  -  abstract base class for all Media Objects
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/session/abstractmo.hpp b/src/proc/mobject/session/abstractmo.hpp
index eff1d5d0c..53abf0466 100644
--- a/src/proc/mobject/session/abstractmo.hpp
+++ b/src/proc/mobject/session/abstractmo.hpp
@@ -1,23 +1,23 @@
 /*
   ABSTRACTMO.hpp  -  abstract base class for all Media Objects
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/allocation.cpp b/src/proc/mobject/session/allocation.cpp
index ae23185b8..03cbfd88d 100644
--- a/src/proc/mobject/session/allocation.cpp
+++ b/src/proc/mobject/session/allocation.cpp
@@ -1,23 +1,23 @@
 /*
   Allocation  -  objective to place a MObject in a specific way  
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/session/allocation.hpp b/src/proc/mobject/session/allocation.hpp
index e668fb469..a1a668b9d 100644
--- a/src/proc/mobject/session/allocation.hpp
+++ b/src/proc/mobject/session/allocation.hpp
@@ -1,23 +1,23 @@
 /*
   ALLOCATION.hpp  -  objective to place a MObject in a specific way
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/auto.cpp b/src/proc/mobject/session/auto.cpp
index a8ecf4c38..b46ea5cae 100644
--- a/src/proc/mobject/session/auto.cpp
+++ b/src/proc/mobject/session/auto.cpp
@@ -1,23 +1,23 @@
 /*
   Auto  -  Media Object holding automation data
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/session/auto.hpp b/src/proc/mobject/session/auto.hpp
index 0ec133bc0..24b82ba9c 100644
--- a/src/proc/mobject/session/auto.hpp
+++ b/src/proc/mobject/session/auto.hpp
@@ -1,23 +1,23 @@
 /*
   AUTO.hpp  -  Media Object holding automation data
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/binding.cpp b/src/proc/mobject/session/binding.cpp
index eac8d70ea..9a763129a 100644
--- a/src/proc/mobject/session/binding.cpp
+++ b/src/proc/mobject/session/binding.cpp
@@ -1,23 +1,23 @@
 /*
   Binding  -  link to use a sequence within the session
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/session/binding.hpp b/src/proc/mobject/session/binding.hpp
index 05c51fd74..0b790da9c 100644
--- a/src/proc/mobject/session/binding.hpp
+++ b/src/proc/mobject/session/binding.hpp
@@ -1,23 +1,23 @@
 /*
   BINDING.hpp  -  link to use a sequence within the session
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/bus-mo.cpp b/src/proc/mobject/session/bus-mo.cpp
index ab43dba67..1ea99c15c 100644
--- a/src/proc/mobject/session/bus-mo.cpp
+++ b/src/proc/mobject/session/bus-mo.cpp
@@ -1,23 +1,23 @@
 /*
   BusMO  -  attachment point to form a global pipe
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/session/bus-mo.hpp b/src/proc/mobject/session/bus-mo.hpp
index 1e686bd37..30d5c3ae6 100644
--- a/src/proc/mobject/session/bus-mo.hpp
+++ b/src/proc/mobject/session/bus-mo.hpp
@@ -1,23 +1,23 @@
 /*
   BUS-MO.hpp  -  attachment point to form a global pipe
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/clip.cpp b/src/proc/mobject/session/clip.cpp
index a99f7c5df..af388fd9b 100644
--- a/src/proc/mobject/session/clip.cpp
+++ b/src/proc/mobject/session/clip.cpp
@@ -1,23 +1,23 @@
 /*
   Clip  -  a Media Clip
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/session/clip.hpp b/src/proc/mobject/session/clip.hpp
index 09aeda4c7..6a6251103 100644
--- a/src/proc/mobject/session/clip.hpp
+++ b/src/proc/mobject/session/clip.hpp
@@ -1,23 +1,23 @@
 /*
   CLIP.hpp  -  a Media Clip
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/compoundclip.cpp b/src/proc/mobject/session/compoundclip.cpp
index caa8e83bd..6de47a052 100644
--- a/src/proc/mobject/session/compoundclip.cpp
+++ b/src/proc/mobject/session/compoundclip.cpp
@@ -1,23 +1,23 @@
 /*
   CompoundClip  -  compound of several clips (multichannel)
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/session/compoundclip.hpp b/src/proc/mobject/session/compoundclip.hpp
index e2dfd9fd9..9e4f32f77 100644
--- a/src/proc/mobject/session/compoundclip.hpp
+++ b/src/proc/mobject/session/compoundclip.hpp
@@ -1,23 +1,23 @@
 /*
   COMPOUNDCLIP.hpp  -  compound of several clips (multichannel)
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/constraint.cpp b/src/proc/mobject/session/constraint.cpp
index 8a767ed45..4a1241cf3 100644
--- a/src/proc/mobject/session/constraint.cpp
+++ b/src/proc/mobject/session/constraint.cpp
@@ -1,23 +1,23 @@
 /*
   Constraint  -  LocatingPin representing an mandatory directive
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/session/constraint.hpp b/src/proc/mobject/session/constraint.hpp
index 191f4b515..eabddc617 100644
--- a/src/proc/mobject/session/constraint.hpp
+++ b/src/proc/mobject/session/constraint.hpp
@@ -1,23 +1,23 @@
 /*
   CONSTRAINT.hpp  -  LocatingPin representing an mandatory directive
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/defsmanager.cpp b/src/proc/mobject/session/defsmanager.cpp
index 7f660f8c8..0c5c134b1 100644
--- a/src/proc/mobject/session/defsmanager.cpp
+++ b/src/proc/mobject/session/defsmanager.cpp
@@ -1,23 +1,23 @@
 /*
   DefsManager  -  access to preconfigured default objects and definitions
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/session/defsmanager.hpp b/src/proc/mobject/session/defsmanager.hpp
index 09b7a0499..7d904b6b8 100644
--- a/src/proc/mobject/session/defsmanager.hpp
+++ b/src/proc/mobject/session/defsmanager.hpp
@@ -1,23 +1,23 @@
 /*
   DEFSMANAGER.hpp  -  access to preconfigured default objects and definitions
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/defsregistry.hpp b/src/proc/mobject/session/defsregistry.hpp
index 0dc6242c5..1ceabfc0a 100644
--- a/src/proc/mobject/session/defsregistry.hpp
+++ b/src/proc/mobject/session/defsregistry.hpp
@@ -1,23 +1,23 @@
 /*
   DEFSREGISTRY.hpp  -  implementation of the default object store
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/effect.cpp b/src/proc/mobject/session/effect.cpp
index de2bfe18a..d190274dd 100644
--- a/src/proc/mobject/session/effect.cpp
+++ b/src/proc/mobject/session/effect.cpp
@@ -1,23 +1,23 @@
 /*
   Effect  -  Model representation of a pluggable and automatable effect.
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/session/effect.hpp b/src/proc/mobject/session/effect.hpp
index ba0f08e8c..9c22e847e 100644
--- a/src/proc/mobject/session/effect.hpp
+++ b/src/proc/mobject/session/effect.hpp
@@ -1,23 +1,23 @@
 /*
   EFFECT.hpp  -  Model representation of a pluggable and automatable effect.
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/element-query.hpp b/src/proc/mobject/session/element-query.hpp
index 9baf6a5d6..fbb3fbe3a 100644
--- a/src/proc/mobject/session/element-query.hpp
+++ b/src/proc/mobject/session/element-query.hpp
@@ -1,23 +1,23 @@
 /*
   ELEMENT-QUERY.hpp  -  session sub-interface to query and retrieve elements
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/fixedlocation.cpp b/src/proc/mobject/session/fixedlocation.cpp
index 238b8c011..1cd7eb98c 100644
--- a/src/proc/mobject/session/fixedlocation.cpp
+++ b/src/proc/mobject/session/fixedlocation.cpp
@@ -1,23 +1,23 @@
 /*
   FixedLocation  - directly positioning a MObject to a fixed location  
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/session/fixedlocation.hpp b/src/proc/mobject/session/fixedlocation.hpp
index 6b6d981c3..ab9b9cc6d 100644
--- a/src/proc/mobject/session/fixedlocation.hpp
+++ b/src/proc/mobject/session/fixedlocation.hpp
@@ -1,23 +1,23 @@
 /*
   FIXEDLOCATION.hpp  -  directly positioning a MObject to a fixed location   
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/fixture.cpp b/src/proc/mobject/session/fixture.cpp
index 9c8209000..053bd3827 100644
--- a/src/proc/mobject/session/fixture.cpp
+++ b/src/proc/mobject/session/fixture.cpp
@@ -1,23 +1,23 @@
 /*
   Fixture  -  the (low level) representation of the Session with explicit placement data
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/session/fixture.hpp b/src/proc/mobject/session/fixture.hpp
index 76f55ce4b..d6ecdc847 100644
--- a/src/proc/mobject/session/fixture.hpp
+++ b/src/proc/mobject/session/fixture.hpp
@@ -1,23 +1,23 @@
 /*
   FIXTURE.hpp  -  the (low level) representation of the Session with explicit placement data
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/label.cpp b/src/proc/mobject/session/label.cpp
index 6f6224fed..58e3cd86f 100644
--- a/src/proc/mobject/session/label.cpp
+++ b/src/proc/mobject/session/label.cpp
@@ -1,23 +1,23 @@
 /*
   Label  -  a user visible Marker or Tag  
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/session/label.hpp b/src/proc/mobject/session/label.hpp
index d2b6c3616..df790d74f 100644
--- a/src/proc/mobject/session/label.hpp
+++ b/src/proc/mobject/session/label.hpp
@@ -1,23 +1,23 @@
 /*
   LABEL.hpp  -  a user visible Marker or Tag
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/lifecycle-advisor.hpp b/src/proc/mobject/session/lifecycle-advisor.hpp
index b595273f2..a3c286af8 100644
--- a/src/proc/mobject/session/lifecycle-advisor.hpp
+++ b/src/proc/mobject/session/lifecycle-advisor.hpp
@@ -1,23 +1,23 @@
 /*
   LIFECYCLE-ADVISOR.hpp  -  outline of the session lifecycle
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/locatingpin.cpp b/src/proc/mobject/session/locatingpin.cpp
index f4e7ce954..1c98c3df1 100644
--- a/src/proc/mobject/session/locatingpin.cpp
+++ b/src/proc/mobject/session/locatingpin.cpp
@@ -1,23 +1,23 @@
 /*
   LocatingPin  -  Chaining and constraining the Placement of a Media Object
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/session/locatingpin.hpp b/src/proc/mobject/session/locatingpin.hpp
index 945947a75..04feae332 100644
--- a/src/proc/mobject/session/locatingpin.hpp
+++ b/src/proc/mobject/session/locatingpin.hpp
@@ -1,23 +1,23 @@
 /*
   LOCATINGPIN.hpp  -  Chaining and constraining the Placement of a Media Object
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/meta.cpp b/src/proc/mobject/session/meta.cpp
index cb61756d5..88d87c443 100644
--- a/src/proc/mobject/session/meta.cpp
+++ b/src/proc/mobject/session/meta.cpp
@@ -1,23 +1,23 @@
 /*
   Meta  -  abstract base class of all MObjects representing meta data or processing instructions
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/session/meta.hpp b/src/proc/mobject/session/meta.hpp
index bea5bdb25..3015bb127 100644
--- a/src/proc/mobject/session/meta.hpp
+++ b/src/proc/mobject/session/meta.hpp
@@ -1,23 +1,23 @@
 /*
   META.hpp  -  abstract base class of all MObjects representing meta data or processing instructions
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/mobjectfactory.cpp b/src/proc/mobject/session/mobjectfactory.cpp
index b7f639d9e..f6c6aa807 100644
--- a/src/proc/mobject/session/mobjectfactory.cpp
+++ b/src/proc/mobject/session/mobjectfactory.cpp
@@ -1,23 +1,23 @@
 /*
   MObjectFactory  -  creating concrete MObject subclass instances
- 
+
   Copyright (C)         Lumiera.org
     2008-2010,          Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/session/mobjectfactory.hpp b/src/proc/mobject/session/mobjectfactory.hpp
index 0d7aa6010..67e1ada4e 100644
--- a/src/proc/mobject/session/mobjectfactory.hpp
+++ b/src/proc/mobject/session/mobjectfactory.hpp
@@ -1,23 +1,23 @@
 /*
   MOBJECTFACTORY.hpp  -  creating concrete MObject subclass instances
- 
+
   Copyright (C)         Lumiera.org
     2008-2010,          Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/placement-index-query-resolver.cpp b/src/proc/mobject/session/placement-index-query-resolver.cpp
index 5b06caf73..ea366b6ac 100644
--- a/src/proc/mobject/session/placement-index-query-resolver.cpp
+++ b/src/proc/mobject/session/placement-index-query-resolver.cpp
@@ -1,23 +1,23 @@
 /*
   placementIndexQueryResolver  -  using PlacementIndex to resolve scope queries
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/session/placement-index-query-resolver.hpp b/src/proc/mobject/session/placement-index-query-resolver.hpp
index 7ae60a7b9..6e4ab424d 100644
--- a/src/proc/mobject/session/placement-index-query-resolver.hpp
+++ b/src/proc/mobject/session/placement-index-query-resolver.hpp
@@ -1,23 +1,23 @@
 /*
   PLACEMENT-INDEX-QUERY-RESOLVER.hpp  -  using PlacementIndex to resolve scope queries
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/placement-index.cpp b/src/proc/mobject/session/placement-index.cpp
index 1772bae18..fab3adda6 100644
--- a/src/proc/mobject/session/placement-index.cpp
+++ b/src/proc/mobject/session/placement-index.cpp
@@ -1,23 +1,23 @@
 /*
   PlacementIndex  -  tracking individual Placements and their relations
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/session/placement-index.hpp b/src/proc/mobject/session/placement-index.hpp
index b94cf0e2b..51dde737d 100644
--- a/src/proc/mobject/session/placement-index.hpp
+++ b/src/proc/mobject/session/placement-index.hpp
@@ -1,23 +1,23 @@
 /*
   PLACEMENT-INDEX.hpp  -  tracking individual Placements and their relations
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/plug.cpp b/src/proc/mobject/session/plug.cpp
index ccc117510..d642ed1e3 100644
--- a/src/proc/mobject/session/plug.cpp
+++ b/src/proc/mobject/session/plug.cpp
@@ -1,23 +1,23 @@
 /*
   Plug  -  LocatingPin for requesting connection to some Pipe
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/session/plug.hpp b/src/proc/mobject/session/plug.hpp
index 333ee3ed8..fb0835c55 100644
--- a/src/proc/mobject/session/plug.hpp
+++ b/src/proc/mobject/session/plug.hpp
@@ -1,23 +1,23 @@
 /*
   PLUG.hpp  -  LocatingPin for requesting connection to some Pipe
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/query-focus-stack.hpp b/src/proc/mobject/session/query-focus-stack.hpp
index d58b02481..42dedc962 100644
--- a/src/proc/mobject/session/query-focus-stack.hpp
+++ b/src/proc/mobject/session/query-focus-stack.hpp
@@ -1,23 +1,23 @@
 /*
   QUERY-FOCUS-STACK.hpp  -  management of current scope within the Session
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/query-focus.cpp b/src/proc/mobject/session/query-focus.cpp
index b6bcf3bd0..2972d2f35 100644
--- a/src/proc/mobject/session/query-focus.cpp
+++ b/src/proc/mobject/session/query-focus.cpp
@@ -1,23 +1,23 @@
 /*
   QueryFocus  -  management of current scope within the Session
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/session/query-focus.hpp b/src/proc/mobject/session/query-focus.hpp
index 3dfe9ba04..9fc74decc 100644
--- a/src/proc/mobject/session/query-focus.hpp
+++ b/src/proc/mobject/session/query-focus.hpp
@@ -1,23 +1,23 @@
 /*
   QUERY-FOCUS.hpp  -  management of current scope within the Session
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/query-resolver.cpp b/src/proc/mobject/session/query-resolver.cpp
index 1461cf7f5..787c58f6d 100644
--- a/src/proc/mobject/session/query-resolver.cpp
+++ b/src/proc/mobject/session/query-resolver.cpp
@@ -1,23 +1,23 @@
 /*
   QueryResolver  -  interface for discovering contents of a scope
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/session/query-resolver.hpp b/src/proc/mobject/session/query-resolver.hpp
index 38a41d874..eedd6811a 100644
--- a/src/proc/mobject/session/query-resolver.hpp
+++ b/src/proc/mobject/session/query-resolver.hpp
@@ -1,23 +1,23 @@
 /*
   QUERY-RESOLVER.hpp  -  interface for discovering contents of a scope
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/relativelocation.cpp b/src/proc/mobject/session/relativelocation.cpp
index 7ae39ff3a..557d3b66d 100644
--- a/src/proc/mobject/session/relativelocation.cpp
+++ b/src/proc/mobject/session/relativelocation.cpp
@@ -1,23 +1,23 @@
 /*
   RelativeLocation  -  Placement implementation attaching MObjects relative to another one
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/session/relativelocation.hpp b/src/proc/mobject/session/relativelocation.hpp
index ff0d159f2..46b2a6d4b 100644
--- a/src/proc/mobject/session/relativelocation.hpp
+++ b/src/proc/mobject/session/relativelocation.hpp
@@ -1,23 +1,23 @@
 /*
   RELATIVELOCATION.hpp  -  Placement implementation attaching MObjects relative to another one
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/root.cpp b/src/proc/mobject/session/root.cpp
index 401a90dcb..d3133c2da 100644
--- a/src/proc/mobject/session/root.cpp
+++ b/src/proc/mobject/session/root.cpp
@@ -1,23 +1,23 @@
 /*
   Root  -  root element of the high-level model, global session scope
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/session/root.hpp b/src/proc/mobject/session/root.hpp
index 8d5b744ad..c8dc18631 100644
--- a/src/proc/mobject/session/root.hpp
+++ b/src/proc/mobject/session/root.hpp
@@ -1,23 +1,23 @@
 /*
   ROOT.hpp  -  root element of the high-level model, global session scope
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/scope-locator.hpp b/src/proc/mobject/session/scope-locator.hpp
index 5512f3917..a3c427722 100644
--- a/src/proc/mobject/session/scope-locator.hpp
+++ b/src/proc/mobject/session/scope-locator.hpp
@@ -1,23 +1,23 @@
 /*
   SCOPE-LOCATOR.hpp  -  management and registration point for the QueryFocus-system
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/scope-path.cpp b/src/proc/mobject/session/scope-path.cpp
index c713e2fc0..5c750d920 100644
--- a/src/proc/mobject/session/scope-path.cpp
+++ b/src/proc/mobject/session/scope-path.cpp
@@ -1,23 +1,23 @@
 /*
   ScopePath  -  logical access path down from Session root
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/session/scope-path.hpp b/src/proc/mobject/session/scope-path.hpp
index 61799d95d..da23516d8 100644
--- a/src/proc/mobject/session/scope-path.hpp
+++ b/src/proc/mobject/session/scope-path.hpp
@@ -1,23 +1,23 @@
 /*
   SCOPE-PATH.hpp  -  logical access path down from Session root
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file scope-path.hpp
diff --git a/src/proc/mobject/session/scope-query.hpp b/src/proc/mobject/session/scope-query.hpp
index f8d7e600a..166e2615a 100644
--- a/src/proc/mobject/session/scope-query.hpp
+++ b/src/proc/mobject/session/scope-query.hpp
@@ -1,23 +1,23 @@
 /*
   SCOPE-QUERY.hpp  -  query to discover the contents of a container-like part of the model
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/scope.cpp b/src/proc/mobject/session/scope.cpp
index 2143cb4f5..24b684a03 100644
--- a/src/proc/mobject/session/scope.cpp
+++ b/src/proc/mobject/session/scope.cpp
@@ -1,23 +1,23 @@
 /*
   Scope  -  nested search scope for properties of placement
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/session/scope.hpp b/src/proc/mobject/session/scope.hpp
index a4b9ca3fd..d3b463dc2 100644
--- a/src/proc/mobject/session/scope.hpp
+++ b/src/proc/mobject/session/scope.hpp
@@ -1,23 +1,23 @@
 /*
   SCOPE.hpp  -  nested search scope for properties of placement
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/segment.cpp b/src/proc/mobject/session/segment.cpp
index 45c593c67..07320761d 100644
--- a/src/proc/mobject/session/segment.cpp
+++ b/src/proc/mobject/session/segment.cpp
@@ -1,23 +1,23 @@
 /*
   Segment  -  Segment of the timeline for rendering.
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 #include "proc/mobject/session/segment.hpp"
diff --git a/src/proc/mobject/session/segment.hpp b/src/proc/mobject/session/segment.hpp
index 66f03b9bc..3a0835c87 100644
--- a/src/proc/mobject/session/segment.hpp
+++ b/src/proc/mobject/session/segment.hpp
@@ -1,23 +1,23 @@
 /*
   SEGMENT.hpp  -  Segment of the timeline for rendering.
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/segmentation.cpp b/src/proc/mobject/session/segmentation.cpp
index f19b8041b..b8c8fd660 100644
--- a/src/proc/mobject/session/segmentation.cpp
+++ b/src/proc/mobject/session/segmentation.cpp
@@ -1,23 +1,23 @@
 /*
   Segementation  -  Partitioning of a timeline for organising the render graph.
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 #include "proc/mobject/session/segmentation.hpp"
diff --git a/src/proc/mobject/session/segmentation.hpp b/src/proc/mobject/session/segmentation.hpp
index 2decf122c..4312a6205 100644
--- a/src/proc/mobject/session/segmentation.hpp
+++ b/src/proc/mobject/session/segmentation.hpp
@@ -1,23 +1,23 @@
 /*
   SEGMENTATION.hpp  -  Partitioning of a timeline for organising the render graph.
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/sess-manager-impl.cpp b/src/proc/mobject/session/sess-manager-impl.cpp
index c3294d891..0c9d1b5bc 100644
--- a/src/proc/mobject/session/sess-manager-impl.cpp
+++ b/src/proc/mobject/session/sess-manager-impl.cpp
@@ -1,23 +1,23 @@
 /*
   SessManagerImpl  -  global session access and lifecycle
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/session/sess-manager-impl.hpp b/src/proc/mobject/session/sess-manager-impl.hpp
index dcd671d2f..14af631c6 100644
--- a/src/proc/mobject/session/sess-manager-impl.hpp
+++ b/src/proc/mobject/session/sess-manager-impl.hpp
@@ -1,23 +1,23 @@
 /*
   SESS-MANAGER-IMPL.hpp  -  global session access and lifecycle
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/session-impl.cpp b/src/proc/mobject/session/session-impl.cpp
index 6ce106049..e091414b2 100644
--- a/src/proc/mobject/session/session-impl.cpp
+++ b/src/proc/mobject/session/session-impl.cpp
@@ -1,23 +1,23 @@
 /*
   SessionImpl  -  holds the complete session data to be edited by the user
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/session/session-impl.hpp b/src/proc/mobject/session/session-impl.hpp
index c741bde80..b5416057e 100644
--- a/src/proc/mobject/session/session-impl.hpp
+++ b/src/proc/mobject/session/session-impl.hpp
@@ -1,23 +1,23 @@
 /*
   SESSION-IMPL.hpp  -  holds the complete session data to be edited by the user
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/session-interface-modules.hpp b/src/proc/mobject/session/session-interface-modules.hpp
index 437bc5663..9e03cad4c 100644
--- a/src/proc/mobject/session/session-interface-modules.hpp
+++ b/src/proc/mobject/session/session-interface-modules.hpp
@@ -1,23 +1,23 @@
 /*
   SESSION-INTERFACE-MODULES.hpp  -  composing the public session API from several interface modules
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/session-query.hpp b/src/proc/mobject/session/session-query.hpp
index 5514b9a4c..15cf82d69 100644
--- a/src/proc/mobject/session/session-query.hpp
+++ b/src/proc/mobject/session/session-query.hpp
@@ -1,23 +1,23 @@
 /*
   SESSION-QUERY.hpp  -  querying for session contents in various ways
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/session-service-defaults.hpp b/src/proc/mobject/session/session-service-defaults.hpp
index 85073e96f..70cbd1b4a 100644
--- a/src/proc/mobject/session/session-service-defaults.hpp
+++ b/src/proc/mobject/session/session-service-defaults.hpp
@@ -1,23 +1,23 @@
 /*
   SESSION-SERVICE-DEFAULTS.hpp  -  session implementation service API: manage default objects
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/session-service-explore-scope.hpp b/src/proc/mobject/session/session-service-explore-scope.hpp
index 98d998a2f..e3330fe27 100644
--- a/src/proc/mobject/session/session-service-explore-scope.hpp
+++ b/src/proc/mobject/session/session-service-explore-scope.hpp
@@ -1,23 +1,23 @@
 /*
   SESSION-SERVICE-EXPLORE-SCOPE.hpp  -  session implementation service API: explore scope
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/session-service-fetch.hpp b/src/proc/mobject/session/session-service-fetch.hpp
index 50f62c7c5..fd883dffb 100644
--- a/src/proc/mobject/session/session-service-fetch.hpp
+++ b/src/proc/mobject/session/session-service-fetch.hpp
@@ -1,23 +1,23 @@
 /*
   SESSION-SERVICE-FETCH.hpp  -  session implementation service API: fetch PlacementRef
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/session-service-mock-index.hpp b/src/proc/mobject/session/session-service-mock-index.hpp
index 4389a80f6..44d4ab446 100644
--- a/src/proc/mobject/session/session-service-mock-index.hpp
+++ b/src/proc/mobject/session/session-service-mock-index.hpp
@@ -1,23 +1,23 @@
 /*
   SESSION-SERVICE-MOCK-INDEX.hpp  -  session service API: mock PlacementIndex for tests
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/session-service-mutate.hpp b/src/proc/mobject/session/session-service-mutate.hpp
index a1cdcb4e2..dbd063592 100644
--- a/src/proc/mobject/session/session-service-mutate.hpp
+++ b/src/proc/mobject/session/session-service-mutate.hpp
@@ -1,23 +1,23 @@
 /*
   SESSION-SERVICE-MUTATE.hpp  -  session implementation service API: add/remove session contents
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/session-services.cpp b/src/proc/mobject/session/session-services.cpp
index 76ebe2d58..c75a6c9bd 100644
--- a/src/proc/mobject/session/session-services.cpp
+++ b/src/proc/mobject/session/session-services.cpp
@@ -1,23 +1,23 @@
 /*
   SessionServices  -  accessing Proc-Layer internal session implementation services
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/session/session-services.hpp b/src/proc/mobject/session/session-services.hpp
index 889f70cbd..a44fddae8 100644
--- a/src/proc/mobject/session/session-services.hpp
+++ b/src/proc/mobject/session/session-services.hpp
@@ -1,23 +1,23 @@
 /*
   SESSION-SERVICES.hpp  -  accessing Proc-Layer internal session implementation services
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/session.cpp b/src/proc/mobject/session/session.cpp
index ba414dc65..a1ff4c737 100644
--- a/src/proc/mobject/session/session.cpp
+++ b/src/proc/mobject/session/session.cpp
@@ -1,23 +1,23 @@
 /*
   Session  -  holds the complete session to be edited by the user
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/session/simpleclip.cpp b/src/proc/mobject/session/simpleclip.cpp
index 97796a00e..e404532bf 100644
--- a/src/proc/mobject/session/simpleclip.cpp
+++ b/src/proc/mobject/session/simpleclip.cpp
@@ -1,23 +1,23 @@
 /*
   SimpleClip  -  Elementary clip (single media stream only)
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/session/simpleclip.hpp b/src/proc/mobject/session/simpleclip.hpp
index f0dc62c02..6b6c23913 100644
--- a/src/proc/mobject/session/simpleclip.hpp
+++ b/src/proc/mobject/session/simpleclip.hpp
@@ -1,23 +1,23 @@
 /*
   SIMPLECLIP.hpp  -  Elementary clip (single media stream only)
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/specific-contents-query.hpp b/src/proc/mobject/session/specific-contents-query.hpp
index 0fbf713e7..4437441bc 100644
--- a/src/proc/mobject/session/specific-contents-query.hpp
+++ b/src/proc/mobject/session/specific-contents-query.hpp
@@ -1,23 +1,23 @@
 /*
   SPECIFIC-CONTENTS-QUERY.hpp  -  pick specific contents from the model, using a filter
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/track.cpp b/src/proc/mobject/session/track.cpp
index 8d7c5eb22..73e811b90 100644
--- a/src/proc/mobject/session/track.cpp
+++ b/src/proc/mobject/session/track.cpp
@@ -1,23 +1,23 @@
 /*
   Track  -  A grouping device within the Session.
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/session/track.hpp b/src/proc/mobject/session/track.hpp
index 0bff48744..60fb8afa5 100644
--- a/src/proc/mobject/session/track.hpp
+++ b/src/proc/mobject/session/track.hpp
@@ -1,23 +1,23 @@
 /*
   TRACK.hpp  -  A grouping device within the Session.
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/session/wish.cpp b/src/proc/mobject/session/wish.cpp
index ddf90d307..3704c77e6 100644
--- a/src/proc/mobject/session/wish.cpp
+++ b/src/proc/mobject/session/wish.cpp
@@ -1,23 +1,23 @@
 /*
   Wish  -  LocatingPin representing a low-priority directive
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/mobject/session/wish.hpp b/src/proc/mobject/session/wish.hpp
index 7fe447e4e..ae5ffbeab 100644
--- a/src/proc/mobject/session/wish.hpp
+++ b/src/proc/mobject/session/wish.hpp
@@ -1,23 +1,23 @@
 /*
   WISH.hpp  -  LocatingPin representing a low-priority directive
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/proc/mobject/test-dummy-mobject.hpp b/src/proc/mobject/test-dummy-mobject.hpp
index 24c1df0f2..14542b629 100644
--- a/src/proc/mobject/test-dummy-mobject.hpp
+++ b/src/proc/mobject/test-dummy-mobject.hpp
@@ -1,23 +1,23 @@
 /*
   TEST-DUMMY-MOBJECT.hpp  -  dummy MObject hierarchy for unit tests
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file test-dummy-mobject.hpp
diff --git a/src/proc/play/dummy-image-generator.cpp b/src/proc/play/dummy-image-generator.cpp
index 603b0d033..250549b42 100644
--- a/src/proc/play/dummy-image-generator.cpp
+++ b/src/proc/play/dummy-image-generator.cpp
@@ -1,24 +1,24 @@
 /*
   DummyImageGenerator  -  creating test output frames for simulated playback
- 
+
   Copyright (C)         Lumiera.org
     2009,               Joel Holdsworth <joel@airwebreathe.org.uk>,
                         Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/play/dummy-image-generator.hpp b/src/proc/play/dummy-image-generator.hpp
index 17056997d..e2d70d322 100644
--- a/src/proc/play/dummy-image-generator.hpp
+++ b/src/proc/play/dummy-image-generator.hpp
@@ -1,24 +1,24 @@
 /*
   DUMMY-IMAGE-GENERATOR.hpp  -  creating test output frames for simulated playback
- 
+
   Copyright (C)         Lumiera.org
     2009,               Joel Holdsworth <joel@airwebreathe.org.uk>,
                         Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file dummy-image-generator.hpp
diff --git a/src/proc/play/dummy-player-interface-proxy.hpp b/src/proc/play/dummy-player-interface-proxy.hpp
index 05319dc27..3e4ccdcd4 100644
--- a/src/proc/play/dummy-player-interface-proxy.hpp
+++ b/src/proc/play/dummy-player-interface-proxy.hpp
@@ -1,23 +1,23 @@
 /*
   DummyPlayer(Proxy)  -  access point and service implementing a dummy test player
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/play/dummy-player-service.cpp b/src/proc/play/dummy-player-service.cpp
index 54ce69e9d..ea443f709 100644
--- a/src/proc/play/dummy-player-service.cpp
+++ b/src/proc/play/dummy-player-service.cpp
@@ -1,23 +1,23 @@
 /*
   DummyPlayerService  -  access point and service implementing a dummy test player
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/play/dummy-player-service.hpp b/src/proc/play/dummy-player-service.hpp
index 8dc1f87e8..75e0f3d78 100644
--- a/src/proc/play/dummy-player-service.hpp
+++ b/src/proc/play/dummy-player-service.hpp
@@ -1,23 +1,23 @@
 /*
   DUMMY-PLAYER-SERVICE.hpp  -  service implementing a dummy test player
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file dummy-player-service.hpp
diff --git a/src/proc/play/tick-service.hpp b/src/proc/play/tick-service.hpp
index a81335913..a67116020 100644
--- a/src/proc/play/tick-service.hpp
+++ b/src/proc/play/tick-service.hpp
@@ -1,24 +1,24 @@
 /*
   TICK-SERVICE.hpp  -  issuing timed callbacks
- 
+
   Copyright (C)         Lumiera.org
     2009,               Joel Holdsworth <joel@airwebreathe.org.uk>,
                         Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file tick-service.hpp
diff --git a/src/proc/state.cpp b/src/proc/state.cpp
index fa9f32dc3..939bd6721 100644
--- a/src/proc/state.cpp
+++ b/src/proc/state.cpp
@@ -1,23 +1,23 @@
 /*
   State  -  Key Interface representing a render process and encapsulating state
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/src/proc/state.hpp b/src/proc/state.hpp
index a37e85933..ca0a6a44c 100644
--- a/src/proc/state.hpp
+++ b/src/proc/state.hpp
@@ -1,23 +1,23 @@
 /*
   STATE.hpp  -  Key Interface representing a render process and encapsulating state
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/src/tool/luidgen.c b/src/tool/luidgen.c
index 84ed75588..7452288a8 100644
--- a/src/tool/luidgen.c
+++ b/src/tool/luidgen.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/tests/backend/test-filedescriptors.c b/tests/backend/test-filedescriptors.c
index ecd717e9b..b10f5845e 100644
--- a/tests/backend/test-filedescriptors.c
+++ b/tests/backend/test-filedescriptors.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/tests/backend/test-filehandles.c b/tests/backend/test-filehandles.c
index 285fb5a2e..7e13c8c7f 100644
--- a/tests/backend/test-filehandles.c
+++ b/tests/backend/test-filehandles.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/tests/backend/test-fileheader.c b/tests/backend/test-fileheader.c
index ca14b545a..b19ba5204 100644
--- a/tests/backend/test-fileheader.c
+++ b/tests/backend/test-fileheader.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/tests/backend/test-filemmap.c b/tests/backend/test-filemmap.c
index 0c64d0382..bd1b4ce7a 100644
--- a/tests/backend/test-filemmap.c
+++ b/tests/backend/test-filemmap.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/tests/backend/test-resourcecollector.c b/tests/backend/test-resourcecollector.c
index d555eb282..6629ea2f8 100644
--- a/tests/backend/test-resourcecollector.c
+++ b/tests/backend/test-resourcecollector.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/tests/backend/test-threadpool.c b/tests/backend/test-threadpool.c
index 8173361de..ed3204a9b 100644
--- a/tests/backend/test-threadpool.c
+++ b/tests/backend/test-threadpool.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/tests/backend/test-threads.c b/tests/backend/test-threads.c
index 73108ab6e..a3b3697a3 100644
--- a/tests/backend/test-threads.c
+++ b/tests/backend/test-threads.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/tests/bugs/bugmain.c b/tests/bugs/bugmain.c
index 7823b279e..f932a0321 100644
--- a/tests/bugs/bugmain.c
+++ b/tests/bugs/bugmain.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/tests/common/ref-array-test.cpp b/tests/common/ref-array-test.cpp
index 2d18f1f11..b0127167f 100644
--- a/tests/common/ref-array-test.cpp
+++ b/tests/common/ref-array-test.cpp
@@ -1,23 +1,23 @@
 /*
   RefArray(Test)  -  unittest for wrapping with array-of-refs access
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/common/test-config.c b/tests/common/test-config.c
index 522eb5fee..e1a72636d 100644
--- a/tests/common/test-config.c
+++ b/tests/common/test-config.c
@@ -7,8 +7,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/tests/common/test-interfaces.c b/tests/common/test-interfaces.c
index 5616369d0..93440a530 100644
--- a/tests/common/test-interfaces.c
+++ b/tests/common/test-interfaces.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/tests/components/backend/mediaaccessmock.cpp b/tests/components/backend/mediaaccessmock.cpp
index 820b5487a..e15a2213c 100644
--- a/tests/components/backend/mediaaccessmock.cpp
+++ b/tests/components/backend/mediaaccessmock.cpp
@@ -1,23 +1,23 @@
 /*
   MediaAccessMock.hpp  -  a test (stub) target object for testing the factories
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/backend/mediaaccessmock.hpp b/tests/components/backend/mediaaccessmock.hpp
index 4199b29f8..e48733bc1 100644
--- a/tests/components/backend/mediaaccessmock.hpp
+++ b/tests/components/backend/mediaaccessmock.hpp
@@ -1,23 +1,23 @@
 /*
   MEDIAACCESSMOCK.hpp  -  a test (stub) target object for testing the factories
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/tests/components/backend/mediaaccessmocktest.cpp b/tests/components/backend/mediaaccessmocktest.cpp
index a81f6fe8f..60d770b89 100644
--- a/tests/components/backend/mediaaccessmocktest.cpp
+++ b/tests/components/backend/mediaaccessmocktest.cpp
@@ -1,23 +1,23 @@
 /*
   MediaAccessMock(Test)  -  checking our Test Mock replacing the MediaAccessFacade
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/asset/asset-category-test.cpp b/tests/components/proc/asset/asset-category-test.cpp
index b58f3297b..bc0676011 100644
--- a/tests/components/proc/asset/asset-category-test.cpp
+++ b/tests/components/proc/asset/asset-category-test.cpp
@@ -1,23 +1,23 @@
 /*
   AssetCategory(Test)  -  verifying Asset category tuple functions
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/asset/asset-diagnostics.hpp b/tests/components/proc/asset/asset-diagnostics.hpp
index 856f131b3..08619bbba 100644
--- a/tests/components/proc/asset/asset-diagnostics.hpp
+++ b/tests/components/proc/asset/asset-diagnostics.hpp
@@ -1,23 +1,23 @@
 /*
   ASSET-DIAGNOSTICS.hpp  -  collection of test and debug helpers
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 /** @file asset-diagnostics.hpp
diff --git a/tests/components/proc/asset/basicpipetest.cpp b/tests/components/proc/asset/basicpipetest.cpp
index 0ec9a7050..6084dba5e 100644
--- a/tests/components/proc/asset/basicpipetest.cpp
+++ b/tests/components/proc/asset/basicpipetest.cpp
@@ -1,23 +1,23 @@
 /*
   BasicPipe(Test)  -  checking the basic properties of Pipe Assets
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/asset/compoundmediatest.cpp b/tests/components/proc/asset/compoundmediatest.cpp
index d3a2324f8..f7bf248d0 100644
--- a/tests/components/proc/asset/compoundmediatest.cpp
+++ b/tests/components/proc/asset/compoundmediatest.cpp
@@ -1,23 +1,23 @@
 /*
   CompoundMedia(Test)  -  handling multichannel Media Assets
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/asset/create-asset-test.cpp b/tests/components/proc/asset/create-asset-test.cpp
index 2c4adf382..716155f7d 100644
--- a/tests/components/proc/asset/create-asset-test.cpp
+++ b/tests/components/proc/asset/create-asset-test.cpp
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/tests/components/proc/asset/deleteassettest.cpp b/tests/components/proc/asset/deleteassettest.cpp
index d8c79f761..b47a93755 100644
--- a/tests/components/proc/asset/deleteassettest.cpp
+++ b/tests/components/proc/asset/deleteassettest.cpp
@@ -1,23 +1,23 @@
 /*
   DeleteAsset(Test)  -  deleting and Asset with all dependencies
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/asset/dependent-assets-test.cpp b/tests/components/proc/asset/dependent-assets-test.cpp
index 8661e6efd..65783b20c 100644
--- a/tests/components/proc/asset/dependent-assets-test.cpp
+++ b/tests/components/proc/asset/dependent-assets-test.cpp
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/tests/components/proc/asset/entry-id-test.cpp b/tests/components/proc/asset/entry-id-test.cpp
index 4c266f30e..c25e9f82c 100644
--- a/tests/components/proc/asset/entry-id-test.cpp
+++ b/tests/components/proc/asset/entry-id-test.cpp
@@ -1,23 +1,23 @@
 /*
   EntryID(Test)  -  proof-of-concept test for a combined hash+symbolic ID
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/asset/identityofassetstest.cpp b/tests/components/proc/asset/identityofassetstest.cpp
index 5ab11bad3..6f13cb7fc 100644
--- a/tests/components/proc/asset/identityofassetstest.cpp
+++ b/tests/components/proc/asset/identityofassetstest.cpp
@@ -1,23 +1,23 @@
 /*
   IdentityOfAssets(Test)  -  Asset object identity and versioning
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/asset/makecliptest.cpp b/tests/components/proc/asset/makecliptest.cpp
index 29169849a..4042053a7 100644
--- a/tests/components/proc/asset/makecliptest.cpp
+++ b/tests/components/proc/asset/makecliptest.cpp
@@ -1,23 +1,23 @@
 /*
   MakeClip(Test)  -  create a Clip from a Media Asset
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/asset/mediastructurequerytest.cpp b/tests/components/proc/asset/mediastructurequerytest.cpp
index 2f5a58c53..99f0aaab8 100644
--- a/tests/components/proc/asset/mediastructurequerytest.cpp
+++ b/tests/components/proc/asset/mediastructurequerytest.cpp
@@ -1,23 +1,23 @@
 /*
   MediaStructureQuery(Test)  -  check functionallity used for creating media assets
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/asset/orderingofassetstest.cpp b/tests/components/proc/asset/orderingofassetstest.cpp
index 98c43b9b4..cd4009e7f 100644
--- a/tests/components/proc/asset/orderingofassetstest.cpp
+++ b/tests/components/proc/asset/orderingofassetstest.cpp
@@ -1,23 +1,23 @@
 /*
   OrderingOfAssets(Test)  -  equality and comparisons
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/asset/testasset.cpp b/tests/components/proc/asset/testasset.cpp
index 3a6ffb61d..12eba65ad 100644
--- a/tests/components/proc/asset/testasset.cpp
+++ b/tests/components/proc/asset/testasset.cpp
@@ -1,23 +1,23 @@
 /*
   TestClip  -  test clip (stub) for checking Model/Session functionality
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/asset/testasset.hpp b/tests/components/proc/asset/testasset.hpp
index 716cd33f7..7dbcbe636 100644
--- a/tests/components/proc/asset/testasset.hpp
+++ b/tests/components/proc/asset/testasset.hpp
@@ -1,23 +1,23 @@
 /*
   TESTASSET.hpp  -  test asset (stub) for checking internal asset functionality
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/tests/components/proc/asset/testclipasset.hpp b/tests/components/proc/asset/testclipasset.hpp
index fc501625c..eb5167abc 100644
--- a/tests/components/proc/asset/testclipasset.hpp
+++ b/tests/components/proc/asset/testclipasset.hpp
@@ -1,23 +1,23 @@
 /*
   TESTCLIPASSET.hpp  -  test Media-Asset (clip) for checking Assets and MObjects
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/tests/components/proc/asset/typed-id-test.cpp b/tests/components/proc/asset/typed-id-test.cpp
index 633a07443..7835c162b 100644
--- a/tests/components/proc/asset/typed-id-test.cpp
+++ b/tests/components/proc/asset/typed-id-test.cpp
@@ -1,23 +1,23 @@
 /*
   TypedID(Test)  -  verifying registration service for ID to type association
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/control/argument-tuple-accept-test.cpp b/tests/components/proc/control/argument-tuple-accept-test.cpp
index db0c7a12f..c264ca255 100644
--- a/tests/components/proc/control/argument-tuple-accept-test.cpp
+++ b/tests/components/proc/control/argument-tuple-accept-test.cpp
@@ -1,23 +1,23 @@
 /*
   ArgumentTupleAccept(Test)  -  verify synthesising a bind(...) function
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/control/command-argument-test.cpp b/tests/components/proc/control/command-argument-test.cpp
index ac9c857cf..8f5feb85f 100644
--- a/tests/components/proc/control/command-argument-test.cpp
+++ b/tests/components/proc/control/command-argument-test.cpp
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/tests/components/proc/control/command-basic-test.cpp b/tests/components/proc/control/command-basic-test.cpp
index 528436430..76ef584d2 100644
--- a/tests/components/proc/control/command-basic-test.cpp
+++ b/tests/components/proc/control/command-basic-test.cpp
@@ -1,23 +1,23 @@
 /*
   CommandBasic(Test)  -  checking simple ProcDispatcher command definition and execution
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/control/command-binding-test.cpp b/tests/components/proc/control/command-binding-test.cpp
index ee20869a8..0f500a3b7 100644
--- a/tests/components/proc/control/command-binding-test.cpp
+++ b/tests/components/proc/control/command-binding-test.cpp
@@ -1,23 +1,23 @@
 /*
   CommandBinding(Test)  -  special cases of binding command arguments
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/control/command-clone-builder-test.cpp b/tests/components/proc/control/command-clone-builder-test.cpp
index 568ba6c90..802dfb361 100644
--- a/tests/components/proc/control/command-clone-builder-test.cpp
+++ b/tests/components/proc/control/command-clone-builder-test.cpp
@@ -1,23 +1,23 @@
 /*
   CommandCloneBuilder(Test)  -  verify building an implementation clone
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/control/command-equality-test.cpp b/tests/components/proc/control/command-equality-test.cpp
index ce400384d..715a3b83f 100644
--- a/tests/components/proc/control/command-equality-test.cpp
+++ b/tests/components/proc/control/command-equality-test.cpp
@@ -1,23 +1,23 @@
 /*
   CommandEquality(Test)  -  verify equality comparisons on command's subsystems
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/control/command-mutation-test.cpp b/tests/components/proc/control/command-mutation-test.cpp
index 7dd5a19eb..fbbbaa716 100644
--- a/tests/components/proc/control/command-mutation-test.cpp
+++ b/tests/components/proc/control/command-mutation-test.cpp
@@ -1,23 +1,23 @@
 /*
   CommandMutation(Test)  -  checking the functor and undo-functor used within Proc-commands
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/control/command-registry-test.cpp b/tests/components/proc/control/command-registry-test.cpp
index c44c8edef..f0958a48b 100644
--- a/tests/components/proc/control/command-registry-test.cpp
+++ b/tests/components/proc/control/command-registry-test.cpp
@@ -1,23 +1,23 @@
 /*
   CommandRegistry(Test)  -  verify command registration and allocation
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/control/command-use1-test.cpp b/tests/components/proc/control/command-use1-test.cpp
index 68c37ebff..aae370d4f 100644
--- a/tests/components/proc/control/command-use1-test.cpp
+++ b/tests/components/proc/control/command-use1-test.cpp
@@ -1,23 +1,23 @@
 /*
   CommandUse1(Test)  -  usage aspects I
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/control/command-use2-test.cpp b/tests/components/proc/control/command-use2-test.cpp
index 9b407d90e..29d5c6c90 100644
--- a/tests/components/proc/control/command-use2-test.cpp
+++ b/tests/components/proc/control/command-use2-test.cpp
@@ -1,23 +1,23 @@
 /*
   CommandUse2(Test)  -  usage aspects II
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/control/command-use3-test.cpp b/tests/components/proc/control/command-use3-test.cpp
index 441acd881..5d3d29799 100644
--- a/tests/components/proc/control/command-use3-test.cpp
+++ b/tests/components/proc/control/command-use3-test.cpp
@@ -1,23 +1,23 @@
 /*
   CommandUse3(Test)  -  usage aspects III
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/control/handling-pattern-basics-test.cpp b/tests/components/proc/control/handling-pattern-basics-test.cpp
index cc58464ae..87458b177 100644
--- a/tests/components/proc/control/handling-pattern-basics-test.cpp
+++ b/tests/components/proc/control/handling-pattern-basics-test.cpp
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/tests/components/proc/control/handling-pattern-standard-impl-test.cpp b/tests/components/proc/control/handling-pattern-standard-impl-test.cpp
index 996116a50..c73a11246 100644
--- a/tests/components/proc/control/handling-pattern-standard-impl-test.cpp
+++ b/tests/components/proc/control/handling-pattern-standard-impl-test.cpp
@@ -1,23 +1,23 @@
 /*
   HandlingPatternStandardImpl(Test)  -  cover the provided standard command handling patterns
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/control/memento-tie-test.cpp b/tests/components/proc/control/memento-tie-test.cpp
index e4cd61a3c..684078d8b 100644
--- a/tests/components/proc/control/memento-tie-test.cpp
+++ b/tests/components/proc/control/memento-tie-test.cpp
@@ -1,23 +1,23 @@
 /*
   MementoTie(Test)  -  check the mechanism for capturing and providing undo-state
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/control/test-dummy-commands.cpp b/tests/components/proc/control/test-dummy-commands.cpp
index 520ad90fb..81daa1020 100644
--- a/tests/components/proc/control/test-dummy-commands.cpp
+++ b/tests/components/proc/control/test-dummy-commands.cpp
@@ -1,23 +1,23 @@
 /*
   test-dummy-commands  -  global checksum variables used to build test commands
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/control/test-dummy-commands.hpp b/tests/components/proc/control/test-dummy-commands.hpp
index 142ac8cd8..1a8bd5eb3 100644
--- a/tests/components/proc/control/test-dummy-commands.hpp
+++ b/tests/components/proc/control/test-dummy-commands.hpp
@@ -1,23 +1,23 @@
 /*
   TEST-DUMMY-COMMANDS.hpp  -  dummy functions used to build test commands
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/tests/components/proc/engine/buff-table-test.cpp b/tests/components/proc/engine/buff-table-test.cpp
index 4342b46ad..267978d49 100644
--- a/tests/components/proc/engine/buff-table-test.cpp
+++ b/tests/components/proc/engine/buff-table-test.cpp
@@ -1,23 +1,23 @@
 /*
   BuffTable(Test)  -  check consistency of buffer table chunk allocation
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/engine/node-basic-test.cpp b/tests/components/proc/engine/node-basic-test.cpp
index e5b44d739..7cd47d650 100644
--- a/tests/components/proc/engine/node-basic-test.cpp
+++ b/tests/components/proc/engine/node-basic-test.cpp
@@ -1,23 +1,23 @@
 /*
   NodeBasic(Test)  -  unit test covering render node basic lifecycle and usage
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/engine/node-fabrication-test.cpp b/tests/components/proc/engine/node-fabrication-test.cpp
index 7130b5397..ccc0ad798 100644
--- a/tests/components/proc/engine/node-fabrication-test.cpp
+++ b/tests/components/proc/engine/node-fabrication-test.cpp
@@ -1,23 +1,23 @@
 /*
   NodeFabrication(Test)  -  building render nodes
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/engine/node-operation-test.cpp b/tests/components/proc/engine/node-operation-test.cpp
index 8ac2b56d4..d6823cbaa 100644
--- a/tests/components/proc/engine/node-operation-test.cpp
+++ b/tests/components/proc/engine/node-operation-test.cpp
@@ -1,23 +1,23 @@
 /*
   NodeOperation(Test)  -  verify proper render node operation and calldown
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/engine/node-source-test.cpp b/tests/components/proc/engine/node-source-test.cpp
index d00a87b47..b8bba352b 100644
--- a/tests/components/proc/engine/node-source-test.cpp
+++ b/tests/components/proc/engine/node-source-test.cpp
@@ -1,23 +1,23 @@
 /*
   NodeSource(Test)  -  unit test of the source reading render node
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/mobject/builder/buildertooltest.cpp b/tests/components/proc/mobject/builder/buildertooltest.cpp
index 3aacaebfe..52a85f0af 100644
--- a/tests/components/proc/mobject/builder/buildertooltest.cpp
+++ b/tests/components/proc/mobject/builder/buildertooltest.cpp
@@ -1,23 +1,23 @@
 /*
   BuilderTool(Test)  -  specialised visitor used within the builder for processing Placements
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/mobject/builder/buildsegmenttest.cpp b/tests/components/proc/mobject/builder/buildsegmenttest.cpp
index f47f7fbe0..39679814d 100644
--- a/tests/components/proc/mobject/builder/buildsegmenttest.cpp
+++ b/tests/components/proc/mobject/builder/buildsegmenttest.cpp
@@ -1,23 +1,23 @@
 /*
   BuildSegment(Test)  -  building the render-tree for a segment of the Timeline
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/mobject/builder/fixture-change-detector-test.cpp b/tests/components/proc/mobject/builder/fixture-change-detector-test.cpp
index 3d885f350..f41a8fe20 100644
--- a/tests/components/proc/mobject/builder/fixture-change-detector-test.cpp
+++ b/tests/components/proc/mobject/builder/fixture-change-detector-test.cpp
@@ -1,23 +1,23 @@
 /*
   FixtureChangeDetector(Test)  -  detecting segmentation differences
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/mobject/builder/model-port-registry-test.cpp b/tests/components/proc/mobject/builder/model-port-registry-test.cpp
index c37407b4b..d9fea6e99 100644
--- a/tests/components/proc/mobject/builder/model-port-registry-test.cpp
+++ b/tests/components/proc/mobject/builder/model-port-registry-test.cpp
@@ -1,23 +1,23 @@
 /*
   ModelPortRegistry(Test)  -  verify handling of model ports
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/mobject/builder/segmentation-datastructure-test.cpp b/tests/components/proc/mobject/builder/segmentation-datastructure-test.cpp
index ac6c66d30..91cd1cd05 100644
--- a/tests/components/proc/mobject/builder/segmentation-datastructure-test.cpp
+++ b/tests/components/proc/mobject/builder/segmentation-datastructure-test.cpp
@@ -1,23 +1,23 @@
 /*
   SegmentationDatastructure(Test)  -  verify basic properties of the Segmentation
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/mobject/controller/rendersegmenttest.cpp b/tests/components/proc/mobject/controller/rendersegmenttest.cpp
index ba20b4754..a74d1bdb4 100644
--- a/tests/components/proc/mobject/controller/rendersegmenttest.cpp
+++ b/tests/components/proc/mobject/controller/rendersegmenttest.cpp
@@ -1,23 +1,23 @@
 /*
   RenderSegment(Test)  -  Proc-Layer Integrationtest
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/mobject/mobject-interface-test.cpp b/tests/components/proc/mobject/mobject-interface-test.cpp
index 8c46b75f1..b1c5a1bae 100644
--- a/tests/components/proc/mobject/mobject-interface-test.cpp
+++ b/tests/components/proc/mobject/mobject-interface-test.cpp
@@ -1,23 +1,23 @@
 /*
   MObjectInterface(Test)  -  covers behaviour common to all MObjects
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/mobject/mobject-ref-test.cpp b/tests/components/proc/mobject/mobject-ref-test.cpp
index b01c7391c..c4b9bbd50 100644
--- a/tests/components/proc/mobject/mobject-ref-test.cpp
+++ b/tests/components/proc/mobject/mobject-ref-test.cpp
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/tests/components/proc/mobject/output-mapping-test.cpp b/tests/components/proc/mobject/output-mapping-test.cpp
index 18dd9eb60..e8a6a7e03 100644
--- a/tests/components/proc/mobject/output-mapping-test.cpp
+++ b/tests/components/proc/mobject/output-mapping-test.cpp
@@ -1,23 +1,23 @@
 /*
   OutputMapping(Test)  -  verify generic output designation mapping
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/mobject/placement-basic-test.cpp b/tests/components/proc/mobject/placement-basic-test.cpp
index ff9f41069..44a79b6e8 100644
--- a/tests/components/proc/mobject/placement-basic-test.cpp
+++ b/tests/components/proc/mobject/placement-basic-test.cpp
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/tests/components/proc/mobject/placement-hierarchy-test.cpp b/tests/components/proc/mobject/placement-hierarchy-test.cpp
index 1bea743ee..12196b603 100644
--- a/tests/components/proc/mobject/placement-hierarchy-test.cpp
+++ b/tests/components/proc/mobject/placement-hierarchy-test.cpp
@@ -1,23 +1,23 @@
 /*
   PlacementHierarchy(Test)  -  cooperating hierarchical placement types
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/mobject/placement-object-identity-test.cpp b/tests/components/proc/mobject/placement-object-identity-test.cpp
index dee2467bd..6d3e1044c 100644
--- a/tests/components/proc/mobject/placement-object-identity-test.cpp
+++ b/tests/components/proc/mobject/placement-object-identity-test.cpp
@@ -1,23 +1,23 @@
 /*
   PlacementObjectIdentity(Test)  -  object identity for placements into the session
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/mobject/placement-ref-test.cpp b/tests/components/proc/mobject/placement-ref-test.cpp
index b8c873c21..dce4db94d 100644
--- a/tests/components/proc/mobject/placement-ref-test.cpp
+++ b/tests/components/proc/mobject/placement-ref-test.cpp
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/tests/components/proc/mobject/session/addcliptest.cpp b/tests/components/proc/mobject/session/addcliptest.cpp
index 541d0289a..34e83d2b5 100644
--- a/tests/components/proc/mobject/session/addcliptest.cpp
+++ b/tests/components/proc/mobject/session/addcliptest.cpp
@@ -1,23 +1,23 @@
 /*
   AddClip(Test)  -  adding an Clip-MObject to the Model/Session
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/mobject/session/defsmanagerimpltest.cpp b/tests/components/proc/mobject/session/defsmanagerimpltest.cpp
index ba16d24d8..164dc9b9a 100644
--- a/tests/components/proc/mobject/session/defsmanagerimpltest.cpp
+++ b/tests/components/proc/mobject/session/defsmanagerimpltest.cpp
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/tests/components/proc/mobject/session/defsmanagertest.cpp b/tests/components/proc/mobject/session/defsmanagertest.cpp
index 8c75bcaf5..5f41fb462 100644
--- a/tests/components/proc/mobject/session/defsmanagertest.cpp
+++ b/tests/components/proc/mobject/session/defsmanagertest.cpp
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/tests/components/proc/mobject/session/defsregistryimpltest.cpp b/tests/components/proc/mobject/session/defsregistryimpltest.cpp
index 5e5799385..a9e12b28b 100644
--- a/tests/components/proc/mobject/session/defsregistryimpltest.cpp
+++ b/tests/components/proc/mobject/session/defsregistryimpltest.cpp
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/tests/components/proc/mobject/session/deletecliptest.cpp b/tests/components/proc/mobject/session/deletecliptest.cpp
index 07d275607..e803f165e 100644
--- a/tests/components/proc/mobject/session/deletecliptest.cpp
+++ b/tests/components/proc/mobject/session/deletecliptest.cpp
@@ -1,23 +1,23 @@
 /*
   DeleteClip(Test)  -  removing an Clip-MObject from the Session
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/mobject/session/placement-index-query-test.cpp b/tests/components/proc/mobject/session/placement-index-query-test.cpp
index aa4694d77..efb049cbf 100644
--- a/tests/components/proc/mobject/session/placement-index-query-test.cpp
+++ b/tests/components/proc/mobject/session/placement-index-query-test.cpp
@@ -1,23 +1,23 @@
 /*
   PlacementIndexQuery(Test)  -  querying the placement index through the generic query interface 
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/mobject/session/placement-index-test.cpp b/tests/components/proc/mobject/session/placement-index-test.cpp
index 4ad4d88d5..c61f4b586 100644
--- a/tests/components/proc/mobject/session/placement-index-test.cpp
+++ b/tests/components/proc/mobject/session/placement-index-test.cpp
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/tests/components/proc/mobject/session/placement-scope-test.cpp b/tests/components/proc/mobject/session/placement-scope-test.cpp
index bcf086077..3d3ab194a 100644
--- a/tests/components/proc/mobject/session/placement-scope-test.cpp
+++ b/tests/components/proc/mobject/session/placement-scope-test.cpp
@@ -1,23 +1,23 @@
 /*
   PlacementScope(Test)  -  accessing and navigating placement scope
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/mobject/session/query-focus-stack-test.cpp b/tests/components/proc/mobject/session/query-focus-stack-test.cpp
index de09676d4..d5f733b58 100644
--- a/tests/components/proc/mobject/session/query-focus-stack-test.cpp
+++ b/tests/components/proc/mobject/session/query-focus-stack-test.cpp
@@ -1,23 +1,23 @@
 /*
   QueryFocusStack(Test)  -  verify the stack of focus path frames
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/mobject/session/query-focus-test.cpp b/tests/components/proc/mobject/session/query-focus-test.cpp
index 2ce9d92d2..ae12108b2 100644
--- a/tests/components/proc/mobject/session/query-focus-test.cpp
+++ b/tests/components/proc/mobject/session/query-focus-test.cpp
@@ -1,23 +1,23 @@
 /*
   QueryFocus(Test)  -  verify proper management of current scope
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/mobject/session/query-resolver-test.cpp b/tests/components/proc/mobject/session/query-resolver-test.cpp
index d3a785b0f..42cfe1045 100644
--- a/tests/components/proc/mobject/session/query-resolver-test.cpp
+++ b/tests/components/proc/mobject/session/query-resolver-test.cpp
@@ -1,23 +1,23 @@
 /*
   QueryResolver(Test)  -  issuing typed queries over a generic interface
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/mobject/session/rebuildfixturetest.cpp b/tests/components/proc/mobject/session/rebuildfixturetest.cpp
index 751eb5b80..170582dd6 100644
--- a/tests/components/proc/mobject/session/rebuildfixturetest.cpp
+++ b/tests/components/proc/mobject/session/rebuildfixturetest.cpp
@@ -1,23 +1,23 @@
 /*
   RebuildFixture(Test)  -  (re)building the explicit placements
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/mobject/session/scope-path-test.cpp b/tests/components/proc/mobject/session/scope-path-test.cpp
index e2f9cc3d3..80b578c9a 100644
--- a/tests/components/proc/mobject/session/scope-path-test.cpp
+++ b/tests/components/proc/mobject/session/scope-path-test.cpp
@@ -1,23 +1,23 @@
 /*
   ScopePath(Test)  -  verify handling of logical access path down from Session root
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/mobject/session/scope-query-test.cpp b/tests/components/proc/mobject/session/scope-query-test.cpp
index 293863383..bce023e3d 100644
--- a/tests/components/proc/mobject/session/scope-query-test.cpp
+++ b/tests/components/proc/mobject/session/scope-query-test.cpp
@@ -1,23 +1,23 @@
 /*
   ScopeQuery(Test)  -  running queries to discover container contents, filtering (sub)types 
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/mobject/session/session-element-query-test.cpp b/tests/components/proc/mobject/session/session-element-query-test.cpp
index 9215b97fa..08e742af9 100644
--- a/tests/components/proc/mobject/session/session-element-query-test.cpp
+++ b/tests/components/proc/mobject/session/session-element-query-test.cpp
@@ -1,23 +1,23 @@
 /*
   SessionElementQuery(Test)  -  querying and retrieving elements from the session 
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/mobject/session/session-element-tracker-test.cpp b/tests/components/proc/mobject/session/session-element-tracker-test.cpp
index 7561f40d4..207d099a6 100644
--- a/tests/components/proc/mobject/session/session-element-tracker-test.cpp
+++ b/tests/components/proc/mobject/session/session-element-tracker-test.cpp
@@ -1,23 +1,23 @@
 /*
   SessionElementTracker(Test)  -  check the facility to track and expose selected model elements
- 
+
   Copyright (C)         Lumiera.org
     2008-2010,          Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/mobject/session/session-modify-parts-test.cpp b/tests/components/proc/mobject/session/session-modify-parts-test.cpp
index 120ec4f0f..f7cb3d974 100644
--- a/tests/components/proc/mobject/session/session-modify-parts-test.cpp
+++ b/tests/components/proc/mobject/session/session-modify-parts-test.cpp
@@ -1,23 +1,23 @@
 /*
   SessionModifyParts(Test)  -  adding and removing elements, changing structure
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/mobject/session/session-service-access-test.cpp b/tests/components/proc/mobject/session/session-service-access-test.cpp
index c1d7bc877..0cdd56479 100644
--- a/tests/components/proc/mobject/session/session-service-access-test.cpp
+++ b/tests/components/proc/mobject/session/session-service-access-test.cpp
@@ -1,23 +1,23 @@
 /*
   SessionServiceAccess(Test)  -  accessing implementation level session services
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/mobject/session/session-structure-test.cpp b/tests/components/proc/mobject/session/session-structure-test.cpp
index 19921ce6b..458633d5c 100644
--- a/tests/components/proc/mobject/session/session-structure-test.cpp
+++ b/tests/components/proc/mobject/session/session-structure-test.cpp
@@ -1,23 +1,23 @@
 /*
   SessionStructure(Test)  -  verifying basic Session/Model structure
- 
+
   Copyright (C)         Lumiera.org
     2008-2010,          Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/mobject/session/sessionmanagertest.cpp b/tests/components/proc/mobject/session/sessionmanagertest.cpp
index e116ca9f2..f36e3871c 100644
--- a/tests/components/proc/mobject/session/sessionmanagertest.cpp
+++ b/tests/components/proc/mobject/session/sessionmanagertest.cpp
@@ -1,23 +1,23 @@
 /*
   SessionManager(Test)  -  accessing, loading and saving the Session/Model
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/mobject/session/test-scope-invalid.hpp b/tests/components/proc/mobject/session/test-scope-invalid.hpp
index ecfa18f04..23435d144 100644
--- a/tests/components/proc/mobject/session/test-scope-invalid.hpp
+++ b/tests/components/proc/mobject/session/test-scope-invalid.hpp
@@ -1,23 +1,23 @@
 /*
   TEST-SCOPE-INVALID.hpp  -  helper for placement scope and scope stack tests
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/tests/components/proc/mobject/session/test-scopes.cpp b/tests/components/proc/mobject/session/test-scopes.cpp
index 8edfacc21..04b09ae27 100644
--- a/tests/components/proc/mobject/session/test-scopes.cpp
+++ b/tests/components/proc/mobject/session/test-scopes.cpp
@@ -1,23 +1,23 @@
 /*
   TEST-SCOPES.cpp  -  builds a test PlacementIndex containing dummy Placements as nested scopes
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/mobject/session/test-scopes.hpp b/tests/components/proc/mobject/session/test-scopes.hpp
index c83856791..8b9b3a2fe 100644
--- a/tests/components/proc/mobject/session/test-scopes.hpp
+++ b/tests/components/proc/mobject/session/test-scopes.hpp
@@ -1,23 +1,23 @@
 /*
   TEST-SCOPES.hpp  -  builds a test PlacementIndex containing dummy Placements as nested scopes
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/tests/components/proc/mobject/session/testclip.cpp b/tests/components/proc/mobject/session/testclip.cpp
index 37cda9636..c8c916512 100644
--- a/tests/components/proc/mobject/session/testclip.cpp
+++ b/tests/components/proc/mobject/session/testclip.cpp
@@ -1,23 +1,23 @@
 /*
   TestClip  -  test clip (stub) for checking Model/Session functionality
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/components/proc/mobject/session/testclip.hpp b/tests/components/proc/mobject/session/testclip.hpp
index fadaf7e58..5907f6750 100644
--- a/tests/components/proc/mobject/session/testclip.hpp
+++ b/tests/components/proc/mobject/session/testclip.hpp
@@ -1,23 +1,23 @@
 /*
   TESTCLIP.hpp  -  test clip (stub) for checking Model/Session functionality
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/tests/components/proc/mobject/session/testroot.hpp b/tests/components/proc/mobject/session/testroot.hpp
index 0b0585f79..69af08447 100644
--- a/tests/components/proc/mobject/session/testroot.hpp
+++ b/tests/components/proc/mobject/session/testroot.hpp
@@ -1,23 +1,23 @@
 /*
   TESTROOT.hpp  -  test dummy model root for checking Model/Session functionality
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/tests/components/proc/mobject/session/testsession1.hpp b/tests/components/proc/mobject/session/testsession1.hpp
index 198e796ff..4b67fcd08 100644
--- a/tests/components/proc/mobject/session/testsession1.hpp
+++ b/tests/components/proc/mobject/session/testsession1.hpp
@@ -1,23 +1,23 @@
 /*
   TESTSESSION1.hpp  -  complete session configuration used for various tests
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/tests/components/proc/mobject/session/timeline-sequence-handling-test.cpp b/tests/components/proc/mobject/session/timeline-sequence-handling-test.cpp
index 7d81c8dbb..c250b6019 100644
--- a/tests/components/proc/mobject/session/timeline-sequence-handling-test.cpp
+++ b/tests/components/proc/mobject/session/timeline-sequence-handling-test.cpp
@@ -1,23 +1,23 @@
 /*
   TimelineSequenceHandling(Test)  -  managing the top level session facade objects
- 
+
   Copyright (C)         Lumiera.org
     2008-2010,          Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/advice/advice-basics-test.cpp b/tests/lib/advice/advice-basics-test.cpp
index dcdde8992..809f53814 100644
--- a/tests/lib/advice/advice-basics-test.cpp
+++ b/tests/lib/advice/advice-basics-test.cpp
@@ -1,23 +1,23 @@
 /*
   AdviceBasics(Test)  -  basic behaviour of the Advice collaboration
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/advice/advice-binding-pattern-test.cpp b/tests/lib/advice/advice-binding-pattern-test.cpp
index 285b3065e..54c6741d5 100644
--- a/tests/lib/advice/advice-binding-pattern-test.cpp
+++ b/tests/lib/advice/advice-binding-pattern-test.cpp
@@ -1,23 +1,23 @@
 /*
   AdviceBindingPattern(Test)  -  cover pattern matching used to dispatch Advice
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/advice/advice-configuration-test.cpp b/tests/lib/advice/advice-configuration-test.cpp
index c4448a67a..0ea2be33d 100644
--- a/tests/lib/advice/advice-configuration-test.cpp
+++ b/tests/lib/advice/advice-configuration-test.cpp
@@ -1,23 +1,23 @@
 /*
   AdviceConfiguration(Test)  -  cover the various policies to configure Advice
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/advice/advice-index-test.cpp b/tests/lib/advice/advice-index-test.cpp
index 1e516c958..a8f382905 100644
--- a/tests/lib/advice/advice-index-test.cpp
+++ b/tests/lib/advice/advice-index-test.cpp
@@ -1,23 +1,23 @@
 /*
   AdviceIndex(Test)  -  cover the index datastructure used to implement Advice dispatch
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/advice/advice-multiplicity-test.cpp b/tests/lib/advice/advice-multiplicity-test.cpp
index 35cf42e5b..c95da30e3 100644
--- a/tests/lib/advice/advice-multiplicity-test.cpp
+++ b/tests/lib/advice/advice-multiplicity-test.cpp
@@ -1,23 +1,23 @@
 /*
   AdviceMultiplicity(Test)  -  verify correctness when dispatching multiple Advices concurrently
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/advice/advice-situations-test.cpp b/tests/lib/advice/advice-situations-test.cpp
index 35110156a..88de5debb 100644
--- a/tests/lib/advice/advice-situations-test.cpp
+++ b/tests/lib/advice/advice-situations-test.cpp
@@ -1,23 +1,23 @@
 /*
   AdviceSituations(Test)  -  catalogue of standard Advice usage scenarios
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/allocationclustertest.cpp b/tests/lib/allocationclustertest.cpp
index 7a91e5a3d..6e2d38e65 100644
--- a/tests/lib/allocationclustertest.cpp
+++ b/tests/lib/allocationclustertest.cpp
@@ -1,23 +1,23 @@
 /*
   AllocationCluster(Test)  -  verify bulk (de)allocating a family of objects
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/appconfigtest.cpp b/tests/lib/appconfigtest.cpp
index b7e6cb310..5a65f25d6 100644
--- a/tests/lib/appconfigtest.cpp
+++ b/tests/lib/appconfigtest.cpp
@@ -1,23 +1,23 @@
 /*
   Appconfig(Test)  -  accessing the always-available AppState singleton
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/bool-checkable-test.cpp b/tests/lib/bool-checkable-test.cpp
index ede6aba25..41175202c 100644
--- a/tests/lib/bool-checkable-test.cpp
+++ b/tests/lib/bool-checkable-test.cpp
@@ -1,23 +1,23 @@
 /*
   BoolCheckable(Test)  -  verify the mixin for implicit conversion to bool
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/custom-shared-ptr-test.cpp b/tests/lib/custom-shared-ptr-test.cpp
index adb7c6f35..c6d9e147d 100644
--- a/tests/lib/custom-shared-ptr-test.cpp
+++ b/tests/lib/custom-shared-ptr-test.cpp
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/tests/lib/del-stash-test.cpp b/tests/lib/del-stash-test.cpp
index dbe325be2..48c4f9823 100644
--- a/tests/lib/del-stash-test.cpp
+++ b/tests/lib/del-stash-test.cpp
@@ -1,23 +1,23 @@
 /*
   DelStash(Test)  -  verify a facility to memorise and trigger deleter functions
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/exceptionerrortest.cpp b/tests/lib/exceptionerrortest.cpp
index 2de614293..2fa28bbc8 100644
--- a/tests/lib/exceptionerrortest.cpp
+++ b/tests/lib/exceptionerrortest.cpp
@@ -1,23 +1,23 @@
 /*
   ExceptionError(Test)  -  throwing and catching our exception type
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/factory-special-test.cpp b/tests/lib/factory-special-test.cpp
index 4c912e284..eaa714422 100644
--- a/tests/lib/factory-special-test.cpp
+++ b/tests/lib/factory-special-test.cpp
@@ -1,23 +1,23 @@
 /*
   Factory-Special(Test)  -  testing the more advanced features of factory
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/factorytest.cpp b/tests/lib/factorytest.cpp
index 1100c489f..8e46771c2 100644
--- a/tests/lib/factorytest.cpp
+++ b/tests/lib/factorytest.cpp
@@ -1,23 +1,23 @@
 /*
   Factory(Test)  -  unittest for the object creating factory
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/format-helper-test.cpp b/tests/lib/format-helper-test.cpp
index 6e4c82c1c..4c246ff3d 100644
--- a/tests/lib/format-helper-test.cpp
+++ b/tests/lib/format-helper-test.cpp
@@ -1,23 +1,23 @@
 /*
   FormatHelper(Test)  -  validate formatting and diagnostics helpers
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/functor-util-test.cpp b/tests/lib/functor-util-test.cpp
index 045583234..0692158fe 100644
--- a/tests/lib/functor-util-test.cpp
+++ b/tests/lib/functor-util-test.cpp
@@ -1,23 +1,23 @@
 /*
   FunctorUtil(Test)  -  verifying function object and signal utilities
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/hash-indexed-test.cpp b/tests/lib/hash-indexed-test.cpp
index a9791e0dd..00281767d 100644
--- a/tests/lib/hash-indexed-test.cpp
+++ b/tests/lib/hash-indexed-test.cpp
@@ -1,23 +1,23 @@
 /*
   HashIndexed(Test)  -  proof-of-concept test for a hash based and typed ID
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/helloworldtest.cpp b/tests/lib/helloworldtest.cpp
index 7e99b06ff..529b536ed 100644
--- a/tests/lib/helloworldtest.cpp
+++ b/tests/lib/helloworldtest.cpp
@@ -1,23 +1,23 @@
 /*
   HelloWorld(Test)  -  how to use this test framework...
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/item-wrapper-test.cpp b/tests/lib/item-wrapper-test.cpp
index 0f8c108f7..ba0ec5442 100644
--- a/tests/lib/item-wrapper-test.cpp
+++ b/tests/lib/item-wrapper-test.cpp
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/tests/lib/iter-adapter-stl-test.cpp b/tests/lib/iter-adapter-stl-test.cpp
index c72dfbcfb..c4aafff4a 100644
--- a/tests/lib/iter-adapter-stl-test.cpp
+++ b/tests/lib/iter-adapter-stl-test.cpp
@@ -1,23 +1,23 @@
 /*
   IterAdapterSTL(Test)  -  building various custom iterators for a given container
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/iter-adapter-test.cpp b/tests/lib/iter-adapter-test.cpp
index 5ed333787..6376c49bc 100644
--- a/tests/lib/iter-adapter-test.cpp
+++ b/tests/lib/iter-adapter-test.cpp
@@ -1,23 +1,23 @@
 /*
   IterAdapter(Test)  -  building various custom iterators for a given container
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/iter-source-test.cpp b/tests/lib/iter-source-test.cpp
index 8257852a8..694556be8 100644
--- a/tests/lib/iter-source-test.cpp
+++ b/tests/lib/iter-source-test.cpp
@@ -1,23 +1,23 @@
 /*
   IterSource(Test)  -  how to build an opaque iterator-based data source
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/itertools-test.cpp b/tests/lib/itertools-test.cpp
index 5ebc7cd77..6b47a69a7 100644
--- a/tests/lib/itertools-test.cpp
+++ b/tests/lib/itertools-test.cpp
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/tests/lib/lifecycletest.cpp b/tests/lib/lifecycletest.cpp
index 432ba79ef..c437aa74b 100644
--- a/tests/lib/lifecycletest.cpp
+++ b/tests/lib/lifecycletest.cpp
@@ -1,23 +1,23 @@
 /*
   LifeCycle(Test)  -  checking the lifecycle callback hooks provided by AppState
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/mainsuite.cpp b/tests/lib/mainsuite.cpp
index 4b2429356..882ee78d4 100644
--- a/tests/lib/mainsuite.cpp
+++ b/tests/lib/mainsuite.cpp
@@ -7,8 +7,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/tests/lib/meta/config-flags-test.cpp b/tests/lib/meta/config-flags-test.cpp
index 5159a21cf..572bc3adf 100644
--- a/tests/lib/meta/config-flags-test.cpp
+++ b/tests/lib/meta/config-flags-test.cpp
@@ -1,23 +1,23 @@
 /*
   ConfigFlags(Test)  -  generating a configuration type defined by flags
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/meta/duck-detector-test.cpp b/tests/lib/meta/duck-detector-test.cpp
index bf0c15f5a..064ed9041 100644
--- a/tests/lib/meta/duck-detector-test.cpp
+++ b/tests/lib/meta/duck-detector-test.cpp
@@ -1,23 +1,23 @@
 /*
   DuckDetector(Test)  -  detecting properties of a type at compile time
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/meta/dummy-functions.hpp b/tests/lib/meta/dummy-functions.hpp
index 0957cbada..017624a01 100644
--- a/tests/lib/meta/dummy-functions.hpp
+++ b/tests/lib/meta/dummy-functions.hpp
@@ -1,23 +1,23 @@
 /*
   DUMMY-FUNCTIONS  -  mock functions for checking functor utils
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/meta/function-closure-test.cpp b/tests/lib/meta/function-closure-test.cpp
index 3f9714b7c..e024ff808 100644
--- a/tests/lib/meta/function-closure-test.cpp
+++ b/tests/lib/meta/function-closure-test.cpp
@@ -1,23 +1,23 @@
 /*
   FunctionClosure(Test)  -  appending, mixing and filtering typelists
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/meta/function-composition-test.cpp b/tests/lib/meta/function-composition-test.cpp
index cd0569223..9761d87b6 100644
--- a/tests/lib/meta/function-composition-test.cpp
+++ b/tests/lib/meta/function-composition-test.cpp
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/tests/lib/meta/function-erasure-test.cpp b/tests/lib/meta/function-erasure-test.cpp
index 96bf9f50f..b4eefad76 100644
--- a/tests/lib/meta/function-erasure-test.cpp
+++ b/tests/lib/meta/function-erasure-test.cpp
@@ -1,23 +1,23 @@
 /*
   FunctionErasure(Test)  -  verify the wrapping of functor object with type erasure
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/meta/generator-test.cpp b/tests/lib/meta/generator-test.cpp
index a43a76183..e6fdf1cf8 100644
--- a/tests/lib/meta/generator-test.cpp
+++ b/tests/lib/meta/generator-test.cpp
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/tests/lib/meta/iterable-classification-test.cpp b/tests/lib/meta/iterable-classification-test.cpp
index b4cc0a684..8c5b8b770 100644
--- a/tests/lib/meta/iterable-classification-test.cpp
+++ b/tests/lib/meta/iterable-classification-test.cpp
@@ -1,23 +1,23 @@
 /*
   IterableClassification(Test)  -  detecting iterability of a generic type
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/meta/tuple-diagnostics.hpp b/tests/lib/meta/tuple-diagnostics.hpp
index 127b845e1..69a29b6f1 100644
--- a/tests/lib/meta/tuple-diagnostics.hpp
+++ b/tests/lib/meta/tuple-diagnostics.hpp
@@ -1,23 +1,23 @@
 /*
   TUPLE-DIAGNOSTICS  -  helper for diagnostics of type tuples
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/meta/type-tuple-test.cpp b/tests/lib/meta/type-tuple-test.cpp
index e02ed392c..aa773b3a2 100644
--- a/tests/lib/meta/type-tuple-test.cpp
+++ b/tests/lib/meta/type-tuple-test.cpp
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/tests/lib/meta/typelist-diagnostics.hpp b/tests/lib/meta/typelist-diagnostics.hpp
index 98728f3a7..bd924b1d8 100644
--- a/tests/lib/meta/typelist-diagnostics.hpp
+++ b/tests/lib/meta/typelist-diagnostics.hpp
@@ -1,23 +1,23 @@
 /*
   TYPELIST-DIAGNOSTICS  -  helper for testing the typelist based utilities
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/meta/typelist-manip-test.cpp b/tests/lib/meta/typelist-manip-test.cpp
index 0f28ca961..ce51270a5 100644
--- a/tests/lib/meta/typelist-manip-test.cpp
+++ b/tests/lib/meta/typelist-manip-test.cpp
@@ -1,23 +1,23 @@
 /*
   TypeListManip(Test)  -  appending, mixing and filtering typelists
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/meta/typelist-test.cpp b/tests/lib/meta/typelist-test.cpp
index c31c4a70d..041f8eaf2 100644
--- a/tests/lib/meta/typelist-test.cpp
+++ b/tests/lib/meta/typelist-test.cpp
@@ -1,23 +1,23 @@
 /*
   TypeList(Test)  -  check the typelist metaprogramming facility
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/meta/typeseq-manip-test.cpp b/tests/lib/meta/typeseq-manip-test.cpp
index a64e5f02c..1221c610b 100644
--- a/tests/lib/meta/typeseq-manip-test.cpp
+++ b/tests/lib/meta/typeseq-manip-test.cpp
@@ -1,23 +1,23 @@
 /*
   TypeSeqManip(Test)  -  simple manipulations on type sequences
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/multifact-argument-test.cpp b/tests/lib/multifact-argument-test.cpp
index 1957a2499..5edd52e44 100644
--- a/tests/lib/multifact-argument-test.cpp
+++ b/tests/lib/multifact-argument-test.cpp
@@ -1,23 +1,23 @@
 /*
   MultiFactArgument(Test)  -  passing additional invocation arguments to registered factory functions
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/multifact-test.cpp b/tests/lib/multifact-test.cpp
index 2f39deaf8..89495f0b3 100644
--- a/tests/lib/multifact-test.cpp
+++ b/tests/lib/multifact-test.cpp
@@ -1,23 +1,23 @@
 /*
   MultiFact(Test)  -  unittest for the configurable object-family creating factory
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/null-value-test.cpp b/tests/lib/null-value-test.cpp
index eaee31bc3..57eb6085b 100644
--- a/tests/lib/null-value-test.cpp
+++ b/tests/lib/null-value-test.cpp
@@ -1,23 +1,23 @@
 /*
   NullValue(Test)  -  verify the singleton holder for NIL or default values
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/opaque-holder-test.cpp b/tests/lib/opaque-holder-test.cpp
index 29f3fa125..1b95f8471 100644
--- a/tests/lib/opaque-holder-test.cpp
+++ b/tests/lib/opaque-holder-test.cpp
@@ -1,23 +1,23 @@
 /*
   OpaqueHolder(Test)  -  check the inline type erasure helper
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/opaque-unchecked-buffer-test.cpp b/tests/lib/opaque-unchecked-buffer-test.cpp
index 222b719e4..50e3de2e0 100644
--- a/tests/lib/opaque-unchecked-buffer-test.cpp
+++ b/tests/lib/opaque-unchecked-buffer-test.cpp
@@ -1,23 +1,23 @@
 /*
   OpaqueUncheckedBuffer(Test)  -  passive inline buffer test
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/optional-ref-test.cpp b/tests/lib/optional-ref-test.cpp
index a8e293cfd..5bfb5128a 100644
--- a/tests/lib/optional-ref-test.cpp
+++ b/tests/lib/optional-ref-test.cpp
@@ -1,23 +1,23 @@
 /*
   OptionalRef(Test)  -  verify an optional and switchable object link
- 
+
   Copyright (C)         Lumiera.org
     2010,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/query/query-utils-test.cpp b/tests/lib/query/query-utils-test.cpp
index a05b46c5f..70a9f59ec 100644
--- a/tests/lib/query/query-utils-test.cpp
+++ b/tests/lib/query/query-utils-test.cpp
@@ -1,23 +1,23 @@
 /*
   QueryUtils(Test)  -  checking various utils provided for dealing with config queries
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/query/querydiagnostics.hpp b/tests/lib/query/querydiagnostics.hpp
index 47d73283f..69214d32d 100644
--- a/tests/lib/query/querydiagnostics.hpp
+++ b/tests/lib/query/querydiagnostics.hpp
@@ -1,23 +1,23 @@
 /*
   QUERYDIAGNOSTICS.hpp  -  helpers for writing tests covering config queries
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/tests/lib/removefromsettest.cpp b/tests/lib/removefromsettest.cpp
index ce9f825ec..0bc2a0da3 100644
--- a/tests/lib/removefromsettest.cpp
+++ b/tests/lib/removefromsettest.cpp
@@ -1,23 +1,23 @@
 /*
   RemoveFromSet(Test)  -  algorithm removing predicated elements from set
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/sanitised-identifier-test.cpp b/tests/lib/sanitised-identifier-test.cpp
index 7913795f1..a0b0d59de 100644
--- a/tests/lib/sanitised-identifier-test.cpp
+++ b/tests/lib/sanitised-identifier-test.cpp
@@ -1,23 +1,23 @@
 /*
   SanitizedIdentifier(Test)  -  remove non-standard-chars and punctuation
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/scoped-holder-test.cpp b/tests/lib/scoped-holder-test.cpp
index ff913c60e..b424ec685 100644
--- a/tests/lib/scoped-holder-test.cpp
+++ b/tests/lib/scoped-holder-test.cpp
@@ -1,23 +1,23 @@
 /*
   ScopedHolder(Test)  -  holding and owning noncopyable objects
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/scoped-holder-transfer-test.cpp b/tests/lib/scoped-holder-transfer-test.cpp
index eafefb390..a01609ddf 100644
--- a/tests/lib/scoped-holder-transfer-test.cpp
+++ b/tests/lib/scoped-holder-transfer-test.cpp
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/tests/lib/scoped-ptrvect-test.cpp b/tests/lib/scoped-ptrvect-test.cpp
index 26c8719b5..48461e56b 100644
--- a/tests/lib/scoped-ptrvect-test.cpp
+++ b/tests/lib/scoped-ptrvect-test.cpp
@@ -1,23 +1,23 @@
 /*
   ScopedPtrVect(Test)  -  holding and owning a collection of noncopyable objects
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/singleton-subclass-test.cpp b/tests/lib/singleton-subclass-test.cpp
index 113385cfd..054883f71 100644
--- a/tests/lib/singleton-subclass-test.cpp
+++ b/tests/lib/singleton-subclass-test.cpp
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/tests/lib/singleton-test.cpp b/tests/lib/singleton-test.cpp
index eaebc100d..028881865 100644
--- a/tests/lib/singleton-test.cpp
+++ b/tests/lib/singleton-test.cpp
@@ -1,23 +1,23 @@
 /*
   Singleton(Test)  -  unittest for our Singleton template
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/singletontestmocktest.cpp b/tests/lib/singletontestmocktest.cpp
index 66b9b0244..27a0ce086 100644
--- a/tests/lib/singletontestmocktest.cpp
+++ b/tests/lib/singletontestmocktest.cpp
@@ -1,23 +1,23 @@
 /*
   SingletonTestMock(Test)  -  using Singleton for injecting Test-Mocks
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/streamtypebasicstest.cpp b/tests/lib/streamtypebasicstest.cpp
index 069afa3ab..bf5f191b6 100644
--- a/tests/lib/streamtypebasicstest.cpp
+++ b/tests/lib/streamtypebasicstest.cpp
@@ -1,23 +1,23 @@
 /*
   StreamTypeBasics(Test)  -  check the fundamentals of stream type information
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/streamtypelifecycletest.cpp b/tests/lib/streamtypelifecycletest.cpp
index 9ef328d3d..1c1466407 100644
--- a/tests/lib/streamtypelifecycletest.cpp
+++ b/tests/lib/streamtypelifecycletest.cpp
@@ -1,23 +1,23 @@
 /*
   StreamTypeLifecycle(Test)  -  check lifecycle of the stream type registration
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/sub-id-test.cpp b/tests/lib/sub-id-test.cpp
index 56b8170b9..6794c92d5 100644
--- a/tests/lib/sub-id-test.cpp
+++ b/tests/lib/sub-id-test.cpp
@@ -1,23 +1,23 @@
 /*
   SubID(Test)  -  exploring possible properties of an extensible symbolic identifier
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/subsystem-runner-test.cpp b/tests/lib/subsystem-runner-test.cpp
index 10da60ac7..8eebc7d26 100644
--- a/tests/lib/subsystem-runner-test.cpp
+++ b/tests/lib/subsystem-runner-test.cpp
@@ -1,23 +1,23 @@
 /*
   SubsystemRunner(Test)  -  validate starting and stopping of dependent subsystems
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/symbol-hashtable-test.cpp b/tests/lib/symbol-hashtable-test.cpp
index 501aa8579..801e65518 100644
--- a/tests/lib/symbol-hashtable-test.cpp
+++ b/tests/lib/symbol-hashtable-test.cpp
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/tests/lib/symbol-test.cpp b/tests/lib/symbol-test.cpp
index 08dd79197..89d1b4cd1 100644
--- a/tests/lib/symbol-test.cpp
+++ b/tests/lib/symbol-test.cpp
@@ -1,23 +1,23 @@
 /*
   Symbol(Test)  -  verify basic properties of a Symbol datatype
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/sync-classlock-test.cpp b/tests/lib/sync-classlock-test.cpp
index 59377ae16..3f8010e12 100644
--- a/tests/lib/sync-classlock-test.cpp
+++ b/tests/lib/sync-classlock-test.cpp
@@ -1,23 +1,23 @@
 /*
   SyncClasslock(Test)  -  validate the type-based Monitor locking
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/sync-locking-test.cpp b/tests/lib/sync-locking-test.cpp
index 30734a759..9fa27cbb9 100644
--- a/tests/lib/sync-locking-test.cpp
+++ b/tests/lib/sync-locking-test.cpp
@@ -1,23 +1,23 @@
 /*
   SyncLocking(Test)  -  check the monitor object based locking
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/sync-timedwait-test.cpp b/tests/lib/sync-timedwait-test.cpp
index 91d8918cc..6632a10ad 100644
--- a/tests/lib/sync-timedwait-test.cpp
+++ b/tests/lib/sync-timedwait-test.cpp
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/tests/lib/sync-waiting-test.cpp b/tests/lib/sync-waiting-test.cpp
index 2a16ae02b..c86306548 100644
--- a/tests/lib/sync-waiting-test.cpp
+++ b/tests/lib/sync-waiting-test.cpp
@@ -1,23 +1,23 @@
 /*
   SyncWaiting(Test)  -  check the monitor object based wait/notification
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/test/cmdlinewrappertest.cpp b/tests/lib/test/cmdlinewrappertest.cpp
index 81434839a..df5a74a57 100644
--- a/tests/lib/test/cmdlinewrappertest.cpp
+++ b/tests/lib/test/cmdlinewrappertest.cpp
@@ -1,23 +1,23 @@
 /*
   Cmdlinewrapper(Test)  -  build vector of tokens from cmdline, various conversions
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/test/test-helper-test.cpp b/tests/lib/test/test-helper-test.cpp
index e78ef316d..c8fdb8a4b 100644
--- a/tests/lib/test/test-helper-test.cpp
+++ b/tests/lib/test/test-helper-test.cpp
@@ -1,23 +1,23 @@
 /*
   TestHelper(Test)  -  validate the unittest support functions
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/test/testoptiontest.cpp b/tests/lib/test/testoptiontest.cpp
index 31dde772d..2fd3761d4 100644
--- a/tests/lib/test/testoptiontest.cpp
+++ b/tests/lib/test/testoptiontest.cpp
@@ -1,23 +1,23 @@
 /*
   TestOption(Test)  -  parsing of cmd line options for running Testcases
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/testdummy.hpp b/tests/lib/testdummy.hpp
index 605a92fc7..76dcac652 100644
--- a/tests/lib/testdummy.hpp
+++ b/tests/lib/testdummy.hpp
@@ -1,23 +1,23 @@
 /*
   TESTDUMMY.hpp  -  yet another test dummy for tracking ctor/dtor calls
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/teststreamtypes.hpp b/tests/lib/teststreamtypes.hpp
index 22947b50a..fda471b74 100644
--- a/tests/lib/teststreamtypes.hpp
+++ b/tests/lib/teststreamtypes.hpp
@@ -1,23 +1,23 @@
 /*
   TESTSTREAMTYPES.hpp  -  create test (stub) stream type information
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/tests/lib/testtargetobj.hpp b/tests/lib/testtargetobj.hpp
index c3b1e77ef..01313a891 100644
--- a/tests/lib/testtargetobj.hpp
+++ b/tests/lib/testtargetobj.hpp
@@ -1,23 +1,23 @@
 /*
   TESTTARGETOBJ.hpp  -  a test (stub) target object for testing the factories
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 */
 
 
diff --git a/tests/lib/thread-wrapper-join-test.cpp b/tests/lib/thread-wrapper-join-test.cpp
index 2a5a62f8b..30b655cdd 100644
--- a/tests/lib/thread-wrapper-join-test.cpp
+++ b/tests/lib/thread-wrapper-join-test.cpp
@@ -1,23 +1,23 @@
 /*
   ThreadWrapperJoin(Test)  -  wait blocking on termination of a thread
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/thread-wrapper-test.cpp b/tests/lib/thread-wrapper-test.cpp
index 498175e4c..42d3a2b0e 100644
--- a/tests/lib/thread-wrapper-test.cpp
+++ b/tests/lib/thread-wrapper-test.cpp
@@ -1,23 +1,23 @@
 /*
   ThreadWrapper(Test)  -  starting threads and passing context
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/time-wrapper-test.cpp b/tests/lib/time-wrapper-test.cpp
index cb5d4b5e5..1cd388cbe 100644
--- a/tests/lib/time-wrapper-test.cpp
+++ b/tests/lib/time-wrapper-test.cpp
@@ -1,23 +1,23 @@
 /*
   TimeWrapper(Test)  -  working with gavl_time_t values in C++...
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/typed-allocation-manager-test.cpp b/tests/lib/typed-allocation-manager-test.cpp
index 8593c3a98..f72d6bdbd 100644
--- a/tests/lib/typed-allocation-manager-test.cpp
+++ b/tests/lib/typed-allocation-manager-test.cpp
@@ -1,23 +1,23 @@
 /*
   TypedAllocationManager(Test)  -  check interface to pooled allocations
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/typed-counter-test.cpp b/tests/lib/typed-counter-test.cpp
index e5bcd3e6b..b012c1f5e 100644
--- a/tests/lib/typed-counter-test.cpp
+++ b/tests/lib/typed-counter-test.cpp
@@ -1,23 +1,23 @@
 /*
   TypedCounter(Test)  -  managing a set of type based contexts
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/util-foreach-test.cpp b/tests/lib/util-foreach-test.cpp
index 9ffa6b790..e9eb3f54c 100644
--- a/tests/lib/util-foreach-test.cpp
+++ b/tests/lib/util-foreach-test.cpp
@@ -1,23 +1,23 @@
 /*
   UtilForeach(Test)  -  helpers for doing something for each element
- 
+
   Copyright (C)         Lumiera.org
     2009,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/vector-transfer-test.cpp b/tests/lib/vector-transfer-test.cpp
index 3d5a3b771..2ffd27622 100644
--- a/tests/lib/vector-transfer-test.cpp
+++ b/tests/lib/vector-transfer-test.cpp
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/tests/lib/visitingtoolconcept.cpp b/tests/lib/visitingtoolconcept.cpp
index 302bd3a6d..676672d7d 100644
--- a/tests/lib/visitingtoolconcept.cpp
+++ b/tests/lib/visitingtoolconcept.cpp
@@ -1,23 +1,23 @@
 /*
   VisitingTool(Concept)  -  working out our own Visitor library implementation
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/visitingtoolextendedtest.cpp b/tests/lib/visitingtoolextendedtest.cpp
index 3038e9471..8021f0241 100644
--- a/tests/lib/visitingtoolextendedtest.cpp
+++ b/tests/lib/visitingtoolextendedtest.cpp
@@ -1,23 +1,23 @@
 /*
   VisitingToolExtended(Test)  -  check obscure corner cases of visitor lib implementation
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/lib/visitingtooltest.cpp b/tests/lib/visitingtooltest.cpp
index e27d8b00c..80a8eee5a 100644
--- a/tests/lib/visitingtooltest.cpp
+++ b/tests/lib/visitingtooltest.cpp
@@ -1,23 +1,23 @@
 /*
   VisitingTool(Test)  -  check the standard visitor use case
- 
+
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/library/test-error.c b/tests/library/test-error.c
index 0a2d418a4..40e907f8d 100644
--- a/tests/library/test-error.c
+++ b/tests/library/test-error.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/tests/library/test-llist.c b/tests/library/test-llist.c
index b9ef45a84..305ba8d97 100644
--- a/tests/library/test-llist.c
+++ b/tests/library/test-llist.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/tests/library/test-locking.c b/tests/library/test-locking.c
index a59a6d920..8a8ad8f61 100644
--- a/tests/library/test-locking.c
+++ b/tests/library/test-locking.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/tests/library/test-luid.c b/tests/library/test-luid.c
index 72aeb3bca..e04e3f584 100644
--- a/tests/library/test-luid.c
+++ b/tests/library/test-luid.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/tests/library/test-mpool.c b/tests/library/test-mpool.c
index 18c770b2c..fdd4dba22 100644
--- a/tests/library/test-mpool.c
+++ b/tests/library/test-mpool.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/tests/library/test-psplay.c b/tests/library/test-psplay.c
index 54199f9d9..2eb738c9f 100644
--- a/tests/library/test-psplay.c
+++ b/tests/library/test-psplay.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/tests/library/test-safeclib.c b/tests/library/test-safeclib.c
index ba46b172e..cbff85479 100644
--- a/tests/library/test-safeclib.c
+++ b/tests/library/test-safeclib.c
@@ -4,8 +4,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/tests/plugin/examplepluginc/example_plugin.c b/tests/plugin/examplepluginc/example_plugin.c
index 60992745d..9751413b0 100644
--- a/tests/plugin/examplepluginc/example_plugin.c
+++ b/tests/plugin/examplepluginc/example_plugin.c
@@ -1,23 +1,23 @@
 /*
   example_plugin  -  example plugin for testing the interface/plugin system
- 
+
   Copyright (C)         Lumiera.org
     2008,               Christian Thaeter <ct@pipapo.org>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/plugin/test-cpp-plugin/example_plugin.cpp b/tests/plugin/test-cpp-plugin/example_plugin.cpp
index b99d951d3..a41473f51 100644
--- a/tests/plugin/test-cpp-plugin/example_plugin.cpp
+++ b/tests/plugin/test-cpp-plugin/example_plugin.cpp
@@ -1,24 +1,24 @@
 /*
   example_plugin.cpp  -  example plugin (C++) for testing the interface/plugin system
- 
+
   Copyright (C)         Lumiera.org
     2008,               Christian Thaeter <ct@pipapo.org>,
                         Hermann Vosseler <Ichthyostega@web.de>
- 
+
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
- 
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
- 
+
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
+
 * *****************************************************/
 
 
diff --git a/tests/test.h b/tests/test.h
index 19378d448..1fc00955c 100644
--- a/tests/test.h
+++ b/tests/test.h
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/tests/tool/vgsuppression.c b/tests/tool/vgsuppression.c
index ffc88298f..852cc3bc4 100644
--- a/tests/tool/vgsuppression.c
+++ b/tests/tool/vgsuppression.c
@@ -6,8 +6,8 @@
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of the
-  License, or (at your option) any later version.
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of

From 7fc462209ee8dbf8fdd40cfd4c2866a7fc421b86 Mon Sep 17 00:00:00 2001
From: Ichthyostega <prg@ichthyostega.de>
Date: Sat, 18 Dec 2010 00:58:19 +0100
Subject: [PATCH 26/28] some naming cleanup and namespace indentation fixes

---
 src/lib/Makefile.am                           |  12 +-
 ...tioncluster.cpp => allocation-cluster.cpp} |   2 +-
 ...tioncluster.hpp => allocation-cluster.hpp} |  12 +-
 ...letonfactory.hpp => singleton-factory.hpp} |  22 +-
 src/lib/singleton-policies.hpp                | 138 +++++++
 ...nfigure.hpp => singleton-preconfigure.hpp} |  10 +-
 src/lib/singleton.hpp                         |  14 +-
 src/lib/singletonpolicies.hpp                 | 138 -------
 src/lib/sync-classlock.hpp                    |   2 +-
 src/lib/test/mockinjector.hpp                 |   2 +-
 src/proc/Makefile.am                          |   6 +-
 src/proc/engine/nodefactory.cpp               |   2 +-
 src/proc/engine/nodewiring.hpp                |   2 +-
 src/proc/mobject/session.hpp                  |   2 +-
 .../{defsmanager.cpp => defs-manager.cpp}     |   4 +-
 src/proc/mobject/session/defs-manager.hpp     | 128 ++++++
 .../{defsregistry.hpp => defs-registry.hpp}   | 265 ++++++------
 src/proc/mobject/session/defsmanager.hpp      | 130 ------
 src/proc/mobject/session/root.cpp             |   2 +-
 .../mobject/session/sess-manager-impl.cpp     |   2 +-
 .../session/session-interface-modules.hpp     |   2 +-
 src/proc/mobject/session/session.cpp          |   2 +-
 tests/components/Makefile.am                  |   6 +-
 .../proc/control/command-use1-test.cpp        |   4 +-
 .../proc/engine/node-basic-test.cpp           |   2 +-
 .../proc/mobject/placement-basic-test.cpp     | 110 +++--
 .../session/defs-manager-impl-test.cpp        | 176 ++++++++
 .../mobject/session/defs-manager-test.cpp     | 204 +++++++++
 .../session/defs-registry-impl-test.cpp       | 292 +++++++++++++
 .../mobject/session/defsmanagerimpltest.cpp   | 172 --------
 .../proc/mobject/session/defsmanagertest.cpp  | 197 ---------
 .../mobject/session/defsregistryimpltest.cpp  | 296 -------------
 tests/lib/Makefile.am                         |   4 +-
 tests/lib/allocation-cluster-test.cpp         | 234 +++++++++++
 tests/lib/allocationclustertest.cpp           | 236 -----------
 tests/lib/scoped-holder-transfer-test.cpp     | 391 +++++++++---------
 ...cktest.cpp => singleton-testmock-test.cpp} |   0
 tests/lib/typed-allocation-manager-test.cpp   |   2 +-
 tests/lib/vector-transfer-test.cpp            | 248 ++++++-----
 39 files changed, 1732 insertions(+), 1741 deletions(-)
 rename src/lib/{allocationcluster.cpp => allocation-cluster.cpp} (99%)
 rename src/lib/{allocationcluster.hpp => allocation-cluster.hpp} (96%)
 rename src/lib/{singletonfactory.hpp => singleton-factory.hpp} (91%)
 create mode 100644 src/lib/singleton-policies.hpp
 rename src/lib/{singletonpreconfigure.hpp => singleton-preconfigure.hpp} (92%)
 delete mode 100644 src/lib/singletonpolicies.hpp
 rename src/proc/mobject/session/{defsmanager.cpp => defs-manager.cpp} (97%)
 create mode 100644 src/proc/mobject/session/defs-manager.hpp
 rename src/proc/mobject/session/{defsregistry.hpp => defs-registry.hpp} (64%)
 delete mode 100644 src/proc/mobject/session/defsmanager.hpp
 create mode 100644 tests/components/proc/mobject/session/defs-manager-impl-test.cpp
 create mode 100644 tests/components/proc/mobject/session/defs-manager-test.cpp
 create mode 100644 tests/components/proc/mobject/session/defs-registry-impl-test.cpp
 delete mode 100644 tests/components/proc/mobject/session/defsmanagerimpltest.cpp
 delete mode 100644 tests/components/proc/mobject/session/defsmanagertest.cpp
 delete mode 100644 tests/components/proc/mobject/session/defsregistryimpltest.cpp
 create mode 100644 tests/lib/allocation-cluster-test.cpp
 delete mode 100644 tests/lib/allocationclustertest.cpp
 rename tests/lib/{singletontestmocktest.cpp => singleton-testmock-test.cpp} (100%)

diff --git a/src/lib/Makefile.am b/src/lib/Makefile.am
index 74911c158..9837f7da3 100644
--- a/src/lib/Makefile.am
+++ b/src/lib/Makefile.am
@@ -35,7 +35,7 @@ liblumiera_la_LIBADD =	 					\
 liblumiera_la_SOURCES =					\
 	$(liblumiera_la_srcdir)/advice/advice.cpp	\
 	$(liblumiera_la_srcdir)/advice/binding.cpp	\
-	$(liblumiera_la_srcdir)/allocationcluster.cpp	\
+	$(liblumiera_la_srcdir)/allocation-cluster.cpp	\
 	$(liblumiera_la_srcdir)/cmdline.cpp		\
 	$(liblumiera_la_srcdir)/condition.c		\
 	$(liblumiera_la_srcdir)/error.c			\
@@ -69,8 +69,8 @@ noinst_HEADERS +=						\
 	$(liblumiera_la_srcdir)/advice.hpp			\
 	$(liblumiera_la_srcdir)/advice/binding.hpp		\
 	$(liblumiera_la_srcdir)/advice/index.hpp		\
-	$(liblumiera_la_srcdir)/allocationcluster.hpp		\
-	$(liblumiera_la_srcdir)/allocationcluster.hpp		\
+	$(liblumiera_la_srcdir)/allocation-cluster.hpp		\
+	$(liblumiera_la_srcdir)/allocation-cluster.hpp		\
 	$(liblumiera_la_srcdir)/condition.h			\
 	$(liblumiera_la_srcdir)/error.h				\
 	$(liblumiera_la_srcdir)/error.hpp			\
@@ -103,9 +103,9 @@ noinst_HEADERS +=						\
 	$(liblumiera_la_srcdir)/scoped-holder.hpp		\
 	$(liblumiera_la_srcdir)/singleton-subclass.hpp		\
 	$(liblumiera_la_srcdir)/singleton.hpp			\
-	$(liblumiera_la_srcdir)/singletonfactory.hpp		\
-	$(liblumiera_la_srcdir)/singletonpolicies.hpp		\
-	$(liblumiera_la_srcdir)/singletonpreconfigure.hpp	\
+	$(liblumiera_la_srcdir)/singleton-factory.hpp		\
+	$(liblumiera_la_srcdir)/singleton-policies.hpp		\
+	$(liblumiera_la_srcdir)/singleton-preconfigure.hpp	\
 	$(liblumiera_la_srcdir)/sync-classlock.hpp		\
 	$(liblumiera_la_srcdir)/sync.hpp			\
 	$(liblumiera_la_srcdir)/sync.hpp			\
diff --git a/src/lib/allocationcluster.cpp b/src/lib/allocation-cluster.cpp
similarity index 99%
rename from src/lib/allocationcluster.cpp
rename to src/lib/allocation-cluster.cpp
index 7e186ec93..605e15a5c 100644
--- a/src/lib/allocationcluster.cpp
+++ b/src/lib/allocation-cluster.cpp
@@ -21,7 +21,7 @@
 * *****************************************************/
 
 
-#include "lib/allocationcluster.hpp"
+#include "lib/allocation-cluster.hpp"
 #include "lib/error.hpp"
 #include "lib/util.hpp"
 #include "lib/sync.hpp"
diff --git a/src/lib/allocationcluster.hpp b/src/lib/allocation-cluster.hpp
similarity index 96%
rename from src/lib/allocationcluster.hpp
rename to src/lib/allocation-cluster.hpp
index 638aa0564..12f9e9a9f 100644
--- a/src/lib/allocationcluster.hpp
+++ b/src/lib/allocation-cluster.hpp
@@ -1,5 +1,5 @@
 /*
-  ALLOCATIONCLUSTER.hpp  -  allocating and owning a pile of objects
+  ALLOCATION-CLUSTER.hpp  -  allocating and owning a pile of objects
 
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
@@ -20,7 +20,7 @@
 
 */
 
-/** @file allocationcluster.hpp
+/** @file allocation-cluster.hpp
  ** Memory management for the low-level model (render nodes network).
  ** The model is organised into temporal segments, which are considered
  ** to be structurally constant and uniform. The objects within each
@@ -35,17 +35,17 @@
  ** templates, and thus need to be in the header. This way they can
  ** exploit the type information available in call context. This
  ** information is passed to generic implementation functions
- ** defined in allocationcluster.cpp . In a similar vein, the 
+ ** defined in allocation-cluster.cpp . In a similar vein, the 
  ** AllocationCluster::MemoryManger is just forward declared.
  **
- ** @see allocationclustertest.cpp
+ ** @see allocation-cluster-test.cpp
  ** @see builder::ToolFactory
  ** @see frameid.hpp
  */
 
 
-#ifndef LIB_ALLOCATIONCLUSTER_H
-#define LIB_ALLOCATIONCLUSTER_H
+#ifndef LIB_ALLOCATION_CLUSTER_H
+#define LIB_ALLOCATION_CLUSTER_H
 
 #include <vector>
 #include <boost/scoped_ptr.hpp>
diff --git a/src/lib/singletonfactory.hpp b/src/lib/singleton-factory.hpp
similarity index 91%
rename from src/lib/singletonfactory.hpp
rename to src/lib/singleton-factory.hpp
index 65a6a3bd8..5f5070aa4 100644
--- a/src/lib/singletonfactory.hpp
+++ b/src/lib/singleton-factory.hpp
@@ -1,5 +1,5 @@
 /*
-  SINGLETONFACTORY.hpp  -  template for implementing the singleton pattern
+  SINGLETON-FACTORY.hpp  -  template for implementing the singleton pattern
 
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
@@ -31,11 +31,11 @@ This code is heavily inspired by
 
 
 
-#ifndef LIB_SINGLETONFACTORY_H
-#define LIB_SINGLETONFACTORY_H
+#ifndef LIB_SINGLETON_FACTORY_H
+#define LIB_SINGLETON_FACTORY_H
 
 
-#include "lib/singletonpolicies.hpp"  // several Policies usable together with SingletonFactory
+#include "lib/singleton-policies.hpp"  // several Policies usable together with SingletonFactory
 
 #include "lib/nobug-init.hpp"
 #include "include/logging.h"
@@ -45,9 +45,9 @@ This code is heavily inspired by
 namespace lib {
   
   /**
-   * A configurable Template for implementing Singletons. 
+   * A configurable Template for implementing Singletons.
    * Actually this is a Factory object, which could be placed into a static field
-   * of the Singleton (target) class or used directly. 
+   * of the Singleton (target) class or used directly.
    * @note internally uses static fields, so all factory instances share pInstance_
    * @note there is an ongoing discussion regarding Double Checked Locking pattern,
    *       which in this case boils down to the question: does \c pthread_mutex_lock/unlock
@@ -71,7 +71,7 @@ namespace lib {
       
       static PType pInstance_;
       static bool isDead_;
-
+      
       
     public:
       /** Interface to be used by SingletonFactory's clients.
@@ -84,7 +84,7 @@ namespace lib {
           if (!pInstance_)
             {
               ThreadLock guard  SIDEEFFECT;
-
+              
               if (!pInstance_)
                 {
                   if (isDead_)
@@ -114,15 +114,15 @@ namespace lib {
           isDead_ = true;
         }
     };
-    
   
-  // Storage for SingletonFactory's static fields...  
+  
+  // Storage for SingletonFactory's static fields...
   template
     < class SI,
       template <class> class C,
       template <class> class L
     >
-    typename SingletonFactory<SI,C,L>::PType 
+    typename SingletonFactory<SI,C,L>::PType
     SingletonFactory<SI,C,L>::pInstance_;
   
   template
diff --git a/src/lib/singleton-policies.hpp b/src/lib/singleton-policies.hpp
new file mode 100644
index 000000000..7c688c829
--- /dev/null
+++ b/src/lib/singleton-policies.hpp
@@ -0,0 +1,138 @@
+/*
+  SINGLETON-POLICIES.hpp  -  how to manage creation, lifecycle and multithreading
+
+  Copyright (C)         Lumiera.org
+    2008,               Hermann Vosseler <Ichthyostega@web.de>
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License as
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+ 
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+====================================================================
+This code is heavily inspired by  
+ The Loki Library (loki-lib/trunk/include/loki/Singleton.h)
+    Copyright (c) 2001 by Andrei Alexandrescu
+    This Loki code accompanies the book:
+    Alexandrescu, Andrei. "Modern C++ Design: Generic Programming
+        and Design Patterns Applied". 
+        Copyright (c) 2001. Addison-Wesley. ISBN 0201704315
+ 
+*/
+
+
+
+#ifndef LIB_SINGLETON_POLICIES_H
+#define LIB_SINGLETON_POLICIES_H
+
+#include "lib/nobug-init.hpp"
+#include "lib/error.hpp"
+
+#include <vector>
+
+
+namespace lib {
+namespace singleton {
+  
+  
+  /* === several Policies usable in conjunction with lib::Singleton === */
+  
+  /** 
+   * Policy placing the Singleton instance into a statically allocated buffer
+   */
+  template<class S>
+  struct StaticCreate
+    {
+      static S* create ()
+        {
+#if NOBUG_MODE_ALPHA
+          static uint callCount = 0;
+          ASSERT ( 0 == callCount++ );
+#endif              
+          static char buff[sizeof(S)];
+          return new(buff) S();
+        }
+      static void destroy (S* pSi)
+        {
+          pSi-> ~S();
+        }
+    };
+  
+  
+  /**
+   * Policy for creating the Singleton instance heap allocated
+   */
+  template<class S>
+  struct HeapCreate
+    {
+      static S* create ()         { return new S; }
+      static void destroy (S* pS) { delete pS;    }
+    };
+  
+  
+  
+  
+  
+  typedef void (*DelFunc)(void);
+  using std::vector;
+  
+  /**
+   * Policy relying on the compiler/runtime system for Singleton Lifecycle
+   */
+  template<class S>
+  struct AutoDestroy
+    {
+      /** implements the Singleton removal by calling
+       *  the provided deleter function(s) at application shutdown,
+       *  relying on the runtime system calling destructors of static
+       *  objects. Because this Policy class can be shared between 
+       *  several Singletons, we need to memorise all registered
+       *  deleter functions for calling them at shutdown.
+       */ 
+      static void
+      scheduleDelete (DelFunc kill_the_singleton)
+        {
+             class DeleteTrigger
+                    {
+                      vector<DelFunc> dels_;
+                      
+                    public:
+                      void schedule (DelFunc del)
+                        { 
+                          dels_.push_back(del); 
+                        }
+                     ~DeleteTrigger()
+                        { 
+                          vector<DelFunc>::iterator i = dels_.begin();
+                          for ( ; i != dels_.end(); ++i )
+                            (*i)(); // invoke deleter function
+                        }
+                    };
+                    
+          REQUIRE (kill_the_singleton);
+          static DeleteTrigger finally;
+          finally.schedule (kill_the_singleton);
+        }
+      
+      static void
+      onDeadReference ()
+        {
+          throw lumiera::error::Logic ("Trying to access the a Singleton instance that has "
+                                       "already been released or finished its lifecycle.");
+        }
+    };
+  
+  
+  
+  
+}} // namespace lib::singleton
+#endif
diff --git a/src/lib/singletonpreconfigure.hpp b/src/lib/singleton-preconfigure.hpp
similarity index 92%
rename from src/lib/singletonpreconfigure.hpp
rename to src/lib/singleton-preconfigure.hpp
index b7c39fa83..5101c634e 100644
--- a/src/lib/singletonpreconfigure.hpp
+++ b/src/lib/singleton-preconfigure.hpp
@@ -1,5 +1,5 @@
 /*
-  SINGLETONPRECONFIGURE  -  declare the configuration of some Singleton types in advance
+  SINGLETON-PRECONFIGURE  -  declare the configuration of some Singleton types in advance
 
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
@@ -20,7 +20,7 @@
 
 */
 
-/** @file singletonpreconfigure.hpp
+/** @file singleton-preconfigure.hpp
  ** Pre-configuration of some Singleton types, done by template specialisation.
  ** Typically the client code just includes singleton.h and uses the Singleton
  ** type. But in some cases, we want to configure specific (dependency injection)
@@ -37,12 +37,12 @@
  ** @note we declare the specialisations into the target namespace
  ** 
  ** @see SingletonFactory
- ** @see singletontestmocktest.hpp
+ ** @see SingletonTestMock_test
  */
 
 
-#ifndef LIB_SINGLETONPRECONFIGURE_H
-#define LIB_SINGLETONPRECONFIGURE_H
+#ifndef LIB_SINGLETON_PRECONFIGURE_H
+#define LIB_SINGLETON_PRECONFIGURE_H
 
 #include "lib/test/mockinjector.hpp"
 
diff --git a/src/lib/singleton.hpp b/src/lib/singleton.hpp
index d2f82bd9e..f7af5ddba 100644
--- a/src/lib/singleton.hpp
+++ b/src/lib/singleton.hpp
@@ -24,19 +24,19 @@
  ** Factory for creating Singleton instances.
  ** This configuration header just pulls in some other implementation headers in 
  ** the right order. The basic class template for creating singletons resides in
- ** singletonfactory.hpp, besides we need policy classes defining how to create
+ ** singleton-factory.hpp, besides we need policy classes defining how to create
  ** the singleton objects and  how to manage singleton lifecycle. Finally,
  ** we want to preconfigure singleton factories for some important facilities;
  ** e.g. sometimes we want to include a hook for injecting Test Mock instances.
  **
- ** You'll find the default Policies in singletonfactory.hpp and the default
- ** definition of type lumiera::singleton in singletonpreconfigure.hpp
+ ** You'll find the default Policies in singleton-factory.hpp and the default
+ ** definition of type lumiera::singleton in singleton-preconfigure.hpp
  ** 
  ** @see SingletonFactory
  ** @see singleton::StaticCreate
  ** @see singleton::AutoDestroy 
  ** @see singletontest.hpp
- ** @see singletontestmocktest.hpp
+ ** @see SingletonTestMock_test
  */
 
 
@@ -44,9 +44,9 @@
 #define LIB_SINGLETON_H
 
 
-#include "lib/singletonpolicies.hpp"
-#include "lib/singletonfactory.hpp"
-#include "lib/singletonpreconfigure.hpp"
+#include "lib/singleton-policies.hpp"
+#include "lib/singleton-factory.hpp"
+#include "lib/singleton-preconfigure.hpp"
 
 
 #endif
diff --git a/src/lib/singletonpolicies.hpp b/src/lib/singletonpolicies.hpp
deleted file mode 100644
index 49cb27223..000000000
--- a/src/lib/singletonpolicies.hpp
+++ /dev/null
@@ -1,138 +0,0 @@
-/*
-  SINGLETONPOLICIES.hpp  -  how to manage creation, lifecycle and multithreading
-
-  Copyright (C)         Lumiera.org
-    2008,               Hermann Vosseler <Ichthyostega@web.de>
-
-  This program is free software; you can redistribute it and/or
-  modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of
-  the License, or (at your option) any later version.
-
-  This program is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
- 
-  You should have received a copy of the GNU General Public License
-  along with this program; if not, write to the Free Software
-  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
-====================================================================
-This code is heavily inspired by  
- The Loki Library (loki-lib/trunk/include/loki/Singleton.h)
-    Copyright (c) 2001 by Andrei Alexandrescu
-    This Loki code accompanies the book:
-    Alexandrescu, Andrei. "Modern C++ Design: Generic Programming
-        and Design Patterns Applied". 
-        Copyright (c) 2001. Addison-Wesley. ISBN 0201704315
- 
-*/
-
-
-
-#ifndef LIB_SINGLETONPOLICIES_H
-#define LIB_SINGLETONPOLICIES_H
-
-#include "lib/nobug-init.hpp"
-#include "lib/error.hpp"
-
-#include <vector>
-
-
-namespace lib {
-  namespace singleton {
-    
-    
-    /* === several Policies usable in conjunction with lib::Singleton === */
-    
-    /** 
-     * Policy placing the Singleton instance into a statically allocated buffer
-     */
-    template<class S>
-    struct StaticCreate
-      {
-        static S* create ()
-          {
-#ifdef DEBUG
-            static uint callCount = 0;
-            ASSERT ( 0 == callCount++ );
-#endif              
-            static char buff[sizeof(S)];
-            return new(buff) S();
-          }
-        static void destroy (S* pSi)
-          {
-            pSi-> ~S();
-          }
-      };
-    
-    
-    /**
-     * Policy for creating the Singleton instance heap allocated
-     */
-    template<class S>
-    struct HeapCreate
-      {
-        static S* create ()         { return new S; }
-        static void destroy (S* pS) { delete pS;    }
-      };
-    
-    
-    
-    
-    
-    typedef void (*DelFunc)(void);
-    using std::vector;
-    
-    /**
-     * Policy relying on the compiler/runtime system for Singleton Lifecycle
-     */
-    template<class S>
-    struct AutoDestroy
-      {
-        /** implements the Singleton removal by calling
-         *  the provided deleter function(s) at application shutdown,
-         *  relying on the runtime system calling destructors of static
-         *  objects. Because this Policy class can be shared between 
-         *  several Singletons, we need to memorise all registered
-         *  deleter functions for calling them at shutdown.
-         */ 
-        static void
-        scheduleDelete (DelFunc kill_the_singleton)
-          {
-               class DeleteTrigger
-                      {
-                        vector<DelFunc> dels_;
-                        
-                      public:
-                        void schedule (DelFunc del) 
-                          { 
-                            dels_.push_back(del); 
-                          }
-                       ~DeleteTrigger()        
-                          { 
-                            vector<DelFunc>::iterator i = dels_.begin();
-                            for ( ; i != dels_.end(); ++i )
-                              (*i)(); // invoke deleter func 
-                          }
-                      };
-                      
-            REQUIRE (kill_the_singleton);
-            static DeleteTrigger finally;
-            finally.schedule (kill_the_singleton);
-          }
-        
-        static void
-        onDeadReference ()
-          {
-            throw lumiera::error::Logic ("Trying to access the a Singleton instance that has "
-                                         "already been released or finished its lifecycle.");
-          }
-      };
-    
-    
-    
-    
-}} // namespace lib::singleton
-#endif
diff --git a/src/lib/sync-classlock.hpp b/src/lib/sync-classlock.hpp
index 350e0c615..60ffba9bd 100644
--- a/src/lib/sync-classlock.hpp
+++ b/src/lib/sync-classlock.hpp
@@ -29,7 +29,7 @@
  **
  ** @note simply using the ClassLock may cause a Monitor object (with a mutex) to be
  **       created at static initialisation and destroyed on application shutdown.
- ** @see singletonfactory.hpp usage example
+ ** @see singleton-factory.hpp usage example
  */
 
 
diff --git a/src/lib/test/mockinjector.hpp b/src/lib/test/mockinjector.hpp
index 32a647988..dbc47d3ed 100644
--- a/src/lib/test/mockinjector.hpp
+++ b/src/lib/test/mockinjector.hpp
@@ -26,7 +26,7 @@
 #define LUMIERA_TEST_MOCKINJECTOR_H
 
 
-#include "lib/singletonfactory.hpp"
+#include "lib/singleton-factory.hpp"
 
 #include <boost/scoped_ptr.hpp>
 
diff --git a/src/proc/Makefile.am b/src/proc/Makefile.am
index d8e58f786..4d0cdc17f 100644
--- a/src/proc/Makefile.am
+++ b/src/proc/Makefile.am
@@ -155,7 +155,7 @@ liblumiprocmobjectsession_la_SOURCES =							\
 	$(liblumiprocmobjectsession_la_srcdir)/clip.cpp					\
 	$(liblumiprocmobjectsession_la_srcdir)/compoundclip.cpp				\
 	$(liblumiprocmobjectsession_la_srcdir)/constraint.cpp				\
-	$(liblumiprocmobjectsession_la_srcdir)/defsmanager.cpp				\
+	$(liblumiprocmobjectsession_la_srcdir)/defs-manager.cpp				\
 	$(liblumiprocmobjectsession_la_srcdir)/effect.cpp				\
 	$(liblumiprocmobjectsession_la_srcdir)/fixedlocation.cpp			\
 	$(liblumiprocmobjectsession_la_srcdir)/fixture.cpp				\
@@ -237,8 +237,8 @@ noinst_HEADERS +=									\
 	$(liblumiproc_la_srcdir)/mobject/session/clip.hpp				\
 	$(liblumiproc_la_srcdir)/mobject/session/compoundclip.hpp			\
 	$(liblumiproc_la_srcdir)/mobject/session/constraint.hpp				\
-	$(liblumiproc_la_srcdir)/mobject/session/defsmanager.hpp			\
-	$(liblumiproc_la_srcdir)/mobject/session/defsregistry.hpp			\
+	$(liblumiproc_la_srcdir)/mobject/session/defs-manager.hpp			\
+	$(liblumiproc_la_srcdir)/mobject/session/defs-registry.hpp			\
 	$(liblumiproc_la_srcdir)/mobject/session/effect.hpp				\
 	$(liblumiproc_la_srcdir)/mobject/session/fixedlocation.hpp			\
 	$(liblumiproc_la_srcdir)/mobject/session/fixture.hpp				\
diff --git a/src/proc/engine/nodefactory.cpp b/src/proc/engine/nodefactory.cpp
index 52aceb647..eb3ec1913 100644
--- a/src/proc/engine/nodefactory.cpp
+++ b/src/proc/engine/nodefactory.cpp
@@ -23,7 +23,7 @@
 
 #include "proc/engine/nodefactory.hpp"
 #include "proc/mobject/session/effect.hpp"
-#include "lib/allocationcluster.hpp"
+#include "lib/allocation-cluster.hpp"
 
 #include "proc/engine/nodewiring.hpp"
 
diff --git a/src/proc/engine/nodewiring.hpp b/src/proc/engine/nodewiring.hpp
index 79a7cb0d1..9f263ab06 100644
--- a/src/proc/engine/nodewiring.hpp
+++ b/src/proc/engine/nodewiring.hpp
@@ -26,7 +26,7 @@
 
 
 #include "proc/engine/procnode.hpp"
-#include "lib/allocationcluster.hpp"
+#include "lib/allocation-cluster.hpp"
 #include "proc/engine/nodewiring-def.hpp"
 
 //#include <boost/noncopyable.hpp>
diff --git a/src/proc/mobject/session.hpp b/src/proc/mobject/session.hpp
index b60821096..22dd59bdf 100644
--- a/src/proc/mobject/session.hpp
+++ b/src/proc/mobject/session.hpp
@@ -51,7 +51,7 @@
 
 #include "proc/mobject/placement.hpp"
 #include "proc/mobject/mobject-ref.hpp"
-#include "proc/mobject/session/defsmanager.hpp"               ////////////////////////////TICKET #643  forward declare this?
+#include "proc/mobject/session/defs-manager.hpp"               ////////////////////////////TICKET #643  forward declare this?
 #include "lib/ref-array.hpp"
 #include "lib/singleton.hpp"
 #include "lib/symbol.hpp"
diff --git a/src/proc/mobject/session/defsmanager.cpp b/src/proc/mobject/session/defs-manager.cpp
similarity index 97%
rename from src/proc/mobject/session/defsmanager.cpp
rename to src/proc/mobject/session/defs-manager.cpp
index 0c5c134b1..5dd350947 100644
--- a/src/proc/mobject/session/defsmanager.cpp
+++ b/src/proc/mobject/session/defs-manager.cpp
@@ -21,8 +21,8 @@
 * *****************************************************/
 
 
-#include "proc/mobject/session/defsmanager.hpp"
-#include "proc/mobject/session/defsregistry.hpp"
+#include "proc/mobject/session/defs-manager.hpp"
+#include "proc/mobject/session/defs-registry.hpp"
 #include "common/configrules.hpp"
 #include "lib/error.hpp"
 
diff --git a/src/proc/mobject/session/defs-manager.hpp b/src/proc/mobject/session/defs-manager.hpp
new file mode 100644
index 000000000..0fbcb1ab5
--- /dev/null
+++ b/src/proc/mobject/session/defs-manager.hpp
@@ -0,0 +1,128 @@
+/*
+  DEFS-MANAGER.hpp  -  access to preconfigured default objects and definitions
+
+  Copyright (C)         Lumiera.org
+    2008,               Hermann Vosseler <Ichthyostega@web.de>
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License as
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+*/
+
+
+#ifndef MOBJECT_SESSION_DEFS_MANAGER_H
+#define MOBJECT_SESSION_DEFS_MANAGER_H
+
+
+#include "lib/p.hpp"
+#include "lib/query.hpp"
+
+#include <boost/scoped_ptr.hpp>
+#include <boost/noncopyable.hpp>
+
+
+
+namespace mobject {
+namespace session {
+  
+  
+  using lumiera::P;
+  using boost::scoped_ptr;
+  
+  namespace impl { class DefsRegistry; }
+  
+  
+  /**
+   * Organise a collection of preconfigured default objects.
+   * For various kinds of objects we can tweak the default parametrisation
+   * as part of the general session configuration. A ref to an instance of
+   * this class is accessible through the current session and can be used
+   * to fill in parts of the configuration of new objects, if the user 
+   * code didn't give more specific parameters. Necessary sub-objects 
+   * will be created on demand, and any default configuration, once
+   * found, will be remembered and stored with the current session.
+   * 
+   * @note while the logic of defaults handling can be considered
+   *       roughly final, as of 12/09 most of the actual object
+   *       handling is placeholder code.
+   */
+  class DefsManager : private boost::noncopyable
+    {
+      scoped_ptr<impl::DefsRegistry> defsRegistry;
+      
+    public:
+      
+      DefsManager ()  throw();
+     ~DefsManager ();
+      
+      /** common access point: retrieve the default object fulfilling
+       *  some given conditions. May silently trigger object creation.
+       *  @throw error::Config in case no solution is possible, which
+       *         is considered \e misconfiguration. 
+       */
+      template<class TAR>
+      P<TAR> operator() (lumiera::Query<TAR> const&);
+      
+      
+      /** search through the registered defaults, never create anything.
+       *  @return object fulfilling the query, \c empty ptr if not found. 
+       */
+      template<class TAR>
+      P<TAR> search  (lumiera::Query<TAR> const&);
+      
+      /** retrieve an object fulfilling the query and register it as default.
+       *  The resolution is delegated to the ConfigQuery system (which may cause
+       *  creation of new object instances) 
+       *  @return object fulfilling the query, \c empty ptr if no solution.
+       */ 
+      template<class TAR>
+      P<TAR> create  (lumiera::Query<TAR> const&);
+      
+      /** register the given object as default, after ensuring it fulfils the
+       *  query. The latter may cause some properties of the object to be set,
+       *  trigger creation of additional objects, and may fail altogether.
+       *  @return true if query was successful and object is registered as default
+       *  @note only a weak ref to the object is stored
+       */ 
+      template<class TAR>
+      bool define  (P<TAR> const&, lumiera::Query<TAR> const&  =lumiera::Query<TAR>());
+      
+      /** remove the defaults registration of the given object, if there was such
+       *  @return false if nothing has been changed because the object wasn't registered
+       */
+      template<class TAR>
+      bool forget  (P<TAR> const&);
+      
+      
+// Q: can we have something along the line of...?
+//
+//        template
+//          < class TAR,                   ///< the target to query for 
+//            template <class> class SMP  ///<  smart pointer class to wrap the result
+//          >
+//        SMP<TAR> operator() (const lumiera::Query<TAR>&);
+
+// 12/09: according to my current knowledge of template metaprogramming, the answer is "no",
+//        but we could use a traits template to set up a fixed association of smart pointers
+//        and kinds of target object. This would allow to define a templated operator() returning
+//        the result wrapped into the right holder. But currently I don't see how to build a sensible
+//        implementation infrastructure backing such an interface.
+//////////TICKET #452
+      
+    };
+  
+  
+  
+}} // namespace mobject::session
+#endif
diff --git a/src/proc/mobject/session/defsregistry.hpp b/src/proc/mobject/session/defs-registry.hpp
similarity index 64%
rename from src/proc/mobject/session/defsregistry.hpp
rename to src/proc/mobject/session/defs-registry.hpp
index 1ceabfc0a..a6fc169cb 100644
--- a/src/proc/mobject/session/defsregistry.hpp
+++ b/src/proc/mobject/session/defs-registry.hpp
@@ -1,5 +1,5 @@
 /*
-  DEFSREGISTRY.hpp  -  implementation of the default object store
+  DEFS-REGISTRY.hpp  -  implementation of the default object store
 
   Copyright (C)         Lumiera.org
     2008,               Hermann Vosseler <Ichthyostega@web.de>
@@ -21,23 +21,23 @@
 */
 
 
-/** @file defsregistry.hpp
+/** @file defs-registry.hpp
  ** A piece of implementation code factored out into a separate header (include).
- ** Only used in defsmanager.cpp and for the unit tests. We can't place it into
- ** a separate compilation unit, because defsmanager.cpp defines some explicit
+ ** Only used in defs-manager.cpp and for the unit tests. We can't place it into
+ ** a separate compilation unit, because defs-manager.cpp defines some explicit
  ** template instantiation, which cause the different Slots of the DefsrRegistry#table_
  ** to be filled with data and defaults for the specific Types.
  ** 
  ** @see mobject::session::DefsManager
- ** @see defsregistryimpltest.cpp
+ ** @see DefsRegistryImpl_test
  **
  */
 
 
 
 
-#ifndef MOBJECT_SESSION_DEFSREGISTRY_H
-#define MOBJECT_SESSION_DEFSREGISTRY_H
+#ifndef MOBJECT_SESSION_DEFS_REGISTRY_H
+#define MOBJECT_SESSION_DEFS_REGISTRY_H
 
 
 #include "lib/sync-classlock.hpp"
@@ -55,131 +55,131 @@
 
 
 namespace mobject {
-  namespace session {
+namespace session {
+  
+  using lumiera::P;
+  using lumiera::Query;
+  using lib::ClassLock;
+  using std::tr1::weak_ptr;
+  
+  using std::string;
+  using boost::format;
+  using boost::lambda::_1;
+  using boost::lambda::var;  
+  
+  namespace impl {
     
-    using lumiera::P;
-    using lumiera::Query;
-    using lib::ClassLock;
-    using std::tr1::weak_ptr;
+    namespace {
+      uint maxSlots (0); ///< number of different registered Types
+      format dumpRecord ("%2i| %64s --> %s\n");
+    }
     
-    using std::string;
-    using boost::format;
-    using boost::lambda::_1;
-    using boost::lambda::var;  
     
-    namespace impl {
-      
-      namespace {
-        uint maxSlots (0); ///< number of different registered Types
-        format dumpRecord ("%2i| %64s --> %s\n");
-      }
-      
-      
-      struct TableEntry 
-        {
-          virtual ~TableEntry() {};
-        };
-      
-      /** we maintain an independent defaults registry
-       *  for every participating kind of object. */
-      typedef std::vector< P<TableEntry> > Table;
-      
-      
-      /** 
-       * holding a single "default object" entry 
-       */
-      template<class TAR>
-      struct Record
-        {
-          uint degree;
-          Query<TAR> query;
-          weak_ptr<TAR> objRef;
-          
-          Record (const Query<TAR>& q, const P<TAR>& obj)
-            : degree (lumiera::query::countPred (q)),
-              query (q),
-              objRef (obj)
-            { }
-          
-          
-          struct Search  ///< Functor searching for a specific object
-            {
-              Search (const P<TAR>& obj)
-                : obj_(obj) { }
-              
-              const P<TAR>& obj_;
-              
-              bool 
-              operator() (const Record& rec)
-              {
-                P<TAR> storedObj (rec.objRef.lock());
-                return storedObj && (storedObj == obj_);
-              }
-            };
-          
-          struct OrderRelation
-            {
-              inline bool
-              operator() (Record one, Record two) ///< @note doesn't touch the objRef
-                {
-                  return (  one.degree < two.degree
-                         ||(one.degree == two.degree && one.query < two.query)
-                         );
-                }
-            };
+    struct TableEntry 
+      {
+        virtual ~TableEntry() {};
+      };
+    
+    /** we maintain an independent defaults registry
+     *  for every participating kind of object. */
+    typedef std::vector< P<TableEntry> > Table;
+    
+    
+    /**
+     * holding a single "default object" entry 
+     */
+    template<class TAR>
+    struct Record
+      {
+        uint degree;
+        Query<TAR> query;
+        weak_ptr<TAR> objRef;
+        
+        Record (const Query<TAR>& q, const P<TAR>& obj)
+          : degree (lumiera::query::countPred (q)),
+            query (q),
+            objRef (obj)
+          { }
+        
+        
+        struct Search  ///< Functor searching for a specific object
+          {
+            Search (const P<TAR>& obj)
+              : obj_(obj) { }
             
-          operator string ()  const { return str (dumpRecord % degree % query % dumpObj()); }
-          string  dumpObj ()  const { P<TAR> o (objRef.lock()); return o? string(*o):"dead"; }
-        };
-        
-      /** every new kind of object (Type) creates a new
-       *  slot in the main Table holding all registered 
-       *  default objects. Each slot actually holds a
-       *  separate tree (set) of registry entries
-       */
-      template<class TAR>
-      struct Slot : public TableEntry
-        {
-          typedef typename Record<TAR>::OrderRelation Ordering;
-          typedef std::set<Record<TAR>, Ordering> Registry;
-          
-          Registry registry;
-          static size_t index; ///< where to find this Slot in every Table
-          
-          static Registry&
-          access (Table& table)
+            const P<TAR>& obj_;
+            
+            bool 
+            operator() (const Record& rec)
             {
-              if ( !index 
-                 || index > table.size() 
-                 ||!table[index-1])
-                createSlot (table);
-              
-              ASSERT (0 < index && index<=table.size() && table[index-1]);
-              Slot* item = static_cast<Slot*> (table[index-1].get());
-              return item->registry;
+              P<TAR> storedObj (rec.objRef.lock());
+              return storedObj && (storedObj == obj_);
             }
-          
-        private:
-          static void
-          createSlot (Table& table)
-            {
-              ClassLock<TableEntry> guard();
-              if (!index)
-                index = ++maxSlots;
-              if (index > table.size())
-                table.resize (index);
-              table[index-1].reset(new Slot);   
-            }
-        };
+          };
         
+        struct OrderRelation
+          {
+            inline bool
+            operator() (Record one, Record two) ///< @note doesn't touch the objRef
+              {
+                return (  one.degree < two.degree
+                       ||(one.degree == two.degree && one.query < two.query)
+                       );
+              }
+          };
         
-      // static vars to organise one Table Slot per type....
-      template<class TAR>
-      size_t Slot<TAR>::index (0);
-      
-      
+        operator string ()  const { return str (dumpRecord % degree % query % dumpObj()); }
+        string  dumpObj ()  const { P<TAR> o (objRef.lock()); return o? string(*o):"dead"; }
+      };
+      
+    /** every new kind of object (Type) creates a new
+     *  slot in the main Table holding all registered 
+     *  default objects. Each slot actually holds a
+     *  separate tree (set) of registry entries
+     */
+    template<class TAR>
+    struct Slot : public TableEntry
+      {
+        typedef typename Record<TAR>::OrderRelation Ordering;
+        typedef std::set<Record<TAR>, Ordering> Registry;
+        
+        Registry registry;
+        static size_t index; ///< where to find this Slot in every Table
+        
+        static Registry&
+        access (Table& table)
+          {
+            if ( !index 
+               || index > table.size() 
+               ||!table[index-1])
+              createSlot (table);
+            
+            ASSERT (0 < index && index<=table.size() && table[index-1]);
+            Slot* item = static_cast<Slot*> (table[index-1].get());
+            return item->registry;
+          }
+        
+      private:
+        static void
+        createSlot (Table& table)
+          {
+            ClassLock<TableEntry> guard();
+            if (!index)
+              index = ++maxSlots;
+            if (index > table.size())
+              table.resize (index);
+            table[index-1].reset(new Slot);   
+          }
+      };
       
       
+    // static vars to organise one Table Slot per type....
+    template<class TAR>
+    size_t Slot<TAR>::index (0);
+    
+    
+    
+    
     /**
      * @internal Helper for organising preconfigured default objects.
      * Maintains a collection of objects known or encountered as "default"
@@ -235,8 +235,8 @@ namespace mobject {
           public:
             P<TAR> operator* ()    { return ptr; }
             bool  hasNext ()       { return next || findNext(); }
-            Iter  operator++ (int) { Iter tmp=*this; operator++(); return tmp; }            
-            Iter& operator++ ()           
+            Iter  operator++ (int) { Iter tmp=*this; operator++(); return tmp; }
+            Iter& operator++ ()
               { 
                 ptr=findNext();
                 next.reset();
@@ -332,16 +332,13 @@ namespace mobject {
             return res;
           }
       };
-      
-      
-      
-    } // (End) impl namespace
-    
-    using impl::DefsRegistry;
     
     
-  } // namespace mobject::session
-
-} // namespace mobject
-
+    
+  } // (End) impl namespace
+  
+  using impl::DefsRegistry;
+  
+  
+}} // namespace mobject::session
 #endif
diff --git a/src/proc/mobject/session/defsmanager.hpp b/src/proc/mobject/session/defsmanager.hpp
deleted file mode 100644
index 7d904b6b8..000000000
--- a/src/proc/mobject/session/defsmanager.hpp
+++ /dev/null
@@ -1,130 +0,0 @@
-/*
-  DEFSMANAGER.hpp  -  access to preconfigured default objects and definitions
-
-  Copyright (C)         Lumiera.org
-    2008,               Hermann Vosseler <Ichthyostega@web.de>
-
-  This program is free software; you can redistribute it and/or
-  modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of
-  the License, or (at your option) any later version.
-
-  This program is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with this program; if not, write to the Free Software
-  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
-*/
-
-
-#ifndef MOBJECT_SESSION_DEFSMANAGER_H
-#define MOBJECT_SESSION_DEFSMANAGER_H
-
-
-#include "lib/p.hpp"
-#include "lib/query.hpp"
-
-#include <boost/scoped_ptr.hpp>
-#include <boost/noncopyable.hpp>
-
-
-
-namespace mobject {
-  namespace session {
-    
-    
-    using lumiera::P;
-    using boost::scoped_ptr;
-    
-    namespace impl { class DefsRegistry; }
-
-
-    /**
-     * Organise a collection of preconfigured default objects.
-     * For various kinds of objects we can tweak the default parametrisation
-     * as part of the general session configuration. A ref to an instance of
-     * this class is accessible through the current session and can be used
-     * to fill in parts of the configuration of new objects, if the user 
-     * code didn't give more specific parameters. Necessary sub-objects 
-     * will be created on demand, and any default configuration, once
-     * found, will be remembered and stored with the current session.
-     * 
-     * @note while the logic of defaults handling can be considered
-     *       roughly final, as of 12/09 most of the actual object
-     *       handling is placeholder code.
-     */
-    class DefsManager : private boost::noncopyable
-      {
-        scoped_ptr<impl::DefsRegistry> defsRegistry;
-        
-      public:
-        
-        DefsManager ()  throw();
-       ~DefsManager ();
-       
-        /** common access point: retrieve the default object fulfilling
-         *  some given conditions. May silently trigger object creation.
-         *  @throw error::Config in case no solution is possible, which
-         *         is considered \e misconfiguration. 
-         */
-        template<class TAR>
-        P<TAR> operator() (lumiera::Query<TAR> const&);
-        
-        
-        /** search through the registered defaults, never create anything.
-         *  @return object fulfilling the query, \c empty ptr if not found. 
-         */
-        template<class TAR>
-        P<TAR> search  (lumiera::Query<TAR> const&);
-        
-        /** retrieve an object fulfilling the query and register it as default.
-         *  The resolution is delegated to the ConfigQuery system (which may cause
-         *  creation of new object instances) 
-         *  @return object fulfilling the query, \c empty ptr if no solution.
-         */ 
-        template<class TAR>
-        P<TAR> create  (lumiera::Query<TAR> const&);
-        
-        /** register the given object as default, after ensuring it fulfils the
-         *  query. The latter may cause some properties of the object to be set,
-         *  trigger creation of additional objects, and may fail altogether.
-         *  @return true if query was successful and object is registered as default
-         *  @note only a weak ref to the object is stored
-         */ 
-        template<class TAR>
-        bool define  (P<TAR> const&, lumiera::Query<TAR> const&  =lumiera::Query<TAR>());
-        
-        /** remove the defaults registration of the given object, if there was such
-         *  @return false if nothing has been changed because the object wasn't registered
-         */
-        template<class TAR>
-        bool forget  (P<TAR> const&);
-        
-        
-// Q: can we have something along the line of...?
-//
-//        template
-//          < class TAR,                   ///< the target to query for 
-//            template <class> class SMP  ///<  smart pointer class to wrap the result
-//          >
-//        SMP<TAR> operator() (const lumiera::Query<TAR>&);
-
-// 12/09: according to my current knowledge of template metaprogramming, the answer is "no",
-//        but we could use a traits template to set up a fixed association of smart pointers
-//        and kinds of target object. This would allow to define a templated operator() returning
-//        the result wrapped into the right holder. But currently I don't see how to build a sensible
-//        implementation infrastructure backing such an interface.
-//////////TICKET #452
-        
-      };
-
-      
-
-  } // namespace mobject::session
-
-} // namespace mobject
-#endif
diff --git a/src/proc/mobject/session/root.cpp b/src/proc/mobject/session/root.cpp
index d3133c2da..5b6aa6290 100644
--- a/src/proc/mobject/session/root.cpp
+++ b/src/proc/mobject/session/root.cpp
@@ -22,7 +22,7 @@
 
 
 #include "proc/mobject/session/root.hpp"
-#include "proc/mobject/session/defsmanager.hpp"
+#include "proc/mobject/session/defs-manager.hpp"
 
 
 namespace mobject {
diff --git a/src/proc/mobject/session/sess-manager-impl.cpp b/src/proc/mobject/session/sess-manager-impl.cpp
index 0c9d1b5bc..d0e4c4cc4 100644
--- a/src/proc/mobject/session/sess-manager-impl.cpp
+++ b/src/proc/mobject/session/sess-manager-impl.cpp
@@ -40,7 +40,7 @@
 
 #include "proc/mobject/session.hpp"
 #include "proc/mobject/session/sess-manager-impl.hpp"
-#include "proc/mobject/session/defsmanager.hpp"
+#include "proc/mobject/session/defs-manager.hpp"
 #include "proc/mobject/session/lifecycle-advisor.hpp"
 #include "proc/asset/timeline.hpp"
 #include "lib/error.hpp"
diff --git a/src/proc/mobject/session/session-interface-modules.hpp b/src/proc/mobject/session/session-interface-modules.hpp
index 9e03cad4c..daa05b18f 100644
--- a/src/proc/mobject/session/session-interface-modules.hpp
+++ b/src/proc/mobject/session/session-interface-modules.hpp
@@ -73,7 +73,7 @@
 #include "lib/element-tracker.hpp"
 #include "proc/asset/timeline.hpp"
 #include "proc/asset/sequence.hpp"
-#include "proc/mobject/session/defsmanager.hpp"
+#include "proc/mobject/session/defs-manager.hpp"
 #include "proc/mobject/session/element-query.hpp"
 
 
diff --git a/src/proc/mobject/session/session.cpp b/src/proc/mobject/session/session.cpp
index a1ff4c737..891ba1349 100644
--- a/src/proc/mobject/session/session.cpp
+++ b/src/proc/mobject/session/session.cpp
@@ -32,7 +32,7 @@
 
 
 #include "proc/mobject/session.hpp"
-#include "proc/mobject/session/defsmanager.hpp"
+#include "proc/mobject/session/defs-manager.hpp"
 #include "proc/mobject/session/session-impl.hpp"
 #include "proc/mobject/session/sess-manager-impl.hpp"
 
diff --git a/tests/components/Makefile.am b/tests/components/Makefile.am
index 84a87d88a..2de68311a 100644
--- a/tests/components/Makefile.am
+++ b/tests/components/Makefile.am
@@ -85,9 +85,9 @@ test_components_SOURCES =								\
 	$(testcomponents_srcdir)/proc/mobject/placement-object-identity-test.cpp	\
 	$(testcomponents_srcdir)/proc/mobject/placement-ref-test.cpp			\
 	$(testcomponents_srcdir)/proc/mobject/session/addcliptest.cpp			\
-	$(testcomponents_srcdir)/proc/mobject/session/defsmanagerimpltest.cpp		\
-	$(testcomponents_srcdir)/proc/mobject/session/defsmanagertest.cpp		\
-	$(testcomponents_srcdir)/proc/mobject/session/defsregistryimpltest.cpp		\
+	$(testcomponents_srcdir)/proc/mobject/session/defs-manager-impl-test.cpp	\
+	$(testcomponents_srcdir)/proc/mobject/session/defs-manager-test.cpp		\
+	$(testcomponents_srcdir)/proc/mobject/session/defs-registry-impl-test.cpp	\
 	$(testcomponents_srcdir)/proc/mobject/session/deletecliptest.cpp		\
 	$(testcomponents_srcdir)/proc/mobject/session/placement-index-query-test.cpp	\
 	$(testcomponents_srcdir)/proc/mobject/session/placement-index-test.cpp		\
diff --git a/tests/components/proc/control/command-use1-test.cpp b/tests/components/proc/control/command-use1-test.cpp
index aae370d4f..949fcfffd 100644
--- a/tests/components/proc/control/command-use1-test.cpp
+++ b/tests/components/proc/control/command-use1-test.cpp
@@ -127,7 +127,7 @@ namespace test    {
           CHECK ( 0 == command1::check_);
           
           VERIFY_ERROR (INVALID_ARGUMENTS, com.bind ("foo") );
-          com.bind (random());             // note: run-time type check only
+          com.bind (random());              // note: run-time type check only
           CHECK ( com.canExec());
           CHECK (!com.canUndo());
           com();
@@ -159,7 +159,7 @@ namespace test    {
           
           def.operation (command1::operate)
              .captureUndo (command1::capture);
-          CHECK (!def);                       // undo functor still missing
+          CHECK (!def);                        // undo functor still missing
           VERIFY_ERROR (INVALID_COMMAND, Command::get("test.command1.2") );
           
           def.operation (command1::operate)
diff --git a/tests/components/proc/engine/node-basic-test.cpp b/tests/components/proc/engine/node-basic-test.cpp
index 7cd47d650..8e973cc1a 100644
--- a/tests/components/proc/engine/node-basic-test.cpp
+++ b/tests/components/proc/engine/node-basic-test.cpp
@@ -28,7 +28,7 @@
 #include "proc/engine/stateproxy.hpp"
 #include "proc/engine/buffhandle.hpp"
 #include "proc/mobject/session/effect.hpp"
-#include "lib/allocationcluster.hpp"
+#include "lib/allocation-cluster.hpp"
 
 //#include <boost/format.hpp>
 //#include <iostream>
diff --git a/tests/components/proc/mobject/placement-basic-test.cpp b/tests/components/proc/mobject/placement-basic-test.cpp
index 44a79b6e8..150907b62 100644
--- a/tests/components/proc/mobject/placement-basic-test.cpp
+++ b/tests/components/proc/mobject/placement-basic-test.cpp
@@ -30,10 +30,8 @@
 #include "lib/util.hpp"
 #include "proc/mobject/session/mobjectfactory.hpp"   ////TODO: avoidable?
 
-//#include <boost/format.hpp>
 #include <iostream>
 
-//using boost::format;
 using lumiera::Time;
 using util::contains;
 using std::string;
@@ -41,61 +39,57 @@ using std::cout;
 
 
 namespace mobject {
-  namespace session {
-    namespace test  {
-
-      using asset::VIDEO;
-
-
-
-      /*******************************************************************
-       * @test basic behaviour of Placements and access to MObjects.
-       * @see  mobject::Placement
-       * @see  mobject::MObject#create
-       * @see  mobject::Placement#addPlacement
-       * @see  mobject::Placement#resolve
-       */
-      class PlacementBasic_test : public Test
+namespace session {
+namespace test    {
+  
+  using asset::VIDEO;
+  
+  
+  
+  /*******************************************************************
+   * @test basic behaviour of Placements and access to MObjects.
+   * @see  mobject::Placement
+   * @see  mobject::MObject#create
+   * @see  mobject::Placement#addPlacement
+   * @see  mobject::Placement#resolve
+   */
+  class PlacementBasic_test : public Test
+    {
+      typedef shared_ptr<asset::Media> PM;
+      typedef shared_ptr<asset::Clip> PCA;
+      
+      virtual void
+      run (Arg)
         {
-          typedef shared_ptr<asset::Media> PM;
-          typedef shared_ptr<asset::Clip> PCA;
-
-          virtual void
-          run (Arg)
-            {
-              // create Clip-MObject, which is wrapped into a placement (smart ptr)
-              PM media = asset::Media::create("test-1", VIDEO);
-              PCA clipAsset = Media::create(*media);
-              Placement<Clip> pc = MObject::create (*clipAsset, *media);
-
-              // use of the Clip-MObject interface by dereferencing the placement
-              PM clip_media = pc->getMedia();
-              CHECK (clip_media->ident.category.hasKind (VIDEO));
-
-              // using the Placement interface
-              // TODO: how to handle insufficiently determinated Placement? Throw?
-              FixedLocation & fixloc = pc.chain(Time(1)); // TODO: the track??
-              ExplicitPlacement expla = pc.resolve();
-              CHECK (expla.time == Time(1));
-              CHECK (!expla.chain.isOverdetermined());
+          // create Clip-MObject, which is wrapped into a placement (smart ptr)
+          PM media = asset::Media::create("test-1", VIDEO);
+          PCA clipAsset = Media::create(*media);
+          Placement<Clip> pc = MObject::create (*clipAsset, *media);
+          
+          // use of the Clip-MObject interface by dereferencing the placement
+          PM clip_media = pc->getMedia();
+          CHECK (clip_media->ident.category.hasKind (VIDEO));
+          
+          // using the Placement interface
+          // TODO: how to handle insufficiently determinated Placement? Throw?
+          FixedLocation & fixloc = pc.chain(Time(1)); // TODO: the track??
+          ExplicitPlacement expla = pc.resolve();
+          CHECK (expla.time == Time(1));
+          CHECK (!expla.chain.isOverdetermined());
 //            CHECK (*expla == *pc);  ////////////////////////////////////////////TICKET #511 define equivalence of locating chains and solutions
-
-              // now overconstraining with another Placement
-              pc.chain(Time(2));
-              ExplicitPlacement expla2 = pc.resolve();
-              CHECK (expla2.time == Time(2)); // the latest addition wins
-              CHECK (expla2.chain.isOverdetermined());
-            }
-        };
-
-
-      /** Register this test class... */
-      LAUNCHER (PlacementBasic_test, "unit session");
-
-
-
-    } // namespace test
-
-  } // namespace session
-
-} // namespace mobject
+          
+          // now overconstraining with another Placement
+          pc.chain(Time(2));
+          ExplicitPlacement expla2 = pc.resolve();
+          CHECK (expla2.time == Time(2)); // the latest addition wins
+          CHECK (expla2.chain.isOverdetermined());
+        }
+    };
+  
+  
+  /** Register this test class... */
+  LAUNCHER (PlacementBasic_test, "unit session");
+  
+  
+  
+}}} // namespace mobject::session::test
diff --git a/tests/components/proc/mobject/session/defs-manager-impl-test.cpp b/tests/components/proc/mobject/session/defs-manager-impl-test.cpp
new file mode 100644
index 000000000..f3cc8d5e0
--- /dev/null
+++ b/tests/components/proc/mobject/session/defs-manager-impl-test.cpp
@@ -0,0 +1,176 @@
+/*
+  DefsManagerImpl(Test)  -  checking implementation details of the defaults manager
+
+  Copyright (C)         Lumiera.org
+    2008,               Hermann Vosseler <Ichthyostega@web.de>
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License as
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+* *****************************************************/
+
+
+#include "pre_a.hpp"
+
+#include "lib/test/run.hpp"
+#include "lib/util.hpp"
+
+#include "proc/asset.hpp"
+#include "proc/asset/pipe.hpp"
+#include "proc/asset/struct.hpp"
+#include "common/configrules.hpp"
+#include "proc/assetmanager.hpp"
+#include "proc/mobject/session.hpp"
+#include "lib/streamtype.hpp"
+
+#include <boost/format.hpp>
+
+using boost::format;
+using util::isnil;
+using std::string;
+
+
+namespace mobject {
+namespace session {
+namespace test    {
+  
+  using lib::Symbol;
+  using asset::Asset;
+  using asset::AssetManager;
+  using asset::Pipe;
+  using asset::PPipe;
+  using asset::Struct;
+  using lumiera::Query;
+  using lumiera::query::normaliseID;
+  
+  using lumiera::ConfigRules;
+  using lumiera::query::QueryHandler;
+  using lumiera::StreamType;
+  
+  
+  
+  /** shortcut: query for given Pipe-ID */
+  bool
+  find (const string& pID)
+  {
+    return Session::current->defaults.search (Query<Pipe> ("pipe("+pID+")"));
+  }
+  
+  
+  format pattern ("dummy_%s_%i");
+  
+  /** create a random new ID */
+  string
+  newID (Symbol prefix)
+  {
+    return str (pattern % prefix % std::rand());
+  }
+  
+  
+  
+  
+  /************************************************************************
+   * @test verify some general assumptions regarding implementation details
+   *       of the the defaults manager.
+   * @see  DefsManager_test for the "big picture"
+   */
+  class DefsManagerImpl_test : public Test
+    {
+      virtual void
+      run(Arg)
+        {
+          define_and_search();
+          string pipeID = create();
+          forget(pipeID);
+        }
+      
+      
+      
+      
+      void
+      define_and_search ()
+        {
+          string sID = newID ("stream");
+          StreamType::ID stID (sID);
+          
+           // create Pipes explicitly 
+          //  (without utilising default queries)
+          PPipe pipe1 = Struct::retrieve.newPipe (newID("pipe"), newID("stream"));
+          PPipe pipe2 = Struct::retrieve.newPipe (newID("pipe"), sID            );
+          
+          CHECK (pipe1 != pipe2);
+          CHECK (stID == pipe2->getStreamID());
+          
+          CHECK (!find (pipe1->getPipeID()), "accidental clash of random test-IDs");
+          CHECK (!find (pipe2->getPipeID()), "accidental clash of random test-IDs");
+          
+          // now declare that these objects should be considered "default"
+lumiera::query::setFakeBypass("");  /////////////////////////////////////////////////TODO mock resolution
+          CHECK (Session::current->defaults.define (pipe1, Query<Pipe> ("")));   // unrestricted default
+          
+lumiera::query::setFakeBypass("stream("+sID+")"); ///////////////////////////////////TODO mock resolution
+          CHECK (Session::current->defaults.define (pipe2, Query<Pipe> ("stream("+sID+")")));
+          
+          CHECK ( find (pipe1->getPipeID()), "failure declaring object as default");
+          CHECK ( find (pipe2->getPipeID()), "failure declaring object as default");
+          
+          CHECK (stID != pipe1->getStreamID(), "accidental clash");
+          CHECK (!Session::current->defaults.define (pipe1, Query<Pipe> ("stream("+sID+")")));
+                  // can't be registered with this query, due to failure caused by wrong stream-ID
+        }
+      
+      
+      const string&
+      create()
+        {
+          string sID = newID ("stream");
+          Query<Pipe> query_for_streamID ("stream("+sID+")");
+          
+          // issue a ConfigQuery directly, without involving the DefaultsManager
+          QueryHandler<Pipe>& typeHandler = ConfigRules::instance();
+          PPipe pipe1;
+          typeHandler.resolve (pipe1, query_for_streamID);
+          CHECK (pipe1);
+          
+          CHECK (!find (pipe1->getPipeID()));
+          PPipe pipe2 = Session::current->defaults.create (query_for_streamID);
+          CHECK (pipe2);
+          CHECK (pipe2 == pipe1);
+          CHECK ( find (pipe1->getPipeID())); // now declared as "default Pipe" for this stream-ID
+          
+          return pipe1->getPipeID();
+        }
+      
+      
+      void
+      forget (string pID)
+        {
+          PPipe pipe = Pipe::query ("pipe("+pID+")");
+          REQUIRE (find (pipe->getPipeID()), "need an object registered as default");
+          long cnt = pipe.use_count();
+          
+          // now de-register the pipe as "default Pipe"
+          CHECK (Session::current->defaults.forget (pipe));
+          CHECK (!find (pipe->getPipeID()));
+          CHECK (cnt == pipe.use_count());   // indicates DefaultsManager holding only a weak ref.
+        }
+    };
+  
+  
+  /** Register this test class... */
+  LAUNCHER (DefsManagerImpl_test, "function session");
+  
+  
+  
+}}} // namespace mobject::session::test
diff --git a/tests/components/proc/mobject/session/defs-manager-test.cpp b/tests/components/proc/mobject/session/defs-manager-test.cpp
new file mode 100644
index 000000000..3f9ae390e
--- /dev/null
+++ b/tests/components/proc/mobject/session/defs-manager-test.cpp
@@ -0,0 +1,204 @@
+/*
+  DefsManager(Test)  -  checking basic behaviour of the defaults manager
+
+  Copyright (C)         Lumiera.org
+    2008,               Hermann Vosseler <Ichthyostega@web.de>
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License as
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+* *****************************************************/
+
+
+#include "pre_a.hpp"
+
+#include "lib/test/run.hpp"
+#include "lib/symbol.hpp"
+#include "lib/query.hpp"
+#include "lib/util.hpp"
+
+#include "proc/asset.hpp"
+#include "proc/asset/pipe.hpp"
+#include "proc/asset/struct.hpp"
+#include "proc/assetmanager.hpp"
+#include "proc/mobject/session.hpp"
+#include "lib/streamtype.hpp"
+
+#include <boost/format.hpp>
+
+using boost::format;
+using util::isnil;
+using std::string;
+
+
+
+namespace mobject {
+namespace session {
+namespace test    {
+  
+  using util::cStr;
+  using lib::Symbol;
+  using asset::ID;
+  using asset::Asset;
+  using asset::AssetManager;
+  using asset::Pipe;
+  using asset::PPipe;
+  using asset::Struct;
+  using lumiera::Query;
+  using lumiera::query::normaliseID;
+  using lumiera::StreamType;
+  
+  
+  /** shortcut: run just a query
+   *  without creating new instances
+   */
+  bool
+  find (Query<Pipe>& q)
+  {
+    return Session::current->defaults.search (q);
+  }
+  
+  
+  
+  
+  /***********************************************************************
+   * @test basic behaviour of the defaults manager ("the big picture")
+   *       - retrieving a "default" object repeatedly
+   *       - retrieving a more constrained "default" object
+   *       - failure registers a new "default"
+   *       - instance management
+   * 
+   * Using pipe assets as an example. The defaults manager shouldn't
+   * interfere with memory management (it holds weak refs).
+   */
+  class DefsManager_test : public Test
+    {
+      virtual void
+      run (Arg arg)
+        {
+          string pipeID   = isnil(arg)?  "Black Hole" : arg[1];
+          string streamID = 2>arg.size()? "teststream" : arg[2];
+          
+          normaliseID (pipeID);
+          normaliseID (streamID);
+          
+          retrieveSimpleDefault (pipeID);
+          retrieveConstrainedDefault (pipeID, streamID);
+          failureCreatesNewDefault();
+          verifyRemoval();
+        }
+      
+      
+      
+      
+      void
+      retrieveSimpleDefault (string)
+        {
+          PPipe pipe1 = Pipe::query (""); // "the default pipe"
+          PPipe pipe2;
+          
+          // several variants to query for "the default pipe"
+          pipe2 = Pipe::query ("");
+          CHECK (pipe2 == pipe1);
+          pipe2 = Pipe::query ("default(X)");
+          CHECK (pipe2 == pipe1);
+          pipe2 = Session::current->defaults(Query<Pipe> ());
+          CHECK (pipe2 == pipe1);
+          pipe2 = asset::Struct::retrieve (Query<Pipe> ());
+          CHECK (pipe2 == pipe1);
+          pipe2 = asset::Struct::retrieve (Query<Pipe> ("default(P)"));
+          CHECK (pipe2 == pipe1);
+        }
+      
+      
+      void
+      retrieveConstrainedDefault (string pID, string sID)
+        {
+          PPipe pipe1 = Pipe::query (""); // "the default pipe"
+          CHECK ( pipe1->getStreamID() != StreamType::ID(sID),
+                  "stream-ID \"%s\" not suitable for test, because "
+                  "the default-pipe \"%s\" happens to have the same "
+                  "stream-ID. We need it to be different",
+                  sID.c_str(), pID.c_str()
+                 );
+          
+          string query_for_sID ("stream("+sID+")");
+          PPipe pipe2 = Pipe::query (query_for_sID);
+          CHECK (pipe2->getStreamID() == StreamType::ID(sID));
+          CHECK (pipe2 != pipe1);
+          CHECK (pipe2 == Pipe::query (query_for_sID));   // reproducible
+        }
+      
+      
+      void
+      failureCreatesNewDefault()
+        {
+          PPipe pipe1 = Session::current->defaults(Query<Pipe> ());   // "the default pipe"
+          
+          string new_pID (str (format ("dummy_%s_%i")
+                               % pipe1->getPipeID()
+                               % std::rand()
+                              ));     // make random new pipeID
+          Query<Pipe> query_for_new ("pipe("+new_pID+")");
+          
+          CHECK (!find (query_for_new));                              // check it doesn't exist
+          PPipe pipe2 = Session::current->defaults (query_for_new);   // triggers creation
+          CHECK ( find (query_for_new));                              // check it exists now
+          
+          CHECK (pipe1 != pipe2);
+          CHECK (pipe2 == Session::current->defaults (query_for_new));
+        }
+      
+      
+      /** verify the defaults manager holds only weak refs,
+       *  so if an object goes out of scope, any defaults entries
+       *  are purged silently
+       */
+      void
+      verifyRemoval()
+        {
+          Symbol pID ("some_pipe");
+          Query<Pipe> query_for_pID ("pipe("+pID+")");
+          size_t hash;
+            {
+              // create new pipe and declare it to be a default
+              PPipe pipe1 = Struct::retrieve.newInstance<Pipe> (pID);
+              Session::current->defaults.define(pipe1);
+              
+              CHECK (2 == pipe1.use_count());                         // the pipe1 smart-ptr and the AssetManager
+              hash = pipe1->getID();
+            }
+            // pipe1 out of scope....
+           //  AssetManager now should hold the only ref
+          ID<Asset> assetID (hash);
+          
+          AssetManager& aMang (AssetManager::instance());
+          CHECK ( aMang.known (assetID));
+          aMang.remove (assetID);
+          CHECK (!aMang.known (assetID));
+          
+          
+          CHECK (!find(query_for_pID));                               // bare default-query should fail...
+          PPipe pipe2 = Session::current->defaults (query_for_pID);   // triggers re-creation
+          CHECK ( find(query_for_pID));                               // should succeed again
+        }
+    };
+  
+  
+  
+  /** Register this test class... */
+  LAUNCHER (DefsManager_test, "function session");
+  
+  
+}}} // namespace mobject::session::test
diff --git a/tests/components/proc/mobject/session/defs-registry-impl-test.cpp b/tests/components/proc/mobject/session/defs-registry-impl-test.cpp
new file mode 100644
index 000000000..8025bfbf0
--- /dev/null
+++ b/tests/components/proc/mobject/session/defs-registry-impl-test.cpp
@@ -0,0 +1,292 @@
+/*
+  DefsRegistryImpl(Test)  -  verifying correct behaviour of the defaults registry
+
+  Copyright (C)         Lumiera.org
+    2008,               Hermann Vosseler <Ichthyostega@web.de>
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License as
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+* *****************************************************/
+
+
+#include "lib/test/run.hpp"
+#include "lib/util.hpp"
+
+#include "proc/mobject/session/defs-registry.hpp"
+#include "lib/factory.hpp"
+#include "lib/query.hpp"
+#include "lib/p.hpp"
+
+#include "../lib/query/querydiagnostics.hpp"
+
+#include <boost/scoped_ptr.hpp>
+#include <boost/format.hpp>
+#include <map>
+
+using lumiera::P;
+using lumiera::Query;
+using lumiera::query::test::garbage_query;
+using util::isnil;
+
+using boost::scoped_ptr;
+using boost::format;
+using std::string;
+using std::rand;
+using std::map;
+
+
+
+namespace mobject {
+namespace session {
+namespace test    {
+  
+  format typePatt ("Dummy<%2i>");
+  format instancePatt ("obj_%s_%i");
+  format predicatePatt ("%s_%2i( %s )");
+  
+  
+  
+  /** create a random new ID */
+  string
+  newID (string prefix)
+  {
+    return str (instancePatt % prefix % rand());
+  }
+  
+  
+  /** template for generating some different test types */
+  template<int I>
+  struct Dummy
+    {
+      static string name;
+      string instanceID;
+      operator string ()                  const { return instanceID; }
+      bool operator== (const Dummy& odu)  const { return this == &odu; }
+      
+      
+      Dummy () : instanceID (newID (name)) {}
+    };
+  
+  template<int I>
+  string Dummy<I>::name = str (typePatt % I);
+  
+  
+  
+  
+  
+  
+  /************************************************************************
+   * @test build an registry table (just for this test) configured for
+   *       some artificial test Types. Register some entries and verify
+   *       the intended behaviour of the storage structure.
+   * @see  DefsManagerImpl_test for checking the implementation details
+   *       in the actual context used in Lumiera.
+   */
+  class DefsRegistryImpl_test : public Test
+    {
+      scoped_ptr<DefsRegistry> reg_;
+      
+      typedef lumiera::P<Dummy<13> > O;
+      typedef lumiera::P<Dummy<23> > P;
+      
+      typedef Query<Dummy<13> > Q13;
+      typedef Query<Dummy<23> > Q23;
+      
+      typedef DefsRegistry::Iter<Dummy<13> > Iter13;
+      typedef DefsRegistry::Iter<Dummy<23> > Iter23;
+      
+      
+      // fabricating Objects wrapped into smart-ptrs
+      lib::factory::RefcountFac<Dummy<13> > oFac;
+      lib::factory::RefcountFac<Dummy<23> > pFac;
+      
+      O o1, o2, o3;
+      Q13 q1, q2, q3, q4, q5;
+      map<Q23, P> ps;
+      
+    public:
+      DefsRegistryImpl_test ()
+        : o1 (oFac()), o2 (oFac()), o3 (oFac()),
+          q1 (garbage_query (1)),
+          q2 (garbage_query (2)),
+          q3 (garbage_query (3)),
+          q4 (garbage_query (4)),
+          q5 (garbage_query (5))
+        { }
+      
+      
+      virtual void
+      run (Arg)
+        {
+          this->reg_.reset (new DefsRegistry);
+          
+          fill_table ();
+          check_query ();
+          check_remove ();
+        }
+      
+      
+      
+      
+      void
+      fill_table ()
+        {
+           // at start the registry is indeed empty
+          //  thus a query doesn't yield any results....
+          CHECK ( ! *(reg_->candidates(Q13 ("something"))) );
+          
+          reg_->put (o1, q5);
+          reg_->put (o2, q4);
+          reg_->put (o3, q3);
+          reg_->put (o3, q2);
+          reg_->put (o2, q1);
+          reg_->put (o1, Q13()); // the empty query
+          
+          ps.clear();
+          for (int i=0; i<100; ++i)
+            {
+              P px (pFac());
+              Q23 qx (garbage_query());
+              ps[qx] = px;
+              reg_->put (px, qx);
+              px->instanceID = qx;
+            }
+        }
+      
+      
+      void
+      check_query ()
+        {
+          Iter13 i (reg_->candidates(Q13 ("irrelevant query")));
+          CHECK ( i.hasNext());
+          CHECK ( *i++ == o1);   // ordered according to the degree of the queries
+          CHECK ( *i++ == o2);
+          CHECK ( *i++ == o3);
+          CHECK ( *i++ == o3);
+          CHECK ( *i++ == o2);
+          CHECK ( *i   == o1);
+          CHECK (!i.hasNext());
+          CHECK (! *++i ); // null after end
+          
+          i = reg_->candidates(q3);
+          CHECK ( *i++ == o3);   // found by direct match
+          CHECK ( *i++ == o1);   // followed by the ordered enumeration
+          CHECK ( *i++ == o2);
+          CHECK ( *i++ == o3);
+          CHECK ( *i++ == o3);
+          CHECK ( *i++ == o2);
+          CHECK ( *i++ == o1);
+          CHECK (!i.hasNext());
+          
+          i = reg_->candidates(Q13());
+          CHECK ( *i++ == o1);   // found by direct match to the empty query
+          CHECK ( *i++ == o1);
+          CHECK ( *i++ == o2);
+          CHECK ( *i++ == o3);
+          CHECK ( *i++ == o3);
+          CHECK ( *i++ == o2);
+          CHECK ( *i++ == o1);
+          CHECK (!i.hasNext());
+          
+          uint d=0;
+          uint d_prev=0;
+          Iter23 j = reg_->candidates(Q23 ("some crap"));
+          for ( ; *j ; ++j )
+            {
+              CHECK ( *j );
+              Q23 qx ((*j)->instanceID);
+              CHECK ( ps[qx] == (*j));
+              d = lumiera::query::countPred (qx);
+              CHECK ( d_prev <= d );
+              d_prev = d;
+            }
+          CHECK (!j.hasNext());
+          
+          // calling with an arbitrary (registered) query
+          // yields the corresponding object at start of the enumeration
+          j = reg_->candidates(ps.begin()->first);
+          CHECK ( *j == ps.begin()->second);
+          
+        }
+      
+      
+      void
+      check_remove ()
+        {
+          reg_->forget (o2);
+          
+          Iter13 i (reg_->candidates(q4));
+          CHECK ( i.hasNext());
+          CHECK ( *i++ == o1);    // ordered according to the degree of the queries
+                                  // but the o2 entries are missing
+          CHECK ( *i++ == o3);
+          CHECK ( *i++ == o3);
+                                  // missing
+          CHECK ( *i   == o1);
+          CHECK (!i.hasNext());
+          
+          o3.reset(); // killing the only reference....
+                     //  expires the weak ref in the registry
+          
+          i = reg_->candidates(Q13 ("something"));
+          CHECK ( i.hasNext());
+          CHECK ( *i++ == o1);    // ordered according to the degree of the queries
+                                  // but now also the o3 entries are missing...
+          CHECK ( *i   == o1);
+          CHECK (!i.hasNext());
+          
+          CHECK ( reg_->put (o1, q5));   // trying to register the same object at the same place
+                                         // doesn't change anything (but counts as "success")
+          i = reg_->candidates(q5);
+          CHECK ( *i++ == o1); // direct match
+          CHECK ( *i++ == o1);
+          CHECK ( *i++ == o1);
+          CHECK (!i.hasNext());
+          
+          CHECK (!reg_->put (o2, q5));   // trying to (re)register o2 with a existing query
+                                         // counts as failure (nothing changes)
+          i = reg_->candidates(q5);
+          CHECK ( *i++ == o1); // direct match
+          CHECK ( *i++ == o1);
+          CHECK ( *i++ == o1);
+          CHECK (!i.hasNext());
+          
+          CHECK ( reg_->put (o2, q2));   // trying to (re)register o2 with another query succeeds
+          i = reg_->candidates(q2);
+          CHECK ( *i++ == o2); // direct match
+          CHECK ( *i++ == o1);
+          CHECK ( *i++ == o2); // inserted here in the dataset
+          CHECK ( *i++ == o1);
+          CHECK (!i.hasNext());
+          
+          CHECK ( reg_->forget (o1));
+          CHECK (!reg_->forget (o1)); // failure, because it's already removed
+          CHECK ( reg_->forget (o2));
+          
+          o3 = oFac();        // another object is another object (it's irrelevant...)
+          
+          i = reg_->candidates(q2);
+          CHECK (! (*i));  // empty
+        }
+      
+    };
+  
+  
+  /** Register this test class... */
+  LAUNCHER (DefsRegistryImpl_test, "function session");
+  
+  
+  
+}}} // namespace mobject::session::test
diff --git a/tests/components/proc/mobject/session/defsmanagerimpltest.cpp b/tests/components/proc/mobject/session/defsmanagerimpltest.cpp
deleted file mode 100644
index 164dc9b9a..000000000
--- a/tests/components/proc/mobject/session/defsmanagerimpltest.cpp
+++ /dev/null
@@ -1,172 +0,0 @@
-/*
-  DefsManagerImpl(Test)  -  checking implementation details of the defaults manager
-
-  Copyright (C)         Lumiera.org
-    2008,               Hermann Vosseler <Ichthyostega@web.de>
-
-  This program is free software; you can redistribute it and/or
-  modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of
-  the License, or (at your option) any later version.
-
-  This program is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with this program; if not, write to the Free Software
-  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
-* *****************************************************/
-
-
-#include "pre_a.hpp"
-
-#include "lib/test/run.hpp"
-#include "lib/util.hpp"
-
-#include "proc/asset.hpp"
-#include "proc/asset/pipe.hpp"
-#include "common/configrules.hpp"
-#include "proc/assetmanager.hpp"
-#include "proc/mobject/session.hpp"
-#include "lib/streamtype.hpp"
-
-#include <boost/format.hpp>
-
-using boost::format;
-using util::isnil;
-using std::string;
-
-
-namespace asset {
-  namespace test {
-
-    using mobject::Session;
-    using lib::Symbol;
-    using lumiera::Query;
-    using lumiera::query::normaliseID;
-
-    using lumiera::ConfigRules;
-    using lumiera::query::QueryHandler;
-    using lumiera::StreamType;
-    
-    
-    
-    /** shortcut: query for given Pipe-ID */
-    bool
-    find (const string& pID)
-    {
-      return Session::current->defaults.search (Query<Pipe> ("pipe("+pID+")"));
-    }
-
-
-    format pattern ("dummy_%s_%i");
-
-    /** create a random new ID */
-    string
-    newID (Symbol prefix)
-    {
-      return str (pattern % prefix % std::rand());
-    }
-
-
-
-
-    /************************************************************************
-     * @test verify some general assumptions regarding implementation details
-     *       of the the defaults manager.
-     * @see  DefsManager_test for the "big picture"
-     */
-    class DefsManagerImpl_test : public Test
-      {
-        virtual void
-        run(Arg)
-          {
-            define_and_search();
-            string pipeID = create();
-            forget(pipeID);
-          }
-
-
-
-
-        void
-        define_and_search ()
-          {
-            string sID = newID ("stream");
-            StreamType::ID stID (sID);
-            
-             // create Pipes explicitly 
-            //  (without utilising default queries)
-            PPipe pipe1 = Struct::retrieve.newPipe (newID("pipe"), newID("stream"));
-            PPipe pipe2 = Struct::retrieve.newPipe (newID("pipe"), sID            );
-            
-            CHECK (pipe1 != pipe2);
-            CHECK (stID == pipe2->getStreamID());
-            
-            CHECK (!find (pipe1->getPipeID()), "accidental clash of random test-IDs");
-            CHECK (!find (pipe2->getPipeID()), "accidental clash of random test-IDs");
-            
-            // now declare that these objects should be considered "default"
-lumiera::query::setFakeBypass("");  /////////////////////////////////////////////////TODO mock resolution            
-            CHECK (Session::current->defaults.define (pipe1, Query<Pipe> ("")));   // unrestricted default
-
-lumiera::query::setFakeBypass("stream("+sID+")"); ///////////////////////////////////TODO mock resolution            
-            CHECK (Session::current->defaults.define (pipe2, Query<Pipe> ("stream("+sID+")")));
-            
-            CHECK ( find (pipe1->getPipeID()), "failure declaring object as default");
-            CHECK ( find (pipe2->getPipeID()), "failure declaring object as default");
-            
-            CHECK (stID != pipe1->getStreamID(), "accidental clash");
-            CHECK (!Session::current->defaults.define (pipe1, Query<Pipe> ("stream("+sID+")")));
-                    // can't be registered with this query, due to failure caused by wrong stream-ID
-          }
-
-
-        const string&
-        create()
-          {
-            string sID = newID ("stream");
-            Query<Pipe> query_for_streamID ("stream("+sID+")");
-
-            // issue a ConfigQuery directly, without involving the DefaultsManager
-            QueryHandler<Pipe>& typeHandler = ConfigRules::instance();
-            PPipe pipe1;
-            typeHandler.resolve (pipe1, query_for_streamID);
-            CHECK (pipe1);
-
-            CHECK (!find (pipe1->getPipeID()));
-            PPipe pipe2 = Session::current->defaults.create (query_for_streamID);
-            CHECK (pipe2);
-            CHECK (pipe2 == pipe1);
-            CHECK ( find (pipe1->getPipeID())); // now declared as "default Pipe" for this stream-ID
-
-            return pipe1->getPipeID();
-          }
-
-
-        void
-        forget (string pID)
-          {
-            PPipe pipe = Pipe::query ("pipe("+pID+")");
-            REQUIRE (find (pipe->getPipeID()), "need an object registered as default");
-            long cnt = pipe.use_count();
-
-            // now de-register the pipe as "default Pipe"
-            CHECK (Session::current->defaults.forget (pipe));
-            CHECK (!find (pipe->getPipeID()));
-            CHECK (cnt == pipe.use_count());   // indicates DefaultsManager holding only a weak ref.
-          }
-      };
-
-
-    /** Register this test class... */
-    LAUNCHER (DefsManagerImpl_test, "function session");
-
-
-
-  } // namespace test
-
-} // namespace asset
diff --git a/tests/components/proc/mobject/session/defsmanagertest.cpp b/tests/components/proc/mobject/session/defsmanagertest.cpp
deleted file mode 100644
index 5f41fb462..000000000
--- a/tests/components/proc/mobject/session/defsmanagertest.cpp
+++ /dev/null
@@ -1,197 +0,0 @@
-/*
-  DefsManager(Test)  -  checking basic behaviour of the defaults manager
-
-  Copyright (C)         Lumiera.org
-    2008,               Hermann Vosseler <Ichthyostega@web.de>
-
-  This program is free software; you can redistribute it and/or
-  modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of
-  the License, or (at your option) any later version.
-
-  This program is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with this program; if not, write to the Free Software
-  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
-* *****************************************************/
-
-
-#include "pre_a.hpp"
-
-#include "lib/test/run.hpp"
-#include "lib/symbol.hpp"
-#include "lib/query.hpp"
-#include "lib/util.hpp"
-
-#include "proc/asset.hpp"
-#include "proc/asset/pipe.hpp"
-#include "proc/assetmanager.hpp"
-#include "proc/mobject/session.hpp"
-#include "lib/streamtype.hpp"
-
-#include <boost/format.hpp>
-
-using boost::format;
-using util::isnil;
-using std::string;
-
-
-
-namespace asset {
-namespace test  {
-
-    using util::cStr;
-    using lib::Symbol;
-    using mobject::Session;
-    using lumiera::Query;
-    using lumiera::query::normaliseID;
-    using lumiera::StreamType;
-    
-    
-    /** shortcut: run just a query
-     *  without creating new instances
-     */
-    bool
-    find (Query<Pipe>& q)
-    {
-      return Session::current->defaults.search (q);
-    }
-
-
-
-
-    /***********************************************************************
-     * @test basic behaviour of the defaults manager ("the big picture")
-     *       - retrieving a "default" object repeatedly
-     *       - retrieving a more constrained "default" object
-     *       - failure registers a new "default"
-     *       - instance management
-     *
-     * Using pipe assets as an example. The defaults manager shouldn't
-     * interfere with memory management (it holds weak refs).
-     */
-    class DefsManager_test : public Test
-      {
-        virtual void
-        run (Arg arg)
-          {
-            string pipeID   = isnil(arg)?  "Black Hole" : arg[1];
-            string streamID = 2>arg.size()? "teststream" : arg[2] ;
-
-            normaliseID (pipeID);
-            normaliseID (streamID);
-
-            retrieveSimpleDefault (pipeID);
-            retrieveConstrainedDefault (pipeID, streamID);
-            failureCreatesNewDefault();
-            verifyRemoval();
-          }
-
-
-
-
-        void
-        retrieveSimpleDefault (string)
-          {
-            PPipe pipe1 = Pipe::query (""); // "the default pipe"
-            PPipe pipe2;
-
-            // several variants to query for "the default pipe"
-            pipe2 = Pipe::query ("");
-            CHECK (pipe2 == pipe1);
-            pipe2 = Pipe::query ("default(X)");
-            CHECK (pipe2 == pipe1);
-            pipe2 = Session::current->defaults(Query<Pipe> ());
-            CHECK (pipe2 == pipe1);
-            pipe2 = asset::Struct::retrieve (Query<Pipe> ());
-            CHECK (pipe2 == pipe1);
-            pipe2 = asset::Struct::retrieve (Query<Pipe> ("default(P)"));
-            CHECK (pipe2 == pipe1);
-          }
-
-
-        void
-        retrieveConstrainedDefault (string pID, string sID)
-          {
-            PPipe pipe1 = Pipe::query (""); // "the default pipe"
-            CHECK ( pipe1->getStreamID() != StreamType::ID(sID),
-                    "stream-ID \"%s\" not suitable for test, because "
-                    "the default-pipe \"%s\" happens to have the same "
-                    "stream-ID. We need it to be different",
-                    sID.c_str(), pID.c_str()
-                   );
-
-            string query_for_sID ("stream("+sID+")");
-            PPipe pipe2 = Pipe::query (query_for_sID);
-            CHECK (pipe2->getStreamID() == StreamType::ID(sID));
-            CHECK (pipe2 != pipe1);
-            CHECK (pipe2 == Pipe::query (query_for_sID));   // reproducible
-          }
-
-
-        void
-        failureCreatesNewDefault()
-          {
-            PPipe pipe1 = Session::current->defaults(Query<Pipe> ()); // "the default pipe"
-
-            string new_pID (str (format ("dummy_%s_%i")
-                                 % pipe1->getPipeID()
-                                 % std::rand()
-                                ));     // make random new pipeID
-            Query<Pipe> query_for_new ("pipe("+new_pID+")");
-
-            CHECK (!find (query_for_new));                             // check it doesn't exist
-            PPipe pipe2 = Session::current->defaults (query_for_new);   // triggers creation
-            CHECK ( find (query_for_new));                             // check it exists now
-
-            CHECK (pipe1 != pipe2);
-            CHECK (pipe2 == Session::current->defaults (query_for_new));
-          }
-
-
-        /** verify the defaults manager holds only weak refs,
-         *  so if an object goes out of scope, any defaults entries
-         *  are purged silently
-         */
-        void
-        verifyRemoval()
-          {
-            Symbol pID ("some_pipe");
-            Query<Pipe> query_for_pID ("pipe("+pID+")");
-            size_t hash;
-              {
-                // create new pipe and declare it to be a default
-                PPipe pipe1 = Struct::retrieve.newInstance<Pipe> (pID);
-                Session::current->defaults.define(pipe1);
-
-                CHECK (2 == pipe1.use_count());                        // the pipe1 smart-ptr and the AssetManager
-                hash = pipe1->getID();
-              }
-              // pipe1 out of scope....
-             //  AssetManager now should hold the only ref
-            ID<Asset> assetID (hash);
-
-            AssetManager& aMang (AssetManager::instance());
-            CHECK ( aMang.known (assetID));
-            aMang.remove (assetID);
-            CHECK (!aMang.known (assetID));
-
-
-            CHECK (!find(query_for_pID));                              // bare default-query should fail...
-            PPipe pipe2 = Session::current->defaults (query_for_pID);   // triggers re-creation
-            CHECK ( find(query_for_pID));                              // should succeed again
-          }
-      };
-
-
-
-    /** Register this test class... */
-    LAUNCHER (DefsManager_test, "function session");
-
-
-}} // namespace asset::test
diff --git a/tests/components/proc/mobject/session/defsregistryimpltest.cpp b/tests/components/proc/mobject/session/defsregistryimpltest.cpp
deleted file mode 100644
index a9e12b28b..000000000
--- a/tests/components/proc/mobject/session/defsregistryimpltest.cpp
+++ /dev/null
@@ -1,296 +0,0 @@
-/*
-  DefsRegistryImpl(Test)  -  verifying correct behaviour of the defaults registry
-
-  Copyright (C)         Lumiera.org
-    2008,               Hermann Vosseler <Ichthyostega@web.de>
-
-  This program is free software; you can redistribute it and/or
-  modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of
-  the License, or (at your option) any later version.
-
-  This program is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with this program; if not, write to the Free Software
-  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
-* *****************************************************/
-
-
-#include "lib/test/run.hpp"
-#include "lib/util.hpp"
-
-#include "proc/mobject/session/defsregistry.hpp"
-#include "lib/factory.hpp"
-#include "lib/query.hpp"
-#include "lib/p.hpp"
-
-#include "../lib/query/querydiagnostics.hpp"
-
-#include <boost/scoped_ptr.hpp>
-#include <boost/format.hpp>
-#include <map>
-
-using lumiera::P;
-using lumiera::Query;
-using lumiera::query::test::garbage_query;
-using util::isnil;
-
-using boost::scoped_ptr;
-using boost::format;
-using std::string;
-using std::rand;
-using std::map;
-
-
-
-namespace mobject {
-  namespace session {
-    namespace test  {
-
-      format typePatt ("Dummy<%2i>");
-      format instancePatt ("obj_%s_%i");
-      format predicatePatt ("%s_%2i( %s )");
-
-
-
-      /** create a random new ID */
-      string
-      newID (string prefix)
-      {
-        return str (instancePatt % prefix % rand());
-      }
-
-
-      /** template for generating some different test types */
-      template<int I>
-      struct Dummy
-        {
-          static string name;
-          string instanceID;
-          operator string ()                  const { return instanceID; }
-          bool operator== (const Dummy& odu)  const { return this == &odu; }
-
-
-          Dummy () : instanceID (newID (name)) {}
-        };
-
-      template<int I>
-      string Dummy<I>::name = str (typePatt % I);
-
-
-
-
-
-
-      /************************************************************************
-       * @test build an registry table (just for this test) configured for
-       *       some artificial test Types. Register some entries and verify
-       *       the intended behaviour of the storage structure.
-       * @see  DefsManagerImpl_test for checking the implementation details
-       *       in the actual context used in Lumiera.
-       */
-      class DefsRegistryImpl_test : public Test
-        {
-          scoped_ptr<DefsRegistry> reg_;
-
-          typedef lumiera::P<Dummy<13> > O;
-          typedef lumiera::P<Dummy<23> > P;
-
-          typedef Query<Dummy<13> > Q13;
-          typedef Query<Dummy<23> > Q23;
-
-          typedef DefsRegistry::Iter<Dummy<13> > Iter13;
-          typedef DefsRegistry::Iter<Dummy<23> > Iter23;
-
-
-          // fabricating Objects wrapped into smart-ptrs
-          lib::factory::RefcountFac<Dummy<13> > oFac;
-          lib::factory::RefcountFac<Dummy<23> > pFac;
-
-          O o1, o2, o3;
-          Q13 q1, q2, q3, q4, q5;
-          map<Q23, P> ps;
-
-        public:
-          DefsRegistryImpl_test ()
-            : o1 (oFac()), o2 (oFac()), o3 (oFac()),
-              q1 (garbage_query (1)),
-              q2 (garbage_query (2)),
-              q3 (garbage_query (3)),
-              q4 (garbage_query (4)),
-              q5 (garbage_query (5))
-            { }
-
-
-          virtual void
-          run (Arg)
-            {
-              this->reg_.reset (new DefsRegistry);
-
-              fill_table ();
-              check_query ();
-              check_remove ();
-            }
-
-
-
-
-          void
-          fill_table ()
-            {
-               // at start the registry is indeed empty
-              //  thus a query doesn't yield any results....
-              CHECK ( ! *(reg_->candidates(Q13 ("something"))) );
-
-              reg_->put (o1, q5);
-              reg_->put (o2, q4);
-              reg_->put (o3, q3);
-              reg_->put (o3, q2);
-              reg_->put (o2, q1);
-              reg_->put (o1, Q13()); // the empty query
-
-              ps.clear();
-              for (int i=0; i<100; ++i)
-                {
-                  P px (pFac());
-                  Q23 qx (garbage_query());
-                  ps[qx] = px;
-                  reg_->put (px, qx);
-                  px->instanceID = qx;
-                }
-            }
-
-
-          void
-          check_query ()
-            {
-              Iter13 i (reg_->candidates(Q13 ("irrelevant query")));
-              CHECK ( i.hasNext());
-              CHECK ( *i++ == o1);  // ordered according to the degree of the queries
-              CHECK ( *i++ == o2);
-              CHECK ( *i++ == o3);
-              CHECK ( *i++ == o3);
-              CHECK ( *i++ == o2);
-              CHECK ( *i   == o1);
-              CHECK (!i.hasNext());
-              CHECK (! *++i ); // null after end
-
-              i = reg_->candidates(q3);
-              CHECK ( *i++ == o3);  // found by direct match
-              CHECK ( *i++ == o1);  // followed by the ordered enumeration
-              CHECK ( *i++ == o2);
-              CHECK ( *i++ == o3);
-              CHECK ( *i++ == o3);
-              CHECK ( *i++ == o2);
-              CHECK ( *i++ == o1);
-              CHECK (!i.hasNext());
-
-              i = reg_->candidates(Q13());
-              CHECK ( *i++ == o1);  // found by direct match to the empty query
-              CHECK ( *i++ == o1);
-              CHECK ( *i++ == o2);
-              CHECK ( *i++ == o3);
-              CHECK ( *i++ == o3);
-              CHECK ( *i++ == o2);
-              CHECK ( *i++ == o1);
-              CHECK (!i.hasNext());
-
-              uint d=0;
-              uint d_prev=0;
-              Iter23 j = reg_->candidates(Q23 ("some crap"));
-              for ( ; *j ; ++j )
-                {
-                  CHECK ( *j );
-                  Q23 qx ((*j)->instanceID);
-                  CHECK ( ps[qx] == (*j));
-                  d = lumiera::query::countPred (qx);
-                  CHECK ( d_prev <= d );
-                  d_prev = d;
-                }
-              CHECK (!j.hasNext());
-
-              // calling with an arbitrary (registered) query
-              // yields the corresponding object at start of the enumeration
-              j = reg_->candidates(ps.begin()->first);
-              CHECK ( *j == ps.begin()->second);
-
-            }
-
-
-          void
-          check_remove ()
-            {
-              reg_->forget (o2);
-
-              Iter13 i (reg_->candidates(q4));
-              CHECK ( i.hasNext());
-              CHECK ( *i++ == o1);  // ordered according to the degree of the queries
-                                     // but the o2 entries are missing
-              CHECK ( *i++ == o3);
-              CHECK ( *i++ == o3);
-                                     // missing
-              CHECK ( *i   == o1);
-              CHECK (!i.hasNext());
-
-              o3.reset(); // killing the only reference....
-                         //  expires the weak ref in the registry
-
-              i = reg_->candidates(Q13 ("something"));
-              CHECK ( i.hasNext());
-              CHECK ( *i++ == o1);  // ordered according to the degree of the queries
-                                     // but now also the o3 entries are missing...
-              CHECK ( *i   == o1);
-              CHECK (!i.hasNext());
-
-              CHECK ( reg_->put (o1, q5));  // trying to register the same object at the same place
-                                             // doesn't change anything (but counts as "success")
-              i = reg_->candidates(q5);
-              CHECK ( *i++ == o1); // direct match
-              CHECK ( *i++ == o1);
-              CHECK ( *i++ == o1);
-              CHECK (!i.hasNext());
-
-              CHECK (!reg_->put (o2, q5));  // trying to (re)register o2 with a existing query
-                                             // counts as failure (nothing changes)
-              i = reg_->candidates(q5);
-              CHECK ( *i++ == o1); // direct match
-              CHECK ( *i++ == o1);
-              CHECK ( *i++ == o1);
-              CHECK (!i.hasNext());
-
-              CHECK ( reg_->put (o2, q2));  // trying to (re)register o2 with another query succeeds
-              i = reg_->candidates(q2);
-              CHECK ( *i++ == o2); // direct match
-              CHECK ( *i++ == o1);
-              CHECK ( *i++ == o2); // inserted here in the dataset
-              CHECK ( *i++ == o1);
-              CHECK (!i.hasNext());
-
-              CHECK ( reg_->forget (o1));
-              CHECK (!reg_->forget (o1)); // failure, because it's already removed
-              CHECK ( reg_->forget (o2));
-
-              o3 = oFac();        // another object is another object (it's irrelevant...)
-
-              i = reg_->candidates(q2);
-              CHECK (! (*i)); // empty
-            }
-
-        };
-
-
-      /** Register this test class... */
-      LAUNCHER (DefsRegistryImpl_test, "function session");
-
-
-
-    } // namespace test
-
-  } // namespace mobject
-
-} // namespace mobject
diff --git a/tests/lib/Makefile.am b/tests/lib/Makefile.am
index f6930f20b..fd9c76ac4 100644
--- a/tests/lib/Makefile.am
+++ b/tests/lib/Makefile.am
@@ -43,7 +43,7 @@ test_lib_SOURCES =							\
 	$(testlib_srcdir)/advice/advice-index-test.cpp			\
 	$(testlib_srcdir)/advice/advice-multiplicity-test.cpp		\
 	$(testlib_srcdir)/advice/advice-situations-test.cpp		\
-	$(testlib_srcdir)/allocationclustertest.cpp			\
+	$(testlib_srcdir)/allocation-cluster-test.cpp			\
 	$(testlib_srcdir)/appconfigtest.cpp				\
 	$(testlib_srcdir)/bool-checkable-test.cpp			\
 	$(testlib_srcdir)/custom-shared-ptr-test.cpp			\
@@ -87,7 +87,7 @@ test_lib_SOURCES =							\
 	$(testlib_srcdir)/scoped-holder-transfer-test.cpp		\
 	$(testlib_srcdir)/singleton-subclass-test.cpp			\
 	$(testlib_srcdir)/singleton-test.cpp				\
-	$(testlib_srcdir)/singletontestmocktest.cpp			\
+	$(testlib_srcdir)/singleton-testmock-test.cpp			\
 	$(testlib_srcdir)/streamtypebasicstest.cpp			\
 	$(testlib_srcdir)/streamtypelifecycletest.cpp			\
 	$(testlib_srcdir)/sub-id-test.cpp				\
diff --git a/tests/lib/allocation-cluster-test.cpp b/tests/lib/allocation-cluster-test.cpp
new file mode 100644
index 000000000..cf8897bf5
--- /dev/null
+++ b/tests/lib/allocation-cluster-test.cpp
@@ -0,0 +1,234 @@
+/*
+  AllocationCluster(Test)  -  verify bulk (de)allocating a family of objects
+
+  Copyright (C)         Lumiera.org
+    2008,               Hermann Vosseler <Ichthyostega@web.de>
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License as
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+* *****************************************************/
+
+
+
+#include "lib/test/run.hpp"
+#include "lib/test/test-helper.hpp"
+#include "lib/util.hpp"
+#include "lib/util-foreach.hpp"
+
+#include "lib/allocation-cluster.hpp"
+#include "lib/scoped-holder.hpp"
+
+#include <vector>
+#include <limits>
+#include <boost/lexical_cast.hpp>
+
+using boost::lexical_cast;
+using lib::test::showSizeof;
+using util::for_each;
+using util::isnil;
+using ::Test;
+
+using std::numeric_limits;
+using std::vector;
+
+
+
+namespace lib {
+namespace test {
+  
+  namespace { // a family of test dummy classes
+    
+    uint NUM_CLUSTERS = 5;
+    uint NUM_OBJECTS  = 500;
+    uint NUM_FAMILIES = 5;
+    
+    long checksum = 0; // validate proper pairing of ctor/dtor calls
+    bool randomFailures = false;
+    
+    template<uint i>
+    class Dummy
+      {
+        char content[i];
+        
+      public:
+        Dummy (char id=1)
+          {
+            content[0] = id;
+            checksum += id;
+          }
+        Dummy (char i1, char i2, char i3=0)
+          {
+            char id = i1 + i2 + i3;
+            content[0] = id;
+            checksum += id;
+            if (randomFailures && 0 == (rand() % 20))
+              throw id;
+          }
+        
+        ~Dummy()
+          {
+            checksum -= content[0];
+          }
+        
+        char getID()  { return content[0]; }
+      };
+    
+    typedef ScopedHolder<AllocationCluster> PCluster;
+    typedef vector<PCluster> ClusterList;
+    
+    inline char
+    truncChar (uint x)
+      {
+        return x % numeric_limits<char>::max();
+      }
+    
+    template<uint i>
+    void
+    place_object (AllocationCluster& clu, uint id)
+      {
+        clu.create<Dummy<i> > (id);
+      }
+    
+    typedef void (Invoker)(AllocationCluster&, uint);
+    
+    Invoker* invoke[20] = { &place_object<1>
+                          , &place_object<2>
+                          , &place_object<3>
+                          , &place_object<5>
+                          , &place_object<10>
+                          , &place_object<13>
+                          , &place_object<14>
+                          , &place_object<15>
+                          , &place_object<16>
+                          , &place_object<17>
+                          , &place_object<18>
+                          , &place_object<19>
+                          , &place_object<20>
+                          , &place_object<25>
+                          , &place_object<30>
+                          , &place_object<35>
+                          , &place_object<40>
+                          , &place_object<50>
+                          , &place_object<100>
+                          , &place_object<200>
+                          };
+    
+    void
+    fillIt (PCluster& clu)
+      {
+        clu.create();
+        
+        if (20<NUM_FAMILIES)
+          NUM_FAMILIES = 20;
+        
+        for (uint i=0; i<NUM_OBJECTS; ++i)
+          {
+            char id = truncChar(i);
+            (*(invoke[rand() % NUM_FAMILIES])) (*clu,id);
+          }
+      }
+    
+  }
+  
+  
+  
+  /*************************************************************************
+   *  @test verify the proper workings of our custom allocation scheme
+   *        managing families of interconnected objects for the segments
+   *        of the low-level model.
+   */
+  class AllocationCluster_test : public Test
+    {
+      virtual void 
+      run (Arg arg)
+        {
+          if (0 < arg.size()) NUM_CLUSTERS = lexical_cast<uint> (arg[0]);
+          if (1 < arg.size()) NUM_OBJECTS  = lexical_cast<uint> (arg[1]);
+          if (2 < arg.size()) NUM_FAMILIES = lexical_cast<uint> (arg[2]);
+          
+          simpleUsage();
+          checkAllocation();
+          checkErrorHandling();
+        }
+      
+      
+      void
+      simpleUsage()
+        {
+          AllocationCluster clu;
+          
+          char c1(123), c2(56), c3(3), c4(4), c5(5);
+          Dummy<44>& ref1 = clu.create<Dummy<44> > ();
+          Dummy<37>& ref2 = clu.create<Dummy<37> > (c1);
+          Dummy<37>& ref3 = clu.create<Dummy<37> > (c2);
+          Dummy<1234>& rX = clu.create<Dummy<1234> > (c3,c4,c5);
+          
+          CHECK (&ref1);
+          CHECK (&ref2);
+          CHECK (&ref3);
+          CHECK (&rX);
+          TRACE (test, "%s", showSizeof(rX).c_str());
+          
+          CHECK (123==ref2.getID());
+          CHECK (3+4+5==rX.getID());
+          // shows that the returned references actually
+          // point at the objects we created. Just use them
+          // and let them go. When clu goes out of scope,
+          // all created object's dtors will be invoked.
+        }
+      
+      
+      void
+      checkAllocation()
+        {
+          CHECK (0==checksum);
+          {
+            ClusterList clusters (NUM_CLUSTERS);
+            for_each (clusters, fillIt);
+            CHECK (0!=checksum);
+          }
+          CHECK (0==checksum);
+        }
+      
+      
+      void
+      checkErrorHandling()
+        {
+          CHECK (0==checksum);
+          {
+            randomFailures = true;
+            
+            AllocationCluster clu;
+            for (uint i=0; i<NUM_OBJECTS; ++i)
+              try
+                {
+                  char i1 = truncChar(i);
+                  char i2 = truncChar(rand() % 5);
+                  clu.create<Dummy<1> > (i1,i2);
+                }
+              catch (char id)
+                {
+                  checksum -= id;  // exception thrown from within constructor, 
+                }                 //  thus dtor won't be called. Repair the checksum!
+          }
+          randomFailures = false;
+          CHECK (0==checksum);
+        }
+    };
+  
+  LAUNCHER (AllocationCluster_test, "unit common");
+  
+  
+}} // namespace lib::test
diff --git a/tests/lib/allocationclustertest.cpp b/tests/lib/allocationclustertest.cpp
deleted file mode 100644
index 6e2d38e65..000000000
--- a/tests/lib/allocationclustertest.cpp
+++ /dev/null
@@ -1,236 +0,0 @@
-/*
-  AllocationCluster(Test)  -  verify bulk (de)allocating a family of objects
-
-  Copyright (C)         Lumiera.org
-    2008,               Hermann Vosseler <Ichthyostega@web.de>
-
-  This program is free software; you can redistribute it and/or
-  modify it under the terms of the GNU General Public License as
-  published by the Free Software Foundation; either version 2 of
-  the License, or (at your option) any later version.
-
-  This program is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with this program; if not, write to the Free Software
-  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
-* *****************************************************/
-
-
-
-#include "lib/test/run.hpp"
-#include "lib/test/test-helper.hpp"
-#include "lib/util.hpp"
-#include "lib/util-foreach.hpp"
-
-#include "lib/allocationcluster.hpp"
-#include "lib/scoped-holder.hpp"
-
-#include <vector>
-#include <limits>
-#include <boost/lexical_cast.hpp>
-
-using boost::lexical_cast;
-using lib::test::showSizeof;
-using util::for_each;
-using util::isnil;
-using ::Test;
-
-using std::numeric_limits;
-using std::vector;
-
-
-
-namespace lib {
-  namespace test {
-    
-    namespace { // a family of test dummy classes
-      
-      uint NUM_CLUSTERS = 5;
-      uint NUM_OBJECTS  = 500;
-      uint NUM_FAMILIES = 5;
-      
-      long checksum = 0; // validate proper pairing of ctor/dtor calls
-      bool randomFailures = false;
-      
-      template<uint i>
-      class Dummy
-        {
-          char content[i];
-          
-        public:
-          Dummy (char id=1)
-            {
-              content[0] = id;
-              checksum += id;
-            }
-          Dummy (char i1, char i2, char i3=0)
-            {
-              char id = i1 + i2 + i3;
-              content[0] = id;
-              checksum += id;
-              if (randomFailures && 0 == (rand() % 20))
-                throw id;
-            }
-          
-          ~Dummy()
-            {
-              checksum -= content[0];
-            }
-          
-          char getID()  { return content[0]; }
-        };
-      
-      typedef ScopedHolder<AllocationCluster> PCluster;
-      typedef vector<PCluster> ClusterList;
-      
-      inline char
-      truncChar (uint x)
-        {
-          return x % numeric_limits<char>::max();
-        }
-      
-      template<uint i>
-      void
-      place_object (AllocationCluster& clu, uint id)
-        {
-          clu.create<Dummy<i> > (id);
-        }
-      
-      typedef void (Invoker)(AllocationCluster&, uint);
-      
-      Invoker* invoke[20] = { &place_object<1>
-                            , &place_object<2>
-                            , &place_object<3>
-                            , &place_object<5>
-                            , &place_object<10>
-                            , &place_object<13>
-                            , &place_object<14>
-                            , &place_object<15>
-                            , &place_object<16>
-                            , &place_object<17>
-                            , &place_object<18>
-                            , &place_object<19>
-                            , &place_object<20>
-                            , &place_object<25>
-                            , &place_object<30>
-                            , &place_object<35>
-                            , &place_object<40>
-                            , &place_object<50>
-                            , &place_object<100>
-                            , &place_object<200>
-                            };
-      
-      void
-      fillIt (PCluster& clu)
-        {
-          clu.create();
-          
-          if (20<NUM_FAMILIES)
-            NUM_FAMILIES = 20;
-          
-          for (uint i=0; i<NUM_OBJECTS; ++i)
-            {
-              char id = truncChar(i);
-              (*(invoke[rand() % NUM_FAMILIES])) (*clu,id);
-            }
-        }
-      
-    }
-    
-    
-    
-    /*************************************************************************
-     *  @test verify the proper workings of our custom allocation scheme
-     *        managing families of interconnected objects for the segments
-     *        of the low-level model.
-     */
-    class AllocationCluster_test : public Test
-      {
-        virtual void 
-        run (Arg arg)
-          {
-            if (0 < arg.size()) NUM_CLUSTERS = lexical_cast<uint> (arg[0]);
-            if (1 < arg.size()) NUM_OBJECTS  = lexical_cast<uint> (arg[1]);
-            if (2 < arg.size()) NUM_FAMILIES = lexical_cast<uint> (arg[2]);
-            
-            simpleUsage();
-            checkAllocation();
-            checkErrorHandling();
-          }
-        
-        
-        void
-        simpleUsage()
-          {
-            AllocationCluster clu;
-            
-            char c1(123), c2(56), c3(3), c4(4), c5(5);
-            Dummy<44>& ref1 = clu.create<Dummy<44> > ();
-            Dummy<37>& ref2 = clu.create<Dummy<37> > (c1);
-            Dummy<37>& ref3 = clu.create<Dummy<37> > (c2);
-            Dummy<1234>& rX = clu.create<Dummy<1234> > (c3,c4,c5);
-            
-            CHECK (&ref1);
-            CHECK (&ref2);
-            CHECK (&ref3);
-            CHECK (&rX);
-            TRACE (test, "%s", showSizeof(rX).c_str());
-            
-            CHECK (123==ref2.getID());
-            CHECK (3+4+5==rX.getID());
-            // shows that the returned references actually
-            // point at the objects we created. Just use them
-            // and let them go. When clu goes out of scope,
-            // all created object's dtors will be invoked.
-          }
-        
-        
-        void
-        checkAllocation()
-          {
-            CHECK (0==checksum);
-            {
-              ClusterList clusters (NUM_CLUSTERS);
-              for_each (clusters, fillIt);
-              CHECK (0!=checksum);
-            }
-            CHECK (0==checksum);
-          }
-        
-        
-        void
-        checkErrorHandling()
-          {
-            CHECK (0==checksum);
-            {
-              randomFailures = true;
-              
-              AllocationCluster clu;
-              for (uint i=0; i<NUM_OBJECTS; ++i)
-                try
-                  {
-                    char i1 = truncChar(i);
-                    char i2 = truncChar(rand() % 5);
-                    clu.create<Dummy<1> > (i1,i2);
-                  }
-                catch (char id)
-                  {
-                    checksum -= id;  // exception thrown from within constructor, 
-                  }                 //  thus dtor won't be called. Repair the checksum!
-            }
-            randomFailures = false;
-            CHECK (0==checksum);
-          }
-      };
-    
-      LAUNCHER (AllocationCluster_test, "unit common");
-    
-    
-  }// namespace test
-
-} // namespace lib
diff --git a/tests/lib/scoped-holder-transfer-test.cpp b/tests/lib/scoped-holder-transfer-test.cpp
index a01609ddf..0c3773095 100644
--- a/tests/lib/scoped-holder-transfer-test.cpp
+++ b/tests/lib/scoped-holder-transfer-test.cpp
@@ -34,205 +34,204 @@
 
 
 namespace lib {
-  namespace test {
-
-    using ::Test;
-    using util::isnil;
-
-    using std::vector;
-    using std::cout;
-
-    namespace { // extending the Dummy for our special purpose....
-
-      bool throw_in_transfer = false;
-
-      class FixedDummy
-        : public Dummy
-        {
-        public:
-          FixedDummy()
-            {
-              TRACE  (test, "CTOR      FixedDummy() --> this=%p val=%d", this, getVal());
-            }
-
-          ~FixedDummy()
-            {
-              TRACE  (test, "DTOR     ~FixedDummy()  this=%p val=%d", this, getVal());
-            }
-
-          friend void
-          transfer_control (FixedDummy& from, FixedDummy& to)
-          {
-            TRACE  (test, "TRANSFER  target=%p   <-- source=%p  (%d,%d)", &to,&from, to.getVal(),from.getVal());
-
-            if (throw_in_transfer)
-              throw to.getVal();
-            
-            swap (from,to);
-            from.setVal(0); // remove the old Dummy from accounting (checksum) 
-          }
-
-        };
-
-
-      typedef ScopedHolder<FixedDummy>    HolderD;
-      typedef ScopedPtrHolder<FixedDummy> PtrHolderD;
-
-      template<class HOL>
-      struct Table
-        {
-          typedef Allocator_TransferNoncopyable<HOL> Allo;
-          typedef typename std::vector<HOL,Allo> Type;
-
-        };
-    }
-
-
-
-
-    /**********************************************************************************
-     *  @test growing a vector containing noncopyable objects wrapped into ScopedHolder
-     *        instances. This requires the use of a custom allocator, invoking a
-     *        \c transfer_control() function to be provided for the concrete
-     *        noncopyable class type, being invoked when the vector
-     *        needs to reallocate.
-     */
-    class ScopedHolderTransfer_test : public Test
+namespace test {
+  
+  using ::Test;
+  using util::isnil;
+  
+  using std::vector;
+  using std::cout;
+  
+  namespace { // extending the Dummy for our special purpose....
+    
+    bool throw_in_transfer = false;
+    
+    class FixedDummy
+      : public Dummy
       {
-
-        virtual void
-        run (Arg)
+      public:
+        FixedDummy()
           {
-
-            cout << "checking ScopedHolder<Dummy>...\n";
-            buildVector<HolderD>();
-            growVector<HolderD>();
-            checkErrorHandling<HolderD>();
-
-            cout << "checking ScopedPtrHolder<Dummy>...\n";
-            buildVector<PtrHolderD>();
-            growVector<PtrHolderD>();
-            checkErrorHandling<PtrHolderD>();
+            TRACE  (test, "CTOR      FixedDummy() --> this=%p val=%d", this, getVal());
           }
-
-        void create_contained_object (HolderD&    holder) { holder.create();                }
-        void create_contained_object (PtrHolderD& holder) { holder.reset(new FixedDummy()); }
-
-
-        template<class HO>
-        void
-        buildVector()
+        
+       ~FixedDummy()
           {
-            CHECK (0==checksum);
-            {
-              typedef typename Table<HO>::Type Vect;
-
-              Vect table(50);
-              CHECK (0==checksum);
-
-              for (uint i=0; i<10; ++i)
-                create_contained_object (table[i]);
-
-              CHECK (0 < checksum);
-              CHECK ( table[9]);
-              CHECK (!table[10]);
-
-              Dummy *rawP = table[5].get();
-              CHECK (rawP);
-              CHECK (table[5]);
-              CHECK (rawP == &(*table[5]));
-              CHECK (rawP->add(-555) == table[5]->add(-555));
-            }
-            CHECK (0==checksum);
+            TRACE  (test, "DTOR     ~FixedDummy()  this=%p val=%d", this, getVal());
           }
-
-
-        template<class HO>
-        void
-        growVector()
-          {
-            CHECK (0==checksum);
-            {
-              typedef typename Table<HO>::Type Vect;
-
-              Vect table;
-              table.reserve(2);
-              CHECK (0==checksum);
-
-              cout << ".\n..install one element at index[0]\n";
-              table.push_back(HO());
-              CHECK (0==checksum);
-
-              create_contained_object (table[0]); // switches into "managed" state
-              CHECK (0 < checksum);
-              int theSum = checksum;
-
-              cout << ".\n..*** resize table to 16 elements\n";
-              for (uint i=0; i<15; ++i)
-                table.push_back(HO());
-
-              CHECK (theSum==checksum);
-            }
-            CHECK (0==checksum);
-          }
-
-
-        template<class HO>
-        void
-        checkErrorHandling()
-          {
-            CHECK (0==checksum);
-            {
-              typedef typename Table<HO>::Type Vect;
-
-              Vect table(5);
-              table.reserve(5);
-              CHECK (0==checksum);
-
-              create_contained_object (table[2]);
-              create_contained_object (table[4]);
-              CHECK (0 < checksum);
-              int theSum = checksum;
-
-              cout << ".\n.throw some exceptions...\n";
-              throw_in_ctor = true;
-              try
-                {
-                  create_contained_object (table[3]);
-                  NOTREACHED ();
-                }
-              catch (int val)
-                {
-                  CHECK (theSum < checksum);
-                  checksum -= val;
-                  CHECK (theSum==checksum);
-                }
-              CHECK ( table[2]);
-              CHECK (!table[3]); // not created because of exception
-              CHECK ( table[4]);
-
-              throw_in_ctor = false;
-              throw_in_transfer=true;  // can do this only when using ScopedHolder
-              try
-                {
-                  table.resize(10);
-                }
-              catch (int val)
-                {
-                  CHECK ( table.size() < 10);
-                }
-              CHECK (theSum == checksum);
-              throw_in_transfer=false;
-            }
-            CHECK (0==checksum);
-          }
-
+        
+        friend void
+        transfer_control (FixedDummy& from, FixedDummy& to)
+        {
+          TRACE  (test, "TRANSFER  target=%p   <-- source=%p  (%d,%d)", &to,&from, to.getVal(),from.getVal());
+          
+          if (throw_in_transfer)
+            throw to.getVal();
+          
+          swap (from,to);
+          from.setVal(0); // remove the old Dummy from accounting (checksum) 
+        }
+        
       };
-
-    LAUNCHER (ScopedHolderTransfer_test, "unit common");
-
-
-  }// namespace test
-
-} // namespace lib
-
+    
+    
+    typedef ScopedHolder<FixedDummy>    HolderD;
+    typedef ScopedPtrHolder<FixedDummy> PtrHolderD;
+    
+    template<class HOL>
+    struct Table
+      {
+        typedef Allocator_TransferNoncopyable<HOL> Allo;
+        typedef typename std::vector<HOL,Allo> Type;
+        
+      };
+    
+  }//(End) test helpers
+  
+  
+  
+  
+  
+  /**********************************************************************************
+   *  @test growing a vector containing noncopyable objects wrapped into ScopedHolder
+   *        instances. This requires the use of a custom allocator, invoking a
+   *        \c transfer_control() function to be provided for the concrete
+   *        noncopyable class type, being invoked when the vector
+   *        needs to reallocate.
+   */
+  class ScopedHolderTransfer_test : public Test
+    {
+      
+      virtual void
+      run (Arg)
+        {
+          
+          cout << "checking ScopedHolder<Dummy>...\n";
+          buildVector<HolderD>();
+          growVector<HolderD>();
+          checkErrorHandling<HolderD>();
+          
+          cout << "checking ScopedPtrHolder<Dummy>...\n";
+          buildVector<PtrHolderD>();
+          growVector<PtrHolderD>();
+          checkErrorHandling<PtrHolderD>();
+        }
+      
+      void create_contained_object (HolderD&    holder) { holder.create();                }
+      void create_contained_object (PtrHolderD& holder) { holder.reset(new FixedDummy()); }
+      
+      
+      template<class HO>
+      void
+      buildVector()
+        {
+          CHECK (0==checksum);
+          {
+            typedef typename Table<HO>::Type Vect;
+            
+            Vect table(50);
+            CHECK (0==checksum);
+            
+            for (uint i=0; i<10; ++i)
+              create_contained_object (table[i]);
+            
+            CHECK (0 < checksum);
+            CHECK ( table[9]);
+            CHECK (!table[10]);
+            
+            Dummy *rawP = table[5].get();
+            CHECK (rawP);
+            CHECK (table[5]);
+            CHECK (rawP == &(*table[5]));
+            CHECK (rawP->add(-555) == table[5]->add(-555));
+          }
+          CHECK (0==checksum);
+        }
+      
+      
+      template<class HO>
+      void
+      growVector()
+        {
+          CHECK (0==checksum);
+          {
+            typedef typename Table<HO>::Type Vect;
+            
+            Vect table;
+            table.reserve(2);
+            CHECK (0==checksum);
+            
+            cout << ".\n..install one element at index[0]\n";
+            table.push_back(HO());
+            CHECK (0==checksum);
+            
+            create_contained_object (table[0]); // switches into "managed" state
+            CHECK (0 < checksum);
+            int theSum = checksum;
+            
+            cout << ".\n..*** resize table to 16 elements\n";
+            for (uint i=0; i<15; ++i)
+              table.push_back(HO());
+            
+            CHECK (theSum==checksum);
+          }
+          CHECK (0==checksum);
+        }
+      
+      
+      template<class HO>
+      void
+      checkErrorHandling()
+        {
+          CHECK (0==checksum);
+          {
+            typedef typename Table<HO>::Type Vect;
+            
+            Vect table(5);
+            table.reserve(5);
+            CHECK (0==checksum);
+            
+            create_contained_object (table[2]);
+            create_contained_object (table[4]);
+            CHECK (0 < checksum);
+            int theSum = checksum;
+            
+            cout << ".\n.throw some exceptions...\n";
+            throw_in_ctor = true;
+            try
+              {
+                create_contained_object (table[3]);
+                NOTREACHED ();
+              }
+            catch (int val)
+              {
+                CHECK (theSum < checksum);
+                checksum -= val;
+                CHECK (theSum==checksum);
+              }
+            CHECK ( table[2]);
+            CHECK (!table[3]); // not created because of exception
+            CHECK ( table[4]);
+            
+            throw_in_ctor = false;
+            throw_in_transfer=true;  // can do this only when using ScopedHolder
+            try
+              {
+                table.resize(10);
+              }
+            catch (int val)
+              {
+                CHECK ( table.size() < 10);
+              }
+            CHECK (theSum == checksum);
+            throw_in_transfer=false;
+          }
+          CHECK (0==checksum);
+        }
+      
+    };
+  
+  LAUNCHER (ScopedHolderTransfer_test, "unit common");
+  
+  
+}} // namespace lib::test
diff --git a/tests/lib/singletontestmocktest.cpp b/tests/lib/singleton-testmock-test.cpp
similarity index 100%
rename from tests/lib/singletontestmocktest.cpp
rename to tests/lib/singleton-testmock-test.cpp
diff --git a/tests/lib/typed-allocation-manager-test.cpp b/tests/lib/typed-allocation-manager-test.cpp
index f72d6bdbd..bd1b2261f 100644
--- a/tests/lib/typed-allocation-manager-test.cpp
+++ b/tests/lib/typed-allocation-manager-test.cpp
@@ -78,7 +78,7 @@ namespace test{
    *        
    * @see CommandRegistry
    * @see command-registry-test.cpp
-   * @see allocationclustertest.cpp
+   * @see allocation-cluster-test.cpp
    */
   class TypedAllocationManager_test : public Test
     {
diff --git a/tests/lib/vector-transfer-test.cpp b/tests/lib/vector-transfer-test.cpp
index 2ffd27622..98f8f4021 100644
--- a/tests/lib/vector-transfer-test.cpp
+++ b/tests/lib/vector-transfer-test.cpp
@@ -32,132 +32,130 @@
 
 
 namespace lib {
-  namespace test {
-
-    using ::Test;
-    using std::vector;
-    using std::cout;
-
-    namespace { // extending the Dummy for our special purpose....
-
-      class TransDummy
-        : public Dummy
-        {
-        public:
-          TransDummy()
-            {
-              TRACE  (test, "CTOR      TransDummy() --> this=%p", this);
-              setVal(0); // we use val_==0 to mark the "empty" state
-            }
-
-          ~TransDummy()
-            {
-              TRACE  (test, "DTOR     ~TransDummy()  this=%p", this);
-            }
-
-          /* to make Dummy usable within vector, we need to provide
-           * \em special copy operations, an operator bool() and
-           * a transfer_control friend function to be used by
-           * our special allocator.
-           */
-
-          TransDummy (const TransDummy& o)
-            : Dummy()
-            {
-              TRACE  (test, "COPY-ctor TransDummy( ref=%p ) --> this=%p", &o,this);
-              CHECK (!o, "protocol violation: real copy operations inhibited");
-            }
-
-          TransDummy&
-          operator= (TransDummy const& ref)
-            {
-              TRACE  (test, "COPY      target=%p   <-- source=%p", this,&ref);
-              CHECK (!(*this));
-              CHECK (!ref, "protocol violation: real copy operations inhibited");
-              return *this;
-            }
-
-          void
-          setup (int x=0)
-            {
-              setVal (x? x : (rand() % 10000));
-              TRACE  (test, "CREATE    val=%d ---> this=%p", getVal(),this);
-            }
-
-
-          // define implicit conversion to "bool" the naive way...
-          operator bool()  const
-            {
-              return 0!=getVal();
-            }
-
-
-          friend void transfer_control (TransDummy& from, TransDummy& to);
-
-        };
-
-
-      void
-      transfer_control (TransDummy& from, TransDummy& to)
+namespace test {
+  
+  using ::Test;
+  using std::vector;
+  using std::cout;
+  
+  namespace { // extending the Dummy for our special purpose....
+    
+    class TransDummy
+      : public Dummy
       {
-        TRACE  (test, "TRANSFER  target=%p   <-- source=%p", &to,&from);
-        CHECK (!to, "protocol violation: target already manages another object");
-        to.setVal (from.getVal());
-        from.setVal(0);
-      }
-
-      typedef Allocator_TransferNoncopyable<TransDummy> Allo;
-      typedef vector<TransDummy, Allo> TransDummyVector;
-    }
-
-
-
-
-    /**********************************************************************************
-     *  @test growing (re-allocating) a vector with noncopyable objects, with the
-     *        help of a special Allocator and a custom \c transfer_control operation
-     *        provided by the contained objects. The idea is to allow some special
-     *        copy-operations for the purpose of re-allocations within the vector,
-     *        without requiring the object to be really copyable.
-     */
-    class VectorTransfer_test : public Test
-      {
-
-        virtual void
-        run (Arg)
+      public:
+        TransDummy()
           {
-            cout << "\n..setup table space for 2 elements\n";
-            TransDummyVector table;
-            table.reserve(2);
-            CHECK (0==checksum);
-
-            cout << "\n..install one element at index[0]\n";
-            table.push_back(TransDummy());
-            CHECK (0==checksum);
-
-            table[0].setup(); // switches into "managed" state
-            CHECK (0 < checksum);
-            int theSum = checksum;
-
-            cout << "\n..*** resize table to 5 elements\n";
-            table.resize(5);
-            CHECK (theSum==checksum);
-
-            cout << "\n..install another element\n";
-            table[3].setup(375);
-            CHECK (theSum+375==checksum);
-
-            cout << "\n..kill all elements....\n";
-            table.clear();
-            CHECK (0==checksum);
+            TRACE  (test, "CTOR      TransDummy() --> this=%p", this);
+            setVal(0); // we use val_==0 to mark the "empty" state
           }
-
+        
+       ~TransDummy()
+          {
+            TRACE  (test, "DTOR     ~TransDummy()  this=%p", this);
+          }
+        
+        /* to make Dummy usable within vector, we need to provide
+         * \em special copy operations, an operator bool() and
+         * a transfer_control friend function to be used by
+         * our special allocator.
+         */
+        
+        TransDummy (const TransDummy& o)
+          : Dummy()
+          {
+            TRACE  (test, "COPY-ctor TransDummy( ref=%p ) --> this=%p", &o,this);
+            CHECK (!o, "protocol violation: real copy operations inhibited");
+          }
+        
+        TransDummy&
+        operator= (TransDummy const& ref)
+          {
+            TRACE  (test, "COPY      target=%p   <-- source=%p", this,&ref);
+            CHECK (!(*this));
+            CHECK (!ref, "protocol violation: real copy operations inhibited");
+            return *this;
+          }
+        
+        void
+        setup (int x=0)
+          {
+            setVal (x? x : (rand() % 10000));
+            TRACE  (test, "CREATE    val=%d ---> this=%p", getVal(),this);
+          }
+        
+        
+        // define implicit conversion to "bool" the naive way...
+        operator bool()  const
+          {
+            return 0!=getVal();
+          }
+        
+        
+        friend void transfer_control (TransDummy& from, TransDummy& to);
+        
       };
-
-    LAUNCHER (VectorTransfer_test, "unit common");
-
-
-  }// namespace test
-
-} // namespace lib
-
+    
+    
+    
+    void
+    transfer_control (TransDummy& from, TransDummy& to)
+    {
+      TRACE  (test, "TRANSFER  target=%p   <-- source=%p", &to,&from);
+      CHECK (!to, "protocol violation: target already manages another object");
+      to.setVal (from.getVal());
+      from.setVal(0);
+    }
+    
+    typedef Allocator_TransferNoncopyable<TransDummy> Allo;
+    typedef vector<TransDummy, Allo> TransDummyVector;
+  }
+  
+  
+  
+  
+  /**********************************************************************************
+   *  @test growing (re-allocating) a vector with noncopyable objects, with the
+   *        help of a special Allocator and a custom \c transfer_control operation
+   *        provided by the contained objects. The idea is to allow some special
+   *        copy-operations for the purpose of re-allocations within the vector,
+   *        without requiring the object to be really copyable.
+   */
+  class VectorTransfer_test : public Test
+    {
+      
+      virtual void
+      run (Arg)
+        {
+          cout << "\n..setup table space for 2 elements\n";
+          TransDummyVector table;
+          table.reserve(2);
+          CHECK (0==checksum);
+          
+          cout << "\n..install one element at index[0]\n";
+          table.push_back(TransDummy());
+          CHECK (0==checksum);
+          
+          table[0].setup(); // switches into "managed" state
+          CHECK (0 < checksum);
+          int theSum = checksum;
+          
+          cout << "\n..*** resize table to 5 elements\n";
+          table.resize(5);
+          CHECK (theSum==checksum);
+          
+          cout << "\n..install another element\n";
+          table[3].setup(375);
+          CHECK (theSum+375==checksum);
+          
+          cout << "\n..kill all elements....\n";
+          table.clear();
+          CHECK (0==checksum);
+        }
+      
+    };
+  
+  LAUNCHER (VectorTransfer_test, "unit common");
+  
+  
+}} // namespace lib::test

From 2c992a1a4dee631b262f31a8cee5eb85abb24806 Mon Sep 17 00:00:00 2001
From: Ichthyostega <prg@ichthyostega.de>
Date: Sat, 18 Dec 2010 01:01:27 +0100
Subject: [PATCH 27/28] Fix a printf warning in GUI

---
 src/gui/output/xvdisplayer.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/gui/output/xvdisplayer.cpp b/src/gui/output/xvdisplayer.cpp
index 81ed19188..4c0780101 100644
--- a/src/gui/output/xvdisplayer.cpp
+++ b/src/gui/output/xvdisplayer.cpp
@@ -62,7 +62,7 @@ XvDisplayer::XvDisplayer( Gtk::Widget *drawing_area, int width, int height ) :
       for ( unsigned int n = 0; gotPort == false && n < count; ++n )
         {
           // Diagnostics
-          INFO(gui, "%s, %u, %u", adaptorInfo[ n ].name,
+          INFO(gui, "%s, %lu, %lu", adaptorInfo[ n ].name,
             adaptorInfo[ n ].base_id, adaptorInfo[ n ].num_ports - 1);
 
           for ( unsigned int port = adaptorInfo[ n ].base_id;

From 459b1a061f12bb405ab3945b5991e977cc1b6859 Mon Sep 17 00:00:00 2001
From: Ichthyostega <prg@ichthyostega.de>
Date: Sat, 18 Dec 2010 02:22:25 +0100
Subject: [PATCH 28/28] Autotools fixes

---
 src/proc/Makefile.am | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/proc/Makefile.am b/src/proc/Makefile.am
index 4d0cdc17f..56ef795df 100644
--- a/src/proc/Makefile.am
+++ b/src/proc/Makefile.am
@@ -108,9 +108,11 @@ liblumiprocmobjectbuilder_la_CXXFLAGS = $(AM_CXXFLAGS) $(LUMIERA_PROC_CFLAGS) -W
 liblumiprocmobjectbuilder_la_SOURCES =					\
 	$(liblumiprocmobjectbuilder_la_srcdir)/assembler.cpp		\
 	$(liblumiprocmobjectbuilder_la_srcdir)/conmanager.cpp		\
+	$(liblumiprocmobjectbuilder_la_srcdir)/model-port-registry.cpp	\
+	$(liblumiprocmobjectbuilder_la_srcdir)/operationpoint.cpp	\
 	$(liblumiprocmobjectbuilder_la_srcdir)/nodecreatortool.cpp	\
-	$(liblumiprocmobjectbuilder_la_srcdir)/segmentation.cpp		\
 	$(liblumiprocmobjectbuilder_la_srcdir)/segmentation-tool.cpp	\
+	$(liblumiprocmobjectbuilder_la_srcdir)/segmentation.cpp		\
 	$(liblumiprocmobjectbuilder_la_srcdir)/toolfactory.cpp