When developing the import from F-Spot feature in Shotwell, I made sure I isolated the F-Spot specific code from the generic code so that the same feature could be easily implemented to import photographs from other photo management application. So if you want to contribute an import from Picasa feature, here's a quick guide on how to do it.
Alien Database Framework
Everything you need in order to implement a new import feature is provided by the alien database framework. It is composed of 5 classes that you will need to know about and 5 interfaces that you will need to implement, as shown in the class diagram below:
Here's a quick overview of the different components:
- The class where everything starts from. This object is responsible for managing a set of drivers. At the moment, there is only one, the F-Spot driver but hopefully, by the time you finish reading this, there will be a new one.
- A light-weight struct that identifies a unique driver. This struct wraps a simple string. In the case of the F-Spot driver, that string is
- The interface that specifies what the driver implementation needs to provide. It includes a few simple methods that enable the driver support to be included in the Shotwell interface, as well as three more heavy-weight methods that actually perform the database handling. Those methods are called in two steps:
get_discovered_databasesis called first so that the driver can provide the UI a list of databases that are automatically discovered, typically database files found in well known locations such as
open_database_from_filegets called when the user has selected what database to load: those are the methods that will do the heavy lifting.
- A light-weight wrapper that identifies a discovered database and implements lazy loading of the real database.
- A light-weight struct that behaves exactly the same as
AlienDatabaseDriverIDbut uniquely identifies a given database, including its related driver.
- The interface that specifies what the database implementation needs to provide. The method that does all the work is
- A light-weight class that implements a version number in the format x.y.z and is able to compare versions between each other. This is meant to make it possible to validate whether the version found is actually supported by the driver. This is also used heavily in the F-Spot implementation to provide support for different versions of the database.
- AlienDatabasePhoto, AlienDatabaseTag and AlienDatabaseEvent
- A set of interfaces that define data objects handled by the database: photos, tags and events.
Implementing a new driver
Now that you've decided to implement a new driver, let's go through it step by step.
The first thing to do is to provide an implementation of the
AlienDatabaseDriver interface. Let's get the UI related methods out of the way first.
- This should return a hard-coded
AlienDatabaseDriverIDused to identify the driver.
- This should return a display name, most likely the name of the application the driver is for. You may want to make it translatable if you know that the application doesn't have the same name in all languages.
- The name to be used for the menu identifier, which is referenced in the action (see below). This should be a simple hard-coded string.
- A method that returns a
Gtk.ActionEntrythat will be used to construct menu items. The return value should be hard-coded and be consistent with what the
get_menu_namemethod returns. I know, it looks like there's redundant code in there but it seems that Vala has issues with building structs with non-hard-coded strings. This may be simplified in the future. Don't forget to set the label and the tooltip for the action and to make them translatable: see the F-Spot implementation for an example.
That's the UI out of the way. Now let's have a look at database discovery and load.
- This method will be called when the user selects the import menu item and the dialog box appears. It should look in all the well-known locations for a database and return a collection of
DiscoveredAlienDatabaseobjects. Those objects are created from an
AlienDatabaseIDobject that contains two pieces of information: the driver ID and a driver specific string that identifies the database. That driver specific string can be whatever you want. At its simplest, it can just be the path to the database file.
- Those two methods are the ones that do the heavy lifting. They basically provide exactly the same function with a slightly different signature so you will probably want to factorise the code and make both of them call an internal private function that performs the bulk of the work. At this point, you need to open the database file and extract the version number out of it. If there is any error, it's the time to report it as this is called while the import dialogue is still displayed to the user and can provide early feedback. There are two error domains you can use for that: use
DatabaseErrorfor any generic database issue, such as problems opening the file or reading the tables; and use
AlienDatabaseErrorto report a database that you can read but which has a version number that you don't support. If everything goes well, return an implementation of
Now that you've loaded the database, it's time to extract data out of it. For that purpose, you now need to provide an implementation of the
AlienDatabase interface. Once again, there are a few UI related methods and some data related ones so let's start with the UI bits.
- This method returns the driver specific URI for this database. It must be consistent with what is used in the
- A string that is suitable for display in the UI and that identifies the database to the user.
And now for the bulk of the implementation:
- Return the version of this database. By the time this method is called, the database should already have been opened so it should only fail if something really unexpected happens.
- This is the important method, where the content of the database is read and photo references are extracted. Try to be as lenient as possible in this method so that it doesn't throw an exception. If an unexpected piece of data is returned, try to recover from it rather than throw an exception. If a photo entry can't be read properly, just ignore it and continue with the next one. Throwing an exception will abort the whole import so make sure you only do it if you're absolutely sure that you can't do anything else.
Data objects implementation
The last three interfaces define light-weight data objects that should all be created by the
get_photos method in the
AlienDatabase implementation. I will only detail
AlienDatabasePhoto as the other two are trivial and only return a name.
- Both strings together provide the fully qualified path of the image file for the photo.
- Return the objects that contain the details of the tags and event for the photo. Note that because Shotwell only supports one event per photo, only a single instance can be returned, not a collection. Also note that because Shotwell does not currently support hierarchical tags, all tags just contain a name. If the database you import from supports hierarchical tags, you should decide whether you want to import all tags or only leaf tags.
- Return a five-star rating for the photo. If the database you import from doesn't support ratings, just return
Rating.UNRATED. If your rating is stored as an integer, use the
- A title for the photo, if the source database supports it. Otherwise, return
- This method returns a values that identifies an import roll. It should be a value that is equivalent to a time stamp. If the source database doesn't support this, just return
Register your driver
The only thing left to do is to register your new driver with the handler. For this, you will need to modify the
AlienDatabaseHandler constructor to add a call to
register_driver with an instance of your driver. I know, this is not ideal but there is a ticket on the Yorba tracker to implement a real plugin mechanism. Once this is done, this last step should go away. And as an added bonus, if libpeas is used for this as expected, you should then be able to write your plugins in other languages than Vala!
Go and write great code!
That's it. If you want to enable import from your (old) favourite photo management application to Shotwell, just follow this guide and contribute a patch. Of course, the reality of things means that it will probably not be that simple, it all depends on the complexity of the source database. You may also want to be able to support several versions of that source database. For an example on how to do this, have a look at the F-Spot implementation.