Daren@Work

Converting line endings on the cheap

2012-01-18T14:29:00.001+01:00

You're at a client's PC, installing some scripts and need to edit a text file. Of course your client has no real editor, just that stupid notepad.exe! And then you notice: All the line endings are wrong, that is, they're LF (unix convention) as opposed to CR-LF (dos convention). That is because you do have a real editor, and so does the other guy working on that file and one of you was not working on windows, because it's only an OS, right? A tool, not a religion.

Not religous either: What escapes your mouth when you are confronted with a single line of script and black box characters laughing at you where line breaks should be.

Now, users of cygwin are probably familiar with a myriad of tools (e.g. dos2unix.exe) to convert from dos line endings to unix line endings. You might be able to get tr to work for you too. Or you could just open the file in your trusty real editor and type away.

But your client has none of this installed.

What your client does have installed, is MS Word. Seriously. I'm going to use MS Word now. This is how:

open the script/text file in notepad

select all text, copy it to the clipboard ([CTRL]+[A], [CTRL]+[C])

open a blank document in MS Word

paste from the clipboard ([CTRL]+[V])

select all text in MS Word, copy it to the clipboard ([CTRL]+[A], [CTRL]+[C])

paste over (replacing) the selection in notepad ([CTRL]+[V])

close MS Word and wash your hands to get rid of the dirty hack feeling...

How to install Trac on a Synology DS2011+

2011-11-11T16:37:00.003+01:00

In a previous post, I described installing Trac on a Synology DS209+II. I recently had to migrate this installation to a Synology DS2011+ and ran into some snags. This post will help you avoid spending all the hours I did on getting it to work.

Modifying the Synology DiskStation

To be able to do anything to your DS2011+, you first have to install the ipkg bootstrap. I basically followed along with page on the synology forum Overview on modifying the Synology Server, bootstrap, ipkg etc.:

You need to enable ssh access to your NAS and then log in with PuTTY

The Synology DS2011+ has a "Marvell Kirkwood mv6282" processor, so these steps should do the trick:

cd /volume1/@tmp
wget http://wizjos.endofinternet.net/synology/archief/syno-mvkw-bootstrap_1.2-7_arm-ds111.xsh
chmod +x syno-mvkw-bootstrap_1.2-7_arm-ds111.xsh
sh syno-mvk-bootstrap_1.2-7_arm-ds111.xsh
rm syno-mvk-bootstrap_1.2-7_arm-ds111.xsh

After rebooting the NAS, you can enter these commands:

ipkg update
ipkg upgrade

We are now ready to start installing all the stuff needed for running Trac!

Software to install

Apache

Log on to your DS2011+ and install the following package:

ipkg install apache

Now we have a second httpd listening on port 8000. The configuration file for this instance of apache is /opt/etc/apache2/httpd.conf. You can find the log files in /opt/var/apache2/log. Also note that it is started on system boot by the script /opt/etc/init.d/S80apache. I suggest you execute this script and see if apache starts up nicely.

I ran into some problems with this installation: A syntax error on line 74 of /opt/etc/apache2/httpd.conf. Somehow apache can't load the mod_ext_filter.so. I didn't really care and just commented out that line.

Subversion

Create a new share using the DSM (that web interface on port 5000) - call it "svn". It will show up on your box as /volume1/svn.

I mainly followed the Step-by-step guide to installing Subversion on the Synology wiki. But I didn't bother messing with inetd.conf, since I am running svn under apache with mod_dav_svn. So, that leaves the following steps:

ipkg install svn
su svnowner
cd /volume1/svn
svnadmin create testsvn

You now have a new repository on your NAS called "testsvn". You just can't access it yet - but we'll fix that next! Also note that the Step-by-step guide to installing Subversion includes a few hints on how to get su svnowner to work if you get an error message.

To get Apache to serve your subversion repository, append this to /opt/etc/apache2/httpd.conf:

# Subversion
Include etc/apache2/conf.d/mod_dav_svn.conf

You will have to create /opt/etc/apache2/conf.d/mod_dav_svn.conf of course:

LoadModule dav_svn_module     libexec/mod_dav_svn.so
LoadModule authz_svn_module   libexec/mod_authz_svn.so

<Location /svn>
   DAV svn
   SVNParentPath /volume1/svn
   AuthType Basic
   AuthName "Subversion repository"
   AuthUserFile /volume1/svn/svn-auth-file
   Require valid-user
</Location>

Trac

So far, this guide is much the same as the one it replaces. The new stuff is in the version of python used:

ipkg install python26 py26-trac py26-genshi py26-setuptools sqlite svn-py

The need for upgrading comes from the package svn-py, which is now python 2.6.

Create a share (using the DSM) called "trac-env". This is where we will keep our trac installations.

I am now running Trac version 0.12. The Trac environments can be found at /volume1/trac-env. They are called "MYTRAC1" and "MYTRAC2". Access to them is via the following URLs:

http://myserver.example.com:8888/MYTRAC1

http://myserver.example.com:8888/MYTRAC2

Trac is run using tracd. This is configured to start automatically on system start by creation of the following file: /opt/etc/init.d/S81trac:

#!/bin/sh
# run tracd
/opt/bin/tracd -d -p 8888 -e /volume1/trac-env

The file must be set to executable for root (see documentation for chmod), so that it will be run at system start.

Trac configuration files can be found at

/volume1/trac-env/MYTRAC1/conf/trac.ini

/volume1/trac-env/MYTRAC2/conf/trac.ini

Authentication via Apache

appended following lines to /opt/etc/apache2/httpd.conf:

# Subversion
Include etc/apache2/conf.d/trac.conf

And then, create the file /opt/etc/apache2/conf.d/trac.conf:

# allow Apache to be used for authenticating Trac
<Directory /opt/share/www/trac>
   AuthType Basic
   AuthName "Subversion repository"
   AuthUserFile /volume1/svn/svn-auth-file
   Require valid-user
</Directory>

Authentication is done with the AccountManager plugin for trac (http://trac-hacks.org/wiki/AccountManagerPlugin). The website has a good explanation on how that works. See the copies of the trac.ini files for reference. I'd like to point out the last section:

[account-manager]
password_store = HttpAuthStore
authentication_url = http://myserver.example.com:8000/trac

This is where we tell Trac to use our Apache Server for authentication. Note how the authentication_url is the same as the Directory in trac.conf.

Backup

Backup is still the same as in the previous post, so I'll just point you there: http://darenatwork.blogspot.com/2011/03/how-to-install-trac-on-synology-ds209ii.html

Using the Snoop Objects dialog from RevitLookup in RevitPythonShell

2011-08-12T16:19:00.001+02:00

One of my main goals with RevitPythonShell is to provide a handy environment for exploring the Autodesk Revit API. But anyone seriously interested in exploring the Revit API should also be familiar with RevitLookup, formally known as RvtMgdDbg. This tool can be found in the SDK and includes a handy command for "snooping" a selected element called "Snoop Current Selection...". I use this so often, that I created a keyboard shortcut to invoke it. It provides vital information for working with Revit objects - information you probably want access to while inside an interactive RPS shell!

Unfortunately, you can't execute plugins while inside the RPS shell. Well, not through the Revit UI. You can access them via code. This blog is about a simple little module I wrote that let's you do this anywhere inside the shell:

>>>import revitsnoop

>>>snooper = revitsnoop.RevitSnoop(__revit__)

>>>snooper.snoop(doc.ProjectInformation)

And have a dialog like this popped up:

Notice how you specify the object you want to snoop in code, as opposed to having to select it in the UI. Pretty nifty, eh?

How it works

The Autodesk.Revit.UI.UIApplication object has a property LoadedApplications that returns a list of all loaded external applications. As long as you have RevitLookup installed (quick test: can you find it in the Add-Ins tab?), it will show up in this list. It is pretty easy to find it:

rlapp = [app for app in uiApplication.LoadedApplications
         if app.GetType().Namespace == 'RevitLookup'
         and app.GetType().Name == 'App'][0]

I can't test with isinstance, since RPS doesn't know about RevitLookup yet and therefore I can't name the type. That is why I used GetType() and compared the namespace and name of the type.

Once we have the type, though, we can load the assembly and import RevitLookup as a module into IronPython:

import clr
clr.AddReference(rlapp.GetType().Assembly)
import RevitLookup

The statement import RevitLookup will only work after adding a reference to the assembly, but afterwards, we can start using the classes inside. To figure out what had to be done, I checked the source for RevitLookup, specifically the ExternalCommand that implements the "Snoop Current Selection..." functionality: RevitLookup.CmdSnoopModScope. It would have been possible to create an instance of this class and call its Execute method, but it turned out to be quicker and easier to just implement the body myself:

# See note in CollectorExt.cs in the RevitLookup source:
RevitLookup.Snoop.CollectorExts.CollectorExt.m_app = __revit__

# create a list of elements to snoop
elementSet = ElementSet()
elementSet.Insert(doc.ProjectInformation)

# create and show the dialog
form = RevitLookup.Snoop.Forms.Objects(elementSet)
form.ShowDialog()

This code is wrapped up in a module called revitsnoop for your convenience in the RevitPythonShell download section. To use it, place it inside one of the search paths configured in RPS.

The Code

For completeness sake, here is the whole module:

'''
revitsnoop.py

a simple library to access the RevitLookup snoop functionality
while inside the interactive shell...
'''
import clr
from Autodesk.Revit.DB import ElementSet

class RevitSnoop(object):
    def __init__(self, uiApplication):
        '''
        for RevitSnoop to function properly, it needs to be instantiated
        with a reverence to the Revit Application object.
        '''
        # find the RevitLookup plugin
        rlapp = [app for app in uiApplication.LoadedApplications
                 if app.GetType().Namespace == 'RevitLookup'
                 and app.GetType().Name == 'App'][0]
        # tell IronPython about the assembly of the RevitLookup plugin
        clr.AddReference(rlapp.GetType().Assembly)
        import RevitLookup
        self.RevitLookup = RevitLookup
        # See note in CollectorExt.cs in the RevitLookup source:
        self.RevitLookup.Snoop.CollectorExts.CollectorExt.m_app = uiApplication

    def snoop(self, element):
        elementSet = ElementSet()
        elementSet.Insert(element)
        form = self.RevitLookup.Snoop.Forms.Objects(elementSet)
        form.ShowDialog()

I think a logical further improvement would be to add some methods (e.g. snoopDocument and snoopApplication) for accessing the other useful functions of RevitLookup. But by now you should already know how to do it yourself!

Wall.Orientation Property for walls based on arcs in Autodesk Revit 2011

2011-06-30T13:36:00.001+02:00

This is what the documentation for the Wall.Orientation property in Autodesk Revit 2011 says:

The normal vector projected from the exterior side of the wall.

While this is tried and tested, it is only half of the story. I don't know the whole story, but this post is about one exception i found: Walls based on an arc.

Repro steps:

create a new Revit document
in the ribbon, on the "Home" tab click "Wall"
in the "Draw" panel, choose the icon "Start-End-Radius Arc"
create a wall by specifying the start, the end... well, you get it.

So, we now have a wall that isn't planar:

What is its orientation? What do you think it should be? Let's ask Revit! I'm going to use the RevitPythonShell (RPS) to query this wall, so we can see interactivly what is going on:

>>>collector = FilteredElementCollector(doc)

>>>wall = collector.OfClass(Wall).ToElements()[0]

>>>wall.Orientation

<Autodesk.Revit.DB.XYZ object at 0x000000000000002F [(-0.858104216, 0.513475563, 0.000000000)]>

I was expecting the orientation to be due North: (0, 1, 0). That is where the orientation handle bars are shown. But that is not what we get. What we get is a vector from the curve center point to the start point of the arc:

>>>curve = wall.Location.Curve

>>>P0 = curve.get_EndPoint(0)

>>>M = curve.Center

>>>Vector(P0, M)

IronTextBoxControl error: name 'Vector' is not defined
>>>XYZ(P0.X - M.X, P0.Y - M.Y, P0.Z - M.Z)

<Autodesk.Revit.DB.XYZ object at 0x0000000000000030 [(-34.284776903, 20.515451146, 0.000000000)]>
>>>r = XYZ(P0.X - M.X, P0.Y - M.Y, P0.Z - M.Z)

>>>r.Normalize()

<Autodesk.Revit.DB.XYZ object at 0x0000000000000031 [(-0.858104216, 0.513475563, 0.000000000)]>
>>>

As you can see, the orientation has the same direction as a vector from the arc center to the start point of the arc. This is for walls that face away from the arc center. Let's flip the wall and see what happens:

>>>t.Start()

<Autodesk.Revit.DB.TransactionStatus object at 0x0000000000000032 [Started]>
>>>wall.flip()

>>>t.Commit()

<Autodesk.Revit.DB.TransactionStatus object at 0x0000000000000033 [Committed]>
>>>wall.Orientation

<Autodesk.Revit.DB.XYZ object at 0x0000000000000034 [(0.858104216, -0.513475563, 0.000000000)]>
>>>

As you see, the vector changed it's orientation too. So, for arcs with wall orientation facing the arc center, the Wall.Orientation property is the normalized vector from the arc start point to the arc center.

Which of the parameters on the ProjectInfo are built in?

2011-05-27T16:59:00.001+02:00

Yesterday I needed to know which of the ProjectInfo parameters are actually built in and can be relied on to be found in any Autodesk Revit Architecture document. Of course I fired up RPS and had a go at finding a solution. Here is what I came up with:

import clr
clr.AddReference('RevitAPI')
clr.AddReference('mscorlib')
from Autodesk.Revit.DB import *
from System import Enum

doc = __revit__.ActiveUIDocument.Document
pi = doc.ProjectInformation
params = list(pi.Parameters)
builtInParameterIds = set([p.Id.IntegerValue for p in params if p.Id.IntegerValue < 0])
for id in builtInParameterIds:
    parameter = pi.get_Parameter(Enum.ToObject(BuiltInParameter, id))
    name = Enum.GetName(BuiltInParameter, id)
    if parameter:
        print name, ': ', parameter.AsString()
    else:
        print name, ': <NULL>'

There are some aspects of this script I'd like to point out, since they might help you writing your own scripts:

This gives you access to the System.Enum type. The BuiltInParameter enumeration has to be marshalled back and forth to IronPython integers using Enum:

Enum.ToObject(BuiltInParameter, id) returns the enum constant that has the integer value id

Enum.GetName(BuiltInParameter, id) returns the name of the enum constant (handy for printing to the user)

Also note that all the predefined parameters in Revit have negative ids - that is how we find them:

The output on a test project on my computer is:

PROJECT_ISSUE_DATE :  Projekt Datum
GBXML_EDIT_DATA_PARAM : <NULL>
PROJECT_STATUS :  Projekt  Status
CLIENT_NAME :  Bauherr
PROJECT_ADDRESS :  Projektadresse
PROJECT_NAME :  Projekt Name
PROJECT_NUMBER :  01212

Adding both 32 and 64 bit versions of DLLs to a Visual Studio 2010 Setup project

2011-05-19T15:56:00.001+02:00

I ran into a snag, when trying to create an installer using a Visual Studio 2010 Setup project that would install for 32 and 64 bit versions of Autodesk Revit Architecture. Since my program depends on a DLL (in this case System.Data.SQLite.dll) that ships in two different versions, I wanted to include both in the MSI and then copy the correct one to the installation folder with a CustomAction project. The snag consists of this pesky error message whenever you add a 64 bit dll to a Setup project that is targeting x86:

File 'System.Data.SQLite.dll' of project output 'Content Files from MYPROJECT (Active)' targeting 'AMD64' is not compatible with the project's target platform 'x86'

That was easy to fix! All I had to do was include the file with a different extension, right? So... I renamed System.Data.SQLite.dll to System.Data.SQLite.txt and added it to MYPROJECT as a new content file. Same error when building the setup project:

File 'System.Data.SQLite.txt' of project output 'Content Files from MYPROJECT (Active)' targeting 'AMD64' is not compatible with the project's target platform 'x86'

It seems, the setup project figures out that you have a DLL here, even if the extension doesn't is something totally different. I tried various extensions to no avail.

So, the next logical step would be to use the old email zip file trick, right? It is rather easy to zip a DLL. Any number of tools will do that for you. It turns out to be rather tricky to unzip a DLL in C# inside your CustomAction.

It is possible to use a 3rd party library for unzipping, but I didn't really want to add a dependency just for the installer. Instead, I opted to use the DEFLATE algorithm provided in .NET here: System.IO.Compression.DeflateStream.

Given a file compressed with this algorithm, the code to inflate it back to normal size is trivial:

using (var srcFile = File.OpenRead(@"C:\MYPATH\System.Data.SQLite.x64"))
{
    using (var dstFile = File.OpenWrite(@"C:\MYPATH\System.Data.SQLite.dll"))
    {
        using (var deflator = new DeflateStream(srcFile, CompressionMode.Decompress))
        {
            CopyStream(deflator, dstFile);
        }
    }
}

Just... how to get the original file into the deflated version? I couldn't find a tool that reliably did this for me, so I created my own: http://code.google.com/p/deflate/

To quote from the projects page:

This project provides two simple programs:

deflate.exe inflate.exe They are implented using the System.IO.Compression.DeflateStream provided in .NET.

Usage:
C:\> type MYFILE | deflate.exe > MYFILE.deflated
C:\> type MYFILE.deflated | inflate.exe > MYFILE

I now have the honour to present the steps to create a DLL targeted at a different architecture as your setup:

deflate the file using deflate.exe, naming it with a different extension (e.g. .x64)

add it to your main project as a content file

add a custom action project to your solution

add the custom action to the setup projects "Install" custom actions

inflate the file inside the custom actions Install method using System.IO.Compression.DeflateStream (see code above)

do a little dance around your desk, down the hall, and past as many coworkers as you care to annoy :)

Listing Window Dimensions with RevitPythonShell

2011-04-14T10:27:00.001+02:00

I wrote this quick script this morning and thought I should share:

import clr
clr.AddReference('RevitAPI')
from Autodesk.Revit.DB import *

doc = __revit__.ActiveUIDocument.Document

import revitutil

def main():
    windows = revitutil.listWindows(doc)

    for w in windows:
        instance_width = revitutil.meters(w.get_Parameter(BuiltInParameter.WINDOW_WIDTH).AsDouble())
        instance_height = revitutil.meters(w.get_Parameter(BuiltInParameter.WINDOW_HEIGHT).AsDouble())

        wt = doc.get_Element(w.GetTypeId())

        type_width = revitutil.meters(wt.get_Parameter(BuiltInParameter.WINDOW_WIDTH).AsDouble())
        type_height = revitutil.meters(wt.get_Parameter(BuiltInParameter.WINDOW_HEIGHT).AsDouble())

        rough_width = revitutil.meters(wt.get_Parameter(BuiltInParameter.FAMILY_ROUGH_WIDTH_PARAM).AsDouble())
        rough_height = revitutil.meters(wt.get_Parameter(BuiltInParameter.FAMILY_ROUGH_WIDTH_PARAM).AsDouble())

        wid = w.Id.IntegerValue
        wname = w.Name

        print "%(wid)d\t%(wname)s\t%(instance_width).2f\t%(instance_height).2f\t%(type_width)s\t%(type_height).2f\t%(rough_width).2f\t%(rough_height).2f" % locals()


if __name__ == '__main__':
    import traceback
    try:
        main()
    except:
        traceback.print_exc()

It doesn't do much more than you could do with a window schedule in the Revit GUI, except that I couldn't figure out how to distinguish instance width and type width in window schedules. As I was trying to debug some code that made that distinction, I needed some goggles! Out pops RPS to the rescue ;)

One thing I'd like to point out is the structure of the script. I tend to write my canned commands in RPS following this structure:

import stuff and create a doc variable (I normally just copy the contens of the InitScript for this)

define a main() function that handles the code

use the if __name__ == '__main__' idiom to wrap calling the main function in a try block

The reason for using the try block is traceback.print_exc() which prints a nice error message to the console that helps debugging!

List Parameters of Current Selection

2011-04-06T14:55:00.001+02:00

This is another post about using the RevitPythonShell (RPS) for accessing the Revit API. I assume you are using a variation of the default InitScript, as that provides a handy selection variable.

The following session in the RPS shell assumes you have selected a wall in your Revit model. It then provides a list of the names of all parameters on the walls type:

>>>w

<Autodesk.Revit.DB.Wall object at 0x000000000000002B [Autodesk.Revit.DB.Wall]>
>>>wt = doc.get_Element(w.GetTypeId())

>>>plist = list(wt.Parameters)

>>>pnames = [p.Definition.Name for p in plist]

>>>pnames

['Description', 'DPV:DpvConstruction', 'Fire Rating', 'Structure', 'Assembly Description', 'Type Mark', 'Cost', 'Coarse Scale Fill Color', 'URL', 'Function', 'Width', 'Wrapping at Inserts', 'Assembly Code', 'Type Comments', 'Coarse Scale Fill Pattern', 'Keynote', 'Model', 'Wrapping at Ends', 'Manufacturer']
>>>

Exporting Images with the Autodesk Revit API

2011-03-31T16:24:00.001+02:00

I tried to find some sample code for using the Document.ExportImage method in Autodesk Revit 2011 but couldn't find any. So I wrote my own sample code and posted it on the RevitPythonShell wiki as a featured script. I'd like to share it here too:

'''
exportImage.py

Export the currently visible view as a PNG image to a location specified by the user.
'''
import clr
clr.AddReference('RevitAPI')
from Autodesk.Revit.DB import *

doc = __revit__.ActiveUIDocument.Document

# collect file location from user
clr.AddReference('System.Windows.Forms')
from System.Windows.Forms import DialogResult, SaveFileDialog
dialog = SaveFileDialog()
dialog.Title = 'Export current view as PNG'
dialog.Filter = 'PNG files (*.PNG)|*.PNG'

if dialog.ShowDialog() == DialogResult.OK:
    # set up the export options
    options = ImageExportOptions()
    options.ExportRange = ExportRange.VisibleRegionOfCurrentView
    options.FilePath = dialog.FileName
    options.HLRandWFViewsFileType = ImageFileType.PNG
    options.ImageResolution = ImageResolution.DPI_72
    options.ZoomType = ZoomFitType.Zoom
    options.ShadowViewsFileType = ImageFileType.PNG

    doc.ExportImage(options)

__window__.Close()

The above code does some stuff necessary for any canned command in RPS: It adds references to the RevitAPI and imports the Autodesk.Revit.DB types. I also open a SaveFileDialog using code found here: http://www.ironpython.info/index.php/SaveFileDialog.

How to install Trac on a Synology DS209+II

2011-03-16T11:35:00.001+01:00

These are some short notes on how I (successfully) installed Trac on a Synology DS209+II. The process should be similar for many other Synology servers. Please comment on any errors you find or snags you run into.

I modified my Synology server from the original Synology setup:

installed ipkg bootstrap (http://forum.synology.com/wiki/index.php/Overview_on_modifying_the_Synology_Server,_bootstrap,_ipkg_etc)

installed subversion according to (http://forum.synology.com/wiki/index.php/Step-by-step_guide_to_installing_Subversion_on_ARM-based_Synology_Products)

omitted WebSVN installation

Subversion directory is /volume1/svn

did not configure inetd to run svnserve, as we are using Apache (see below)

no changes to /etc/inetd.conf

no changes to /etc/services

since subversion is served by apache, we need to make sure the repositories have the same user as the apache server.

chown -R nobody:users /volume1/svn/MYREPO1

chown -R nobody:users /volume1/svn/MYREPO2

issued following commands in the root console:

ipkg update

ipkg install py25-trac py25-genshi py25-setuptools svn-py

maybe also: ipkg install sqlite

ipkg install apache

Now we have a second httpd listening on port 8000

Configuration file is /opt/etc/apache2/httpd.conf

Log files are in /opt/var/apache2/log/

Configuration of Apache for Subversion

I appended following lines to /opt/etc/apache2/httpd.conf:

# Subversion
Include etc/apache2/conf.d/mod_dav_svn.conf

Also, I created a file /opt/etc/apache2/conf.d/mod_dav_svn.conf with following contents:

LoadModule dav_svn_module     libexec/mod_dav_svn.so
LoadModule authz_svn_module   libexec/mod_authz_svn.so

<Location /svn>
   DAV svn
   SVNParentPath /volume1/svn
   AuthType Basic
   AuthName "Subversion repository"
   AuthUserFile /volume1/svn/svn-auth-file
   Require valid-user
</Location>

# allow Apache to be used for authenticating Trac
<Directory /opt/share/www/trac>
   AuthType Basic
   AuthName "Subversion repository"
   AuthUserFile /volume1/svn/svn-auth-file
   Require valid-user
</Directory>

This expects a file /volume1/svn/svn-auth-file to be present. That file contains the passwords used for Subversion (and, via Apache, Trac authentication). This file is generated with apaches htpasswd -c command. I used the cm too, to force md5 hashing of the passwords. Also, I added the folder /opt/share/www/trac` - this is used later on for Trac authentication, as I instruct Apache to authenticate this URL and tell Trac to use it for authentication.

Trac configuration

I am running Trac version 0.11.7. The Trac environments can be found at /volume1/trac-env. They are called "MYTRAC1" and "MYTRAC2". Access to them is via the following URLs:

http://myserver.example.com:8888/MYTRAC1

http://myserver.example.com:8888/MYTRAC2

Trac is run using tracd. This is configured to start automatically on system start by creation of the following file: /opt/etc/init.d/S81trac:

#!/bin/sh
# run tracd
/opt/bin/tracd -d -p 8888 -auth=*,/volume1/svn/svn-auth-file,myserver.example.com -e /volume1/trac-env

The file must be set to executable for root (see documentation for chmod), so that it will be run at system start.

Trac configuration files can be found at

/volume1/trac-env/MYTRAC1/conf/trac.ini

/volume1/trac-env/MYTRAC2/conf/trac.ini

Authentication via Apache

[account-manager]
password_store = HttpAuthStore
authentication_url = http://myserver.example.com:8000/trac

This is where we tell Trac to use our Apache Server for authentication.

Backup

Backing up Trac

Trac is backed up with the trac-admin hotcopy command. The configuration of the backup is in /etc/crontab. It is done by executing the script /volume1/trac-env/tracbackup:

#!/bin/sh

/opt/bin/trac-admin /v9olume1/trac-env/MYTRAC1 hotcopy `date +/volumeUSB1/usbshare/TracBackup/%Y%m%d_trac_hotcopy_MYTRAC1`
/opt/bin/trac-admin /v9olume1/trac-env/MYTRAC2 hotcopy `date +/volumeUSB1/usbshare/TracBackup/%Y%m%d_trac_hotcopy_MYTRAC2`

# make sure other computers connecting to the share
# can delete these files
chmod 777 /volumeUSB1/usbshare/TracBackup/*

FIXME: these still have to be deleted regularly. I do this from my PC, so as to keep the complexity on the server minimal.

Backing up Subversion

Subversion is backed up with the svnadmin dump command, since this can then be read in from other subversion versions. The configuration of the backup is in /etc/crontab. It is done by executing the script /volume1/svn/svnbackup:

#!/bin/sh

/opt/bin/svnadmin dump /volume1/svn/MYREPO1 > `date +/volumeUSB1/usbshare/SvnBackup/%Y%m%d_svn_dump_MYREPO1`
/opt/bin/svnadmin dump /volume1/svn/MYREPO2 > `date +/volumeUSB1/usbshare/SvnBackup/%Y%m%d_svn_dump_MYREPO2`

# make sure other computers connecting to the share
# can delete these files
chmod 777 /volumeUSB1/usbshare/SvnBackup/*

FIXME: these still have to be deleted regularly. I do this from my PC, so as to keep the complexity on the server minimal.

Status Bar Text and WPF

2011-02-10T16:39:00.001+01:00

Yesterday, Jeremy Tammik posted how to change the status bar text in Revit. Toward the end of his post, he mentions using GetCurrentProcess to find the HWND of the main Revit window.

Yay! says I: Now I can print out status text, without cluttering up my shiny WPF window.

Nay! says WPF: It doesn't work.

Imagine my frustration... I spent some time analysing this using SPY++ and found out, that WPF dialogs are not children of the main application window. If your IExternalCommand starts a WPF window, then you should note the HWND first and then show the dialog. You can keep the HWND in a class variable, since it won't change. I ended up with a utility static class StatusText:

public static class StatusText
{
    [DllImport("user32.dll", SetLastError = true, CharSet = CharSet.Auto)]
    static extern int SetWindowText(IntPtr hWnd, string lpString);

    [DllImport("user32.dll", SetLastError = true)]
    static extern IntPtr FindWindowEx(IntPtr hwndParent, IntPtr hwndChildAfter,
                                      string lpszClass, string lpszWindow);

    private static IntPtr _hwndRevit = new IntPtr();

    /// <summary>
    /// Set the handle to the revit main window here before calling
    /// SetStatusText.
    /// (also, set it in the IExternalCommand.Execute thread, not
    /// in your WPF thread)
    /// </summary>
    public static void SetRevitWindowHandle(IntPtr hwnd)
    {
        _hwndRevit = hwnd;
    }

    /// <summary>
    /// Set the status text of the current revit instance.
    /// </summary>
    public static void SetStatusText(string text)
    {
        IntPtr statusBar = FindWindowEx(_hwndRevit, IntPtr.Zero,
                                        "msctls_statusbar32", "");

        if (statusBar != IntPtr.Zero)
        {
            SetWindowText(statusBar, text);
        }
    }

}

You can then just issue a

StatusText.SetStatusText("hello, world!");

whenever you need to display something cool. Bonus points for hooking this up to a TraceListener ;)

A Pattern For Asynchronously Updating Revit Documents

2010-11-26T09:29:00.001+01:00

With Revit 2011 we got a new event: UIApplication.Idling. This post is about how to use the Idling event to update a Revit document outside the scope of an IExternalCommand.

Imagine a dialog, opened by an IExternalCommand. Let us leave the dialog open and return Result.Succeeded. Let us also set the dialog to stay on top always. A bit like a tool window with some funky gadgets and commands. We want those commands to alter something in the Revit document and then update its gadgets to display stuff.

If you just stash away the ExternalCommandData and try to access the Revit application using that, you will crash Revit sooner or later. I forget the exact message, but something along the lines of reading/writing memory you shouldn't be. But you were warned by the docs, so, stop whining: Outside of the IExternalCommand.Execute method, the command data becomes stale and should not be used anymore.

Create a static Queue of Action<UIApplication>. You can store this in your IExternalApplication implementation and initialize it to an empty list on startup. This queue has to be static as you want it to persist while the class is loaded in memory (the class will be loaded by Revit on startup).

Next, hook up to the Idling event in your IExternalApplication.OnStartup method:

private static Queue<Action<UIApplication>> _tasks;
public Result OnStartup(UIControlledApplication revit)
{
    _tasks = new Queue<Action<UIApplication>>()
    revit.Idling += OnIdling;
}

Great. Now for the implementation of OnIdling:

private void OnIdling(object sender, IdlingEventArgs e)
{
    var app = (UIApplication)sender;
    lock (_tasks)
    {
        if (_tasks.Count > 0)
        {
            Action<UIApplication> task = _tasks.Dequeue();

            // execute the task!
            task(app);
        }
    }
}

This is one half of the equation. Next, we have to get the tasks into queue. Also, note that I'm locking the queue before reading it, since the dialog might access it at the same time as we are reading and I just want to be safe here.

To add a tasks to the queue, we just need a method in the IExternalApplication that will accept it:

public static void EnqueueTask(Action<UIDocument> task)
{
    lock (_tasks)
    {
        _tasks.Enqueue(task);
    }
}

This can then be called from your dialogs code, e.g. when a button is pressed. Assuming your IExternalApplication is called FooPlugin, an invocation could look something like this:

public void YouPushedMyButton(object sender, EventArgs args)
{
     FooPlugin.Enqueue((app) => {
         var doc = app.ActiveUIDocument.Document;
         doc.ProjectInformation.ClientName = "Boss Murphy";
     });
}

If you are not familiar with the (app) => { /* statements */ } this is a statement lambda. You might want to read the chapter Lambda Expressions from the C# Programming Guide on msdn.

A nice property of these lambda expressions is, that they create a closure around the variables that were in scope at the time of creation. Instead of "Boss Murphy" I could also have assigned some instance value from the dialog or a local variable from YouPushedMyButton.

The next time Revit fires an Idling Event, your tasks will be executed!

Oh, one thing: You will have to make sure you open a transaction. I haven't done this in the example, to keep things short and simple, but it's going to go boom on you! There are two possible places for this: Either in the lambda statement directly, or, if you know for sure that you are always going to need a transaction (all your tasks will be writing to the document), you could add it in the OnIdling event handler, wrapping the task(app) call.

Listing Level Elevations with RevitPythonShell

2010-11-12T16:52:00.001+01:00

I recently stumbled apon the Revit APP blog and spotted a simple code listing for getting all level elevations. This should be a no-brainer using the RevitPythonShell (RPS), so I fired up a shell and started typing. This is a session transcript in the shell:

>>>import clr

>>>clr.AddReference('RevitAPI')

>>>import Autodesk.Revit.DB

>>>collector = Autodesk.Revit.DB.FilteredElementCollector(__revit__.ActiveUIDocument.Document)

>>>elems = collector.WhereElementIsNotElementType().OfClass(Autodesk.Revit.DB.Level).ToElements()

>>>for lv in elems:
...    print '%s: %.2f' % (lv.Name, lv.Elevation)
...
Level 1: 0.00
Level 2: 9.84
>>>

I am getting a bit fed up of typing import clr and referencing RevitAPI whenever I use RPS so my next step will be to try and add that by default. I'll keep you posted about that.

Unit Testing Revit Plugins

2010-11-10T09:21:00.001+01:00

Yesterday, Jeremy Tammik brought an interesting thread on augi (Unit testing with Revit API) to my attention, suggesting that I might like to add something on the RevitPythonShell (RPS).

I couldn't register as a member on augi (some mail thing I don't want to digg into), so I thought I'd add my thoughts here.

First a disclaimer: I'm not test infected. I don't floss my teeth every day either - unit testing is just one of those things you should be doing, but nothing really bad happens if you don't. Especially if you use tooth picks etc.

Unit tests (as I understand the term) cannot be dependent on an environment (in this case: Revit). So running a test as a Revit plugin with a Revit document is not a unit test. It is an integration test. I do plenty of these. Here is how:

Using the RPS, I create a "driver" script that loads the assembly to be tested (see the loadplugin module) and executes its public methods, much the same way as the IExternalCommand implementation would. Note here, that I tend to keep my IExternalCommand implementations "dumb", refactoring the logic to other parts of the assembly, so that I don't have to test the IExternalCommand itself (it should just be evident that it works, e.g. instantiate plugin object, call public method on it passing some command data, return).

The "driver" script can be registered as an RPS command and will then show up in the Revit Ribbon. You can even assign a keyboard shortcut to it using the standard Revit procedure for shortcuts (you will have to restart Revit after registering the RPS command first, as it only then gets promoted to an IExternalCommand). Run it often (after every compile)!

I generally don't register plugins that are under development with Revit, so that Revit doesn't lock the assembly on startup - this way, I can keep the source open in Visual Studio and build to my hearts content. The "driver" script will just pick up the newest build and test it.

Anything written to "Debug.WriteLine" will be output in the RPS window. This is handy for testing stuff!

Once you are at the "driver" script level, you can employ pythons unit testing libraries: unittest and also use the doc tests. This also keeps your tests separate from your production code, especially since you are using another language to write the tests!

If you really want to do unit testing, you will have to go the full monty - this is the reason for unit testing anyway:

Split up your code into Revit dependent functionality and modules.

Study refactoring as taught by the masters of the discipline (I like Martin Fowlers Refactoring).

Make sure your plugin abstracts from the Revit stuff into a logical model that you can then mock and write tests to.

Regard the Revit API as an I/O interface or a database connection that is not part of unit testing.

Revit Room Boundaries

2010-11-09T17:19:00.001+01:00

This came up today at work: For a given room, what are the room bounding objects?

Questions like these can easily be solved with RevitPythonShell. So I fired up an RPS shell and came up with the following script:

import clr
clr.AddReference('RevitAPI')
from Autodesk.Revit.DB.Architecture import Room
from Autodesk.Revit.DB import Wall

sel = __revit__.ActiveUIDocument.Selection.Elements
rooms = [e for e in sel if type(e) is Room]
for room in rooms:
    for bsa in room.Boundary:     # bsa = BoundarySegmentArray
        for bs in bsa:            # bs = BoundarySegment
            print bs.Element

This gets you quite close. I added a featured script to the RPS site that can be used as an RPS command and prints the element id for boundary segments that are model elements.

Obfuscating an Autodesk Revit Plugin

2010-10-06T15:06:00.001+02:00

Jeremy Tammik mentions obfuscation for Revit plugins in his post Obfuscation Tools. I would like to mention two free obfusctators I have used:

Eazfuscator

Babel .NET

Both of these can be hooked up to your build script so that they obfuscate automatically. Please read their documentation on how to do this.

I liked Eazfuscator a lot and used it for all dependant assemblies of my project, but sadly, it chokes on references to the assembly RevitAPI. So for developing Autodesk Revit Plugins, it will not work.

Babel .NET can obfuscate assemblies that reference RevitAPI.dll. I tied it into my build process in Visual Studio 2010 as a Post-build event command line:

select your project in the Solution Explorer

right-click and choose Properties from the context menu
in the tab Build Events, enter the following in the field Post-build event command line:
if /I "$(ConfigurationName)" NEQ "Debug" "C:\Program Files\Babel\Babel.exe" "$(TargetPath)" --stringencrypt --output "$(TargetPath)"

This assumes, of course, that you have installed Babel .NET to C:\Program Files\Babel. Also note, that the build configuration "Debug" is excluded from obfuscation.

Deleting a bunch of Elements By ElementId in RevitPythonShell

2010-08-19T10:27:00.001+02:00

I know I promised examples for RevitPythonShell and never delivered. Well, here is an example I came across this morning:

I had to delete a bunch of elements from a document. I new the ids of the elements and was about to manually delete them using the "Select by ID" tool in Revit and deleting them one by one. I know this works, because I did the exact same thing yesterday on the exact same document, but forgot to save the changes. I'd just have to do all that tedious work again.

But then I thought: Wait a minute... aren't we supposed to be scripting this stuff?

So, here is a session in the shell part of RevitPythonShell

>>>ids = [136116, 136119, 136120, 136121, 136122, 136131, 136132, 136133, 136134, 136135, 136136, 136137, 136138, 136139, 136140, 136141, 136142, 136143, 136144, 136145, 136155, 136165, 136206, 136306, 136309, 136419, 136422]

>>>import clr

>>>clr.AddReference("RevitAPI")

>>>from Autodesk.Revit.DB import *

>>>transaction = Transaction(doc, "find all the mutants!")

>>>transaction.Start()

>>>for id in ids:
...    doc.Delete(doc.get_Element(ElementId(id)))
...
List[ElementId]([<Autodesk.Revit.DB.ElementId object at 0x000000000000002D [136116]>])
List[ElementId]([<Autodesk.Revit.DB.ElementId object at 0x000000000000002E [136119]>])
List[ElementId]([<Autodesk.Revit.DB.ElementId object at 0x000000000000002F [136120]>])
List[ElementId]([<Autodesk.Revit.DB.ElementId object at 0x0000000000000030 [136121]>])
List[ElementId]([<Autodesk.Revit.DB.ElementId object at 0x0000000000000031 [136122]>])
List[ElementId]([<Autodesk.Revit.DB.ElementId object at 0x0000000000000032 [136131]>, <Autodesk.Revit.DB.ElementId object at 0x0000000000000033 [170627]>])
List[ElementId]([<Autodesk.Revit.DB.ElementId object at 0x0000000000000034 [136132]>])
List[ElementId]([<Autodesk.Revit.DB.ElementId object at 0x0000000000000035 [136133]>])
List[ElementId]([<Autodesk.Revit.DB.ElementId object at 0x0000000000000036 [136134]>, <Autodesk.Revit.DB.ElementId object at 0x0000000000000037 [170628]>])
List[ElementId]([<Autodesk.Revit.DB.ElementId object at 0x0000000000000038 [136135]>])
List[ElementId]([<Autodesk.Revit.DB.ElementId object at 0x0000000000000039 [136136]>])
List[ElementId]([<Autodesk.Revit.DB.ElementId object at 0x000000000000003A [136137]>, <Autodesk.Revit.DB.ElementId object at 0x000000000000003B [170629]>])
List[ElementId]([<Autodesk.Revit.DB.ElementId object at 0x000000000000003C [136138]>])
List[ElementId]([<Autodesk.Revit.DB.ElementId object at 0x000000000000003D [136139]>])
List[ElementId]([<Autodesk.Revit.DB.ElementId object at 0x000000000000003E [136140]>, <Autodesk.Revit.DB.ElementId object at 0x000000000000003F [170630]>])
List[ElementId]([<Autodesk.Revit.DB.ElementId object at 0x0000000000000040 [136141]>])
List[ElementId]([<Autodesk.Revit.DB.ElementId object at 0x0000000000000041 [136142]>])
List[ElementId]([<Autodesk.Revit.DB.ElementId object at 0x0000000000000042 [136143]>, <Autodesk.Revit.DB.ElementId object at 0x0000000000000043 [170631]>])
List[ElementId]([<Autodesk.Revit.DB.ElementId object at 0x0000000000000044 [136144]>])
List[ElementId]([<Autodesk.Revit.DB.ElementId object at 0x0000000000000045 [136145]>])
List[ElementId]([<Autodesk.Revit.DB.ElementId object at 0x0000000000000046 [136155]>])
List[ElementId]([<Autodesk.Revit.DB.ElementId object at 0x0000000000000047 [136165]>])
List[ElementId]([<Autodesk.Revit.DB.ElementId object at 0x0000000000000048 [136206]>])
List[ElementId]([<Autodesk.Revit.DB.ElementId object at 0x0000000000000049 [136306]>])
List[ElementId]([<Autodesk.Revit.DB.ElementId object at 0x000000000000004A [136309]>])
List[ElementId]([<Autodesk.Revit.DB.ElementId object at 0x000000000000004B [136419]>])
List[ElementId]([<Autodesk.Revit.DB.ElementId object at 0x000000000000004C [136422]>])
>>>transaction.Commit()

<Autodesk.Revit.DB.TransactionStatus object at 0x000000000000004D [Committed]>
>>>

Here a few notes that might illuminate some parts of working with RevitPythonShell:

access to the Revit API is added by the following lines

import clr
clr.AddReference("RevitAPI")
from Autodesk.Revit.DB import *

the document is provided via the __revit__ variable

doc = __revit__.ActiveUIDocument.Document

you need to start a transaction before changing the document

transaction = Transaction(doc, "call this whatever you like")
transaction.Start()
# do stuff
transaction.Commit()

to get an element given an integer, use this technique

element = doc.get_Element(ElementId(myinteger))

Document.Delete() returns a list of deleted elements on each call. That is what the clutter (List[ElementId]([Autodesk.Revit.DB.ElementID object at...) is all about in the session transcript above.

New release of RevitPythonShell for x64 and Revit 2011 only

2010-07-15T11:50:00.001+02:00

I upgraded my development machine a couple of weeks ago to Windows 7 64-bit. At the same time I migrated all my Revit Addin projects to Autodesk Revit 2011. This includes RevitPythonShell. I finally got round to building a new installer using the RevitAddInUtility. This was as good a project as any to try out building x64 applications and installers for Revit 2011.

Most of the port was done with the help of code I recieved from Jason Schaeffer (joespiff) via the RevitPythonShell google group

I ran into some snares:

Visual Studio 2010 has some restrictions with x64 managed applications
- The Designer will not show your forms unless you set the build platform to "Any CPU" and rebuild.
- The Setup projects bundle the wrong "InstallUtilLib.dll" shim when building x64 .msi packages
  - this has to be manually patched with orca (see my question on stackoverflow.com for current status on how to do this automatically)
Windows 7 doesn't like it when programs modify stuff in the "Program Files" folder, so I moved the RevitPythonShell.xml file to the AppData folder.

My .vimrc

2010-06-09T10:22:00.001+02:00

This is another post for my future self: At the time of writing, my .vimrc looks like this:


" --------------------------------------------------------------------------------
" call system vimrc
" --------------------------------------------------------------------------------
source $VIM/_vimrc

" --------------------------------------------------------------------------------
" startup
" --------------------------------------------------------------------------------
autocmd GUIEnter * simalt ~X    " maximize window

" --------------------------------------------------------------------------------
" opening files
" --------------------------------------------------------------------------------

" change working directory to path of file
autocmd BufEnter * lcd %:p:h    

" reformat xml files (pretty print)
autocmd FileType xml exe ":silent 1,$!xmllint --format --encode UTF-8 --recover - 2>/dev/null"

" --------------------------------------------------------------------------------
" saving files
" --------------------------------------------------------------------------------
set backupdir=./_Backup,$TEMP,.

" --------------------------------------------------------------------------------
" searching
" --------------------------------------------------------------------------------
set hlsearch        " highlight matches to search pattern
set incsearch        " incremental search
set smartcase       " case sensitive if search string contains uppercase letters
set ignorecase        " case insensitive searching

" --------------------------------------------------------------------------------
" configure editor with tabs and nice stuff...
" --------------------------------------------------------------------------------
set expandtab           " enter spaces when tab is pressed
set textwidth=0         " do not break lines when line length increases
set tabstop=4            " use 4 spaces to represent tab
set softtabstop=4
set shiftwidth=4        " number of spaces to use for auto indent
set autoindent          " copy indent from current line when starting a new line

" make backspaces more powerfull
set backspace=indent,eol,start 

set ruler               " show line and column number


" --------------------------------------------------------------------------------
" encoding
" --------------------------------------------------------------------------------
set encoding=utf-8
"set printencoding=utf-8

" --------------------------------------------------------------------------------
" keyboard mappings
" --------------------------------------------------------------------------------
set langmap=¨]

Future Daren, you can find the location of the .vimrc by editing the file $MYVIMRC in vim itself! Unless it hasn't been created yet ($MYVIMRC will then point to the system-wide version). In Windows, just plop a _vimrc file in your %userprofile%.

Google Charts: AnnotatedTimeline

2010-05-12T10:09:00.000+02:00

Note to future self: The Google Charts visualization "AnnotatedTimeline" displays inside a div element. As per documentation, you need to provide height and width of the div element. If you don't (or specify a size too small), the script goes into an infinite loop - I guess it is trying to scale to fit inside the div, but I didn't feel like debugging squashed code...

CakePHP and Umlauts (utf-8)

2010-04-28T12:13:00.000+02:00

I spent the last couple of weeks writing PHP. Not my favorite language, but it does get the job done. I won't bitch about PHP here, since that would be snobbery.

What eases the pain a lot is the CakePHP framework. Except, I couldn't get Umlauts to work. Umlauts are special characters, like a, o and u, but with two dots on them: ä, ö, ü.

I found the solution on this page: http://www.missingfeatures.com/2008/10/23/using-utf8-in-your-cakephp-app/

Not only must you tell your browser that you are using UTF-8, but you must also tell the database connection to use utf-8. Check the database.php file in your app/config directory and add 'encoding' => 'utf8' to the end of the database configuration.

Wiki syntax for UML diagrams

2010-04-14T17:01:00.000+02:00

Yay! I have just implemented my very first Trac Hack: YumlPreprocessorMacro for integrating yuml.me diagrams into the trac wiki.

I have come to depend on using Trac as a bug tracking and documentation tool. I really like using wikis for documentation. I like being able to create links quickly. I like being able to search the documentation in a webby way. I absolutely hate using MS Word for technical documentation.

Often, you want to add little UML sketches to your docs. The workflow normally goes like this:

Open your UML editor of choice
Create UML diagram
Export as image
Include in documentation

Notice how that can be a little disruptive for just a sketch? Most UML tools want you to go BDUF. They want you to create a whole model of everything, when all you really want to do is a little use case. I like the Violet UML Editor precisely because it lets me sketch. But yuml.me really changes the whole game!

Adding canned scripts to the Revit RibbonPanel

2010-03-23T16:14:00.000+01:00

I feal really smug about myself today! I finally figured out how to add
shortcuts to the canned python scripts defined in RevitPythonShell.xml to the
Revit RibbonPanel. I'd like to share some of the fancy magic that went into r65.

RevitPythonShell lets you define a list of named scripts in the
RevitPythonShell.xml file. An exerpt from my personal file looks like this:

  <Commands>
    <!-- a list of preconfigured commands -->
    <Command name="dumpdpvfolder" src="C:\RevitPythonShell\Commands\dpvdumpfolder.py"/>
    <Command name="read model" src="C:\RevitPythonShell\Commands\readmodel.py"/>
    <Command name="Report" src="C:\RevitPythonShell\Commands\report.py"/>
    <Command name="View Model" src="C:\RevitPythonShell\Commands\viewmodel.py"/>
  </Commands>

These are commands I use all the time during development of the
DesignPerformanceViewer (DPV). I use these commands to test parts of the DPV, run
automated tests on lots of input projects etc.

So far, these commands where only displayed in a toolbar above the interactive
shell. On the RibbonPanel provided by Autodesk Revit Architecture 2010 only a
single button was displayed: Open Python Shell. The main reason being: To add
an item to the RibbonPanel, you have to provide a path to an assembly and the
name of a type inside that assembly implementing IExternalCommand.

In the case of RevitPythonShell, we can't specify such an assembly. There is none.
And we can't use a generic type as the IExternalCommand and load the python script
in the Execute() method either, since the arguments to Execute don't contain any hints as
to which button was clicked!

This is where dynamic assemblies and Reflecion.Emit enters the stage: When RevitPythonShell
starts up (IExternalCommand.OnStartup), the list of canned commands is read and a dynamic assembly
is created to hold a dynamically created class for each canned command defined in RevitPythonShell.xml.

This is done with Reflection.Emit in the method RevitPythonShellApplication.CreateCommandLoaderAssembly():

        /// <summary>
        /// Creates a dynamic assembly that contains types for starting the canned commands.
        /// </summary>
        private static void CreateCommandLoaderAssembly()
        {
            var assemblyName = new AssemblyName {Name = "CommandLoaderAssembly", Version = new Version(1, 0, 0, 0)};
            var assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.RunAndSave);
            var moduleBuilder = assemblyBuilder.DefineDynamicModule("CommandLoaderModule", "CommandLoaderAssembly.dll");

            foreach (var command in GetCommands())
            {
                var typebuilder = moduleBuilder.DefineType("Command" + command.Index,
                                                        TypeAttributes.Class | TypeAttributes.Public,
                                                        typeof(CommandLoaderBase));

                var ci = typeof(CommandLoaderBase).GetConstructor(new[] { typeof(string) });

                var constructorBuilder = typebuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, new Type[0]);
                var gen = constructorBuilder.GetILGenerator();
                gen.Emit(OpCodes.Ldarg_0);                // Load "this" onto eval stack
                gen.Emit(OpCodes.Ldstr, command.Source);  // Load the path to the command as a string onto stack
                gen.Emit(OpCodes.Call, ci);               // call base constructor (consumes "this" and the string)
                gen.Emit(OpCodes.Nop);                    // Fill some space - this is how it is generated for equivalent C# code
                gen.Emit(OpCodes.Nop);
                gen.Emit(OpCodes.Nop);
                gen.Emit(OpCodes.Ret);                    // return from constructor
                typebuilder.CreateType();
            }
            assemblyBuilder.Save("CommandLoaderAssembly.dll");            
        }

Now, this is the first time I have ever emitted IL in my life. Naturally, I wanted to get as much done in C# as possible, so the types
generated all inherit CommandLoaderBase:

    /// <summary>
    /// Starts up a ScriptOutput window for a given canned command.
    /// 
    /// It is expected that this will be inherited by dynamic types that have the field
    /// _scriptSource set to point to a python file that will be executed in the constructor.
    /// </summary>
    public abstract class CommandLoaderBase: IExternalCommand
    {
        protected string _scriptSource = "";

        public CommandLoaderBase(string scriptSource)
        {
            _scriptSource = scriptSource;
        }

        public IExternalCommand.Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements)
        {
            var executor = new ScriptExecutor(commandData, message, elements);

            string source;
            using (var reader = File.OpenText(_scriptSource))
            {
                source = reader.ReadToEnd();
            }

            var result = executor.ExecuteScript(source);
            message = executor.Message;
            switch (result)
            {
                case (int)IExternalCommand.Result.Succeeded:
                    return IExternalCommand.Result.Succeeded;
                case (int)IExternalCommand.Result.Cancelled:
                    return IExternalCommand.Result.Cancelled;
                case (int)IExternalCommand.Result.Failed:
                    return IExternalCommand.Result.Failed;
                default:
                    return IExternalCommand.Result.Succeeded;
            }
        }
    }

This base class has a constructor that accepts the path to a python script and
creates a ScriptExecutor (check RevitPythonShell source code) to execute that script in its implementation of
IExternalCommand.Execute().

And now the Reflection/IL stuff starts to make sense: Create a type inheriting from CommandLoaderBase, adding a parameterless constructor (called by
Revit) which in turn calls the base constructor with the path to the script. The resulting IL looks something like this:

    .class public auto ansi Command0
        extends [RevitPythonShell]RevitPythonShell.CommandLoaderBase
    {
        .method public specialname rtspecialname instance void .ctor() cil managed
        {
            .maxstack 2
            L_0000: ldarg.0 
            L_0001: ldstr "C:\\RevitPythonShell\\Commands\\dpvdumpfolder.py"
            L_0006: call instance void [RevitPythonShell]RevitPythonShell.CommandLoaderBase::.ctor(string)
            L_000b: nop 
            L_000c: nop 
            L_000d: nop 
            L_000e: ret 
        }

    }

With "Command0" being the name of the type to instantiate for the first canned script in RevitPythonShell.xml. The C# equivalent looks like this:

    public class Command0 : CommandLoaderBase
    {
        // Methods
        public Command0() : base(@"C:\RevitPythonShell\Commands\dpvdumpfolder.py")
        {
        }
    }

I used Red Gate's .NET Reflector to disassemble the resulting assembly and also as a hint on how to write the Reflection.Emit stuff (created a dummy subclass of CommandLoaderBase with the desired constructor, compiled and then disassembled in Reflector).

Now I need to add a nice interface to manage the canned commands - any ideas?

Using RevitPythonShell to dynamically load plugins for debugging

2010-03-10T16:49:00.003+01:00

Ever since I read Jeremy Tammiks blog post Reload an Add-In to Debug, where he
describes about John Morse's technique for dynamically loading plugins without
having to restart Revit, I have been itching to get this working in
RevitPythonShell!

Finally, with revision 55 and the loadplugin script, I can rapidly iterate
working on my C# projects - no more waiting for Autodesk Revit to restart after
fixing a small mistake!

Here is a little sampe session from the project page:


>>>import loadplugin
>>># use actual path here... (if you don't already have RvtMgdDbg.dll installed, you probably want to go and do so 
>>># right now - check ADN!)
>>>assembly = loadplugin.loadAssembly(r'C:\...\Visual Studio 2008\Projects\RvtMgdDbg\bin\RvtMgdDbg.dll')
>>># result is an assembly object
>>>assembly

<Assembly RvtMgdDbg, Version=1.0.3671.26458, Culture=neutral, PublicKeyToken=null>

>>># pretty cool: IronPython lets you use the assembly like a namespace
>>># also note the use of the special predefined variables for executing plugins!
>>>assembly.RvtMgdDbg.CmdSnoopDb().Execute(__commandData__, __message__, __elements__)

(<Autodesk.Revit.IExternalCommand+Result object at 0x000000000000002D [Succeeded]>, '')
>>>

So how dows it work? Basically, you load an assembly as a byte array and then
use Assembly.Load to load the assembly from the byte array. Dynamically loading
assemblies this way does not lock them on the hard disk, allowing Visual Studio
to overwrite the DLLs at build time.

I suggest you write a test script for your plugin, that you can then save as a
canned command in RevitPythonShell, that loads it via loadplugin.loadAssembly and
does some exercising: Instantiate some types, execute IExternalCommand instances etc.

To make interaction with plugins easier, RevitPythonShell now supports some predefined variables, that give you more access to the context in which the plugin itself was loaded.
This lets you simulate the user clicking on PushButtons in the Ribbon.

Also, I have included a fork of the IronPythonTextBox control, to make plain interactive
use of RevitPythonShell smoother.

Please let me know, if this is of any use to you. Also, I would really appreciate some help, especially in getting the system more user friendly (e.g. script repository etc.).

Extracting music from Mac formatted iPod in Windows XP

2010-02-25T15:57:00.000+01:00

I used these tools to extract the music from my iPod (Mac formatted) under windows:

HFSExplorer (0.21)
Mp3tag v2.45a

HFSExplorer lets you extract data from an HFS file system hooked up to your PC. In this case my iPod. After loading the filesystem from a device (see file menue), navigate to the folder /iPod_Control/Music and extract it to your PCs filesystem, e.g. your Desktop.

The music shows up as a lot of funny folders and files (F00, F01, ...). This is where Mp3tag comes in: One of the functions of this tool is to read the meta information from your music files and create a directory structure from them, with proper file names, folder names for the albums etc. Sweet!

How to create a 3D wireframe with X3D

2010-02-25T15:38:00.000+01:00

All I wanted to do was display some lines in a 3D coordinate system to make sure everything was as it should be. That can't be hard, can it?

Well, it seems it is hard. At least, it's hard to figure out how to do it, because there aren't that many tools that will show you a 3D scene from a file you generate by hand/script.

I quickly found out about the VRML/X3D stuff. It looked ancient. Rotten. Neglected. All sad. A bunch of tutorials made me sure that I didn't want to go that route: None of the tutorials talked about how to display a line in a 3D scene. Instead, it seemed VRML was all about showing shapes: Boxes, cylinders, spheres and stuff like that.

Ugh! Ok. I guess I could just draw really thin boxes and call them lines. But it just gets worse: All shapes are defined in distinces from an origin - so your sphere has a radius. That's it. It is stuck at [0, 0, 0]. But you then translate your shape to where you want it to go. Move it around, rotate it. Etc.

Argh! I had all these nice 3D coordinates for my lines ready. But the docs said I would have to transform them all into this complicated scheme. Which, I am sure makes a lot of sense for 3D modelling. It's just for simple wireframe output that it seems a little bloated.

Well, It's not really that bad: X3D has an element called LineSet that lets you specify... lines! You just write a list of 3D points to the file and off you go!

So, if you are the next person to try creating a simple wireframe with X3D, you might want to have a look at this stub file:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE X3D PUBLIC "ISO//Web3D//DTD X3D 3.0//EN"
  "http://www.web3d.org/specifications/x3d-3.0.dtd">
<X3D profile="Immersive" >
  <Scene>

    <Transform>
      <Shape>
        <LineSet vertexCount="5">
            <Coordinate point="1 0 0
                               1 1 0
                               0 1 0
                               0 0 0
                               1 0 0"
                               />
        </LineSet>
    </Shape>
    <Shape>
        <LineSet vertexCount="5">
            <Coordinate point="1 0 1
                               1 1 1
                               0 1 1
                               0 0 1
                               1 0 1"
                               />
        </LineSet>
    </Shape>
    <Shape>
        <LineSet vertexCount="5">
            <Coordinate point="0 0 1
                               1 0 1
                               1 0 0
                               0 0 0
                               0 0 1"
                               />
        </LineSet>
    </Shape>
    <Shape>
        <LineSet vertexCount="5">
            <Coordinate point="0 1 1
                               1 1 1
                               1 1 0
                               0 1 0
                               0 1 1"
                               />
        </LineSet>
      </Shape>
    </Transform>
  </Scene>
</X3D>

This will create a simple 1x1x1 cube. You can view this with an X3D browser. I used FreeWRL. It is supposed to be only for OSX and Linux, but they do have a windows binary that sort of works. At least for my purposes it is really enough. The other browsers out there (ones that also act as web browser plugins) seem scammy. They let you download a "test" version. What does that meen? Is this a trial version? Do I have to buy it? Where? How much?

So, here is a screenshot of FreeWRL rendering the X3D file above:

I rotated the cube a bit (this is the nice thing about having a dedicated browser - try writing your own!) to make it more recognizable.

Where are all the posts I promised?

2010-02-05T11:55:00.000+01:00

Why oh why have I not delivered on my promise to post neat stuff you can do with RevitPythonShell? Well, what exactly would you want to do with it? I use this tool to scratch an itch - automate a plugin I am writing. I mainly use the Interactive button and type away at the prompt. I also have some canned scripts I like to use, but I'm not sure if posting them here would make a lot of sense: They are very specific to the plugin. But I'll show a little bit, just for the curious among you:

Python 2.5.0 () on cli
Type "help", "copyright", "credits" or "license" for more information.
(InteractiveConsole)
>>> apps = [a for a in __revit__.LoadedApplications if 'DpvApplication' in str(a)]
>>> dpv = apps[0]
>>> dir(dpv)
['ActiveDocument', 'Calculators', 'GetHistory', 'OnShutdown', 'OnStartup', 'Result', 'TakeSnapshot', '__class__', '__delattr__', '__doc__', '__getattribute__', '__hash__', '__init__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__str__']
>>> dpv.TakeSnapshot()
>>> snapshot = dpv.GetHistory(dpv.ActiveDocument).CurrentSnapshot
>>> for room in snapshot.Rooms:
...    print room.Area, room.Name
... 
163.14989375 Raum 1
>>>

Right after the banner, I create a reference to my plugin. This uses the LoadedApplications collection on Autodesk.Revit.Application. As you can see, I then proceed to exercise the plugin, calling its methods (TakeSnapshot, GetHistory, ActiveDocument) etc. You can call any public methods defined in your plugin this way!

But working in the interactive shell for some period has shown some of its weaknesses. I'm busy trying to fix that, but this might still take a while - the last couple of revisions have gone in that direction (but there is no new release yet).

Since this is a tool to make exploring your (C#) plugins easier, it makes sense to customize it a bit. I have configured RevitPythonShell.xml like this:

<?xml version="1.0" encoding="UTF-8"?>
<RevitPythonShell>
  <SearchPaths>
    <!-- a list of paths to add to the engines search path -->
    <SearchPath name="C:\Python25\Lib"/>
    <SearchPath name="C:\RevitPythonShell"/>
  </SearchPaths>
  <Commands>
    <!-- a list of preconfigured commands -->
    <Command name="dumpdpvfolder" src="C:\RevitPythonShell\Commands\dpvdumpfolder.py"/>
    <Command name="read model" src="C:\RevitPythonShell\Commands\readmodel.py"/>
    <Command name="Report" src="C:\RevitPythonShell\Commands\report.py"/>
    <Command name="Interactive" src="C:\RevitPythonShell\Commands\interactive.py"/>
  </Commands>
  <DefaultScript><![CDATA[
# type in a python script to run here and click "Execute"
# you can access the Autodesk.Revit.Application object with the variable __revit__
# the default script (shown below) opens up an interactive interpreter

import code
code.interact(None, None,
  {
    '__name__' : '__console__',
    '__doc__'  : None,
    '__revit__': __revit__
  })]]></DefaultScript>
</RevitPythonShell>

Notice the Commands section: These are shortcuts to stuff I execute often. Conserved scripts that use the technique explained above to exercise the DesignPerformanceViewer plugin.

Name your GUIDs

2010-01-27T14:36:00.000+01:00

Here is a little idea that came to me while waiting for my computer to become responsive again (don't ask):

Wouldn't it be really cool, if there was a name generator for GUIDs? You could submit a GUID and claim a name. That way, people could talk about GUIDs on the phone:

Guy on phone: I'm having problems with foobaz
Supporter: Oh, you want to check the registry for the GUID "PurpleRain"
Guy on phone: (checks up GUID via webservice)

I'll have to think some more about this... You'd want to make sure the names are easy to pronounce, easy to type and hard to get wrong. I'm sure someone has done similar stuff before.

Adding your plugin to the [ExternalApplications] section of Revit.ini

2009-12-23T13:08:00.001+01:00

For the installer for RevitPythonShell, I need to programmatically add the plugin to the [ExternalApplications] section of Revit.ini. Instead of writing a one-off solution, I decided to create a little commandline tool that can be reused for my next project or even your project: addrevitplugin.exe. You can look at the source too!
The tool is written using AutoIt v3, a BASIC derivative with lots of useful functions for automating windows tasks. Expect to see some more samples of such scripts on this blog...
The commandline options to addrevitplugin.exe are:

EAClassName: This corresponds to the key "EAClassName#" in the Revit.ini file
EAAssembly: (optional) This corresponds to the key "EAAssembly#" in the Revit.ini file and is the full path to the .NET assembly containing the plugin class.

Using addrevitplugin.exe, you can either add, update or delete a plugin entry in the "ExternalApplications" section. By specifying EAClassName without EAAssembly, the corresponding plugin is deleted from Revit.ini. If EAAssembly is provided, then the plugin is either added (if it was not yet installed) or updated with the assembly.

I also use this tool in conjunction with Launchy to quickly switch between environments when developing Revit plugins: Create a batch file for each location of your plugin (Debug, Release, Installed) with contents similar to:

addrevitplugin.exe RevitPythonShell.RevitPythonShellApplication "C:\Projects\revitpythonshell\RevitPythonShell\bin\Debug\RevitPythonShell.dll"

Make sure the second argument is enclosed in double quotes if it contains spaces. Create a separate file for each environment.

I named the files debug_RevitPythonShell.bat, release_RevitPythonShell.bat and installed_RevitPythonShell.bat. By saving these files in a directory scanned by Launchy, I can quickly switch between the environments before starting Autodesk Revit Architecture 2010.

Note:If you are not using Autodesk Revit Architecture 2010 on a 32bit system, you will want to change the GUID used to look up the install path in the script addrevitplugin.au3. You will then need to recompile the script using Aut2Exe.exe, which can be obtained from the Auto It website.

Update: I have renamed addrevitplugin.exe to rac32plugin.exe and rac64plugin.exe so that now a 32-bit and a 64-bit version comes precompiled. Also, the scripts have changed somewhat. Please check the project website.

Introducing RevitPythonShell

2009-12-18T14:36:00.005+01:00

RevitPythonShell is a little tool I built to make life in RevitAPI-land a little easier.

When writing plugins for Autodesk Revit Architecture 2010, you have to restart Revit each time you create a new build and manually click your way to the plugins functionality. If you are not so sure about how a given method or property from the API works (or what values to expect when reading it), you will end up with a lot of these edit-compile-run cycles. I don't know how fast your machine is, but starting Revit on mine is not as snappy as I would like. Plus, you can't really experiment, can you?

So, with RevitPythonShell, you can. It embeds IronPython, a .NET port of the python language as a plugin. The main window provides a simple text editor that lets you write a script and execute it. The most useful script is probably this one:

import code
code.interact(None, None, 
        {
            '__name__': '__console__', 
            '__doc__':None, 
            '__revit__': __revit__
        })

This will open up an interactive interpreter loop (known as a REPL), that will let you explore the RevitAPI. And by explore, I mean type a statement, hit enter, see the results, carry on. It doesn't get easier as this!

The above script is actually saved as a "canned command" - an button (in this case named "Interactive") in the toolbar above the main window. Canned commands like these are an ideal place to save scripts you have developed and found useful - a sort of mini-plugin-in-a-plugin architecture.

The default script shown when you start the RevitPythonShell plugin is this one:


# type in a python script to run here...
try:
  # assumes the following file exists: C:\RevitPythonShell\current.py
  import current  
  reload(current)
  
  current.main(__revit__)
except:
  import traceback
  traceback.print_exc()

It imports the module current.py from the search path (normally C:\RevitPythonShell) which contains a script you are currently working on. Clicking the button Execute (or pressing CTRL+RETURN) will execute the contents of the main window, which will in turn import the module and run its main() method.

Loading a script from the file system instead of typing it into the simple editor provided by RevitPythonShell is probably a good idea, since most editors make life a lot easier compared to the TextBox control used here - even Notepad.exe would be preferable!

Note the parameter __revit__ passed into the main method: This is a reference to the Autodesk.Revit.Application API object used by plugins to gain access to Revit.

I will be showing off some of the things you can do with RevitPythonShell in later posts.

Using C# extension methods for Revit Element Parameters

2009-12-09T11:26:00.000+01:00

One of the places using C# extension methods shines is writing getters and setters for element parameters in Autodesk Revit Architecture 2010. Parameters are user defined meta data bound to either an instance or a type in Revit. Accessing these is a bit cumbersome:

public IExternalCommand.Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements)
{
    var document = commandData.Application.ActiveDocument;    
    
    Parameter parameter = document.ProjectInformation.get_Parameter("BuildingCategory");
    if (parameter != null)
    {                
        var buildingCategory = parameter.AsInteger();
        // do something with this information
    }        
}

Imagine typing all that code every time you want to access your parameter in code! Of course you will wrap it up in a method, but wrapping it in an extension method allows for neat syntax:

public static int GetBuildingCategory(this ProjectInfo self)
{
        
    Parameter parameter = self.get_Parameter("BuildingCategory");
    if (parameter != null)
    {
                
        return parameter.AsInteger();
    }        
    // you could also throw an exception here...
    return 0;
}

Now, you can access the property through the element itself, and it shows up in intellisense!

int buildingCategory = document.ProjectInformation.GetBuildingCategory();

In fact, I go a step further in my project, utilizing the t4 templating engine to generate the parameter accessors as well as routines to bind them to the document from an XML file. But that will have to wait for another blog post.

Using C# extension methods to extend plugin architectures

2009-12-03T08:32:00.003+01:00

I've spent a lot of time recently writing a plugin for Autodesk Revit Architecture 2010. Extending Revit involves writing managed code that implements a special interface (Autodesk.Revit.IExternalApplication) that gets called by the host application when special events occur - the application starts up, one of your toolbar buttons was clicked, a document was opened / closed / saved etc.
Access to the host is provided as a parameter to the methods defined in the interface. One of the main objects of interest for the work I'm doing is the Autodesk.Revit.Document class. This is my window into Revit documents, providing information about elements in the document.
The catch: You cannot change how these objects behave, since they are provided by the host. If Autodesk.Revit.Document is missing a Rooms property that lists all the rooms in the document, well, you are out of luck.
The traditional object oriented solution to this problem is inheritance. You subclass the lacking class in question and add the desired functionality. This will not work in a plugin situation. You have no control of how Revit instantiates its document object.
You could decorate the object with new functionality: Implement the Document interface (in this case you would have to extract the interface first) and delegate all invocations to a stashed away instance received via Revit. This can fly, but its pretty ugly to do by hand - you might want to generate this.
C# 3.0 comes with a new solution to this problem: Extension Methods. Lets look at some code.

/// <summary>
/// Provides some utility methods for working with Revit.Document objects.
/// </summary>
public static class RevitDocumentExtensions
{
    /// <summary>
    /// Returns a list of all room objects in a Revit document.
    /// This excludes room
    /// </summary>
    public static IEnumerable<Room> GetRooms(this Document document)
    {
        var roomElements = new List<Element>();
        var filterFactory = document.Application.Create.Filter;
        var filter = filterFactory.NewTypeFilter(typeof(Room));
            document.get_Elements(filter, roomElements);

        // filter the rooms so only the placed ones are returned.
        return roomElements.Cast<Room>().Where(r => r.Location != null);
    }
}

Given an Autodesk.Revit.Document object, GetRooms can be called like so:

var rooms = RevitDocumentExtensions.GetRooms(document);

This is nothing new, hardly exciting, but works.
Did you notice the magic keyword this in the functions signature?

public static IEnumerable<Room> GetRooms(this Document document)

That's new. We are still talking static methods here, and that is all the .NET runtime ever sees, but the C# compiler will allow you to use this method syntactically as if it were defined in the Document class! So our usage chages to this:

var rooms = document.GetRooms();

Neat, huh? It looks as if we have subclassed Autodesk.Revit.Document and added a new instance method. Using this technique, a plugin API can be extended to better suit the needs of the plugin.
I will post more examples on how I used extension methods to augment Revit in my next post.

Response to "Bug tracking isn't a network-effect business"

2009-11-05T07:44:00.000+01:00

Ok, so my first post is going to be a bit of a fanboy post. I've been a keen reader of Joel Spolkys blog since the aticle series "Working on CityDesk". Its fun to read stuff written by a guy who actually knows what writing is all about: Entertaining your audience. A lot of Joels stuff should also be taken in that vain: The reason people read him is not that he is always right, it's that his posts are entertaining. So are the Stackoverflow Podcasts, btw.

I'm kind of surprised about articles like this one on 37signals, that read Joel Spolskys latest post and jump to all kinds of conclusions.

No, building every feature a customer could ever want is not really a bad idea, given that the new FogBugz has a new plugin system! I suspect Joel will be adding stuff missing via the plugin architecture one piece at a time and thus removing reasons for customers not to choose their product.

I for one have certainly seen people choose an inferior product, just because it had one shiny feature - even though it didn't work right.

Using a plugin system to add such features is a rather cool solution to the problem.

Secondly, regarding how Joel apparently wants to move to a sales force-driven company. Wow. Did he say that? I don't think so! There is a big difference between being "sales force-driven" and actually trying to sell your product.

So far, Joel has been able to rely on word of mouth to sell his products. We all fell for them. CityDesk, anyone? It was a cool personal blog thingy (before online blogging tools were invented), but don't try using it as a CMS, just hoping it will eventually grow the features you need. His blog Joel On Software is very popular among developers and I'm sure all his fanboys tried to get their companies to buy FogBugz. Well, at least they all got their bosses to start using bug tracking! And consider FogBugz at the same time.

But, Joel has pretty much said what he has to say. Anything new will be torn apart by the new kids on the blogging block. So his sales machine is coming to a halt. At the same time, his software is getting more and more mature and thus can start to go after the entreprises, that only want big names and sales reps that actually come and visit them etc. We are talking proper business here, not that web stuff you all think is the real world!

Hiring sales people will prove difficult. What makes a good sales person? Snake oil selling qualities (in large quantities)? Heck if I know. And according to Joel, he doesn't really know either.