Merge lp:~meese/pantheon-photos/code-reformat into lp:~pantheon-photos/pantheon-photos/trunk

[meese]

reformats all vala files to http://elementaryos.org/docs/code/code-style

reformats all vala files to http://elementaryos.org/docs/code/code-style

[David Gomes (davidgomes)]

Great job, thank you!

review: Approve

=== modified file 'plugins/common/RESTSupport.vala'
--- plugins/common/RESTSupport.vala	2013-09-24 22:08:27 +0000
+++ plugins/common/RESTSupport.vala	2014-08-08 21:16:43 +0000
@@ -4,7 +4,7 @@
  * (version 2.1 or later).  See the COPYING file in this distribution.
  */
 
-extern Soup.Message soup_form_request_new_from_multipart(string uri, Soup.Multipart multipart);
+extern Soup.Message soup_form_request_new_from_multipart (string uri, Soup.Multipart multipart);
 
 namespace Publishing.RESTSupport {
 
@@ -12,51 +12,51 @@
     private string? endpoint_url = null;
     private Soup.Session soup_session = null;
     private bool transactions_stopped = false;
-    
-    public signal void wire_message_unqueued(Soup.Message message);
-    public signal void authenticated();
-    public signal void authentication_failed(Spit.Publishing.PublishingError err);
-
-    public Session(string? endpoint_url = null) {
+
+    public signal void wire_message_unqueued (Soup.Message message);
+    public signal void authenticated ();
+    public signal void authentication_failed (Spit.Publishing.PublishingError err);
+
+    public Session (string? endpoint_url = null) {
         this.endpoint_url = endpoint_url;
-        soup_session = new Soup.SessionAsync();
-    }
-    
-    protected void notify_wire_message_unqueued(Soup.Message message) {
-        wire_message_unqueued(message);
-    }
-    
-    protected void notify_authenticated() {
-        authenticated();
-    }
-    
-    protected void notify_authentication_failed(Spit.Publishing.PublishingError err) {
-        authentication_failed(err);
-    }
-
-    public abstract bool is_authenticated();
-    
-    public string? get_endpoint_url() {
+        soup_session = new Soup.SessionAsync ();
+    }
+
+    protected void notify_wire_message_unqueued (Soup.Message message) {
+        wire_message_unqueued (message);
+    }
+
+    protected void notify_authenticated () {
+        authenticated ();
+    }
+
+    protected void notify_authentication_failed (Spit.Publishing.PublishingError err) {
+        authentication_failed (err);
+    }
+
+    public abstract bool is_authenticated ();
+
+    public string? get_endpoint_url () {
         return endpoint_url;
     }
-    
-    public void stop_transactions() {
+
+    public void stop_transactions () {
         transactions_stopped = true;
-        soup_session.abort();
+        soup_session.abort ();
     }
-    
-    public bool are_transactions_stopped() {
+
+    public bool are_transactions_stopped () {
         return transactions_stopped;
     }
-    
-    public void send_wire_message(Soup.Message message) {
-        if (are_transactions_stopped())
+
+    public void send_wire_message (Soup.Message message) {
+        if (are_transactions_stopped ())
             return;
 
-        soup_session.request_unqueued.connect(notify_wire_message_unqueued);
-        soup_session.send_message(message);
-        
-        soup_session.request_unqueued.disconnect(notify_wire_message_unqueued);
+        soup_session.request_unqueued.connect (notify_wire_message_unqueued);
+        soup_session.send_message (message);
+
+        soup_session.request_unqueued.disconnect (notify_wire_message_unqueued);
     }
 }
 
@@ -65,23 +65,23 @@
     POST,
     PUT;
 
-    public string to_string() {
+    public string to_string () {
         switch (this) {
-            case HttpMethod.GET:
-                return "GET";
-
-            case HttpMethod.PUT:
-                return "PUT";
-
-            case HttpMethod.POST:
-                return "POST";
-
-            default:
-                error("unrecognized HTTP method enumeration value");
+        case HttpMethod.GET:
+            return "GET";
+
+        case HttpMethod.PUT:
+            return "PUT";
+
+        case HttpMethod.POST:
+            return "POST";
+
+        default:
+            error ("unrecognized HTTP method enumeration value");
         }
     }
 
-    public static HttpMethod from_string(string str) {
+    public static HttpMethod from_string (string str) {
         if (str == "GET") {
             return HttpMethod.GET;
         } else if (str == "PUT") {
@@ -89,7 +89,7 @@
         } else if (str == "POST") {
             return HttpMethod.POST;
         } else {
-            error("unrecognized HTTP method name: %s", str);
+            error ("unrecognized HTTP method name: %s", str);
         }
     }
 }
@@ -98,22 +98,22 @@
     public string key;
     public string value;
 
-    public Argument(string key, string value) {
+    public Argument (string key, string value) {
         this.key = key;
         this.value = value;
     }
 
-    public static int compare(Argument arg1, Argument arg2) {
-        return strcmp(arg1.key, arg2.key);
+    public static int compare (Argument arg1, Argument arg2) {
+        return strcmp (arg1.key, arg2.key);
     }
-    
-    public static Argument[] sort(Argument[] inputArray) {
-        FixedTreeSet<Argument> sorted_args = new FixedTreeSet<Argument>(Argument.compare);
+
+    public static Argument[] sort (Argument[] inputArray) {
+        FixedTreeSet<Argument> sorted_args = new FixedTreeSet<Argument> (Argument.compare);
 
         foreach (Argument arg in inputArray)
-            sorted_args.add(arg);
+            sorted_args.add (arg);
 
-        return sorted_args.to_array();
+        return sorted_args.to_array ();
     }
 }
 
@@ -126,227 +126,227 @@
     private Spit.Publishing.PublishingError? err = null;
     private string? endpoint_url = null;
     private bool use_custom_payload;
-    
-    public signal void chunk_transmitted(int bytes_written_so_far, int total_bytes);
-    public signal void network_error(Spit.Publishing.PublishingError err);
-    public signal void completed();
-    
-    public Transaction(Session parent_session, HttpMethod method = HttpMethod.POST) {
+
+    public signal void chunk_transmitted (int bytes_written_so_far, int total_bytes);
+    public signal void network_error (Spit.Publishing.PublishingError err);
+    public signal void completed ();
+
+    public Transaction (Session parent_session, HttpMethod method = HttpMethod.POST) {
         // if our creator doesn't specify an endpoint url by using the Transaction.with_endpoint_url
         // constructor, then our parent session must have a non-null endpoint url
-        assert(parent_session.get_endpoint_url() != null);
-        
+        assert (parent_session.get_endpoint_url () != null);
+
         this.parent_session = parent_session;
 
-        message = new Soup.Message(method.to_string(), parent_session.get_endpoint_url());
-        message.wrote_body_data.connect(on_wrote_body_data);
+        message = new Soup.Message (method.to_string (), parent_session.get_endpoint_url ());
+        message.wrote_body_data.connect (on_wrote_body_data);
     }
 
-    public Transaction.with_endpoint_url(Session parent_session, string endpoint_url,
-        HttpMethod method = HttpMethod.POST) {
+    public Transaction.with_endpoint_url (Session parent_session, string endpoint_url,
+                                          HttpMethod method = HttpMethod.POST) {
         this.parent_session = parent_session;
         this.endpoint_url = endpoint_url;
-        message = new Soup.Message(method.to_string(), endpoint_url);
+        message = new Soup.Message (method.to_string (), endpoint_url);
     }
 
-    private void on_wrote_body_data(Soup.Buffer written_data) {
+    private void on_wrote_body_data (Soup.Buffer written_data) {
         bytes_written += (int) written_data.length;
-        chunk_transmitted(bytes_written, (int) message.request_body.length);
+        chunk_transmitted (bytes_written, (int) message.request_body.length);
     }
 
-    private void on_message_unqueued(Soup.Message message) {
+    private void on_message_unqueued (Soup.Message message) {
         if (this.message != message)
             return;
 
         try {
-            check_response(message);
+            check_response (message);
         } catch (Spit.Publishing.PublishingError err) {
-            warning("Publishing error: %s", err.message);
-            warning("response validation failed. bad response = '%s'.", get_response());
+            warning ("Publishing error: %s", err.message);
+            warning ("response validation failed. bad response = '%s'.", get_response ());
             this.err = err;
         }
     }
 
-    protected void check_response(Soup.Message message) throws Spit.Publishing.PublishingError {
+    protected void check_response (Soup.Message message) throws Spit.Publishing.PublishingError {
         switch (message.status_code) {
-            case Soup.KnownStatusCode.OK:
-            case Soup.KnownStatusCode.CREATED: // HTTP code 201 (CREATED) signals that a new
-                                               // resource was created in response to a PUT or POST
+        case Soup.KnownStatusCode.OK:
+        case Soup.KnownStatusCode.CREATED: // HTTP code 201 (CREATED) signals that a new
+            // resource was created in response to a PUT or POST
             break;
-            
-            case Soup.KnownStatusCode.CANT_RESOLVE:
-            case Soup.KnownStatusCode.CANT_RESOLVE_PROXY:
-                throw new Spit.Publishing.PublishingError.NO_ANSWER("Unable to resolve %s (error code %u)",
-                    get_endpoint_url(), message.status_code);
-            
-            case Soup.KnownStatusCode.CANT_CONNECT:
-            case Soup.KnownStatusCode.CANT_CONNECT_PROXY:
-                throw new Spit.Publishing.PublishingError.NO_ANSWER("Unable to connect to %s (error code %u)",
-                    get_endpoint_url(), message.status_code);
-            
-            default:
-                // status codes below 100 are used by Soup, 100 and above are defined HTTP codes
-                if (message.status_code >= 100) {
-                    throw new Spit.Publishing.PublishingError.NO_ANSWER("Service %s returned HTTP status code %u %s",
-                        get_endpoint_url(), message.status_code, message.reason_phrase);
-                } else {
-                    throw new Spit.Publishing.PublishingError.NO_ANSWER("Failure communicating with %s (error code %u)",
-                        get_endpoint_url(), message.status_code);
-                }
+
+        case Soup.KnownStatusCode.CANT_RESOLVE:
+        case Soup.KnownStatusCode.CANT_RESOLVE_PROXY:
+            throw new Spit.Publishing.PublishingError.NO_ANSWER ("Unable to resolve %s (error code %u)",
+            get_endpoint_url (), message.status_code);
+
+        case Soup.KnownStatusCode.CANT_CONNECT:
+        case Soup.KnownStatusCode.CANT_CONNECT_PROXY:
+            throw new Spit.Publishing.PublishingError.NO_ANSWER ("Unable to connect to %s (error code %u)",
+            get_endpoint_url (), message.status_code);
+
+        default:
+            // status codes below 100 are used by Soup, 100 and above are defined HTTP codes
+            if (message.status_code >= 100) {
+                throw new Spit.Publishing.PublishingError.NO_ANSWER ("Service %s returned HTTP status code %u %s",
+                get_endpoint_url (), message.status_code, message.reason_phrase);
+            } else {
+                throw new Spit.Publishing.PublishingError.NO_ANSWER ("Failure communicating with %s (error code %u)",
+                        get_endpoint_url (), message.status_code);
+            }
         }
-        
+
         // All valid communication involves body data in the response
         if (message.response_body.data == null || message.response_body.data.length == 0)
-            throw new Spit.Publishing.PublishingError.MALFORMED_RESPONSE("No response data from %s",
-                get_endpoint_url());
+            throw new Spit.Publishing.PublishingError.MALFORMED_RESPONSE ("No response data from %s",
+                    get_endpoint_url ());
     }
 
-    public Argument[] get_arguments() {
+    public Argument[] get_arguments () {
         return arguments;
     }
-    
-    public Argument[] get_sorted_arguments() {
-        return Argument.sort(get_arguments());
+
+    public Argument[] get_sorted_arguments () {
+        return Argument.sort (get_arguments ());
     }
-    
-    protected void set_is_executed(bool is_executed) {
+
+    protected void set_is_executed (bool is_executed) {
         this.is_executed = is_executed;
     }
 
-    protected void send() throws Spit.Publishing.PublishingError {
-        parent_session.wire_message_unqueued.connect(on_message_unqueued);
-        message.wrote_body_data.connect(on_wrote_body_data);
-        parent_session.send_wire_message(message);
-        
-        parent_session.wire_message_unqueued.disconnect(on_message_unqueued);
-        message.wrote_body_data.disconnect(on_wrote_body_data);
-        
+    protected void send () throws Spit.Publishing.PublishingError {
+        parent_session.wire_message_unqueued.connect (on_message_unqueued);
+        message.wrote_body_data.connect (on_wrote_body_data);
+        parent_session.send_wire_message (message);
+
+        parent_session.wire_message_unqueued.disconnect (on_message_unqueued);
+        message.wrote_body_data.disconnect (on_wrote_body_data);
+
         if (err != null)
-            network_error(err);
+            network_error (err);
         else
-            completed();
-        
+            completed ();
+
         if (err != null)
             throw err;
-     }
-
-    public HttpMethod get_method() {
-        return HttpMethod.from_string(message.method);
-    }
-
-    protected virtual void add_header(string key, string value) {
-        message.request_headers.append(key, value);
-    }
-    
+    }
+
+    public HttpMethod get_method () {
+        return HttpMethod.from_string (message.method);
+    }
+
+    protected virtual void add_header (string key, string value) {
+        message.request_headers.append (key, value);
+    }
+
     // set custom_payload to null to have this transaction send the default payload of
     // key-value pairs appended through add_argument(...) (this is how most REST requests work).
     // To send a payload other than traditional key-value pairs (such as an XML document or a JPEG
     // image) to the endpoint, set the custom_payload parameter to a non-null value. If the
-    // custom_payload you specify is text data, then it's null terminated, and its length is just 
+    // custom_payload you specify is text data, then it's null terminated, and its length is just
     // custom_payload.length, so you don't have to pass in a payload_length parameter in this case.
     // If, however, custom_payload is binary data (such as a JEPG), then the caller must set
     // payload_length to the byte length of the custom_payload buffer
-    protected void set_custom_payload(string? custom_payload, string payload_content_type,
-        ulong payload_length = 0) {
-        assert (get_method() != HttpMethod.GET); // GET messages don't have payloads
+    protected void set_custom_payload (string? custom_payload, string payload_content_type,
+                                       ulong payload_length = 0) {
+        assert (get_method () != HttpMethod.GET); // GET messages don't have payloads
 
         if (custom_payload == null) {
             use_custom_payload = false;
             return;
         }
-        
+
         ulong length = (payload_length > 0) ? payload_length : custom_payload.length;
-        message.set_request(payload_content_type, Soup.MemoryUse.COPY, custom_payload.data[0:length]);
+        message.set_request (payload_content_type, Soup.MemoryUse.COPY, custom_payload.data[0:length]);
 
         use_custom_payload = true;
     }
-    
+
     // When writing a specialized transaction subclass you should rarely need to
     // call this method. In general, it's better to leave the underlying Soup message
     // alone and let the Transaction class manage it for you. You should only need
     // to install a new message if your subclass has radically different behavior from
     // normal Transactions -- like multipart encoding.
-    protected void set_message(Soup.Message message) {
+    protected void set_message (Soup.Message message) {
         this.message = message;
     }
-    
-    public bool get_is_executed() {
+
+    public bool get_is_executed () {
         return is_executed;
     }
 
-    public uint get_status_code() {
-        assert(get_is_executed());
+    public uint get_status_code () {
+        assert (get_is_executed ());
         return message.status_code;
     }
 
-    public virtual void execute() throws Spit.Publishing.PublishingError {
+    public virtual void execute () throws Spit.Publishing.PublishingError {
         // if a custom payload is being used, we don't need to peform the tasks that are necessary
         // to prepare a traditional key-value pair REST request; Instead (since we don't
         // know anything about the custom payload), we just put it on the wire and return
         if (use_custom_payload) {
             is_executed = true;
-            send();
+            send ();
 
             return;
-         }
-         
+        }
+
         //  REST POST requests must transmit at least one argument
-        if (get_method() == HttpMethod.POST)
-            assert(arguments.length > 0);
+        if (get_method () == HttpMethod.POST)
+            assert (arguments.length > 0);
 
         // concatenate the REST arguments array into an HTTP formdata string
         string formdata_string = "";
         for (int i = 0; i < arguments.length; i++) {
-            formdata_string += ("%s=%s".printf(arguments[i].key, arguments[i].value));
+            formdata_string += ("%s=%s".printf (arguments[i].key, arguments[i].value));
             if (i < arguments.length - 1)
                 formdata_string += "&";
         }
-        
+
         // for GET requests with arguments, append the formdata string to the endpoint url after a
         // query divider ('?') -- but make sure to save the old (caller-specified) endpoint URL
         // and restore it after the GET so that the underlying Soup message remains consistent
         string old_url = null;
         string url_with_query = null;
-        if (get_method() == HttpMethod.GET && arguments.length > 0) {
-            old_url = message.get_uri().to_string(false);
-            url_with_query = get_endpoint_url() + "?" + formdata_string;
-            message.set_uri(new Soup.URI(url_with_query));
+        if (get_method () == HttpMethod.GET && arguments.length > 0) {
+            old_url = message.get_uri ().to_string (false);
+            url_with_query = get_endpoint_url () + "?" + formdata_string;
+            message.set_uri (new Soup.URI (url_with_query));
         } else {
-            message.set_request("application/x-www-form-urlencoded", Soup.MemoryUse.COPY,
-                formdata_string.data);
+            message.set_request ("application/x-www-form-urlencoded", Soup.MemoryUse.COPY,
+            formdata_string.data);
         }
 
         is_executed = true;
 
         try {
-            debug("sending message to URI = '%s'", message.get_uri().to_string(false));
-            send();
+            debug ("sending message to URI = '%s'", message.get_uri ().to_string (false));
+            send ();
         } finally {
             // if old_url is non-null, then restore it
             if (old_url != null)
-                message.set_uri(new Soup.URI(old_url));
+                message.set_uri (new Soup.URI (old_url));
         }
     }
 
-    public string get_response() {
-        assert(get_is_executed());
+    public string get_response () {
+        assert (get_is_executed ());
         return (string) message.response_body.data;
     }
-    
-    public unowned Soup.MessageHeaders get_response_headers() {
-        assert(get_is_executed());
+
+    public unowned Soup.MessageHeaders get_response_headers () {
+        assert (get_is_executed ());
         return message.response_headers;
     }
-   
-    public void add_argument(string name, string value) {
-        arguments += new Argument(name, value);
-    }
-    
-    public string? get_endpoint_url() {
-        return (endpoint_url != null) ? endpoint_url : parent_session.get_endpoint_url();
-    }
-    
-    public Session get_parent_session() {
+
+    public void add_argument (string name, string value) {
+        arguments += new Argument (name, value);
+    }
+
+    public string? get_endpoint_url () {
+        return (endpoint_url != null) ? endpoint_url : parent_session.get_endpoint_url ();
+    }
+
+    public Session get_parent_session () {
         return parent_session;
     }
 }
@@ -357,177 +357,177 @@
     protected string mime_type;
     protected Gee.HashMap<string, string> message_headers = null;
 
-    public UploadTransaction(Session session, Spit.Publishing.Publishable publishable) {
+    public UploadTransaction (Session session, Spit.Publishing.Publishable publishable) {
         base (session);
         this.publishable = publishable;
-        this.mime_type = media_type_to_mime_type(publishable.get_media_type());
-
-        binary_disposition_table = create_default_binary_disposition_table();
-        
-        message_headers = new Gee.HashMap<string, string>();
+        this.mime_type = media_type_to_mime_type (publishable.get_media_type ());
+
+        binary_disposition_table = create_default_binary_disposition_table ();
+
+        message_headers = new Gee.HashMap<string, string> ();
     }
-    
-    public UploadTransaction.with_endpoint_url(Session session,
-        Spit.Publishing.Publishable publishable, string endpoint_url) {
-        base.with_endpoint_url(session, endpoint_url);
+
+    public UploadTransaction.with_endpoint_url (Session session,
+            Spit.Publishing.Publishable publishable, string endpoint_url) {
+        base.with_endpoint_url (session, endpoint_url);
         this.publishable = publishable;
-        this.mime_type = media_type_to_mime_type(publishable.get_media_type());
-
-        binary_disposition_table = create_default_binary_disposition_table();
-        
-        message_headers = new Gee.HashMap<string, string>();
-    }
-    
-    protected override void add_header(string key, string value) {
-        message_headers.set(key, value);
-    }
-    
-    private static string media_type_to_mime_type(Spit.Publishing.Publisher.MediaType media_type) {
+        this.mime_type = media_type_to_mime_type (publishable.get_media_type ());
+
+        binary_disposition_table = create_default_binary_disposition_table ();
+
+        message_headers = new Gee.HashMap<string, string> ();
+    }
+
+    protected override void add_header (string key, string value) {
+        message_headers.set (key, value);
+    }
+
+    private static string media_type_to_mime_type (Spit.Publishing.Publisher.MediaType media_type) {
         if (media_type == Spit.Publishing.Publisher.MediaType.PHOTO)
             return "image/jpeg";
         else if (media_type == Spit.Publishing.Publisher.MediaType.VIDEO)
             return "video/mpeg";
         else
-            error("UploadTransaction: unknown media type %s.", media_type.to_string());
+            error ("UploadTransaction: unknown media type %s.", media_type.to_string ());
     }
 
-    private GLib.HashTable<string, string> create_default_binary_disposition_table() {
+    private GLib.HashTable<string, string> create_default_binary_disposition_table () {
         GLib.HashTable<string, string> result =
-            new GLib.HashTable<string, string>(GLib.str_hash, GLib.str_equal);
+            new GLib.HashTable<string, string> (GLib.str_hash, GLib.str_equal);
 
-        result.insert("filename", Soup.URI.encode(publishable.get_serialized_file().get_basename(),
-            null));
+        result.insert ("filename", Soup.URI.encode (publishable.get_serialized_file ().get_basename (),
+                       null));
 
         return result;
     }
 
-    protected void set_binary_disposition_table(GLib.HashTable<string, string> new_disp_table) {
+    protected void set_binary_disposition_table (GLib.HashTable<string, string> new_disp_table) {
         binary_disposition_table = new_disp_table;
     }
 
-    public override void execute() throws Spit.Publishing.PublishingError {
-        Argument[] request_arguments = get_arguments();
-        assert(request_arguments.length > 0);
+    public override void execute () throws Spit.Publishing.PublishingError {
+        Argument[] request_arguments = get_arguments ();
+        assert (request_arguments.length > 0);
 
-        Soup.Multipart message_parts = new Soup.Multipart("multipart/form-data");
+        Soup.Multipart message_parts = new Soup.Multipart ("multipart/form-data");
 
         foreach (Argument arg in request_arguments)
-            message_parts.append_form_string(arg.key, arg.value);
+            message_parts.append_form_string (arg.key, arg.value);
 
         string payload;
         size_t payload_length;
         try {
-            FileUtils.get_contents(publishable.get_serialized_file().get_path(), out payload,
-                out payload_length);
+            FileUtils.get_contents (publishable.get_serialized_file ().get_path (), out payload,
+            out payload_length);
         } catch (FileError e) {
-            throw new Spit.Publishing.PublishingError.LOCAL_FILE_ERROR(
-                _("A temporary file needed for publishing is unavailable"));
+            throw new Spit.Publishing.PublishingError.LOCAL_FILE_ERROR (
+                _ ("A temporary file needed for publishing is unavailable"));
         }
 
-        int payload_part_num = message_parts.get_length();
+        int payload_part_num = message_parts.get_length ();
 
-        Soup.Buffer bindable_data = new Soup.Buffer(Soup.MemoryUse.COPY, payload.data[0:payload_length]);
-        message_parts.append_form_file("", publishable.get_serialized_file().get_path(), mime_type,
-            bindable_data);
+        Soup.Buffer bindable_data = new Soup.Buffer (Soup.MemoryUse.COPY, payload.data[0:payload_length]);
+        message_parts.append_form_file ("", publishable.get_serialized_file ().get_path (), mime_type,
+        bindable_data);
 
         unowned Soup.MessageHeaders image_part_header;
         unowned Soup.Buffer image_part_body;
-        message_parts.get_part(payload_part_num, out image_part_header, out image_part_body);
-        image_part_header.set_content_disposition("form-data", binary_disposition_table);
+        message_parts.get_part (payload_part_num, out image_part_header, out image_part_body);
+        image_part_header.set_content_disposition ("form-data", binary_disposition_table);
 
         Soup.Message outbound_message =
-            soup_form_request_new_from_multipart(get_endpoint_url(), message_parts);
+        soup_form_request_new_from_multipart (get_endpoint_url (), message_parts);
         // TODO: there must be a better way to iterate over a map
-        Gee.MapIterator<string, string> i = message_headers.map_iterator();
-        bool cont = i.next();
-        while(cont) {
-            outbound_message.request_headers.append(i.get_key(), i.get_value());
-            cont = i.next();
+        Gee.MapIterator<string, string> i = message_headers.map_iterator ();
+        bool cont = i.next ();
+        while (cont) {
+            outbound_message.request_headers.append (i.get_key (), i.get_value ());
+            cont = i.next ();
         }
-        set_message(outbound_message);
-        
-        set_is_executed(true);
-        send();
+        set_message (outbound_message);
+
+        set_is_executed (true);
+        send ();
     }
 }
 
 public class XmlDocument {
-    // Returns non-null string if an error condition is discovered in the XML (such as a well-known 
+    // Returns non-null string if an error condition is discovered in the XML (such as a well-known
     // node).  The string is used when generating a PublishingError exception.  This delegate does
     // not need to check for general-case malformed XML.
-    public delegate string? CheckForErrorResponse(XmlDocument doc);
-    
-    private Xml.Doc* document;
-
-    private XmlDocument(Xml.Doc* doc) {
+    public delegate string? CheckForErrorResponse (XmlDocument doc);
+
+    private Xml.Doc *document;
+
+    private XmlDocument (Xml.Doc *doc) {
         document = doc;
     }
 
-    ~RESTXmlDocument() {
+    ~RESTXmlDocument () {
         delete document;
     }
 
-    public Xml.Node* get_root_node() {
-        return document->get_root_element();
+    public Xml.Node *get_root_node () {
+        return document->get_root_element ();
     }
 
-    public Xml.Node* get_named_child(Xml.Node* parent, string child_name)
-        throws Spit.Publishing.PublishingError {
-        Xml.Node* doc_node_iter = parent->children;
-    
+    public Xml.Node *get_named_child (Xml.Node *parent, string child_name)
+    throws Spit.Publishing.PublishingError {
+        Xml.Node *doc_node_iter = parent->children;
+
         for ( ; doc_node_iter != null; doc_node_iter = doc_node_iter->next) {
             if (doc_node_iter->name == child_name)
                 return doc_node_iter;
         }
 
-        throw new Spit.Publishing.PublishingError.MALFORMED_RESPONSE("Can't find XML node %s",
-            child_name);
+        throw new Spit.Publishing.PublishingError.MALFORMED_RESPONSE ("Can't find XML node %s",
+        child_name);
     }
 
-    public string get_property_value(Xml.Node* node, string property_key)
-        throws Spit.Publishing.PublishingError {  
-        string value_string = node->get_prop(property_key);
+    public string get_property_value (Xml.Node *node, string property_key)
+    throws Spit.Publishing.PublishingError {
+        string value_string = node->get_prop (property_key);
         if (value_string == null)
-            throw new Spit.Publishing.PublishingError.MALFORMED_RESPONSE("Can't find XML " +
-                "property %s on node %s", property_key, node->name);
+            throw new Spit.Publishing.PublishingError.MALFORMED_RESPONSE ("Can't find XML " +
+            "property %s on node %s", property_key, node->name);
 
         return value_string;
     }
 
-    public static XmlDocument parse_string(string? input_string,
-        CheckForErrorResponse check_for_error_response) throws Spit.Publishing.PublishingError {
+    public static XmlDocument parse_string (string? input_string,
+                                            CheckForErrorResponse check_for_error_response) throws Spit.Publishing.PublishingError {
         if (input_string == null || input_string.length == 0)
-            throw new Spit.Publishing.PublishingError.MALFORMED_RESPONSE("Empty XML string");
+            throw new Spit.Publishing.PublishingError.MALFORMED_RESPONSE ("Empty XML string");
 
         // Does this even start and end with the right characters?
-        if (!input_string.chug().chomp().has_prefix("<") ||
-            !input_string.chug().chomp().has_suffix(">")) {
+        if (!input_string.chug ().chomp ().has_prefix ("<") ||
+        !input_string.chug ().chomp ().has_suffix (">")) {
             // Didn't start or end with a < or > and can't be parsed as XML - treat as malformed.
-            throw new Spit.Publishing.PublishingError.MALFORMED_RESPONSE("Unable to parse XML " +
-                "document");
+            throw new Spit.Publishing.PublishingError.MALFORMED_RESPONSE ("Unable to parse XML " +
+            "document");
         }
 
         // Don't want blanks to be included as text nodes, and want the XML parser to tolerate
         // tolerable XML
-        Xml.Doc* doc = Xml.Parser.read_memory(input_string, (int) input_string.length, null, null,
-            Xml.ParserOption.NOBLANKS | Xml.ParserOption.RECOVER);
+        Xml.Doc *doc = Xml.Parser.read_memory (input_string, (int) input_string.length, null, null,
+        Xml.ParserOption.NOBLANKS | Xml.ParserOption.RECOVER);
         if (doc == null)
-            throw new Spit.Publishing.PublishingError.MALFORMED_RESPONSE("Unable to parse XML " +
-                "document");
+            throw new Spit.Publishing.PublishingError.MALFORMED_RESPONSE ("Unable to parse XML " +
+            "document");
 
         // Since 'doc' is the top level, if it has no children, something is wrong
         // with the XML; we cannot continue normally here.
         if (doc->children == null) {
-            throw new Spit.Publishing.PublishingError.MALFORMED_RESPONSE("Unable to parse XML " +
-                "document");
+            throw new Spit.Publishing.PublishingError.MALFORMED_RESPONSE ("Unable to parse XML " +
+            "document");
         }
-        
-        XmlDocument rest_doc = new XmlDocument(doc);
-
-        string? result = check_for_error_response(rest_doc);
+
+        XmlDocument rest_doc = new XmlDocument (doc);
+
+        string? result = check_for_error_response (rest_doc);
         if (result != null)
-            throw new Spit.Publishing.PublishingError.SERVICE_ERROR("%s", result);
-        
+            throw new Spit.Publishing.PublishingError.SERVICE_ERROR ("%s", result);
+
         return rest_doc;
     }
 }
@@ -537,27 +537,27 @@
    entities are encoded in short, symbolic names (e.g. "ñ" -> &ntilde;). Picasa Web Albums,
    however, doesn't like symbolic encoding, and instead wants non-ASCII entities encoded directly
    as their Unicode code point numbers (e.g. "ñ" -> &241;). */
-public string decimal_entity_encode(string source) {
-    StringBuilder encoded_str_builder = new StringBuilder();
+public string decimal_entity_encode (string source) {
+    StringBuilder encoded_str_builder = new StringBuilder ();
     string current_char = source;
     while (true) {
-        int current_char_value = (int) (current_char.get_char_validated());
-        
+        int current_char_value = (int) (current_char.get_char_validated ());
+
         // null character signals end of string
         if (current_char_value < 1)
             break;
-        
+
         // no need to escape ASCII characters except the ampersand, greater-than sign and less-than
         // signs, which are special in the world of XML
         if ((current_char_value < 128) && (current_char_value != '&') && (current_char_value != '<') &&
-            (current_char_value != '>'))
-            encoded_str_builder.append_unichar(current_char.get_char_validated());
+                (current_char_value != '>'))
+            encoded_str_builder.append_unichar (current_char.get_char_validated ());
         else
-            encoded_str_builder.append("&#%d;".printf(current_char_value));
+            encoded_str_builder.append ("&#%d;".printf (current_char_value));
 
-        current_char = current_char.next_char();
+        current_char = current_char.next_char ();
     }
-    
+
     return encoded_str_builder.str;
 }
 
@@ -565,22 +565,22 @@
     private int current_file = 0;
     private Spit.Publishing.Publishable[] publishables = null;
     private Session session = null;
-	private unowned Spit.Publishing.ProgressCallback? status_updated = null;
-
-    public signal void upload_complete(int num_photos_published);
-    public signal void upload_error(Spit.Publishing.PublishingError err);
-
-    public BatchUploader(Session session, Spit.Publishing.Publishable[] publishables) {
+    private unowned Spit.Publishing.ProgressCallback? status_updated = null;
+
+    public signal void upload_complete (int num_photos_published);
+    public signal void upload_error (Spit.Publishing.PublishingError err);
+
+    public BatchUploader (Session session, Spit.Publishing.Publishable[] publishables) {
         this.publishables = publishables;
         this.session = session;
     }
 
-    private void send_files() {
+    private void send_files () {
         current_file = 0;
         bool stop = false;
         foreach (Spit.Publishing.Publishable publishable in publishables) {
-            GLib.File? file = publishable.get_serialized_file();
-            
+            GLib.File? file = publishable.get_serialized_file ();
+
             // if the current publishable hasn't been serialized, then skip it
             if (file == null) {
                 current_file++;
@@ -588,572 +588,572 @@
             }
 
             double fraction_complete = ((double) current_file) / publishables.length;
-                if (status_updated != null)
-                    status_updated(current_file + 1, fraction_complete);
-
-            Transaction txn = create_transaction(publishables[current_file]);
-           
-            txn.chunk_transmitted.connect(on_chunk_transmitted);
-            
+            if (status_updated != null)
+                status_updated (current_file + 1, fraction_complete);
+
+            Transaction txn = create_transaction (publishables[current_file]);
+
+            txn.chunk_transmitted.connect (on_chunk_transmitted);
+
             try {
-                txn.execute();
+                txn.execute ();
             } catch (Spit.Publishing.PublishingError err) {
-                upload_error(err);
+                upload_error (err);
                 stop = true;
             }
-                
-            txn.chunk_transmitted.disconnect(on_chunk_transmitted);           
-            
+
+            txn.chunk_transmitted.disconnect (on_chunk_transmitted);
+
             if (stop)
                 break;
-            
+
             current_file++;
         }
-        
+
         if (!stop)
-            upload_complete(current_file);
+            upload_complete (current_file);
     }
-    
-    private void on_chunk_transmitted(int bytes_written_so_far, int total_bytes) {
+
+    private void on_chunk_transmitted (int bytes_written_so_far, int total_bytes) {
         double file_span = 1.0 / publishables.length;
         double this_file_fraction_complete = ((double) bytes_written_so_far) / total_bytes;
         double fraction_complete = (current_file * file_span) + (this_file_fraction_complete *
-            file_span);
+                                   file_span);
 
-		if (status_updated != null)
-	        status_updated(current_file + 1, fraction_complete);
+        if (status_updated != null)
+            status_updated (current_file + 1, fraction_complete);
     }
-    
-    protected Session get_session() {
+
+    protected Session get_session () {
         return session;
     }
-    
-    protected Spit.Publishing.Publishable get_current_publishable() {
+
+    protected Spit.Publishing.Publishable get_current_publishable () {
         return publishables[current_file];
     }
-    
-    protected abstract Transaction create_transaction(Spit.Publishing.Publishable publishable);
-    
-    public void upload(Spit.Publishing.ProgressCallback? status_updated = null) {
+
+    protected abstract Transaction create_transaction (Spit.Publishing.Publishable publishable);
+
+    public void upload (Spit.Publishing.ProgressCallback? status_updated = null) {
         this.status_updated = status_updated;
 
         if (publishables.length > 0)
-           send_files();
+            send_files ();
     }
 }
 
 // Remove diacritics in a string, yielding ASCII.  If the given string is in
 // a character set not based on Latin letters (e.g. Cyrillic), the result
 // may be empty.
-public string asciify_string(string s) {
-    string t = s.normalize();  // default normalization yields a maximally decomposed form
-    
-    StringBuilder b = new StringBuilder();
-    for (unowned string u = t; u.get_char() != 0 ; u = u.next_char()) {
-        unichar c = u.get_char();
+public string asciify_string (string s) {
+    string t = s.normalize ();  // default normalization yields a maximally decomposed form
+
+    StringBuilder b = new StringBuilder ();
+    for (unowned string u = t; u.get_char () != 0 ; u = u.next_char ()) {
+        unichar c = u.get_char ();
         if ((int) c < 128)
-            b.append_unichar(c);
+            b.append_unichar (c);
     }
-    
+
     return b.str;
 }
 
 /** @brief Work-around for a problem in libgee where a TreeSet can leak references when it
  * goes out of scope; please see https://bugzilla.gnome.org/show_bug.cgi?id=695045 for more
- * details. This class merely wraps it and adds a call to clear() to the destructor.
+ * details. This class merely wraps it and adds a call to clear () to the destructor.
  */
 public class FixedTreeSet<G> : Gee.TreeSet<G> {
-    public FixedTreeSet(owned CompareDataFunc<G>? comp_func = null) {
-        base((owned) comp_func);
+    public FixedTreeSet (owned CompareDataFunc<G>? comp_func = null) {
+        base ((owned) comp_func);
     }
-    
-    ~FixedTreeSet() {
-        clear();
+
+    ~FixedTreeSet () {
+        clear ();
     }
 }
 
 public abstract class GoogleSession : Session {
-    public abstract string get_user_name();
-    public abstract string get_access_token();
-    public abstract string get_refresh_token();
-    public abstract void deauthenticate();
+    public abstract string get_user_name ();
+    public abstract string get_access_token ();
+    public abstract string get_refresh_token ();
+    public abstract void deauthenticate ();
 }
 
 public abstract class GooglePublisher : Object, Spit.Publishing.Publisher {
     private const string OAUTH_CLIENT_ID = "1073902228337-gm4uf5etk25s0hnnm0g7uv2tm2bm1j0b.apps.googleusercontent.com";
     private const string OAUTH_CLIENT_SECRET = "_kA4RZz72xqed4DqfO7xMmMN";
-    
+
     private class GoogleSessionImpl : GoogleSession {
         public string? access_token;
         public string? user_name;
         public string? refresh_token;
-        
-        public GoogleSessionImpl() {
+
+        public GoogleSessionImpl () {
             this.access_token = null;
             this.user_name = null;
             this.refresh_token = null;
         }
-        
-        public override bool is_authenticated() {
+
+        public override bool is_authenticated () {
             return (access_token != null);
         }
-        
-        public override string get_user_name() {
+
+        public override string get_user_name () {
             assert (user_name != null);
             return user_name;
         }
-        
-        public override string get_access_token() {
-            assert(is_authenticated());
+
+        public override string get_access_token () {
+            assert (is_authenticated ());
             return access_token;
         }
-        
-        public override string get_refresh_token() {
-            assert(refresh_token != null);
+
+        public override string get_refresh_token () {
+            assert (refresh_token != null);
             return refresh_token;
         }
-        
-        public override void deauthenticate() {
+
+        public override void deauthenticate () {
             access_token = null;
             user_name = null;
             refresh_token = null;
         }
     }
-    
+
     private class WebAuthenticationPane : Spit.Publishing.DialogPane, Object {
         public static bool cache_dirty = false;
-        
+
         private WebKit.WebView webview;
         private Gtk.Box pane_widget;
         private Gtk.ScrolledWindow webview_frame;
         private string auth_sequence_start_url;
 
-        public signal void authorized(string auth_code);
+        public signal void authorized (string auth_code);
 
-        public WebAuthenticationPane(string auth_sequence_start_url) {
+        public WebAuthenticationPane (string auth_sequence_start_url) {
             this.auth_sequence_start_url = auth_sequence_start_url;
 
-            pane_widget = new Gtk.Box(Gtk.Orientation.VERTICAL, 0);
-
-            webview_frame = new Gtk.ScrolledWindow(null, null);
-            webview_frame.set_shadow_type(Gtk.ShadowType.ETCHED_IN);
-            webview_frame.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC);
-
-            webview = new WebKit.WebView();
-            webview.get_settings().enable_plugins = false;
-            webview.get_settings().enable_default_context_menu = false;
-
-            webview.load_finished.connect(on_page_load);
-            webview.load_started.connect(on_load_started);
-
-            webview_frame.add(webview);
-            pane_widget.pack_start(webview_frame, true, true, 0);
+            pane_widget = new Gtk.Box (Gtk.Orientation.VERTICAL, 0);
+
+            webview_frame = new Gtk.ScrolledWindow (null, null);
+            webview_frame.set_shadow_type (Gtk.ShadowType.ETCHED_IN);
+            webview_frame.set_policy (Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC);
+
+            webview = new WebKit.WebView ();
+            webview.get_settings ().enable_plugins = false;
+            webview.get_settings ().enable_default_context_menu = false;
+
+            webview.load_finished.connect (on_page_load);
+            webview.load_started.connect (on_load_started);
+
+            webview_frame.add (webview);
+            pane_widget.pack_start (webview_frame, true, true, 0);
         }
-        
-        public static bool is_cache_dirty() {
+
+        public static bool is_cache_dirty () {
             return cache_dirty;
         }
-        
-        private void on_page_load(WebKit.WebFrame origin_frame) {
-            pane_widget.get_window().set_cursor(new Gdk.Cursor(Gdk.CursorType.LEFT_PTR));
-            
-            string page_title = webview.get_title();
-            if (page_title.index_of("state=connect") > 0) {
-                int auth_code_field_start = page_title.index_of("code=");
+
+        private void on_page_load (WebKit.WebFrame origin_frame) {
+            pane_widget.get_window ().set_cursor (new Gdk.Cursor (Gdk.CursorType.LEFT_PTR));
+
+            string page_title = webview.get_title ();
+            if (page_title.index_of ("state=connect") > 0) {
+                int auth_code_field_start = page_title.index_of ("code=");
                 if (auth_code_field_start < 0)
                     return;
 
                 string auth_code =
-                    page_title.substring(auth_code_field_start + 5); // 5 = "code=".length
+                    page_title.substring (auth_code_field_start + 5); // 5 = "code=".length
 
                 cache_dirty = true;
 
-                authorized(auth_code);
+                authorized (auth_code);
             }
         }
 
-        private void on_load_started(WebKit.WebFrame frame) {
-            pane_widget.get_window().set_cursor(new Gdk.Cursor(Gdk.CursorType.WATCH));
+        private void on_load_started (WebKit.WebFrame frame) {
+            pane_widget.get_window ().set_cursor (new Gdk.Cursor (Gdk.CursorType.WATCH));
         }
-        
-        public Spit.Publishing.DialogPane.GeometryOptions get_preferred_geometry() {
+
+        public Spit.Publishing.DialogPane.GeometryOptions get_preferred_geometry () {
             return Spit.Publishing.DialogPane.GeometryOptions.NONE;
         }
-        
-        public Gtk.Widget get_widget() {
+
+        public Gtk.Widget get_widget () {
             return pane_widget;
         }
 
-        public void on_pane_installed() {
-            webview.open(auth_sequence_start_url);
+        public void on_pane_installed () {
+            webview.open (auth_sequence_start_url);
         }
 
-        public void on_pane_uninstalled() {
+        public void on_pane_uninstalled () {
         }
     }
-    
+
     private class GetAccessTokensTransaction : Publishing.RESTSupport.Transaction {
         private const string ENDPOINT_URL = "https://accounts.google.com/o/oauth2/token";
-        
-        public GetAccessTokensTransaction(Session session, string auth_code) {
-            base.with_endpoint_url(session, ENDPOINT_URL);
-            
-            add_argument("code", auth_code);
-            add_argument("client_id", OAUTH_CLIENT_ID);
-            add_argument("client_secret", OAUTH_CLIENT_SECRET);
-            add_argument("redirect_uri", "urn:ietf:wg:oauth:2.0:oob");
-            add_argument("grant_type", "authorization_code");
+
+        public GetAccessTokensTransaction (Session session, string auth_code) {
+            base.with_endpoint_url (session, ENDPOINT_URL);
+
+            add_argument ("code", auth_code);
+            add_argument ("client_id", OAUTH_CLIENT_ID);
+            add_argument ("client_secret", OAUTH_CLIENT_SECRET);
+            add_argument ("redirect_uri", "urn:ietf:wg:oauth:2.0:oob");
+            add_argument ("grant_type", "authorization_code");
         }
     }
 
     private class RefreshAccessTokenTransaction : Publishing.RESTSupport.Transaction {
         private const string ENDPOINT_URL = "https://accounts.google.com/o/oauth2/token";
-        
-        public RefreshAccessTokenTransaction(Session session) {
-            base.with_endpoint_url(session, ENDPOINT_URL);
-        
-            add_argument("client_id", OAUTH_CLIENT_ID);
-            add_argument("client_secret", OAUTH_CLIENT_SECRET);
-            add_argument("refresh_token", ((GoogleSession) session).get_refresh_token());
-            add_argument("grant_type", "refresh_token");
+
+        public RefreshAccessTokenTransaction (Session session) {
+            base.with_endpoint_url (session, ENDPOINT_URL);
+
+            add_argument ("client_id", OAUTH_CLIENT_ID);
+            add_argument ("client_secret", OAUTH_CLIENT_SECRET);
+            add_argument ("refresh_token", ((GoogleSession) session).get_refresh_token ());
+            add_argument ("grant_type", "refresh_token");
         }
     }
 
     public class AuthenticatedTransaction : Publishing.RESTSupport.Transaction {
-        private AuthenticatedTransaction.with_endpoint_url(GoogleSession session,
-            string endpoint_url, Publishing.RESTSupport.HttpMethod method) {
-            base.with_endpoint_url(session, endpoint_url, method);
+        private AuthenticatedTransaction.with_endpoint_url (GoogleSession session,
+                string endpoint_url, Publishing.RESTSupport.HttpMethod method) {
+            base.with_endpoint_url (session, endpoint_url, method);
         }
 
-        public AuthenticatedTransaction(GoogleSession session, string endpoint_url,
-            Publishing.RESTSupport.HttpMethod method) {
-            base.with_endpoint_url(session, endpoint_url, method);
-            assert(session.is_authenticated());
+        public AuthenticatedTransaction (GoogleSession session, string endpoint_url,
+                                         Publishing.RESTSupport.HttpMethod method) {
+            base.with_endpoint_url (session, endpoint_url, method);
+            assert (session.is_authenticated ());
 
-            add_header("Authorization", "Bearer " + session.get_access_token());
+            add_header ("Authorization", "Bearer " + session.get_access_token ());
         }
     }
 
     private class UsernameFetchTransaction : AuthenticatedTransaction {
         private const string ENDPOINT_URL = "https://www.googleapis.com/oauth2/v1/userinfo";
-        
-        public UsernameFetchTransaction(GoogleSession session) {
-            base(session, ENDPOINT_URL, Publishing.RESTSupport.HttpMethod.GET);
+
+        public UsernameFetchTransaction (GoogleSession session) {
+            base (session, ENDPOINT_URL, Publishing.RESTSupport.HttpMethod.GET);
         }
     }
-    
+
     private string scope;
     private GoogleSessionImpl session;
     private WebAuthenticationPane? web_auth_pane;
     private weak Spit.Publishing.PluginHost host;
     private weak Spit.Publishing.Service service;
-    
-    protected GooglePublisher(Spit.Publishing.Service service, Spit.Publishing.PluginHost host,
-        string scope) {
+
+    protected GooglePublisher (Spit.Publishing.Service service, Spit.Publishing.PluginHost host,
+                               string scope) {
         this.scope = scope;
-        this.session = new GoogleSessionImpl();
+        this.session = new GoogleSessionImpl ();
         this.service = service;
         this.host = host;
         this.web_auth_pane = null;
     }
-    
-    private void on_web_auth_pane_authorized(string auth_code) {
-        web_auth_pane.authorized.disconnect(on_web_auth_pane_authorized);
-        
-        debug("EVENT: user authorized scope %s with auth_code %s", scope, auth_code);
-        
-        if (!is_running())
-            return;
-        
-        do_get_access_tokens(auth_code);
-    }
-
-    private void on_get_access_tokens_complete(Publishing.RESTSupport.Transaction txn) {
-        txn.completed.disconnect(on_get_access_tokens_complete);
-        txn.network_error.disconnect(on_get_access_tokens_error);
-
-        debug("EVENT: network transaction to exchange authorization code for access tokens " +
-            "completed successfully.");
-
-        if (!is_running())
-            return;
-
-        do_extract_tokens(txn.get_response());
-    }
-
-    private void on_get_access_tokens_error(Publishing.RESTSupport.Transaction txn,
-        Spit.Publishing.PublishingError err) {
-        txn.completed.disconnect(on_get_access_tokens_complete);
-        txn.network_error.disconnect(on_get_access_tokens_error);
-
-        debug("EVENT: network transaction to exchange authorization code for access tokens " +
-            "failed; response = '%s'", txn.get_response());
-
-        if (!is_running())
-            return;
-
-        host.post_error(err);
-    }
-
-    private void on_refresh_access_token_transaction_completed(Publishing.RESTSupport.Transaction
-        txn) {
-        txn.completed.disconnect(on_refresh_access_token_transaction_completed);
-        txn.network_error.disconnect(on_refresh_access_token_transaction_error);
-
-        debug("EVENT: refresh access token transaction completed successfully.");
-
-        if (!is_running())
-            return;
-
-        if (session.is_authenticated()) // ignore these events if the session is already auth'd
-            return;
-        
-        do_extract_tokens(txn.get_response());
-    }
-    
-    private void on_refresh_access_token_transaction_error(Publishing.RESTSupport.Transaction txn,
-        Spit.Publishing.PublishingError err) {
-        txn.completed.disconnect(on_refresh_access_token_transaction_completed);
-        txn.network_error.disconnect(on_refresh_access_token_transaction_error);
-
-        debug("EVENT: refresh access token transaction caused a network error.");
-
-        if (!is_running())
-            return;
-
-        if (session.is_authenticated()) // ignore these events if the session is already auth'd
-            return;
-        
+
+    private void on_web_auth_pane_authorized (string auth_code) {
+        web_auth_pane.authorized.disconnect (on_web_auth_pane_authorized);
+
+        debug ("EVENT: user authorized scope %s with auth_code %s", scope, auth_code);
+
+        if (!is_running ())
+            return;
+
+        do_get_access_tokens (auth_code);
+    }
+
+    private void on_get_access_tokens_complete (Publishing.RESTSupport.Transaction txn) {
+        txn.completed.disconnect (on_get_access_tokens_complete);
+        txn.network_error.disconnect (on_get_access_tokens_error);
+
+        debug ("EVENT: network transaction to exchange authorization code for access tokens " +
+               "completed successfully.");
+
+        if (!is_running ())
+            return;
+
+        do_extract_tokens (txn.get_response ());
+    }
+
+    private void on_get_access_tokens_error (Publishing.RESTSupport.Transaction txn,
+            Spit.Publishing.PublishingError err) {
+        txn.completed.disconnect (on_get_access_tokens_complete);
+        txn.network_error.disconnect (on_get_access_tokens_error);
+
+        debug ("EVENT: network transaction to exchange authorization code for access tokens " +
+               "failed; response = '%s'", txn.get_response ());
+
+        if (!is_running ())
+            return;
+
+        host.post_error (err);
+    }
+
+    private void on_refresh_access_token_transaction_completed (Publishing.RESTSupport.Transaction
+            txn) {
+        txn.completed.disconnect (on_refresh_access_token_transaction_completed);
+        txn.network_error.disconnect (on_refresh_access_token_transaction_error);
+
+        debug ("EVENT: refresh access token transaction completed successfully.");
+
+        if (!is_running ())
+            return;
+
+        if (session.is_authenticated ()) // ignore these events if the session is already auth'd
+            return;
+
+        do_extract_tokens (txn.get_response ());
+    }
+
+    private void on_refresh_access_token_transaction_error (Publishing.RESTSupport.Transaction txn,
+            Spit.Publishing.PublishingError err) {
+        txn.completed.disconnect (on_refresh_access_token_transaction_completed);
+        txn.network_error.disconnect (on_refresh_access_token_transaction_error);
+
+        debug ("EVENT: refresh access token transaction caused a network error.");
+
+        if (!is_running ())
+            return;
+
+        if (session.is_authenticated ()) // ignore these events if the session is already auth'd
+            return;
+
         // 400 errors indicate that the OAuth client ID and secret have become invalid. In most
         // cases, this can be fixed by logging the user out
-        if (txn.get_status_code() == 400) {
-            do_logout();
+        if (txn.get_status_code () == 400) {
+            do_logout ();
             return;
         }
-        
-        host.post_error(err);       
+
+        host.post_error (err);
     }
 
-    private void on_refresh_token_available(string token) {
-        debug("EVENT: an OAuth refresh token has become available; token = '%s'.", token);
+    private void on_refresh_token_available (string token) {
+        debug ("EVENT: an OAuth refresh token has become available; token = '%s'.", token);
 
-        if (!is_running())
+        if (!is_running ())
             return;
 
         session.refresh_token = token;
     }
-    
-    private void on_access_token_available(string token) {
-        debug("EVENT: an OAuth access token has become available; token = '%s'.", token);
-
-        if (!is_running())
+
+    private void on_access_token_available (string token) {
+        debug ("EVENT: an OAuth access token has become available; token = '%s'.", token);
+
+        if (!is_running ())
             return;
 
         session.access_token = token;
-        
-        do_fetch_username();
-    }
-
-    private void on_fetch_username_transaction_completed(Publishing.RESTSupport.Transaction txn) {
-        txn.completed.disconnect(on_fetch_username_transaction_completed);
-        txn.network_error.disconnect(on_fetch_username_transaction_error);
-        
-        debug("EVENT: username fetch transaction completed successfully.");
-
-        if (!is_running())
-            return;
-
-        do_extract_username(txn.get_response());
-    }
-    
-    private void on_fetch_username_transaction_error(Publishing.RESTSupport.Transaction txn,
-        Spit.Publishing.PublishingError err) {
-        txn.completed.disconnect(on_fetch_username_transaction_completed);
-        txn.network_error.disconnect(on_fetch_username_transaction_error);
-
-        debug("EVENT: username fetch transaction caused a network error");
-
-        if (!is_running())
-            return;
-
-        host.post_error(err);
-    }
-
-    private void do_get_access_tokens(string auth_code) {
-        debug("ACTION: exchanging authorization code for access & refresh tokens");
-        
-        host.install_login_wait_pane();
-        
-        GetAccessTokensTransaction tokens_txn = new GetAccessTokensTransaction(session, auth_code);
-        tokens_txn.completed.connect(on_get_access_tokens_complete);
-        tokens_txn.network_error.connect(on_get_access_tokens_error);
-        
+
+        do_fetch_username ();
+    }
+
+    private void on_fetch_username_transaction_completed (Publishing.RESTSupport.Transaction txn) {
+        txn.completed.disconnect (on_fetch_username_transaction_completed);
+        txn.network_error.disconnect (on_fetch_username_transaction_error);
+
+        debug ("EVENT: username fetch transaction completed successfully.");
+
+        if (!is_running ())
+            return;
+
+        do_extract_username (txn.get_response ());
+    }
+
+    private void on_fetch_username_transaction_error (Publishing.RESTSupport.Transaction txn,
+            Spit.Publishing.PublishingError err) {
+        txn.completed.disconnect (on_fetch_username_transaction_completed);
+        txn.network_error.disconnect (on_fetch_username_transaction_error);
+
+        debug ("EVENT: username fetch transaction caused a network error");
+
+        if (!is_running ())
+            return;
+
+        host.post_error (err);
+    }
+
+    private void do_get_access_tokens (string auth_code) {
+        debug ("ACTION: exchanging authorization code for access & refresh tokens");
+
+        host.install_login_wait_pane ();
+
+        GetAccessTokensTransaction tokens_txn = new GetAccessTokensTransaction (session, auth_code);
+        tokens_txn.completed.connect (on_get_access_tokens_complete);
+        tokens_txn.network_error.connect (on_get_access_tokens_error);
+
         try {
-            tokens_txn.execute();
+            tokens_txn.execute ();
         } catch (Spit.Publishing.PublishingError err) {
-            host.post_error(err);
+            host.post_error (err);
         }
     }
-    
-    private void do_hosted_web_authentication() {
-        debug("ACTION: running OAuth authentication flow in hosted web pane.");
-        
+
+    private void do_hosted_web_authentication () {
+        debug ("ACTION: running OAuth authentication flow in hosted web pane.");
+
         string user_authorization_url = "https://accounts.google.com/o/oauth2/auth?" +
-            "response_type=code&" +
-            "client_id=" + OAUTH_CLIENT_ID + "&" +
-            "redirect_uri=" + Soup.URI.encode("urn:ietf:wg:oauth:2.0:oob", null) + "&" +
-            "scope=" + Soup.URI.encode(scope, null) + "+" +
-            Soup.URI.encode("https://www.googleapis.com/auth/userinfo.profile", null) + "&" +
-            "state=connect&" +
-            "access_type=offline&" +
-            "approval_prompt=force";
-
-        web_auth_pane = new WebAuthenticationPane(user_authorization_url);
-        web_auth_pane.authorized.connect(on_web_auth_pane_authorized);
-        
-        host.install_dialog_pane(web_auth_pane);
-        
+                                        "response_type=code&" +
+                                        "client_id=" + OAUTH_CLIENT_ID + "&" +
+                                        "redirect_uri=" + Soup.URI.encode ("urn:ietf:wg:oauth:2.0:oob", null) + "&" +
+                                        "scope=" + Soup.URI.encode (scope, null) + "+" +
+                                        Soup.URI.encode ("https://www.googleapis.com/auth/userinfo.profile", null) + "&" +
+                                        "state=connect&" +
+                                        "access_type=offline&" +
+                                        "approval_prompt=force";
+
+        web_auth_pane = new WebAuthenticationPane (user_authorization_url);
+        web_auth_pane.authorized.connect (on_web_auth_pane_authorized);
+
+        host.install_dialog_pane (web_auth_pane);
+
     }
 
-    private void do_exchange_refresh_token_for_access_token() {
-        debug("ACTION: exchanging OAuth refresh token for OAuth access token.");
-        
-        host.install_login_wait_pane();
-        
-        RefreshAccessTokenTransaction txn = new RefreshAccessTokenTransaction(session);
-        
-        txn.completed.connect(on_refresh_access_token_transaction_completed);
-        txn.network_error.connect(on_refresh_access_token_transaction_error);
-        
+    private void do_exchange_refresh_token_for_access_token () {
+        debug ("ACTION: exchanging OAuth refresh token for OAuth access token.");
+
+        host.install_login_wait_pane ();
+
+        RefreshAccessTokenTransaction txn = new RefreshAccessTokenTransaction (session);
+
+        txn.completed.connect (on_refresh_access_token_transaction_completed);
+        txn.network_error.connect (on_refresh_access_token_transaction_error);
+
         try {
-            txn.execute();
+            txn.execute ();
         } catch (Spit.Publishing.PublishingError err) {
-            host.post_error(err);
+            host.post_error (err);
         }
     }
 
-    private void do_extract_tokens(string response_body) {
-        debug("ACTION: extracting OAuth tokens from body of server response");
-        
-        Json.Parser parser = new Json.Parser();
-        
+    private void do_extract_tokens (string response_body) {
+        debug ("ACTION: extracting OAuth tokens from body of server response");
+
+        Json.Parser parser = new Json.Parser ();
+
         try {
-            parser.load_from_data(response_body);
+            parser.load_from_data (response_body);
         } catch (Error err) {
-            host.post_error(new Spit.Publishing.PublishingError.MALFORMED_RESPONSE(
-                "Couldn't parse JSON response: " + err.message));
-            return;
-        }
-        
-        Json.Object response_obj = parser.get_root().get_object();
-        
-        if ((!response_obj.has_member("access_token")) && (!response_obj.has_member("refresh_token"))) {
-            host.post_error(new Spit.Publishing.PublishingError.MALFORMED_RESPONSE(
-                "neither access_token nor refresh_token not present in server response"));
-            return;
-        }
-
-        if (response_obj.has_member("refresh_token")) {
-            string refresh_token = response_obj.get_string_member("refresh_token");
+            host.post_error (new Spit.Publishing.PublishingError.MALFORMED_RESPONSE (
+                                 "Couldn't parse JSON response: " + err.message));
+            return;
+        }
+
+        Json.Object response_obj = parser.get_root ().get_object ();
+
+        if ((!response_obj.has_member ("access_token")) && (!response_obj.has_member ("refresh_token"))) {
+            host.post_error (new Spit.Publishing.PublishingError.MALFORMED_RESPONSE (
+                                 "neither access_token nor refresh_token not present in server response"));
+            return;
+        }
+
+        if (response_obj.has_member ("refresh_token")) {
+            string refresh_token = response_obj.get_string_member ("refresh_token");
 
             if (refresh_token != "")
-                on_refresh_token_available(refresh_token);
+                on_refresh_token_available (refresh_token);
         }
-        
-        if (response_obj.has_member("access_token")) {
-            string access_token = response_obj.get_string_member("access_token");
+
+        if (response_obj.has_member ("access_token")) {
+            string access_token = response_obj.get_string_member ("access_token");
 
             if (access_token != "")
-                on_access_token_available(access_token);
-        }
-    }
-
-    private void do_fetch_username() {
-        debug("ACTION: running network transaction to fetch username.");
-
-        host.install_login_wait_pane();
-        host.set_service_locked(true);
-        
-        UsernameFetchTransaction txn = new UsernameFetchTransaction(session);
-        txn.completed.connect(on_fetch_username_transaction_completed);
-        txn.network_error.connect(on_fetch_username_transaction_error);
-        
-        try {
-            txn.execute();
-        } catch (Error err) {
-            host.post_error(err);
-        }
-    }
-
-    private void do_extract_username(string response_body) {
-        debug("ACTION: extracting username from body of server response");
-        
-        Json.Parser parser = new Json.Parser();
-        
-        try {
-            parser.load_from_data(response_body);
-        } catch (Error err) {
-            host.post_error(new Spit.Publishing.PublishingError.MALFORMED_RESPONSE(
-                "Couldn't parse JSON response: " + err.message));
+                on_access_token_available (access_token);
+        }
+    }
+
+    private void do_fetch_username () {
+        debug ("ACTION: running network transaction to fetch username.");
+
+        host.install_login_wait_pane ();
+        host.set_service_locked (true);
+
+        UsernameFetchTransaction txn = new UsernameFetchTransaction (session);
+        txn.completed.connect (on_fetch_username_transaction_completed);
+        txn.network_error.connect (on_fetch_username_transaction_error);
+
+        try {
+            txn.execute ();
+        } catch (Error err) {
+            host.post_error (err);
+        }
+    }
+
+    private void do_extract_username (string response_body) {
+        debug ("ACTION: extracting username from body of server response");
+
+        Json.Parser parser = new Json.Parser ();
+
+        try {
+            parser.load_from_data (response_body);
+        } catch (Error err) {
+            host.post_error (new Spit.Publishing.PublishingError.MALFORMED_RESPONSE (
+                                 "Couldn't parse JSON response: " + err.message));
             return;
         }
-        
-        Json.Object response_obj = parser.get_root().get_object();
-
-        if (response_obj.has_member("name")) {
-            string username = response_obj.get_string_member("name");
+
+        Json.Object response_obj = parser.get_root ().get_object ();
+
+        if (response_obj.has_member ("name")) {
+            string username = response_obj.get_string_member ("name");
 
             if (username != "")
                 session.user_name = username;
         }
-        
-        if (response_obj.has_member("access_token")) {
-            string access_token = response_obj.get_string_member("access_token");
+
+        if (response_obj.has_member ("access_token")) {
+            string access_token = response_obj.get_string_member ("access_token");
 
             if (access_token != "")
                 session.access_token = access_token;
         }
-        
+
         // by the time we get a username, the session should be authenticated, or else something
         // really tragic has happened
-        assert(session.is_authenticated());
-        
-        on_login_flow_complete();
+        assert (session.is_authenticated ());
+
+        on_login_flow_complete ();
     }
 
-    protected unowned Spit.Publishing.PluginHost get_host() {
+    protected unowned Spit.Publishing.PluginHost get_host () {
         return host;
     }
 
-    protected GoogleSession get_session() {
+    protected GoogleSession get_session () {
         return session;
     }
 
-    protected void start_oauth_flow(string? refresh_token = null) {
+    protected void start_oauth_flow (string? refresh_token = null) {
         if (refresh_token != null && refresh_token != "") {
             session.refresh_token = refresh_token;
-            do_exchange_refresh_token_for_access_token();
+            do_exchange_refresh_token_for_access_token ();
         } else {
-            if (WebAuthenticationPane.is_cache_dirty()) {
-                host.install_static_message_pane(_("You have already logged in and out of a Google service during this Shotwell session.\n\nTo continue publishing to Google services, quit and restart Shotwell, then try publishing again."));
+            if (WebAuthenticationPane.is_cache_dirty ()) {
+                host.install_static_message_pane (_ ("You have already logged in and out of a Google service during this Shotwell session.\n\nTo continue publishing to Google services, quit and restart Shotwell, then try publishing again."));
                 return;
             }
 
-            do_hosted_web_authentication();
+            do_hosted_web_authentication ();
         }
     }
-    
-    protected abstract void on_login_flow_complete();
-    
-    protected abstract void do_logout();
-    
-    public abstract bool is_running();
-    
-    public abstract void start();
-    
-    public abstract void stop();
-    
-    public Spit.Publishing.Service get_service() {
+
+    protected abstract void on_login_flow_complete ();
+
+    protected abstract void do_logout ();
+
+    public abstract bool is_running ();
+
+    public abstract void start ();
+
+    public abstract void stop ();
+
+    public Spit.Publishing.Service get_service () {
         return service;
     }
 }

=== modified file 'plugins/common/Resources.vala'
--- plugins/common/Resources.vala	2013-01-21 21:16:09 +0000
+++ plugins/common/Resources.vala	2014-08-08 21:16:43 +0000
@@ -6,26 +6,26 @@
 
 namespace Resources {
 
-public const string WEBSITE_NAME = _("Visit the Yorba web site");
+public const string WEBSITE_NAME = _ ("Visit the Yorba web site");
 public const string WEBSITE_URL = "http://www.yorba.org";
 
 public const string LICENSE = """
-Shotwell is free software; you can redistribute it and/or modify it under the 
-terms of the GNU Lesser General Public License as published by the Free 
-Software Foundation; either version 2.1 of the License, or (at your option) 
-any later version.
-
-Shotwell is distributed in the hope that it will be useful, but WITHOUT 
-ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for 
-more details.
-
-You should have received a copy of the GNU Lesser General Public License 
-along with Shotwell; if not, write to the Free Software Foundation, Inc., 
-51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
-""";
-
-public const string TRANSLATORS = _("translator-credits");
+                              Shotwell is free software; you can redistribute it and/or modify it under the
+                              terms of the GNU Lesser General Public License as published by the Free
+                              Software Foundation; either version 2.1 of the License, or (at your option)
+                              any later version.
+
+                              Shotwell is distributed in the hope that it will be useful, but WITHOUT
+                              ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+                              FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+                              more details.
+
+                              You should have received a copy of the GNU Lesser General Public License
+                              along with Shotwell; if not, write to the Free Software Foundation, Inc.,
+                              51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+                              """;
+
+public const string TRANSLATORS = _ ("translator-credits");
 
 // TODO: modify to load multiple icons
 //
@@ -34,20 +34,20 @@
 // pretty common in the GNOME world), then this function can be modified to load an entire icon
 // set without its interface needing to change, since given one icon filename, we can
 // determine the others.
-public Gdk.Pixbuf[]? load_icon_set(GLib.File? icon_file) {
+public Gdk.Pixbuf[]? load_icon_set (GLib.File? icon_file) {
     Gdk.Pixbuf? icon = null;
     try {
-        icon = new Gdk.Pixbuf.from_file(icon_file.get_path());
+        icon = new Gdk.Pixbuf.from_file (icon_file.get_path ());
     } catch (Error err) {
-        warning("couldn't load icon set from %s.", icon_file.get_path());
+        warning ("couldn't load icon set from %s.", icon_file.get_path ());
     }
-    
+
     if (icon_file != null) {
         Gdk.Pixbuf[] icon_pixbuf_set = new Gdk.Pixbuf[0];
         icon_pixbuf_set += icon;
         return icon_pixbuf_set;
     }
-    
+
     return null;
 }
 

=== modified file 'plugins/common/SqliteSupport.vala'
--- plugins/common/SqliteSupport.vala	2013-01-21 21:16:09 +0000
+++ plugins/common/SqliteSupport.vala	2014-08-08 21:16:43 +0000
@@ -14,62 +14,62 @@
 }
 
 public abstract class ImportableDatabaseTable {
-    
+
     protected static Sqlite.Database db;
-    
+
     public string table_name = null;
-    
-    protected void set_table_name(string table_name) {
+
+    protected void set_table_name (string table_name) {
         this.table_name = table_name;
     }
-    
+
     // This method will throw an error on an SQLite return code unless it's OK, DONE, or ROW, which
     // are considered normal results.
-    protected static void throw_error(string method, int res) throws DatabaseError {
-        string msg = "(%s) [%d] - %s".printf(method, res, db.errmsg());
-        
+    protected static void throw_error (string method, int res) throws DatabaseError {
+        string msg = "(%s) [%d] - %s".printf (method, res, db.errmsg ());
+
         switch (res) {
-            case Sqlite.OK:
-            case Sqlite.DONE:
-            case Sqlite.ROW:
-                return;
-            
-            case Sqlite.PERM:
-            case Sqlite.BUSY:
-            case Sqlite.READONLY:
-            case Sqlite.IOERR:
-            case Sqlite.CORRUPT:
-            case Sqlite.CANTOPEN:
-            case Sqlite.NOLFS:
-            case Sqlite.AUTH:
-            case Sqlite.FORMAT:
-            case Sqlite.NOTADB:
-                throw new DatabaseError.BACKING(msg);
-            
-            case Sqlite.NOMEM:
-                throw new DatabaseError.MEMORY(msg);
-            
-            case Sqlite.ABORT:
-            case Sqlite.LOCKED:
-            case Sqlite.INTERRUPT:
-                throw new DatabaseError.ABORT(msg);
-            
-            case Sqlite.FULL:
-            case Sqlite.EMPTY:
-            case Sqlite.TOOBIG:
-            case Sqlite.CONSTRAINT:
-            case Sqlite.RANGE:
-                throw new DatabaseError.LIMITS(msg);
-            
-            case Sqlite.SCHEMA:
-            case Sqlite.MISMATCH:
-                throw new DatabaseError.TYPESPEC(msg);
-            
-            case Sqlite.ERROR:
-            case Sqlite.INTERNAL:
-            case Sqlite.MISUSE:
-            default:
-                throw new DatabaseError.ERROR(msg);
+        case Sqlite.OK:
+        case Sqlite.DONE:
+        case Sqlite.ROW:
+            return;
+
+        case Sqlite.PERM:
+        case Sqlite.BUSY:
+        case Sqlite.READONLY:
+        case Sqlite.IOERR:
+        case Sqlite.CORRUPT:
+        case Sqlite.CANTOPEN:
+        case Sqlite.NOLFS:
+        case Sqlite.AUTH:
+        case Sqlite.FORMAT:
+        case Sqlite.NOTADB:
+            throw new DatabaseError.BACKING (msg);
+
+        case Sqlite.NOMEM:
+            throw new DatabaseError.MEMORY (msg);
+
+        case Sqlite.ABORT:
+        case Sqlite.LOCKED:
+        case Sqlite.INTERRUPT:
+            throw new DatabaseError.ABORT (msg);
+
+        case Sqlite.FULL:
+        case Sqlite.EMPTY:
+        case Sqlite.TOOBIG:
+        case Sqlite.CONSTRAINT:
+        case Sqlite.RANGE:
+            throw new DatabaseError.LIMITS (msg);
+
+        case Sqlite.SCHEMA:
+        case Sqlite.MISMATCH:
+            throw new DatabaseError.TYPESPEC (msg);
+
+        case Sqlite.ERROR:
+        case Sqlite.INTERNAL:
+        case Sqlite.MISUSE:
+        default:
+            throw new DatabaseError.ERROR (msg);
         }
     }
 }

=== modified file 'plugins/common/VersionNumber.vala'
--- plugins/common/VersionNumber.vala	2013-01-21 21:16:09 +0000
+++ plugins/common/VersionNumber.vala	2014-08-08 21:16:43 +0000
@@ -12,30 +12,30 @@
  */
 public class VersionNumber : Object, Gee.Comparable<VersionNumber> {
     private int[] version;
-    
-    public VersionNumber(int[] version) {
+
+    public VersionNumber (int[] version) {
         this.version = version;
     }
-    
-    public VersionNumber.from_string(string str_version, string separator = ".") {
-        string[] version_items = str_version.split(separator);
+
+    public VersionNumber.from_string (string str_version, string separator = ".") {
+        string[] version_items = str_version.split (separator);
         this.version = new int[version_items.length];
         for (int i = 0; i < version_items.length; i++)
-            this.version[i] = int.parse(version_items[i]);
+            this.version[i] = int.parse (version_items[i]);
     }
-    
-    public string to_string() {
+
+    public string to_string () {
         string[] version_items = new string[this.version.length];
         for (int i = 0; i < this.version.length; i++)
-            version_items[i] = this.version[i].to_string();
-        return string.joinv(".", version_items);
+            version_items[i] = this.version[i].to_string ();
+        return string.joinv (".", version_items);
     }
-    
-    public int compare_to(VersionNumber other) {
+
+    public int compare_to (VersionNumber other) {
         int max_len = ((this.version.length > other.version.length) ?
                        this.version.length : other.version.length);
         int res = 0;
-        for(int i = 0; i < max_len; i++) {
+        for (int i = 0; i < max_len; i++) {
             int this_v = (i < this.version.length ? this.version[i] : 0);
             int other_v = (i < other.version.length ? other.version[i] : 0);
             res = this_v - other_v;

=== modified file 'plugins/shotwell-data-imports/FSpotDatabase.vala'
--- plugins/shotwell-data-imports/FSpotDatabase.vala	2013-01-21 21:16:09 +0000
+++ plugins/shotwell-data-imports/FSpotDatabase.vala	2014-08-08 21:16:43 +0000
@@ -12,8 +12,8 @@
 /**
  * Initialization method for the whole module.
  */
-public void init() {
-    FSpotDatabaseBehavior.create_behavior_map();
+public void init () {
+    FSpotDatabaseBehavior.create_behavior_map ();
 }
 
 /**
@@ -28,29 +28,29 @@
     public FSpotTagsTable tags_table;
     public FSpotRollsTable rolls_table;
     public int64 hidden_tag_id;
-    
-    public FSpotDatabase(File db_file) throws DatabaseError, Spit.DataImports.DataImportError {
-        string filename = db_file.get_path();
-        int res = Sqlite.Database.open_v2(filename, out fspot_db,
-            Sqlite.OPEN_READONLY, null);
+
+    public FSpotDatabase (File db_file) throws DatabaseError, Spit.DataImports.DataImportError {
+        string filename = db_file.get_path ();
+        int res = Sqlite.Database.open_v2 (filename, out fspot_db,
+        Sqlite.OPEN_READONLY, null);
         if (res != Sqlite.OK)
-            throw new DatabaseError.ERROR("Unable to open F-Spot database %s: %d", filename, res);
-        meta_table = new FSpotMetaTable(fspot_db);
-        hidden_tag_id = meta_table.get_hidden_tag_id();
-        
-        FSpotDatabaseBehavior db_behavior = new FSpotDatabaseBehavior(get_version());
-        
-        photos_table = new FSpotPhotosTable(fspot_db, db_behavior);
-        photo_versions_table = new FSpotPhotoVersionsTable(fspot_db, db_behavior);
-        tags_table = new FSpotTagsTable(fspot_db, db_behavior);
-        rolls_table = new FSpotRollsTable(fspot_db, db_behavior);
-    }
-    
-    ~FSpotDatabase() {
-    }
-    
-    private Utils.VersionNumber get_version() throws DatabaseError {
-        return new Utils.VersionNumber.from_string(meta_table.get_db_version());
+            throw new DatabaseError.ERROR ("Unable to open F-Spot database %s: %d", filename, res);
+        meta_table = new FSpotMetaTable (fspot_db);
+        hidden_tag_id = meta_table.get_hidden_tag_id ();
+
+        FSpotDatabaseBehavior db_behavior = new FSpotDatabaseBehavior (get_version ());
+
+        photos_table = new FSpotPhotosTable (fspot_db, db_behavior);
+        photo_versions_table = new FSpotPhotoVersionsTable (fspot_db, db_behavior);
+        tags_table = new FSpotTagsTable (fspot_db, db_behavior);
+        rolls_table = new FSpotRollsTable (fspot_db, db_behavior);
+    }
+
+    ~FSpotDatabase () {
+    }
+
+    private Utils.VersionNumber get_version () throws DatabaseError {
+        return new Utils.VersionNumber.from_string (meta_table.get_db_version ());
     }
 }
 

=== modified file 'plugins/shotwell-data-imports/FSpotDatabaseBehavior.vala'
--- plugins/shotwell-data-imports/FSpotDatabaseBehavior.vala	2013-01-21 21:16:09 +0000
+++ plugins/shotwell-data-imports/FSpotDatabaseBehavior.vala	2014-08-08 21:16:43 +0000
@@ -9,17 +9,17 @@
 private class FSpotBehaviorEntry {
     private Utils.VersionNumber version;
     private FSpotTableBehavior behavior;
-    
-    public FSpotBehaviorEntry(Utils.VersionNumber version, FSpotTableBehavior behavior) {
+
+    public FSpotBehaviorEntry (Utils.VersionNumber version, FSpotTableBehavior behavior) {
         this.version = version;
         this.behavior = behavior;
     }
-    
-    public Utils.VersionNumber get_version() {
+
+    public Utils.VersionNumber get_version () {
         return version;
     }
-    
-    public FSpotTableBehavior get_behavior() {
+
+    public FSpotTableBehavior get_behavior () {
         return behavior;
     }
 }
@@ -35,171 +35,171 @@
     // guaranteed as it hasn't been tested so it's probably better to just
     // bomb out at that point rather than risk importing incorrect data
     public static Utils.VersionNumber MIN_UNSUPPORTED_VERSION =
-        new Utils.VersionNumber({ 19 });
+        new Utils.VersionNumber ({ 19 });
     private static Gee.Map<string, Gee.List<FSpotBehaviorEntry>> behavior_map;
-    
+
     private FSpotTableBehavior<FSpotPhotoRow> photos_behavior;
     private FSpotTableBehavior<FSpotTagRow> tags_behavior;
     private FSpotTableBehavior<FSpotPhotoTagRow> photo_tags_behavior;
     private FSpotTableBehavior<FSpotPhotoVersionRow> photo_versions_behavior;
     private FSpotTableBehavior<FSpotRollRow> rolls_behavior;
-    
-    public static void create_behavior_map() {
-        behavior_map = new Gee.HashMap<string, Gee.List<FSpotBehaviorEntry>>();
+
+    public static void create_behavior_map () {
+        behavior_map = new Gee.HashMap<string, Gee.List<FSpotBehaviorEntry>> ();
         // photos table
-        Gee.List<FSpotBehaviorEntry> photos_list = new Gee.ArrayList<FSpotBehaviorEntry>();
+        Gee.List<FSpotBehaviorEntry> photos_list = new Gee.ArrayList<FSpotBehaviorEntry> ();
         // v0-4
-        photos_list.add(new FSpotBehaviorEntry(
-            new Utils.VersionNumber({ 0 }),
-            FSpotPhotosV0Behavior.get_instance()
-        ));
+        photos_list.add (new FSpotBehaviorEntry (
+                             new Utils.VersionNumber ({ 0 }),
+                             FSpotPhotosV0Behavior.get_instance ()
+                         ));
         // v5-6
-        photos_list.add(new FSpotBehaviorEntry(
-            new Utils.VersionNumber({ 5 }),
-            FSpotPhotosV5Behavior.get_instance()
-        ));
+        photos_list.add (new FSpotBehaviorEntry (
+                             new Utils.VersionNumber ({ 5 }),
+                             FSpotPhotosV5Behavior.get_instance ()
+                         ));
         // v7-10
-        photos_list.add(new FSpotBehaviorEntry(
-            new Utils.VersionNumber({ 7 }),
-            FSpotPhotosV7Behavior.get_instance()
-        ));
+        photos_list.add (new FSpotBehaviorEntry (
+                             new Utils.VersionNumber ({ 7 }),
+                             FSpotPhotosV7Behavior.get_instance ()
+                         ));
         // v11-15
-        photos_list.add(new FSpotBehaviorEntry(
-            new Utils.VersionNumber({ 11 }),
-            FSpotPhotosV11Behavior.get_instance()
-        ));
+        photos_list.add (new FSpotBehaviorEntry (
+                             new Utils.VersionNumber ({ 11 }),
+                             FSpotPhotosV11Behavior.get_instance ()
+                         ));
         // v16
-        photos_list.add(new FSpotBehaviorEntry(
-            new Utils.VersionNumber({ 16 }),
-            FSpotPhotosV16Behavior.get_instance()
-        ));
+        photos_list.add (new FSpotBehaviorEntry (
+                             new Utils.VersionNumber ({ 16 }),
+                             FSpotPhotosV16Behavior.get_instance ()
+                         ));
         // v17
-        photos_list.add(new FSpotBehaviorEntry(
-            new Utils.VersionNumber({ 17 }),
-            FSpotPhotosV17Behavior.get_instance()
-        ));
+        photos_list.add (new FSpotBehaviorEntry (
+                             new Utils.VersionNumber ({ 17 }),
+                             FSpotPhotosV17Behavior.get_instance ()
+                         ));
         // v18+
-        photos_list.add(new FSpotBehaviorEntry(
-            new Utils.VersionNumber({ 18 }),
-            FSpotPhotosV18Behavior.get_instance()
-        ));
-        behavior_map.set(FSpotPhotosTable.TABLE_NAME, photos_list);
+        photos_list.add (new FSpotBehaviorEntry (
+                             new Utils.VersionNumber ({ 18 }),
+                             FSpotPhotosV18Behavior.get_instance ()
+                         ));
+        behavior_map.set (FSpotPhotosTable.TABLE_NAME, photos_list);
         // tags table
-        Gee.List<FSpotBehaviorEntry> tags_list = new Gee.ArrayList<FSpotBehaviorEntry>();
+        Gee.List<FSpotBehaviorEntry> tags_list = new Gee.ArrayList<FSpotBehaviorEntry> ();
         // v0+
-        tags_list.add(new FSpotBehaviorEntry(
-            new Utils.VersionNumber({ 0 }),
-            FSpotTagsV0Behavior.get_instance()
-        ));
-        behavior_map.set(FSpotTagsTable.TABLE_NAME, tags_list);
+        tags_list.add (new FSpotBehaviorEntry (
+                           new Utils.VersionNumber ({ 0 }),
+                           FSpotTagsV0Behavior.get_instance ()
+                       ));
+        behavior_map.set (FSpotTagsTable.TABLE_NAME, tags_list);
         // photo_tags table
-        Gee.List<FSpotBehaviorEntry> photo_tags_list = new Gee.ArrayList<FSpotBehaviorEntry>();
+        Gee.List<FSpotBehaviorEntry> photo_tags_list = new Gee.ArrayList<FSpotBehaviorEntry> ();
         // v0+
-        photo_tags_list.add(new FSpotBehaviorEntry(
-            new Utils.VersionNumber({ 0 }),
-            FSpotPhotoTagsV0Behavior.get_instance()
-        ));
-        behavior_map.set(FSpotPhotoTagsTable.TABLE_NAME, photo_tags_list);
+        photo_tags_list.add (new FSpotBehaviorEntry (
+                                 new Utils.VersionNumber ({ 0 }),
+                                 FSpotPhotoTagsV0Behavior.get_instance ()
+                             ));
+        behavior_map.set (FSpotPhotoTagsTable.TABLE_NAME, photo_tags_list);
         // photo_versions table
-        Gee.List<FSpotBehaviorEntry> photo_versions_list = new Gee.ArrayList<FSpotBehaviorEntry>();
+        Gee.List<FSpotBehaviorEntry> photo_versions_list = new Gee.ArrayList<FSpotBehaviorEntry> ();
         // v0-8
-        photo_versions_list.add(new FSpotBehaviorEntry(
-            new Utils.VersionNumber({ 0 }),
-            FSpotPhotoVersionsV0Behavior.get_instance()
-        ));
+        photo_versions_list.add (new FSpotBehaviorEntry (
+                                     new Utils.VersionNumber ({ 0 }),
+                                     FSpotPhotoVersionsV0Behavior.get_instance ()
+                                 ));
         // v9-15
-        photo_versions_list.add(new FSpotBehaviorEntry(
-            new Utils.VersionNumber({ 9 }),
-            FSpotPhotoVersionsV9Behavior.get_instance()
-        ));
+        photo_versions_list.add (new FSpotBehaviorEntry (
+                                     new Utils.VersionNumber ({ 9 }),
+                                     FSpotPhotoVersionsV9Behavior.get_instance ()
+                                 ));
         // v16
-        photo_versions_list.add(new FSpotBehaviorEntry(
-            new Utils.VersionNumber({ 16 }),
-            FSpotPhotoVersionsV16Behavior.get_instance()
-        ));
+        photo_versions_list.add (new FSpotBehaviorEntry (
+                                     new Utils.VersionNumber ({ 16 }),
+                                     FSpotPhotoVersionsV16Behavior.get_instance ()
+                                 ));
         // v17
-        photo_versions_list.add(new FSpotBehaviorEntry(
-            new Utils.VersionNumber({ 17 }),
-            FSpotPhotoVersionsV17Behavior.get_instance()
-        ));
+        photo_versions_list.add (new FSpotBehaviorEntry (
+                                     new Utils.VersionNumber ({ 17 }),
+                                     FSpotPhotoVersionsV17Behavior.get_instance ()
+                                 ));
         // v18+
-        photo_versions_list.add(new FSpotBehaviorEntry(
-            new Utils.VersionNumber({ 18 }),
-            FSpotPhotoVersionsV18Behavior.get_instance()
-        ));
-        behavior_map.set(FSpotPhotoVersionsTable.TABLE_NAME, photo_versions_list);
+        photo_versions_list.add (new FSpotBehaviorEntry (
+                                     new Utils.VersionNumber ({ 18 }),
+                                     FSpotPhotoVersionsV18Behavior.get_instance ()
+                                 ));
+        behavior_map.set (FSpotPhotoVersionsTable.TABLE_NAME, photo_versions_list);
         // rolls table
-        Gee.List<FSpotBehaviorEntry> rolls_list = new Gee.ArrayList<FSpotBehaviorEntry>();
+        Gee.List<FSpotBehaviorEntry> rolls_list = new Gee.ArrayList<FSpotBehaviorEntry> ();
         // v0-4
-        rolls_list.add(new FSpotBehaviorEntry(
-            new Utils.VersionNumber({ 0 }),
-            FSpotRollsV0Behavior.get_instance()
-        ));
+        rolls_list.add (new FSpotBehaviorEntry (
+                            new Utils.VersionNumber ({ 0 }),
+                            FSpotRollsV0Behavior.get_instance ()
+                        ));
         // v5+
-        rolls_list.add(new FSpotBehaviorEntry(
-            new Utils.VersionNumber({ 5 }),
-            FSpotRollsV5Behavior.get_instance()
-        ));
-        behavior_map.set(FSpotRollsTable.TABLE_NAME, rolls_list);
+        rolls_list.add (new FSpotBehaviorEntry (
+                            new Utils.VersionNumber ({ 5 }),
+                            FSpotRollsV5Behavior.get_instance ()
+                        ));
+        behavior_map.set (FSpotRollsTable.TABLE_NAME, rolls_list);
     }
-    
-    public static FSpotTableBehavior? find_behavior(string table_name, Utils.VersionNumber version) {
+
+    public static FSpotTableBehavior? find_behavior (string table_name, Utils.VersionNumber version) {
         FSpotTableBehavior behavior = null;
-        Gee.List<FSpotBehaviorEntry> behavior_list = behavior_map.get(table_name);
+        Gee.List<FSpotBehaviorEntry> behavior_list = behavior_map.get (table_name);
         if (behavior_list != null)
             foreach (FSpotBehaviorEntry entry in behavior_list) {
-                if (version.compare_to(entry.get_version()) >= 0)
-                    behavior = entry.get_behavior();
+                if (version.compare_to (entry.get_version ()) >= 0)
+                    behavior = entry.get_behavior ();
             }
         else
-            warning("Could not find behavior list for table %s", table_name);
+            warning ("Could not find behavior list for table %s", table_name);
         return behavior;
 
     }
-    public FSpotDatabaseBehavior(Utils.VersionNumber version) throws Spit.DataImports.DataImportError {
-        if (version.compare_to(MIN_UNSUPPORTED_VERSION) >= 0)
-            throw new Spit.DataImports.DataImportError.UNSUPPORTED_VERSION("Version %s is not yet supported", version.to_string());
-        
-        FSpotTableBehavior? photos_generic_behavior = find_behavior(FSpotPhotosTable.TABLE_NAME, version);
+    public FSpotDatabaseBehavior (Utils.VersionNumber version) throws Spit.DataImports.DataImportError {
+        if (version.compare_to (MIN_UNSUPPORTED_VERSION) >= 0)
+            throw new Spit.DataImports.DataImportError.UNSUPPORTED_VERSION ("Version %s is not yet supported", version.to_string ());
+
+        FSpotTableBehavior? photos_generic_behavior = find_behavior (FSpotPhotosTable.TABLE_NAME, version);
         if (photos_generic_behavior != null)
             photos_behavior = photos_generic_behavior as FSpotTableBehavior<FSpotPhotoRow>;
-        FSpotTableBehavior? tags_generic_behavior = find_behavior(FSpotTagsTable.TABLE_NAME, version);
+        FSpotTableBehavior? tags_generic_behavior = find_behavior (FSpotTagsTable.TABLE_NAME, version);
         if (tags_generic_behavior != null)
             tags_behavior = tags_generic_behavior as FSpotTableBehavior<FSpotTagRow>;
-        FSpotTableBehavior? photo_tags_generic_behavior = find_behavior(FSpotPhotoTagsTable.TABLE_NAME, version);
+        FSpotTableBehavior? photo_tags_generic_behavior = find_behavior (FSpotPhotoTagsTable.TABLE_NAME, version);
         if (photo_tags_generic_behavior != null)
             photo_tags_behavior = photo_tags_generic_behavior as FSpotTableBehavior<FSpotPhotoTagRow>;
-        FSpotTableBehavior? photo_versions_generic_behavior = find_behavior(FSpotPhotoVersionsTable.TABLE_NAME, version);
+        FSpotTableBehavior? photo_versions_generic_behavior = find_behavior (FSpotPhotoVersionsTable.TABLE_NAME, version);
         if (photo_versions_generic_behavior != null)
             photo_versions_behavior = photo_versions_generic_behavior as FSpotTableBehavior<FSpotPhotoVersionRow>;
-        FSpotTableBehavior? rolls_generic_behavior = find_behavior(FSpotRollsTable.TABLE_NAME, version);
+        FSpotTableBehavior? rolls_generic_behavior = find_behavior (FSpotRollsTable.TABLE_NAME, version);
         if (rolls_generic_behavior != null)
             rolls_behavior = rolls_generic_behavior as FSpotTableBehavior<FSpotRollRow>;
-        
+
         if (photos_behavior == null || tags_behavior == null ||
-            photo_tags_behavior == null || photo_versions_behavior == null ||
-            rolls_behavior == null
-        )
-            throw new Spit.DataImports.DataImportError.UNSUPPORTED_VERSION("Version %s is not supported", version.to_string());
+        photo_tags_behavior == null || photo_versions_behavior == null ||
+        rolls_behavior == null
+           )
+            throw new Spit.DataImports.DataImportError.UNSUPPORTED_VERSION ("Version %s is not supported", version.to_string ());
     }
-    
-    public FSpotTableBehavior<FSpotPhotoRow> get_photos_behavior() {
+
+    public FSpotTableBehavior<FSpotPhotoRow> get_photos_behavior () {
         return photos_behavior;
     }
-    
-    public FSpotTableBehavior<FSpotTagRow> get_tags_behavior() {
+
+    public FSpotTableBehavior<FSpotTagRow> get_tags_behavior () {
         return tags_behavior;
     }
-    
-    public FSpotTableBehavior<FSpotPhotoTagRow> get_photo_tags_behavior() {
+
+    public FSpotTableBehavior<FSpotPhotoTagRow> get_photo_tags_behavior () {
         return photo_tags_behavior;
     }
-    
-    public FSpotTableBehavior<FSpotPhotoVersionRow> get_photo_versions_behavior() {
+
+    public FSpotTableBehavior<FSpotPhotoVersionRow> get_photo_versions_behavior () {
         return photo_versions_behavior;
     }
-    
-    public FSpotTableBehavior<FSpotRollRow> get_rolls_behavior() {
+
+    public FSpotTableBehavior<FSpotRollRow> get_rolls_behavior () {
         return rolls_behavior;
     }
 }

=== modified file 'plugins/shotwell-data-imports/FSpotDatabaseTable.vala'
--- plugins/shotwell-data-imports/FSpotDatabaseTable.vala	2013-01-21 21:16:09 +0000
+++ plugins/shotwell-data-imports/FSpotDatabaseTable.vala	2014-08-08 21:16:43 +0000
@@ -12,40 +12,40 @@
 public abstract class FSpotDatabaseTable<T> : ImportableDatabaseTable {
     protected unowned Sqlite.Database fspot_db;
     protected FSpotTableBehavior<T> behavior;
-    
-    public FSpotDatabaseTable(Sqlite.Database db) {
+
+    public FSpotDatabaseTable (Sqlite.Database db) {
         this.fspot_db = db;
     }
-    
-    public void set_behavior(FSpotTableBehavior<T> behavior) {
+
+    public void set_behavior (FSpotTableBehavior<T> behavior) {
         this.behavior = behavior;
-        set_table_name(behavior.get_table_name());
+        set_table_name (behavior.get_table_name ());
     }
-    
-    public FSpotTableBehavior<T> get_behavior() {
+
+    public FSpotTableBehavior<T> get_behavior () {
         return behavior;
     }
-    
-    protected string get_joined_column_list(bool with_table = false) {
-        string[] columns = behavior.list_columns();
+
+    protected string get_joined_column_list (bool with_table = false) {
+        string[] columns = behavior.list_columns ();
         if (with_table)
             for (int i = 0; i < columns.length; i++)
-                columns[i] = "%s.%s".printf(table_name, columns[i]);
-        return string.joinv(", ", columns);
+                columns[i] = "%s.%s".printf (table_name, columns[i]);
+        return string.joinv (", ", columns);
     }
-    
-    protected int select_all(out Sqlite.Statement stmt) throws DatabaseError {
-        string column_list = get_joined_column_list();
-        string sql = "SELECT %s FROM %s".printf(column_list, table_name);
-
-        int res = fspot_db.prepare_v2(sql, -1, out stmt);
+
+    protected int select_all (out Sqlite.Statement stmt) throws DatabaseError {
+        string column_list = get_joined_column_list ();
+        string sql = "SELECT %s FROM %s".printf (column_list, table_name);
+
+        int res = fspot_db.prepare_v2 (sql, -1, out stmt);
         if (res != Sqlite.OK)
-            throw_error("Statement failed: %s".printf(sql), res);
-        
-        res = stmt.step();
+            throw_error ("Statement failed: %s".printf (sql), res);
+
+        res = stmt.step ();
         if (res != Sqlite.ROW && res != Sqlite.DONE)
-            throw_error("select_all %s %s".printf(table_name, column_list), res);
-        
+            throw_error ("select_all %s %s".printf (table_name, column_list), res);
+
         return res;
     }
 }

=== modified file 'plugins/shotwell-data-imports/FSpotImporter.vala'
--- plugins/shotwell-data-imports/FSpotImporter.vala	2013-01-21 21:16:09 +0000
+++ plugins/shotwell-data-imports/FSpotImporter.vala	2014-08-08 21:16:43 +0000
@@ -9,29 +9,29 @@
 
     private static Gdk.Pixbuf[] icon_pixbuf_set = null;
 
-    public FSpotService(GLib.File resource_directory) {
+    public FSpotService (GLib.File resource_directory) {
         // initialize the database layer
-        DataImports.FSpot.Db.init();
+        DataImports.FSpot.Db.init ();
         if (icon_pixbuf_set == null)
-            icon_pixbuf_set = Resources.load_icon_set(resource_directory.get_child(ICON_FILENAME));
-    }
-    
-    public int get_pluggable_interface(int min_host_interface, int max_host_interface) {
-        return Spit.negotiate_interfaces(min_host_interface, max_host_interface,
-            Spit.DataImports.CURRENT_INTERFACE);
-    }
-
-    public unowned string get_id() {
+            icon_pixbuf_set = Resources.load_icon_set (resource_directory.get_child (ICON_FILENAME));
+    }
+
+    public int get_pluggable_interface (int min_host_interface, int max_host_interface) {
+        return Spit.negotiate_interfaces (min_host_interface, max_host_interface,
+                                          Spit.DataImports.CURRENT_INTERFACE);
+    }
+
+    public unowned string get_id () {
         return "org.yorba.shotwell.dataimports.fspot";
     }
 
-    public unowned string get_pluggable_name() {
+    public unowned string get_pluggable_name () {
         return "F-Spot";
     }
 
-    public void get_info(ref Spit.PluggableInfo info) {
+    public void get_info (ref Spit.PluggableInfo info) {
         info.authors = "Bruno Girin";
-        info.copyright = _("Copyright 2009-2013 Yorba Foundation");
+        info.copyright = _ ("Copyright 2009-2013 Yorba Foundation");
         info.translators = Resources.TRANSLATORS;
         info.version = _VERSION;
         info.website_name = Resources.WEBSITE_NAME;
@@ -41,11 +41,11 @@
         info.icons = icon_pixbuf_set;
     }
 
-    public void activation(bool enabled) {
+    public void activation (bool enabled) {
     }
-    
-    public Spit.DataImports.DataImporter create_data_importer(Spit.DataImports.PluginHost host) {
-        return new DataImports.FSpot.FSpotDataImporter(this, host);
+
+    public Spit.DataImports.DataImporter create_data_importer (Spit.DataImports.PluginHost host) {
+        return new DataImports.FSpot.FSpotDataImporter (this, host);
     }
 }
 
@@ -53,35 +53,35 @@
 
 internal const string SERVICE_NAME = "F-Spot";
 internal const string SERVICE_WELCOME_MESSAGE =
-    _("Welcome to the F-Spot library import service.\n\nPlease select a library to import, either by selecting one of the existing libraries found by Shotwell or by selecting an alternative F-Spot database file.");
+    _ ("Welcome to the F-Spot library import service.\n\nPlease select a library to import, either by selecting one of the existing libraries found by Shotwell or by selecting an alternative F-Spot database file.");
 internal const string SERVICE_WELCOME_MESSAGE_FILE_ONLY =
-    _("Welcome to the F-Spot library import service.\n\nPlease select an F-Spot database file.");
+    _ ("Welcome to the F-Spot library import service.\n\nPlease select an F-Spot database file.");
 internal const string FILE_IMPORT_LABEL =
-    _("Manually select an F-Spot database file to import:");
+    _ ("Manually select an F-Spot database file to import:");
 internal const string ERROR_CANT_OPEN_DB_FILE =
-    _("Cannot open the selected F-Spot database file: the file does not exist or is not an F-Spot database");
+    _ ("Cannot open the selected F-Spot database file: the file does not exist or is not an F-Spot database");
 internal const string ERROR_UNSUPPORTED_DB_VERSION =
-    _("Cannot open the selected F-Spot database file: this version of the F-Spot database is not supported by Shotwell");
+    _ ("Cannot open the selected F-Spot database file: this version of the F-Spot database is not supported by Shotwell");
 internal const string ERROR_CANT_READ_TAGS_TABLE =
-    _("Cannot read the selected F-Spot database file: error while reading tags table");
+    _ ("Cannot read the selected F-Spot database file: error while reading tags table");
 internal const string ERROR_CANT_READ_PHOTOS_TABLE =
-    _("Cannot read the selected F-Spot database file: error while reading photos table");
+    _ ("Cannot read the selected F-Spot database file: error while reading photos table");
 internal const string MESSAGE_FINAL_SCREEN =
-    _("Shotwell has found %d photos in the F-Spot library and is currently importing them. Duplicates will be automatically detected and removed.\n\nYou can close this dialog and start using Shotwell while the import is taking place in the background.");
+    _ ("Shotwell has found %d photos in the F-Spot library and is currently importing them. Duplicates will be automatically detected and removed.\n\nYou can close this dialog and start using Shotwell while the import is taking place in the background.");
 
 public class FSpotImportableLibrary : Spit.DataImports.ImportableLibrary, GLib.Object {
     private File db_file;
-    
-    public FSpotImportableLibrary(File db_file) {
+
+    public FSpotImportableLibrary (File db_file) {
         this.db_file = db_file;
     }
-    
-    public File get_db_file() {
+
+    public File get_db_file () {
         return db_file;
     }
-    
-    public string get_display_name() {
-        return _("F-Spot library: %s").printf(db_file.get_path());
+
+    public string get_display_name () {
+        return _ ("F-Spot library: %s").printf (db_file.get_path ());
     }
 }
 
@@ -94,8 +94,8 @@
     private FSpotImportableRating rating;
     private string folder_path;
     private string filename;
-    
-    public FSpotImportableItem(
+
+    public FSpotImportableItem (
         DataImports.FSpot.Db.FSpotPhotoRow photo_row,
         DataImports.FSpot.Db.FSpotPhotoVersionRow? photo_version_row,
         DataImports.FSpot.Db.FSpotRollRow? roll_row,
@@ -110,84 +110,84 @@
         this.tags = tags;
         this.event = event;
         if (photo_row.rating > 0)
-            this.rating = new FSpotImportableRating(photo_row.rating);
+            this.rating = new FSpotImportableRating (photo_row.rating);
         else if (is_hidden)
-            this.rating = new FSpotImportableRating(FSpotImportableRating.REJECTED);
+            this.rating = new FSpotImportableRating (FSpotImportableRating.REJECTED);
         else if (is_favorite)
-            this.rating = new FSpotImportableRating(5);
+            this.rating = new FSpotImportableRating (5);
         else
-            this.rating = new FSpotImportableRating(FSpotImportableRating.UNRATED);
-            
+            this.rating = new FSpotImportableRating (FSpotImportableRating.UNRATED);
+
         // store path and filename
         folder_path = (photo_version_row != null) ?
-            photo_version_row.base_path.get_path() :
-            photo_row.base_path.get_path();
+                      photo_version_row.base_path.get_path () :
+                      photo_row.base_path.get_path ();
         filename = (photo_version_row != null) ?
-            photo_version_row.filename :
-            photo_row.filename;
-        
+                   photo_version_row.filename :
+                   photo_row.filename;
+
         // In theory, neither field should be null at that point but belts
         // and braces don't hurt
         if (folder_path != null && filename != null) {
             // check if file exist and if not decode as URL
-            File photo = File.new_for_path(folder_path).get_child(filename);
-                
+            File photo = File.new_for_path (folder_path).get_child (filename);
+
             // If file not found, parse as URI and store back
-            if (!photo.query_exists()) {
-                folder_path = decode_url(folder_path);
-                filename = decode_url(filename);
+            if (!photo.query_exists ()) {
+                folder_path = decode_url (folder_path);
+                filename = decode_url (filename);
             }
         }
     }
-    
-    public Spit.DataImports.ImportableTag[] get_tags() {
+
+    public Spit.DataImports.ImportableTag[] get_tags () {
         Spit.DataImports.ImportableTag[] importable_tags = new Spit.DataImports.ImportableTag[0];
         foreach (FSpotImportableTag tag in tags)
             importable_tags += tag;
         return importable_tags;
     }
-    
-    public Spit.DataImports.ImportableEvent? get_event() {
+
+    public Spit.DataImports.ImportableEvent? get_event () {
         return event;
     }
-    
-    public string get_folder_path() {
+
+    public string get_folder_path () {
         return folder_path;
     }
-    
-    public string get_filename() {
+
+    public string get_filename () {
         return filename;
     }
-    
-    public string? get_title() {
+
+    public string? get_title () {
         return (photo_row.description == null || photo_row.description == "") ? null : photo_row.description;
     }
-    
-    public Spit.DataImports.ImportableRating get_rating() {
+
+    public Spit.DataImports.ImportableRating get_rating () {
         return rating;
     }
-    
-    private string decode_url(string url) {
-        StringBuilder builder = new StringBuilder();
+
+    private string decode_url (string url) {
+        StringBuilder builder = new StringBuilder ();
         for (int idx = 0; idx < url.length; ) {
-            int cidx = url.index_of_char('%', idx);
+            int cidx = url.index_of_char ('%', idx);
             if (cidx > idx) {
-                builder.append(url.slice(idx, cidx));
+                builder.append (url.slice (idx, cidx));
             }
             if (cidx >= 0) {
                 if (cidx < url.length - 2) {
-                    char c1 = url.get(cidx + 1);
-                    char c2 = url.get(cidx + 2);
-                    if (c1.isxdigit() && c1.isxdigit()) {
-                        int ccode = 0x10 * c1.xdigit_value() + c2.xdigit_value();
-                        builder.append_c((char)ccode);
+                    char c1 = url.get (cidx + 1);
+                    char c2 = url.get (cidx + 2);
+                    if (c1.isxdigit () && c1.isxdigit ()) {
+                        int ccode = 0x10 * c1.xdigit_value () + c2.xdigit_value ();
+                        builder.append_c ((char)ccode);
                     }
                     idx = cidx + 3;
                 } else {
                     idx = cidx + 1;
                 }
             } else {
-                builder.append(url.substring(idx));
+                builder.append (url.substring (idx));
                 idx = url.length;
             }
         }
@@ -198,49 +198,49 @@
 public class FSpotImportableTag : Spit.DataImports.ImportableTag, GLib.Object {
     private DataImports.FSpot.Db.FSpotTagRow row;
     private FSpotImportableTag? parent;
-    
-    public FSpotImportableTag(DataImports.FSpot.Db.FSpotTagRow row, FSpotImportableTag? parent) {
+
+    public FSpotImportableTag (DataImports.FSpot.Db.FSpotTagRow row, FSpotImportableTag? parent) {
         this.row = row;
         this.parent = parent;
     }
-    
-    public int64 get_id() {
+
+    public int64 get_id () {
         return row.tag_id;
     }
-    
-    public string get_name() {
+
+    public string get_name () {
         return row.name;
     }
-    
-    public Spit.DataImports.ImportableTag? get_parent() {
-        return parent;
-    }
-    
-    public FSpotImportableTag? get_fspot_parent() {
-        return parent;
-    }
-    
-    public string get_stock_icon() {
+
+    public Spit.DataImports.ImportableTag? get_parent () {
+        return parent;
+    }
+
+    public FSpotImportableTag? get_fspot_parent () {
+        return parent;
+    }
+
+    public string get_stock_icon () {
         return row.stock_icon;
     }
-    
-    public bool is_stock() {
-        return (row.stock_icon.has_prefix(DataImports.FSpot.Db.FSpotTagsTable.PREFIX_STOCK_ICON));
+
+    public bool is_stock () {
+        return (row.stock_icon.has_prefix (DataImports.FSpot.Db.FSpotTagsTable.PREFIX_STOCK_ICON));
     }
-    
-    public FSpotImportableEvent to_event() {
-        return new FSpotImportableEvent(this.row);
+
+    public FSpotImportableEvent to_event () {
+        return new FSpotImportableEvent (this.row);
     }
 }
 
 public class FSpotImportableEvent : Spit.DataImports.ImportableEvent, GLib.Object {
     private DataImports.FSpot.Db.FSpotTagRow row;
-    
-    public FSpotImportableEvent(DataImports.FSpot.Db.FSpotTagRow row) {
+
+    public FSpotImportableEvent (DataImports.FSpot.Db.FSpotTagRow row) {
         this.row = row;
     }
-    
-    public string get_name() {
+
+    public string get_name () {
         return row.name;
     }
 }
@@ -248,62 +248,62 @@
 public class FSpotImportableRating : Spit.DataImports.ImportableRating, GLib.Object {
     public static const int REJECTED = -1;
     public static const int UNRATED = 0;
-    
+
     private int rating_value;
-    
-    public FSpotImportableRating(int rating_value) {
+
+    public FSpotImportableRating (int rating_value) {
         if (rating_value < -1)
             rating_value = -1;
         else if (rating_value > 5)
             rating_value = 5;
         this.rating_value = rating_value;
     }
-    
-    public bool is_rejected() {
+
+    public bool is_rejected () {
         return (rating_value == REJECTED);
     }
-    
-    public bool is_unrated() {
+
+    public bool is_unrated () {
         return (rating_value == UNRATED);
     }
-    
-    public int get_value() {
+
+    public int get_value () {
         return rating_value;
     }
 }
 
 internal class FSpotTagsCache : Object {
     private DataImports.FSpot.Db.FSpotTagsTable tags_table;
-    private Gee.HashMap<int64?, FSpotImportableTag> tags_map;
-    
-    public FSpotTagsCache(DataImports.FSpot.Db.FSpotTagsTable tags_table) throws DatabaseError {
+    private Gee.HashMap < int64?, FSpotImportableTag > tags_map;
+
+    public FSpotTagsCache (DataImports.FSpot.Db.FSpotTagsTable tags_table) throws DatabaseError {
         this.tags_table = tags_table;
-        tags_map = new Gee.HashMap<int64?, FSpotImportableTag> ();
+        tags_map = new Gee.HashMap < int64?, FSpotImportableTag > ();
     }
-    
-    public FSpotImportableTag get_tag(DataImports.FSpot.Db.FSpotTagRow tag_row) throws DatabaseError {
-        FSpotImportableTag? tag = tags_map.get(tag_row.tag_id);
+
+    public FSpotImportableTag get_tag (DataImports.FSpot.Db.FSpotTagRow tag_row) throws DatabaseError {
+        FSpotImportableTag? tag = tags_map.get (tag_row.tag_id);
         if (tag != null) {
             return tag;
         } else {
-            FSpotImportableTag? parent_tag = get_tag_from_id(tag_row.category_id);
-            FSpotImportableTag new_tag = new FSpotImportableTag(tag_row, parent_tag);
+            FSpotImportableTag? parent_tag = get_tag_from_id (tag_row.category_id);
+            FSpotImportableTag new_tag = new FSpotImportableTag (tag_row, parent_tag);
             tags_map[tag_row.tag_id] = new_tag;
             return new_tag;
         }
     }
-    
-    private FSpotImportableTag? get_tag_from_id(int64 tag_id) throws DatabaseError {
+
+    private FSpotImportableTag? get_tag_from_id (int64 tag_id) throws DatabaseError {
         // check whether the tag ID is valid first, otherwise return null
         if (tag_id < 1)
             return null;
-        FSpotImportableTag? tag = tags_map.get(tag_id);
+        FSpotImportableTag? tag = tags_map.get (tag_id);
         if (tag != null)
             return tag;
-        DataImports.FSpot.Db.FSpotTagRow? tag_row = tags_table.get_by_id(tag_id);
+        DataImports.FSpot.Db.FSpotTagRow? tag_row = tags_table.get_by_id (tag_id);
         if (tag_row != null) {
-            FSpotImportableTag? parent_tag = get_tag_from_id(tag_row.category_id);
-            FSpotImportableTag new_tag = new FSpotImportableTag(tag_row, parent_tag);
+            FSpotImportableTag? parent_tag = get_tag_from_id (tag_row.category_id);
+            FSpotImportableTag new_tag = new FSpotImportableTag (tag_row, parent_tag);
             tags_map[tag_id] = new_tag;
             return new_tag;
         }
@@ -317,78 +317,78 @@
     private weak Spit.DataImports.Service service = null;
     private bool running = false;
 
-    public FSpotDataImporter(Spit.DataImports.Service service,
-        Spit.DataImports.PluginHost host) {
-        debug("FSpotDataImporter instantiated.");
+    public FSpotDataImporter (Spit.DataImports.Service service,
+                              Spit.DataImports.PluginHost host) {
+        debug ("FSpotDataImporter instantiated.");
         this.service = service;
         this.host = host;
     }
-    
-    private bool is_running() {
+
+    private bool is_running () {
         return running;
     }
-    
-    public Spit.DataImports.Service get_service() {
+
+    public Spit.DataImports.Service get_service () {
         return service;
     }
 
-    public void start() {
-        if (is_running())
+    public void start () {
+        if (is_running ())
             return;
-        
-        debug("FSpotDataImporter: starting interaction.");
-        
+
+        debug ("FSpotDataImporter: starting interaction.");
+
         running = true;
-        
-        do_discover_importable_libraries();
+
+        do_discover_importable_libraries ();
     }
 
-    public void stop() {
-        debug("FSpotDataImporter: stopping interaction.");
-        
+    public void stop () {
+        debug ("FSpotDataImporter: stopping interaction.");
+
         running = false;
     }
-    
+
     // Actions and event implementation
-    
+
     /**
      * Action that discovers importable libraries based on standard locations.
      */
-    private void do_discover_importable_libraries() {
+    private void do_discover_importable_libraries () {
         Spit.DataImports.ImportableLibrary[] discovered_libraries =
             new Spit.DataImports.ImportableLibrary[0];
-        
+
         File[] db_files = {
             // where the DB is in Ubuntu Lucid
-            File.new_for_path(Environment.get_user_config_dir()).
-                get_child("f-spot").get_child("photos.db"),
+            File.new_for_path (Environment.get_user_config_dir ()).
+            get_child ("f-spot").get_child ("photos.db"),
             // where it seems to be in Ubuntu Jaunty
-            File.new_for_path(Environment.get_home_dir()).get_child(".gnome2").
-                get_child("f-spot").get_child("photos.db"),
+            File.new_for_path (Environment.get_home_dir ()).get_child (".gnome2").
+            get_child ("f-spot").get_child ("photos.db"),
             // where it should really be if it followed the XDG spec
-            File.new_for_path(Environment.get_user_data_dir()).
-                get_child("f-spot").get_child("photos.db")
+            File.new_for_path (Environment.get_user_data_dir ()).
+            get_child ("f-spot").get_child ("photos.db")
         };
-        
+
         foreach (File db_file in db_files) {
-            if (db_file.query_exists(null)) {
-                discovered_libraries += new FSpotImportableLibrary(db_file);
-                message("Discovered importable library: %s", db_file.get_path());
+            if (db_file.query_exists (null)) {
+                discovered_libraries += new FSpotImportableLibrary (db_file);
+                message ("Discovered importable library: %s", db_file.get_path ());
             }
         }
-        
-        host.install_library_selection_pane(
+
+        host.install_library_selection_pane (
             (discovered_libraries.length > 0 ? SERVICE_WELCOME_MESSAGE : SERVICE_WELCOME_MESSAGE_FILE_ONLY),
             discovered_libraries,
             FILE_IMPORT_LABEL
         );
     }
-    
-    public void on_library_selected(Spit.DataImports.ImportableLibrary library) {
-        on_file_selected(((FSpotImportableLibrary)library).get_db_file());
+
+    public void on_library_selected (Spit.DataImports.ImportableLibrary library) {
+        on_file_selected (((FSpotImportableLibrary)library).get_db_file ());
     }
-    
-    public void on_file_selected(File file) {
+
+    public void on_file_selected (File file) {
         DataImports.FSpot.Db.FSpotDatabase database;
         FSpotTagsCache tags_cache;
         Gee.ArrayList<DataImports.FSpot.Db.FSpotPhotoRow> all_photos;
@@ -396,29 +396,29 @@
         double progress_plugin_to_host_ratio = 0.5;
         double current_progress = 0.0;
         try {
-            database = new DataImports.FSpot.Db.FSpotDatabase(file);
-        } catch(DatabaseError e) {
-            debug("FSpotDataImporter: Can't open database file: %s".printf(e.message));
-            host.post_error_message(ERROR_CANT_OPEN_DB_FILE);
-            return;
-        } catch(Spit.DataImports.DataImportError e) {
-            debug("FSpotDataImporter: Unsupported F-Spot database version: %s".printf(e.message));
-            host.post_error_message(ERROR_UNSUPPORTED_DB_VERSION);
-            return;
-        }
-        try {
-            tags_cache = new FSpotTagsCache(database.tags_table);
-        } catch(DatabaseError e) {
-            debug("FSpotDataImporter: Can't read tags table: %s".printf(e.message));
-            host.post_error_message(ERROR_CANT_READ_TAGS_TABLE);
-            return;
-        }
-        host.install_import_progress_pane(_("Preparing to import"));
-        try {
-            all_photos = database.photos_table.get_all();
-        } catch(DatabaseError e) {
-            debug("FSpotDataImporter: Can't read photos table: %s".printf(e.message));
-            host.post_error_message(ERROR_CANT_READ_PHOTOS_TABLE);
+            database = new DataImports.FSpot.Db.FSpotDatabase (file);
+        } catch (DatabaseError e) {
+            debug ("FSpotDataImporter: Can't open database file: %s".printf (e.message));
+            host.post_error_message (ERROR_CANT_OPEN_DB_FILE);
+            return;
+        } catch (Spit.DataImports.DataImportError e) {
+            debug ("FSpotDataImporter: Unsupported F-Spot database version: %s".printf (e.message));
+            host.post_error_message (ERROR_UNSUPPORTED_DB_VERSION);
+            return;
+        }
+        try {
+            tags_cache = new FSpotTagsCache (database.tags_table);
+        } catch (DatabaseError e) {
+            debug ("FSpotDataImporter: Can't read tags table: %s".printf (e.message));
+            host.post_error_message (ERROR_CANT_READ_TAGS_TABLE);
+            return;
+        }
+        host.install_import_progress_pane (_ ("Preparing to import"));
+        try {
+            all_photos = database.photos_table.get_all ();
+        } catch (DatabaseError e) {
+            debug ("FSpotDataImporter: Can't read photos table: %s".printf (e.message));
+            host.post_error_message (ERROR_CANT_READ_PHOTOS_TABLE);
             return;
         }
         if (all_photos.size > 0)
@@ -429,7 +429,7 @@
             FSpotImportableTag[] tags = new FSpotImportableTag[0];
             FSpotImportableEvent? event = null;
             DataImports.FSpot.Db.FSpotRollRow? roll_row = null;
-            
+
             // TODO: We do not convert F-Spot events to Shotwell events because F-Spot's events
             // are essentially tags.  We would need to detect if the tag is an event (use
             // is_tag_event) and then assign the event to the photo ... since a photo can be
@@ -438,126 +438,126 @@
             try {
                 foreach (
                     DataImports.FSpot.Db.FSpotTagRow tag_row in
-                    database.tags_table.get_by_photo_id(photo_row.photo_id)
+                    database.tags_table.get_by_photo_id (photo_row.photo_id)
                 ) {
-                    FSpotImportableTag tag = tags_cache.get_tag(tag_row);
-                    if (is_tag_hidden(tag, database.hidden_tag_id))
+                    FSpotImportableTag tag = tags_cache.get_tag (tag_row);
+                    if (is_tag_hidden (tag, database.hidden_tag_id))
                         hidden = true;
-                    else if (is_tag_favorite(tag))
+                    else if (is_tag_favorite (tag))
                         favorite = true;
                     else
                         tags += tag;
                 }
-            } catch(DatabaseError e) {
+            } catch (DatabaseError e) {
                 // log the error and leave the tag list empty
-                message("Failed to retrieve tags for photo ID %ld: %s", (long) photo_row.photo_id,
-                    e.message);
+                message ("Failed to retrieve tags for photo ID %ld: %s", (long) photo_row.photo_id,
+                         e.message);
             }
-            
+
             try {
-                roll_row = database.rolls_table.get_by_id(photo_row.roll_id);
+                roll_row = database.rolls_table.get_by_id (photo_row.roll_id);
             } catch (DatabaseError e) {
                 // log the error and leave the roll row null
-                message("Failed to retrieve roll for photo ID %ld: %s", (long) photo_row.photo_id,
-                    e.message);
+                message ("Failed to retrieve roll for photo ID %ld: %s", (long) photo_row.photo_id,
+                         e.message);
             }
-            
+
             Spit.DataImports.ImportableMediaItem[] importable_items = new Spit.DataImports.ImportableMediaItem[0];
             try {
                 Gee.ArrayList<DataImports.FSpot.Db.FSpotPhotoVersionRow> photo_versions =
-                    database.photo_versions_table.get_by_photo_id(photo_row.photo_id);
+                    database.photo_versions_table.get_by_photo_id (photo_row.photo_id);
                 bool photo_versions_added = false;   // set to true if at least one version was added
                 bool photo_versions_skipped = false; // set to true if at least one version was skipped due to missing file details
                 foreach (DataImports.FSpot.Db.FSpotPhotoVersionRow photo_version_row in photo_versions) {
                     if (photo_version_row.base_path != null && photo_version_row.filename != null) {
-                        importable_items += new FSpotImportableItem(
-                            photo_row, photo_version_row, roll_row, tags, event, hidden, favorite
-                        );
+                        importable_items += new FSpotImportableItem (
+                                                photo_row, photo_version_row, roll_row, tags, event, hidden, favorite
+                                            );
                         photo_versions_added = true;
                     } else {
                         photo_versions_skipped = true;
                     }
                 }
-                
+
                 // Older versions of F-Spot (0.4.3.1 at least, perhaps later) did not maintain photo_versions,
                 // this handles that case
                 // It also handles the case when we had to skip any photo version due to missing
                 // file details
                 if (photo_versions_skipped || !photo_versions_added) {
                     if (photo_row.base_path != null && photo_row.filename != null) {
-                        importable_items += new FSpotImportableItem(
-                            photo_row, null, roll_row, tags, event, hidden, favorite
-                        );
+                        importable_items += new FSpotImportableItem (
+                                                photo_row, null, roll_row, tags, event, hidden, favorite
+                                            );
                     }
                 }
             } catch (DatabaseError e) {
                 // if we can't load the different versions, do the best we can
                 // and create one photo from the photo row that was found earlier
-                message("Failed to retrieve versions for photo ID %ld: %s", (long) photo_row.photo_id,
-                    e.message);
+                message ("Failed to retrieve versions for photo ID %ld: %s", (long) photo_row.photo_id,
+                         e.message);
                 if (photo_row.base_path != null && photo_row.filename != null) {
-                    importable_items += new FSpotImportableItem(
-                        photo_row, null, roll_row, tags, event, hidden, favorite
-                    );
+                    importable_items += new FSpotImportableItem (
+                                            photo_row, null, roll_row, tags, event, hidden, favorite
+                                        );
                 }
             }
             // If the importer is still running, import the items and loop,
             // otherwise break the loop
             if (running) {
-                host.prepare_media_items_for_import(
+                host.prepare_media_items_for_import (
                     importable_items,
                     current_progress + (progress_delta_per_photo * progress_plugin_to_host_ratio),
                     progress_delta_per_photo * (1 - progress_plugin_to_host_ratio),
                     null
                 );
                 current_progress += progress_delta_per_photo;
-                host.update_import_progress_pane(current_progress);
+                host.update_import_progress_pane (current_progress);
             } else {
                 break;
             }
         }
-        host.finalize_import(on_imported_items_count);
+        host.finalize_import (on_imported_items_count);
     }
-    
-    public void on_imported_items_count(int imported_items_count) {
-        host.install_static_message_pane(
-            MESSAGE_FINAL_SCREEN.printf(imported_items_count),
+
+    public void on_imported_items_count (int imported_items_count) {
+        host.install_static_message_pane (
+            MESSAGE_FINAL_SCREEN.printf (imported_items_count),
             Spit.DataImports.PluginHost.ButtonMode.CLOSE
         );
     }
-    
-    private bool is_tag_event(FSpotImportableTag tag) {
-        bool result = (DataImports.FSpot.Db.FSpotTagsTable.STOCK_ICON_EVENTS == tag.get_stock_icon());
-        if (!result) {
-            FSpotImportableTag? parent = tag.get_fspot_parent();
-            if (parent == null)
-                result = false;
-            else
-                result = is_tag_event(parent);
-        }
-        return result;
-    }
-    
-    private bool is_tag_hidden(FSpotImportableTag tag, int64 hidden_tag_id) {
-        bool result = (hidden_tag_id == tag.get_id());
-        if (!result) {
-            FSpotImportableTag? parent = tag.get_fspot_parent();
-            if (parent == null)
-                result = false;
-            else
-                result = is_tag_hidden(parent, hidden_tag_id);
-        }
-        return result;
-    }
-    
-    private bool is_tag_favorite(FSpotImportableTag tag) {
-        bool result = (DataImports.FSpot.Db.FSpotTagsTable.STOCK_ICON_FAV == tag.get_stock_icon());
-        if (!result) {
-            FSpotImportableTag? parent = tag.get_fspot_parent();
-            if (parent == null)
-                result = false;
-            else
-                result = is_tag_favorite(parent);
+
+    private bool is_tag_event (FSpotImportableTag tag) {
+        bool result = (DataImports.FSpot.Db.FSpotTagsTable.STOCK_ICON_EVENTS == tag.get_stock_icon ());
+        if (!result) {
+            FSpotImportableTag? parent = tag.get_fspot_parent ();
+            if (parent == null)
+                result = false;
+            else
+                result = is_tag_event (parent);
+        }
+        return result;
+    }
+
+    private bool is_tag_hidden (FSpotImportableTag tag, int64 hidden_tag_id) {
+        bool result = (hidden_tag_id == tag.get_id ());
+        if (!result) {
+            FSpotImportableTag? parent = tag.get_fspot_parent ();
+            if (parent == null)
+                result = false;
+            else
+                result = is_tag_hidden (parent, hidden_tag_id);
+        }
+        return result;
+    }
+
+    private bool is_tag_favorite (FSpotImportableTag tag) {
+        bool result = (DataImports.FSpot.Db.FSpotTagsTable.STOCK_ICON_FAV == tag.get_stock_icon ());
+        if (!result) {
+            FSpotImportableTag? parent = tag.get_fspot_parent ();
+            if (parent == null)
+                result = false;
+            else
+                result = is_tag_favorite (parent);
         }
         return result;
     }

=== modified file 'plugins/shotwell-data-imports/FSpotMetaTable.vala'
--- plugins/shotwell-data-imports/FSpotMetaTable.vala	2013-01-21 21:16:09 +0000
+++ plugins/shotwell-data-imports/FSpotMetaTable.vala	2014-08-08 21:16:43 +0000
@@ -30,50 +30,50 @@
  *    attempting to read the rest of the database so we might as well abort.
  */
 public class FSpotMetaTable : FSpotDatabaseTable<FSpotMetaRow> {
-    
-    public FSpotMetaTable(Sqlite.Database db) {
-        base(db);
-        set_behavior(FSpotMetaBehavior.get_instance());
+
+    public FSpotMetaTable (Sqlite.Database db) {
+        base (db);
+        set_behavior (FSpotMetaBehavior.get_instance ());
     }
-    
-    public string? get_data(string name) throws DatabaseError {
-        string[] columns = behavior.list_columns();
-        string column_list = string.joinv(", ", columns);
-        string sql = "SELECT %s FROM %s WHERE name=?".printf(column_list, table_name);
+
+    public string? get_data (string name) throws DatabaseError {
+        string[] columns = behavior.list_columns ();
+        string column_list = string.joinv (", ", columns);
+        string sql = "SELECT %s FROM %s WHERE name=?".printf (column_list, table_name);
         Sqlite.Statement stmt;
-        int res = fspot_db.prepare_v2(sql, -1, out stmt);
-        if (res != Sqlite.OK)
-            throw_error("Statement failed: %s".printf(sql), res);
-        
-        res = stmt.bind_text(1, name);
-        if (res != Sqlite.OK)
-            throw_error("Bind failed for name %s".printf(name), res);
-        
-        res = stmt.step();
+        int res = fspot_db.prepare_v2 (sql, -1, out stmt);
+        if (res != Sqlite.OK)
+            throw_error ("Statement failed: %s".printf (sql), res);
+
+        res = stmt.bind_text (1, name);
+        if (res != Sqlite.OK)
+            throw_error ("Bind failed for name %s".printf (name), res);
+
+        res = stmt.step ();
         if (res != Sqlite.ROW) {
             if (res != Sqlite.DONE)
-                throw_error("FSpotMetaTable.get_data", res);
-            
+                throw_error ("FSpotMetaTable.get_data", res);
+
             return null;
         }
-        
+
         FSpotMetaRow row;
-        behavior.build_row(stmt, out row);
+        behavior.build_row (stmt, out row);
         return row.data;
     }
-    
-    public string? get_app_version() throws DatabaseError {
-        return get_data("F-Spot Version");
-    }
-    
-    public string? get_db_version() throws DatabaseError {
-        return get_data("F-Spot Database Version");
-    }
-    
-    public int64 get_hidden_tag_id() throws DatabaseError {
-        string id_str = get_data("Hidden Tag Id");
-        if(id_str != null) {
-            return int64.parse(id_str);
+
+    public string? get_app_version () throws DatabaseError {
+        return get_data ("F-Spot Version");
+    }
+
+    public string? get_db_version () throws DatabaseError {
+        return get_data ("F-Spot Database Version");
+    }
+
+    public int64 get_hidden_tag_id () throws DatabaseError {
+        string id_str = get_data ("Hidden Tag Id");
+        if (id_str != null) {
+            return int64.parse (id_str);
         } else {
             return -1;
         }
@@ -82,30 +82,30 @@
 
 public class FSpotMetaBehavior : FSpotTableBehavior<FSpotMetaRow>, Object {
     public static const string TABLE_NAME = "Meta";
-    
+
     private static FSpotMetaBehavior instance;
-    
-    private FSpotMetaBehavior() {
+
+    private FSpotMetaBehavior () {
     }
-    
-    public static FSpotMetaBehavior get_instance() {
+
+    public static FSpotMetaBehavior get_instance () {
         if (instance == null)
-            instance = new FSpotMetaBehavior();
+            instance = new FSpotMetaBehavior ();
         return instance;
     }
-    
-    public string get_table_name() {
+
+    public string get_table_name () {
         return TABLE_NAME;
     }
-    
-    public string[] list_columns() {
+
+    public string[] list_columns () {
         return { "name", "data" };
     }
-    
-    public void build_row(Sqlite.Statement stmt, out FSpotMetaRow row, int offset = 0) {
-        row = new FSpotMetaRow();
-        row.name = stmt.column_text(offset + 0);
-        row.data = stmt.column_text(offset + 1);
+
+    public void build_row (Sqlite.Statement stmt, out FSpotMetaRow row, int offset = 0) {
+        row = new FSpotMetaRow ();
+        row.name = stmt.column_text (offset + 0);
+        row.data = stmt.column_text (offset + 1);
     }
 }
 

=== modified file 'plugins/shotwell-data-imports/FSpotPhotoTagsTable.vala'
--- plugins/shotwell-data-imports/FSpotPhotoTagsTable.vala	2013-01-21 21:16:09 +0000
+++ plugins/shotwell-data-imports/FSpotPhotoTagsTable.vala	2014-08-08 21:16:43 +0000
@@ -19,37 +19,37 @@
  */
 public class FSpotPhotoTagsTable : FSpotDatabaseTable<FSpotPhotoTagRow> {
     public static const string TABLE_NAME = "Photo_Tags";
-    
-    public FSpotPhotoTagsTable(Sqlite.Database db, FSpotDatabaseBehavior db_behavior) {
-        base(db);
-        set_behavior(db_behavior.get_photo_tags_behavior());
+
+    public FSpotPhotoTagsTable (Sqlite.Database db, FSpotDatabaseBehavior db_behavior) {
+        base (db);
+        set_behavior (db_behavior.get_photo_tags_behavior ());
     }
 }
 
 public class FSpotPhotoTagsV0Behavior : FSpotTableBehavior<FSpotPhotoTagRow>, Object {
     private static FSpotPhotoTagsV0Behavior instance;
-    
-    private FSpotPhotoTagsV0Behavior() {
+
+    private FSpotPhotoTagsV0Behavior () {
     }
-    
-    public static FSpotPhotoTagsV0Behavior get_instance() {
+
+    public static FSpotPhotoTagsV0Behavior get_instance () {
         if (instance == null)
-            instance = new FSpotPhotoTagsV0Behavior();
+            instance = new FSpotPhotoTagsV0Behavior ();
         return instance;
     }
-    
-    public string get_table_name() {
+
+    public string get_table_name () {
         return FSpotPhotoTagsTable.TABLE_NAME;
     }
 
-    public string[] list_columns() {
+    public string[] list_columns () {
         return { "photo_id", "tag_id" };
     }
-    
-    public void build_row(Sqlite.Statement stmt, out FSpotPhotoTagRow row, int offset = 0) {
-        row = new FSpotPhotoTagRow();
-        row.photo_id = stmt.column_int64(offset + 0);
-        row.tag_id = stmt.column_int64(offset + 1);
+
+    public void build_row (Sqlite.Statement stmt, out FSpotPhotoTagRow row, int offset = 0) {
+        row = new FSpotPhotoTagRow ();
+        row.photo_id = stmt.column_int64 (offset + 0);
+        row.tag_id = stmt.column_int64 (offset + 1);
     }
 }
 

=== modified file 'plugins/shotwell-data-imports/FSpotPhotoVersionsTable.vala'
--- plugins/shotwell-data-imports/FSpotPhotoVersionsTable.vala	2013-01-21 21:16:09 +0000
+++ plugins/shotwell-data-imports/FSpotPhotoVersionsTable.vala	2014-08-08 21:16:43 +0000
@@ -25,37 +25,37 @@
 public class FSpotPhotoVersionsTable : FSpotDatabaseTable<FSpotPhotoVersionRow> {
     public static const string TABLE_NAME = "Photo_versions";
 
-    public FSpotPhotoVersionsTable(Sqlite.Database db, FSpotDatabaseBehavior db_behavior) {
-        base(db);
-        set_behavior(db_behavior.get_photo_versions_behavior());
+    public FSpotPhotoVersionsTable (Sqlite.Database db, FSpotDatabaseBehavior db_behavior) {
+        base (db);
+        set_behavior (db_behavior.get_photo_versions_behavior ());
     }
-    
-    public Gee.ArrayList<FSpotPhotoVersionRow> get_by_photo_id(int64 photo_id) throws DatabaseError {
-        Gee.ArrayList<FSpotPhotoVersionRow> rows = new Gee.ArrayList<FSpotPhotoVersionRow?>();
-        
+
+    public Gee.ArrayList<FSpotPhotoVersionRow> get_by_photo_id (int64 photo_id) throws DatabaseError {
+        Gee.ArrayList<FSpotPhotoVersionRow> rows = new Gee.ArrayList < FSpotPhotoVersionRow?> ();
+
         Sqlite.Statement stmt;
-        
-        string column_list = get_joined_column_list();
-        string sql = "SELECT %s FROM %s WHERE photo_id=?".printf(
+
+        string column_list = get_joined_column_list ();
+        string sql = "SELECT %s FROM %s WHERE photo_id=?".printf (
             column_list, table_name
         );
 
-        int res = fspot_db.prepare_v2(sql, -1, out stmt);
-        if (res != Sqlite.OK)
-            throw_error("Statement failed: %s".printf(sql), res);
-        
-        res = stmt.bind_int64(1, photo_id);
-        if (res != Sqlite.OK)
-            throw_error("Bind failed for photo_id", res);
-        
-        res = stmt.step();
+        int res = fspot_db.prepare_v2 (sql, -1, out stmt);
+        if (res != Sqlite.OK)
+            throw_error ("Statement failed: %s".printf (sql), res);
+
+        res = stmt.bind_int64 (1, photo_id);
+        if (res != Sqlite.OK)
+            throw_error ("Bind failed for photo_id", res);
+
+        res = stmt.step ();
         while (res == Sqlite.ROW) {
             FSpotPhotoVersionRow row;
-            behavior.build_row(stmt, out row);
-            rows.add(row);
-            res = stmt.step();
+            behavior.build_row (stmt, out row);
+            rows.add (row);
+            res = stmt.step ();
         }
-        
+
         return rows;
     }
 }
@@ -66,35 +66,35 @@
 // be handled in a way identical to v0-7
 public class FSpotPhotoVersionsV0Behavior : FSpotTableBehavior<FSpotPhotoVersionRow>, Object {
     private static FSpotPhotoVersionsV0Behavior instance;
-    
-    private FSpotPhotoVersionsV0Behavior() {
+
+    private FSpotPhotoVersionsV0Behavior () {
     }
-    
-    public static FSpotPhotoVersionsV0Behavior get_instance() {
+
+    public static FSpotPhotoVersionsV0Behavior get_instance () {
         if (instance == null)
-            instance = new FSpotPhotoVersionsV0Behavior();
+            instance = new FSpotPhotoVersionsV0Behavior ();
         return instance;
     }
-    
-    public string get_table_name() {
+
+    public string get_table_name () {
         return FSpotPhotoVersionsTable.TABLE_NAME;
-    }    
-    
-    public string[] list_columns() {
+    }
+
+    public string[] list_columns () {
         return { "photo_id", "version_id", "name", "uri" };
     }
-    
-    public void build_row(Sqlite.Statement stmt, out FSpotPhotoVersionRow row, int offset = 0) {
-        row = new FSpotPhotoVersionRow();
-        row.photo_id = stmt.column_int64(offset + 0);
-        row.version_id = stmt.column_int64(offset + 1);
-        row.name = stmt.column_text(offset + 2);
-
-        string? full_path = stmt.column_text(offset + 3);
+
+    public void build_row (Sqlite.Statement stmt, out FSpotPhotoVersionRow row, int offset = 0) {
+        row = new FSpotPhotoVersionRow ();
+        row.photo_id = stmt.column_int64 (offset + 0);
+        row.version_id = stmt.column_int64 (offset + 1);
+        row.name = stmt.column_text (offset + 2);
+
+        string? full_path = stmt.column_text (offset + 3);
         if (full_path != null) {
-            File uri = File.new_for_uri(full_path);
-            row.base_path = uri.get_parent();
-            row.filename = uri.get_basename();
+            File uri = File.new_for_uri (full_path);
+            row.base_path = uri.get_parent ();
+            row.filename = uri.get_basename ();
         }
 
         row.md5_sum = "";
@@ -106,40 +106,41 @@
 // add protected field
 public class FSpotPhotoVersionsV9Behavior : FSpotTableBehavior<FSpotPhotoVersionRow>, Object {
     private static FSpotPhotoVersionsV9Behavior instance;
-    
-    private FSpotPhotoVersionsV9Behavior() {
+
+    private FSpotPhotoVersionsV9Behavior () {
     }
-    
-    public static FSpotPhotoVersionsV9Behavior get_instance() {
+
+    public static FSpotPhotoVersionsV9Behavior get_instance () {
         if (instance == null)
-            instance = new FSpotPhotoVersionsV9Behavior();
+            instance = new FSpotPhotoVersionsV9Behavior ();
         return instance;
     }
-    
-    public string get_table_name() {
+
+    public string get_table_name () {
         return FSpotPhotoVersionsTable.TABLE_NAME;
-    }    
-    
-    public string[] list_columns() {
+    }
+
+    public string[] list_columns () {
         return { "photo_id", "version_id", "name", "uri",
-            "protected" };
+                 "protected"
+               };
     }
-    
-    public void build_row(Sqlite.Statement stmt, out FSpotPhotoVersionRow row, int offset = 0) {
-        row = new FSpotPhotoVersionRow();
-        row.photo_id = stmt.column_int64(offset + 0);
-        row.version_id = stmt.column_int64(offset + 1);
-        row.name = stmt.column_text(offset + 2);
-
-        string? full_path = stmt.column_text(offset + 3);
+
+    public void build_row (Sqlite.Statement stmt, out FSpotPhotoVersionRow row, int offset = 0) {
+        row = new FSpotPhotoVersionRow ();
+        row.photo_id = stmt.column_int64 (offset + 0);
+        row.version_id = stmt.column_int64 (offset + 1);
+        row.name = stmt.column_text (offset + 2);
+
+        string? full_path = stmt.column_text (offset + 3);
         if (full_path != null) {
-            File uri = File.new_for_uri(full_path);
-            row.base_path = uri.get_parent();
-            row.filename = uri.get_basename();
+            File uri = File.new_for_uri (full_path);
+            row.base_path = uri.get_parent ();
+            row.filename = uri.get_basename ();
         }
 
         row.md5_sum = "";
-        row.is_protected = (stmt.column_int(offset + 4) > 0);
+        row.is_protected = (stmt.column_int (offset + 4) > 0);
     }
 }
 
@@ -147,40 +148,41 @@
 // add md5_sum in photo_versions
 public class FSpotPhotoVersionsV16Behavior : FSpotTableBehavior<FSpotPhotoVersionRow>, Object {
     private static FSpotPhotoVersionsV16Behavior instance;
-    
-    private FSpotPhotoVersionsV16Behavior() {
+
+    private FSpotPhotoVersionsV16Behavior () {
     }
-    
-    public static FSpotPhotoVersionsV16Behavior get_instance() {
+
+    public static FSpotPhotoVersionsV16Behavior get_instance () {
         if (instance == null)
-            instance = new FSpotPhotoVersionsV16Behavior();
+            instance = new FSpotPhotoVersionsV16Behavior ();
         return instance;
     }
-    
-    public string get_table_name() {
+
+    public string get_table_name () {
         return FSpotPhotoVersionsTable.TABLE_NAME;
-    }    
-    
-    public string[] list_columns() {
+    }
+
+    public string[] list_columns () {
         return { "photo_id", "version_id", "name", "uri",
-            "md5_sum", "protected" };
+                 "md5_sum", "protected"
+               };
     }
-    
-    public void build_row(Sqlite.Statement stmt, out FSpotPhotoVersionRow row, int offset = 0) {
-        row = new FSpotPhotoVersionRow();
-        row.photo_id = stmt.column_int64(offset + 0);
-        row.version_id = stmt.column_int64(offset + 1);
-        row.name = stmt.column_text(offset + 2);
-
-        string? full_path = stmt.column_text(offset + 3);
+
+    public void build_row (Sqlite.Statement stmt, out FSpotPhotoVersionRow row, int offset = 0) {
+        row = new FSpotPhotoVersionRow ();
+        row.photo_id = stmt.column_int64 (offset + 0);
+        row.version_id = stmt.column_int64 (offset + 1);
+        row.name = stmt.column_text (offset + 2);
+
+        string? full_path = stmt.column_text (offset + 3);
         if (full_path != null) {
-            File uri = File.new_for_uri(full_path);
-            row.base_path = uri.get_parent();
-            row.filename = uri.get_basename();
+            File uri = File.new_for_uri (full_path);
+            row.base_path = uri.get_parent ();
+            row.filename = uri.get_basename ();
         }
 
-        row.md5_sum = stmt.column_text(offset + 4);
-        row.is_protected = (stmt.column_int(offset + 5) > 0);
+        row.md5_sum = stmt.column_text (offset + 4);
+        row.is_protected = (stmt.column_int (offset + 5) > 0);
     }
 }
 
@@ -189,40 +191,41 @@
 // design introduced in v0, albeit with a URI rather than a file system path)
 public class FSpotPhotoVersionsV17Behavior : FSpotTableBehavior<FSpotPhotoVersionRow>, Object {
     private static FSpotPhotoVersionsV17Behavior instance;
-    
-    private FSpotPhotoVersionsV17Behavior() {
+
+    private FSpotPhotoVersionsV17Behavior () {
     }
-    
-    public static FSpotPhotoVersionsV17Behavior get_instance() {
+
+    public static FSpotPhotoVersionsV17Behavior get_instance () {
         if (instance == null)
-            instance = new FSpotPhotoVersionsV17Behavior();
+            instance = new FSpotPhotoVersionsV17Behavior ();
         return instance;
     }
-    
-    public string get_table_name() {
+
+    public string get_table_name () {
         return FSpotPhotoVersionsTable.TABLE_NAME;
-    }    
-    
-    public string[] list_columns() {
+    }
+
+    public string[] list_columns () {
         return { "photo_id", "version_id", "name", "base_uri", "filename",
-            "md5_sum", "protected" };
+                 "md5_sum", "protected"
+               };
     }
-    
-    public void build_row(Sqlite.Statement stmt, out FSpotPhotoVersionRow row, int offset = 0) {
-        row = new FSpotPhotoVersionRow();
-        row.photo_id = stmt.column_int64(offset + 0);
-        row.version_id = stmt.column_int64(offset + 1);
-        row.name = stmt.column_text(offset + 2);
-        
-        string? base_path = stmt.column_text(offset + 3);
-        string? filename = stmt.column_text(offset + 4);
+
+    public void build_row (Sqlite.Statement stmt, out FSpotPhotoVersionRow row, int offset = 0) {
+        row = new FSpotPhotoVersionRow ();
+        row.photo_id = stmt.column_int64 (offset + 0);
+        row.version_id = stmt.column_int64 (offset + 1);
+        row.name = stmt.column_text (offset + 2);
+
+        string? base_path = stmt.column_text (offset + 3);
+        string? filename = stmt.column_text (offset + 4);
         if (base_path != null && filename != null) {
-            row.base_path = File.new_for_uri(base_path);
+            row.base_path = File.new_for_uri (base_path);
             row.filename = filename;
         }
-        
-        row.md5_sum = stmt.column_text(offset + 5);
-        row.is_protected = (stmt.column_int(offset + 6) > 0);
+
+        row.md5_sum = stmt.column_text (offset + 5);
+        row.is_protected = (stmt.column_int (offset + 6) > 0);
     }
 }
 
@@ -230,40 +233,41 @@
 // md5_sum renamed import_md5
 public class FSpotPhotoVersionsV18Behavior : FSpotTableBehavior<FSpotPhotoVersionRow>, Object {
     private static FSpotPhotoVersionsV18Behavior instance;
-    
-    private FSpotPhotoVersionsV18Behavior() {
+
+    private FSpotPhotoVersionsV18Behavior () {
     }
-    
-    public static FSpotPhotoVersionsV18Behavior get_instance() {
+
+    public static FSpotPhotoVersionsV18Behavior get_instance () {
         if (instance == null)
-            instance = new FSpotPhotoVersionsV18Behavior();
+            instance = new FSpotPhotoVersionsV18Behavior ();
         return instance;
     }
-    
-    public string get_table_name() {
+
+    public string get_table_name () {
         return FSpotPhotoVersionsTable.TABLE_NAME;
-    }    
-    
-    public string[] list_columns() {
+    }
+
+    public string[] list_columns () {
         return { "photo_id", "version_id", "name", "base_uri", "filename",
-            "import_md5", "protected" };
+                 "import_md5", "protected"
+               };
     }
-    
-    public void build_row(Sqlite.Statement stmt, out FSpotPhotoVersionRow row, int offset = 0) {
-        row = new FSpotPhotoVersionRow();
-        row.photo_id = stmt.column_int64(offset + 0);
-        row.version_id = stmt.column_int64(offset + 1);
-        row.name = stmt.column_text(offset + 2);
-        
-        string? base_path = stmt.column_text(offset + 3);
-        string? filename = stmt.column_text(offset + 4);
+
+    public void build_row (Sqlite.Statement stmt, out FSpotPhotoVersionRow row, int offset = 0) {
+        row = new FSpotPhotoVersionRow ();
+        row.photo_id = stmt.column_int64 (offset + 0);
+        row.version_id = stmt.column_int64 (offset + 1);
+        row.name = stmt.column_text (offset + 2);
+
+        string? base_path = stmt.column_text (offset + 3);
+        string? filename = stmt.column_text (offset + 4);
         if (base_path != null && filename != null) {
-            row.base_path = File.new_for_uri(base_path);
+            row.base_path = File.new_for_uri (base_path);
             row.filename = filename;
         }
-        
-        row.md5_sum = stmt.column_text(offset + 5);
-        row.is_protected = (stmt.column_int(offset + 6) > 0);
+
+        row.md5_sum = stmt.column_text (offset + 5);
+        row.is_protected = (stmt.column_int (offset + 6) > 0);
     }
 }
 

=== modified file 'plugins/shotwell-data-imports/FSpotPhotosTable.vala'
--- plugins/shotwell-data-imports/FSpotPhotosTable.vala	2013-01-21 21:16:09 +0000
+++ plugins/shotwell-data-imports/FSpotPhotosTable.vala	2014-08-08 21:16:43 +0000
@@ -26,24 +26,24 @@
  */
 public class FSpotPhotosTable : FSpotDatabaseTable<FSpotPhotoRow> {
     public static const string TABLE_NAME = "Photos";
-    
-    public FSpotPhotosTable(Sqlite.Database db, FSpotDatabaseBehavior db_behavior) {
-        base(db);
-        set_behavior(db_behavior.get_photos_behavior());
+
+    public FSpotPhotosTable (Sqlite.Database db, FSpotDatabaseBehavior db_behavior) {
+        base (db);
+        set_behavior (db_behavior.get_photos_behavior ());
     }
-    
-    public Gee.ArrayList<FSpotPhotoRow> get_all() throws DatabaseError {
-        Gee.ArrayList<FSpotPhotoRow> all = new Gee.ArrayList<FSpotPhotoRow?>();
-        
+
+    public Gee.ArrayList<FSpotPhotoRow> get_all () throws DatabaseError {
+        Gee.ArrayList<FSpotPhotoRow> all = new Gee.ArrayList < FSpotPhotoRow?> ();
+
         Sqlite.Statement stmt;
-        int res = select_all(out stmt);
+        int res = select_all (out stmt);
         while (res == Sqlite.ROW) {
             FSpotPhotoRow row;
-            behavior.build_row(stmt, out row);
-            all.add(row);
-            res = stmt.step();
+            behavior.build_row (stmt, out row);
+            all.add (row);
+            res = stmt.step ();
         }
-        
+
         return all;
     }
 }
@@ -52,40 +52,41 @@
 // The original table format
 public class FSpotPhotosV0Behavior : FSpotTableBehavior<FSpotPhotoRow>, Object {
     private static FSpotPhotosV0Behavior instance;
-    
-    private FSpotPhotosV0Behavior() {
+
+    private FSpotPhotosV0Behavior () {
     }
-    
-    public static FSpotPhotosV0Behavior get_instance() {
+
+    public static FSpotPhotosV0Behavior get_instance () {
         if (instance == null)
-            instance = new FSpotPhotosV0Behavior();
+            instance = new FSpotPhotosV0Behavior ();
         return instance;
     }
-    
-    public string get_table_name() {
+
+    public string get_table_name () {
         return FSpotPhotosTable.TABLE_NAME;
     }
-    
-    public string[] list_columns() {
+
+    public string[] list_columns () {
         return { "id", "time", "directory_path", "name", "description",
-            "default_version_id" };
+                 "default_version_id"
+               };
     }
-    
-    public void build_row(Sqlite.Statement stmt, out FSpotPhotoRow row, int offset = 0) {
-        row = new FSpotPhotoRow();
-        row.photo_id = stmt.column_int64(offset + 0);
-        row.time = (time_t) stmt.column_int64(offset + 1);
-        
-        string? base_path = stmt.column_text(offset + 2);
-        string? filename = stmt.column_text(offset + 3);
+
+    public void build_row (Sqlite.Statement stmt, out FSpotPhotoRow row, int offset = 0) {
+        row = new FSpotPhotoRow ();
+        row.photo_id = stmt.column_int64 (offset + 0);
+        row.time = (time_t) stmt.column_int64 (offset + 1);
+
+        string? base_path = stmt.column_text (offset + 2);
+        string? filename = stmt.column_text (offset + 3);
         if (base_path != null && filename != null) {
-            row.base_path = File.new_for_uri(base_path);
+            row.base_path = File.new_for_uri (base_path);
             row.filename = filename;
         }
-        
-        row.description = stmt.column_text(offset + 4);
+
+        row.description = stmt.column_text (offset + 4);
         row.roll_id = INVALID_ID;
-        row.default_version_id = stmt.column_int64(offset + 5);
+        row.default_version_id = stmt.column_int64 (offset + 5);
         row.rating = 0;
         row.md5_sum = "";
     }
@@ -96,40 +97,41 @@
 // table migrated from imports)
 public class FSpotPhotosV5Behavior : FSpotTableBehavior<FSpotPhotoRow>, Object {
     private static FSpotPhotosV5Behavior instance;
-    
-    private FSpotPhotosV5Behavior() {
+
+    private FSpotPhotosV5Behavior () {
     }
-    
-    public static FSpotPhotosV5Behavior get_instance() {
+
+    public static FSpotPhotosV5Behavior get_instance () {
         if (instance == null)
-            instance = new FSpotPhotosV5Behavior();
+            instance = new FSpotPhotosV5Behavior ();
         return instance;
     }
-    
-    public string get_table_name() {
+
+    public string get_table_name () {
         return FSpotPhotosTable.TABLE_NAME;
     }
-    
-    public string[] list_columns() {
+
+    public string[] list_columns () {
         return { "id", "time", "directory_path", "name", "description", "roll_id",
-            "default_version_id" };
+                 "default_version_id"
+               };
     }
-    
-    public void build_row(Sqlite.Statement stmt, out FSpotPhotoRow row, int offset = 0) {
-        row = new FSpotPhotoRow();
-        row.photo_id = stmt.column_int64(offset + 0);
-        row.time = (time_t) stmt.column_int64(offset + 1);
-        
-        string? base_path = stmt.column_text(offset + 2);
-        string? filename = stmt.column_text(offset + 3);
+
+    public void build_row (Sqlite.Statement stmt, out FSpotPhotoRow row, int offset = 0) {
+        row = new FSpotPhotoRow ();
+        row.photo_id = stmt.column_int64 (offset + 0);
+        row.time = (time_t) stmt.column_int64 (offset + 1);
+
+        string? base_path = stmt.column_text (offset + 2);
+        string? filename = stmt.column_text (offset + 3);
         if (base_path != null && filename != null) {
-            row.base_path = File.new_for_uri(base_path);
+            row.base_path = File.new_for_uri (base_path);
             row.filename = filename;
         }
-        
-        row.description = stmt.column_text(offset + 4);
-        row.roll_id = stmt.column_int64(offset + 5);
-        row.default_version_id = stmt.column_int64(offset + 6);
+
+        row.description = stmt.column_text (offset + 4);
+        row.roll_id = stmt.column_int64 (offset + 5);
+        row.default_version_id = stmt.column_int64 (offset + 6);
         row.rating = 0;
         row.md5_sum = "";
     }
@@ -141,40 +143,41 @@
 // different URI prefix such as remote files
 public class FSpotPhotosV7Behavior : FSpotTableBehavior<FSpotPhotoRow>, Object {
     private static FSpotPhotosV7Behavior instance;
-    
-    private FSpotPhotosV7Behavior() {
+
+    private FSpotPhotosV7Behavior () {
     }
-    
-    public static FSpotPhotosV7Behavior get_instance() {
+
+    public static FSpotPhotosV7Behavior get_instance () {
         if (instance == null)
-            instance = new FSpotPhotosV7Behavior();
+            instance = new FSpotPhotosV7Behavior ();
         return instance;
     }
-    
-    public string get_table_name() {
+
+    public string get_table_name () {
         return FSpotPhotosTable.TABLE_NAME;
     }
-    
-    public string[] list_columns() {
+
+    public string[] list_columns () {
         return { "id", "time", "uri", "description", "roll_id",
-            "default_version_id" };
+                 "default_version_id"
+               };
     }
-    
-    public void build_row(Sqlite.Statement stmt, out FSpotPhotoRow row, int offset = 0) {
-        row = new FSpotPhotoRow();
-        row.photo_id = stmt.column_int64(offset + 0);
-        row.time = (time_t) stmt.column_int64(offset + 1);
-
-        string? full_path = stmt.column_text(offset + 2);
+
+    public void build_row (Sqlite.Statement stmt, out FSpotPhotoRow row, int offset = 0) {
+        row = new FSpotPhotoRow ();
+        row.photo_id = stmt.column_int64 (offset + 0);
+        row.time = (time_t) stmt.column_int64 (offset + 1);
+
+        string? full_path = stmt.column_text (offset + 2);
         if (full_path != null) {
-            File uri = File.new_for_uri(full_path);
-            row.base_path = uri.get_parent();
-            row.filename = uri.get_basename();
+            File uri = File.new_for_uri (full_path);
+            row.base_path = uri.get_parent ();
+            row.filename = uri.get_basename ();
         }
 
-        row.description = stmt.column_text(offset + 3);
-        row.roll_id = stmt.column_int64(offset + 4);
-        row.default_version_id = stmt.column_int64(offset + 5);
+        row.description = stmt.column_text (offset + 3);
+        row.roll_id = stmt.column_int64 (offset + 4);
+        row.default_version_id = stmt.column_int64 (offset + 5);
         row.rating = 0;
         row.md5_sum = "";
     }
@@ -184,41 +187,42 @@
 // v11 introduced the concept of rating so add this to the list of fields
 public class FSpotPhotosV11Behavior : FSpotTableBehavior<FSpotPhotoRow>, Object {
     private static FSpotPhotosV11Behavior instance;
-    
-    private FSpotPhotosV11Behavior() {
+
+    private FSpotPhotosV11Behavior () {
     }
-    
-    public static FSpotPhotosV11Behavior get_instance() {
+
+    public static FSpotPhotosV11Behavior get_instance () {
         if (instance == null)
-            instance = new FSpotPhotosV11Behavior();
+            instance = new FSpotPhotosV11Behavior ();
         return instance;
     }
-    
-    public string get_table_name() {
+
+    public string get_table_name () {
         return FSpotPhotosTable.TABLE_NAME;
     }
-    
-    public string[] list_columns() {
+
+    public string[] list_columns () {
         return { "id", "time", "uri", "description", "roll_id",
-            "default_version_id", "rating" };
+                 "default_version_id", "rating"
+               };
     }
-    
-    public void build_row(Sqlite.Statement stmt, out FSpotPhotoRow row, int offset = 0) {
-        row = new FSpotPhotoRow();
-        row.photo_id = stmt.column_int64(offset + 0);
-        row.time = (time_t) stmt.column_int64(offset + 1);
-
-        string? full_path = stmt.column_text(offset + 2);
+
+    public void build_row (Sqlite.Statement stmt, out FSpotPhotoRow row, int offset = 0) {
+        row = new FSpotPhotoRow ();
+        row.photo_id = stmt.column_int64 (offset + 0);
+        row.time = (time_t) stmt.column_int64 (offset + 1);
+
+        string? full_path = stmt.column_text (offset + 2);
         if (full_path != null) {
-            File uri = File.new_for_uri(full_path);
-            row.base_path = uri.get_parent();
-            row.filename = uri.get_basename();
+            File uri = File.new_for_uri (full_path);
+            row.base_path = uri.get_parent ();
+            row.filename = uri.get_basename ();
         }
 
-        row.description = stmt.column_text(offset + 3);
-        row.roll_id = stmt.column_int64(offset + 4);
-        row.default_version_id = stmt.column_int64(offset + 5);
-        row.rating = stmt.column_int(offset + 6);
+        row.description = stmt.column_text (offset + 3);
+        row.roll_id = stmt.column_int64 (offset + 4);
+        row.default_version_id = stmt.column_int64 (offset + 5);
+        row.rating = stmt.column_int (offset + 6);
         row.md5_sum = "";
     }
 }
@@ -227,42 +231,43 @@
 // v16 introduced the MD5 sum so add this to the list of fields
 public class FSpotPhotosV16Behavior : FSpotTableBehavior<FSpotPhotoRow>, Object {
     private static FSpotPhotosV16Behavior instance;
-    
-    private FSpotPhotosV16Behavior() {
+
+    private FSpotPhotosV16Behavior () {
     }
-    
-    public static FSpotPhotosV16Behavior get_instance() {
+
+    public static FSpotPhotosV16Behavior get_instance () {
         if (instance == null)
-            instance = new FSpotPhotosV16Behavior();
+            instance = new FSpotPhotosV16Behavior ();
         return instance;
     }
-    
-    public string get_table_name() {
+
+    public string get_table_name () {
         return FSpotPhotosTable.TABLE_NAME;
     }
-    
-    public string[] list_columns() {
+
+    public string[] list_columns () {
         return { "id", "time", "uri", "description", "roll_id",
-            "default_version_id", "rating", "md5_sum" };
+                 "default_version_id", "rating", "md5_sum"
+               };
     }
-    
-    public void build_row(Sqlite.Statement stmt, out FSpotPhotoRow row, int offset = 0) {
-        row = new FSpotPhotoRow();
-        row.photo_id = stmt.column_int64(offset + 0);
-        row.time = (time_t) stmt.column_int64(offset + 1);
-
-        string? full_path = stmt.column_text(offset + 2);
+
+    public void build_row (Sqlite.Statement stmt, out FSpotPhotoRow row, int offset = 0) {
+        row = new FSpotPhotoRow ();
+        row.photo_id = stmt.column_int64 (offset + 0);
+        row.time = (time_t) stmt.column_int64 (offset + 1);
+
+        string? full_path = stmt.column_text (offset + 2);
         if (full_path != null) {
-            File uri = File.new_for_uri(full_path);
-            row.base_path = uri.get_parent();
-            row.filename = uri.get_basename();
+            File uri = File.new_for_uri (full_path);
+            row.base_path = uri.get_parent ();
+            row.filename = uri.get_basename ();
         }
 
-        row.description = stmt.column_text(offset + 3);
-        row.roll_id = stmt.column_int64(offset + 4);
-        row.default_version_id = stmt.column_int64(offset + 5);
-        row.rating = stmt.column_int(offset + 6);
-        row.md5_sum = stmt.column_text(offset + 7);
+        row.description = stmt.column_text (offset + 3);
+        row.roll_id = stmt.column_int64 (offset + 4);
+        row.default_version_id = stmt.column_int64 (offset + 5);
+        row.rating = stmt.column_int (offset + 6);
+        row.md5_sum = stmt.column_text (offset + 7);
     }
 }
 
@@ -271,83 +276,85 @@
 // design introduced in v0, albeit with a URI rather than a file system path)
 public class FSpotPhotosV17Behavior : FSpotTableBehavior<FSpotPhotoRow>, Object {
     private static FSpotPhotosV17Behavior instance;
-    
-    private FSpotPhotosV17Behavior() {
+
+    private FSpotPhotosV17Behavior () {
     }
-    
-    public static FSpotPhotosV17Behavior get_instance() {
+
+    public static FSpotPhotosV17Behavior get_instance () {
         if (instance == null)
-            instance = new FSpotPhotosV17Behavior();
+            instance = new FSpotPhotosV17Behavior ();
         return instance;
     }
-    
-    public string get_table_name() {
+
+    public string get_table_name () {
         return FSpotPhotosTable.TABLE_NAME;
     }
-    
-    public string[] list_columns() {
+
+    public string[] list_columns () {
         return { "id", "time", "base_uri", "filename", "description", "roll_id",
-            "default_version_id", "rating", "md5_sum" };
+                 "default_version_id", "rating", "md5_sum"
+               };
     }
-    
-    public void build_row(Sqlite.Statement stmt, out FSpotPhotoRow row, int offset = 0) {
-        row = new FSpotPhotoRow();
-        row.photo_id = stmt.column_int64(offset + 0);
-        row.time = (time_t) stmt.column_int64(offset + 1);
-        
-        string? base_path = stmt.column_text(offset + 2);
-        string? filename = stmt.column_text(offset + 3);
+
+    public void build_row (Sqlite.Statement stmt, out FSpotPhotoRow row, int offset = 0) {
+        row = new FSpotPhotoRow ();
+        row.photo_id = stmt.column_int64 (offset + 0);
+        row.time = (time_t) stmt.column_int64 (offset + 1);
+
+        string? base_path = stmt.column_text (offset + 2);
+        string? filename = stmt.column_text (offset + 3);
         if (base_path != null && filename != null) {
-            row.base_path = File.new_for_uri(base_path);
+            row.base_path = File.new_for_uri (base_path);
             row.filename = filename;
         }
-        
-        row.description = stmt.column_text(offset + 4);
-        row.roll_id = stmt.column_int64(offset + 5);
-        row.default_version_id = stmt.column_int64(offset + 6);
-        row.rating = stmt.column_int(offset + 7);
-        row.md5_sum = stmt.column_text(offset + 8);
+
+        row.description = stmt.column_text (offset + 4);
+        row.roll_id = stmt.column_int64 (offset + 5);
+        row.default_version_id = stmt.column_int64 (offset + 6);
+        row.rating = stmt.column_int (offset + 7);
+        row.md5_sum = stmt.column_text (offset + 8);
     }
 }
 
 // v18: no more MD5 hash in the photos table: moved to photo_versions table
 public class FSpotPhotosV18Behavior : FSpotTableBehavior<FSpotPhotoRow>, Object {
     private static FSpotPhotosV18Behavior instance;
-    
-    private FSpotPhotosV18Behavior() {
+
+    private FSpotPhotosV18Behavior () {
     }
-    
-    public static FSpotPhotosV18Behavior get_instance() {
+
+    public static FSpotPhotosV18Behavior get_instance () {
         if (instance == null)
-            instance = new FSpotPhotosV18Behavior();
+            instance = new FSpotPhotosV18Behavior ();
         return instance;
     }
-    
-    public string get_table_name() {
+
+    public string get_table_name () {
         return FSpotPhotosTable.TABLE_NAME;
     }
-    
-    public string[] list_columns() {
+
+    public string[] list_columns () {
         return { "id", "time", "base_uri", "filename", "description", "roll_id",
-            "default_version_id", "rating" };
+                 "default_version_id", "rating"
+               };
     }
-    
-    public void build_row(Sqlite.Statement stmt, out FSpotPhotoRow row, int offset = 0) {
-        row = new FSpotPhotoRow();
-        row.photo_id = stmt.column_int64(offset + 0);
-        row.time = (time_t) stmt.column_int64(offset + 1);
-        
-        string? base_path = stmt.column_text(offset + 2);
-        string? filename = stmt.column_text(offset + 3);
+
+    public void build_row (Sqlite.Statement stmt, out FSpotPhotoRow row, int offset = 0) {
+        row = new FSpotPhotoRow ();
+        row.photo_id = stmt.column_int64 (offset + 0);
+        row.time = (time_t) stmt.column_int64 (offset + 1);
+
+        string? base_path = stmt.column_text (offset + 2);
+        string? filename = stmt.column_text (offset + 3);
         if (base_path != null && filename != null) {
-            row.base_path = File.new_for_uri(base_path);
+            row.base_path = File.new_for_uri (base_path);
             row.filename = filename;
         }
-        
-        row.description = stmt.column_text(offset + 4);
-        row.roll_id = stmt.column_int64(offset + 5);
-        row.default_version_id = stmt.column_int64(offset + 6);
-        row.rating = stmt.column_int(offset + 7);
+
+        row.description = stmt.column_text (offset + 4);
+        row.roll_id = stmt.column_int64 (offset + 5);
+        row.default_version_id = stmt.column_int64 (offset + 6);
+        row.rating = stmt.column_int (offset + 7);
         row.md5_sum = "";
     }
 }

=== modified file 'plugins/shotwell-data-imports/FSpotRollsTable.vala'
--- plugins/shotwell-data-imports/FSpotRollsTable.vala	2013-01-21 21:16:09 +0000
+++ plugins/shotwell-data-imports/FSpotRollsTable.vala	2014-08-08 21:16:43 +0000
@@ -20,32 +20,32 @@
 public class FSpotRollsTable : FSpotDatabaseTable<FSpotRollRow> {
     public static const string TABLE_NAME = "Rolls";
     public static const string TABLE_NAME_PRE_V5 = "Imports";
-    
-    public FSpotRollsTable(Sqlite.Database db, FSpotDatabaseBehavior db_behavior) {
-        base(db);
-        set_behavior(db_behavior.get_rolls_behavior());
+
+    public FSpotRollsTable (Sqlite.Database db, FSpotDatabaseBehavior db_behavior) {
+        base (db);
+        set_behavior (db_behavior.get_rolls_behavior ());
     }
-    
-    public FSpotRollRow? get_by_id(int64 roll_id) throws DatabaseError {
+
+    public FSpotRollRow? get_by_id (int64 roll_id) throws DatabaseError {
         Sqlite.Statement stmt;
         FSpotRollRow? row = null;
-        string column_list = get_joined_column_list();
-        string sql = "SELECT %s FROM %s WHERE id=?".printf(column_list, table_name);
-
-        int res = fspot_db.prepare_v2(sql, -1, out stmt);
-        if (res != Sqlite.OK)
-            throw_error("Statement failed: %s".printf(sql), res);
-        
-        res = stmt.bind_int64(1, roll_id);
-        if (res != Sqlite.OK)
-            throw_error("Bind failed for roll_id", res);
-        
-        res = stmt.step();
+        string column_list = get_joined_column_list ();
+        string sql = "SELECT %s FROM %s WHERE id=?".printf (column_list, table_name);
+
+        int res = fspot_db.prepare_v2 (sql, -1, out stmt);
+        if (res != Sqlite.OK)
+            throw_error ("Statement failed: %s".printf (sql), res);
+
+        res = stmt.bind_int64 (1, roll_id);
+        if (res != Sqlite.OK)
+            throw_error ("Bind failed for roll_id", res);
+
+        res = stmt.step ();
         if (res == Sqlite.ROW)
-            behavior.build_row(stmt, out row);
+            behavior.build_row (stmt, out row);
         else if (res == Sqlite.DONE)
-            message("Could not find roll row with ID %d", (int)roll_id);
-        
+            message ("Could not find roll row with ID %d", (int)roll_id);
+
         return row;
     }
 }
@@ -53,28 +53,28 @@
 // Rolls table behavior for v0-4
 public class FSpotRollsV0Behavior : FSpotTableBehavior<FSpotRollRow>, Object {
     private static FSpotRollsV0Behavior instance;
-    
-    private FSpotRollsV0Behavior() {
+
+    private FSpotRollsV0Behavior () {
     }
-    
-    public static FSpotRollsV0Behavior get_instance() {
+
+    public static FSpotRollsV0Behavior get_instance () {
         if (instance == null)
-            instance = new FSpotRollsV0Behavior();
+            instance = new FSpotRollsV0Behavior ();
         return instance;
     }
-    
-    public string get_table_name() {
+
+    public string get_table_name () {
         return FSpotRollsTable.TABLE_NAME_PRE_V5;
     }
 
-    public string[] list_columns() {
+    public string[] list_columns () {
         return { "id", "time" };
     }
-    
-    public void build_row(Sqlite.Statement stmt, out FSpotRollRow row, int offset = 0) {
-        row = new FSpotRollRow();
-        row.id = stmt.column_int64(offset + 0);
-        row.time = (time_t) stmt.column_int64(offset + 1);
+
+    public void build_row (Sqlite.Statement stmt, out FSpotRollRow row, int offset = 0) {
+        row = new FSpotRollRow ();
+        row.id = stmt.column_int64 (offset + 0);
+        row.time = (time_t) stmt.column_int64 (offset + 1);
     }
 }
 
@@ -82,28 +82,28 @@
 // Table name changed from "imports" to "rolls"
 public class FSpotRollsV5Behavior : FSpotTableBehavior<FSpotRollRow>, Object {
     private static FSpotRollsV5Behavior instance;
-    
-    private FSpotRollsV5Behavior() {
+
+    private FSpotRollsV5Behavior () {
     }
-    
-    public static FSpotRollsV5Behavior get_instance() {
+
+    public static FSpotRollsV5Behavior get_instance () {
         if (instance == null)
-            instance = new FSpotRollsV5Behavior();
+            instance = new FSpotRollsV5Behavior ();
         return instance;
     }
-    
-    public string get_table_name() {
+
+    public string get_table_name () {
         return FSpotRollsTable.TABLE_NAME;
     }
 
-    public string[] list_columns() {
+    public string[] list_columns () {
         return { "id", "time" };
     }
-    
-    public void build_row(Sqlite.Statement stmt, out FSpotRollRow row, int offset = 0) {
-        row = new FSpotRollRow();
-        row.id = stmt.column_int64(offset + 0);
-        row.time = (time_t) stmt.column_int64(offset + 1);
+
+    public void build_row (Sqlite.Statement stmt, out FSpotRollRow row, int offset = 0) {
+        row = new FSpotRollRow ();
+        row.id = stmt.column_int64 (offset + 0);
+        row.time = (time_t) stmt.column_int64 (offset + 1);
     }
 }
 

=== modified file 'plugins/shotwell-data-imports/FSpotTableBehavior.vala'
--- plugins/shotwell-data-imports/FSpotTableBehavior.vala	2013-01-21 21:16:09 +0000
+++ plugins/shotwell-data-imports/FSpotTableBehavior.vala	2014-08-08 21:16:43 +0000
@@ -17,11 +17,11 @@
  * contain the data for a single database row.
  */
 public interface FSpotTableBehavior<T> : Object {
-    public abstract string get_table_name();
-    
-    public abstract string[] list_columns();
-    
-    public abstract void build_row(Sqlite.Statement stmt, out T row, int offset = 0);
+    public abstract string get_table_name ();
+
+    public abstract string[] list_columns ();
+
+    public abstract void build_row (Sqlite.Statement stmt, out T row, int offset = 0);
 }
 
 }

=== modified file 'plugins/shotwell-data-imports/FSpotTagsTable.vala'
--- plugins/shotwell-data-imports/FSpotTagsTable.vala	2013-01-21 21:16:09 +0000
+++ plugins/shotwell-data-imports/FSpotTagsTable.vala	2014-08-08 21:16:43 +0000
@@ -23,102 +23,102 @@
  */
 public class FSpotTagsTable : FSpotDatabaseTable<FSpotTagRow> {
     public static const string TABLE_NAME = "Tags";
-    
+
     public static const string PREFIX_STOCK_ICON = "stock_icon:";
     public static const string STOCK_ICON_FAV    = "stock_icon:emblem-favorite";
     public static const string STOCK_ICON_PEOPLE = "stock_icon:emblem-people";
     public static const string STOCK_ICON_PLACES = "stock_icon:emblem-places";
     public static const string STOCK_ICON_EVENTS = "stock_icon:emblem-event";
-    
+
     private FSpotTableBehavior<FSpotPhotoTagRow> photo_tags_behavior;
-    
-    public FSpotTagsTable(Sqlite.Database db, FSpotDatabaseBehavior db_behavior) {
-        base(db);
-        set_behavior(db_behavior.get_tags_behavior());
-        photo_tags_behavior = db_behavior.get_photo_tags_behavior();
+
+    public FSpotTagsTable (Sqlite.Database db, FSpotDatabaseBehavior db_behavior) {
+        base (db);
+        set_behavior (db_behavior.get_tags_behavior ());
+        photo_tags_behavior = db_behavior.get_photo_tags_behavior ();
     }
-    
-    public FSpotTagRow? get_by_id(int64 tag_id) throws DatabaseError {
+
+    public FSpotTagRow? get_by_id (int64 tag_id) throws DatabaseError {
         Sqlite.Statement stmt;
         FSpotTagRow? row = null;
-        string column_list = get_joined_column_list();
-        string sql = "SELECT %s FROM %s WHERE id=?".printf(column_list, table_name);
+        string column_list = get_joined_column_list ();
+        string sql = "SELECT %s FROM %s WHERE id=?".printf (column_list, table_name);
 
-        int res = fspot_db.prepare_v2(sql, -1, out stmt);
+        int res = fspot_db.prepare_v2 (sql, -1, out stmt);
         if (res != Sqlite.OK)
-            throw_error("Statement failed: %s".printf(sql), res);
-        
-        res = stmt.bind_int64(1, tag_id);
-        assert(res == Sqlite.OK);
-        
-        res = stmt.step();
+            throw_error ("Statement failed: %s".printf (sql), res);
+
+        res = stmt.bind_int64 (1, tag_id);
+        assert (res == Sqlite.OK);
+
+        res = stmt.step ();
         if (res == Sqlite.ROW)
-            behavior.build_row(stmt, out row);
+            behavior.build_row (stmt, out row);
         else if (res == Sqlite.DONE)
-            message("Could not find tag row with ID %d", (int)tag_id);
-        
+            message ("Could not find tag row with ID %d", (int)tag_id);
+
         return row;
     }
-    
-    public Gee.ArrayList<FSpotTagRow> get_by_photo_id(int64 photo_id) throws DatabaseError {
-        Gee.ArrayList<FSpotTagRow> rows = new Gee.ArrayList<FSpotTagRow?>();
-        
+
+    public Gee.ArrayList<FSpotTagRow> get_by_photo_id (int64 photo_id) throws DatabaseError {
+        Gee.ArrayList<FSpotTagRow> rows = new Gee.ArrayList < FSpotTagRow?> ();
+
         Sqlite.Statement stmt;
-        
-        string column_list = get_joined_column_list(true);
-        string sql = "SELECT %1$s FROM %2$s, %3$s WHERE %3$s.photo_id=? AND %3$s.tag_id = %2$s.id".printf(
-            column_list, table_name, photo_tags_behavior.get_table_name()
+
+        string column_list = get_joined_column_list (true);
+        string sql = "SELECT %1$s FROM %2$s, %3$s WHERE %3$s.photo_id=? AND %3$s.tag_id = %2$s.id".printf (
+            column_list, table_name, photo_tags_behavior.get_table_name ()
         );
 
-        int res = fspot_db.prepare_v2(sql, -1, out stmt);
-        if (res != Sqlite.OK)
-            throw_error("Statement failed: %s".printf(sql), res);
-        
-        res = stmt.bind_int64(1, photo_id);
-        if (res != Sqlite.OK)
-            throw_error("Bind failed for photo_id", res);
-        
-        res = stmt.step();
+        int res = fspot_db.prepare_v2 (sql, -1, out stmt);
+        if (res != Sqlite.OK)
+            throw_error ("Statement failed: %s".printf (sql), res);
+
+        res = stmt.bind_int64 (1, photo_id);
+        if (res != Sqlite.OK)
+            throw_error ("Bind failed for photo_id", res);
+
+        res = stmt.step ();
         while (res == Sqlite.ROW) {
             FSpotTagRow row;
-            behavior.build_row(stmt, out row);
-            rows.add(row);
-            res = stmt.step();
+            behavior.build_row (stmt, out row);
+            rows.add (row);
+            res = stmt.step ();
         }
-        
+
         return rows;
     }
 }
 
 public class FSpotTagsV0Behavior : FSpotTableBehavior<FSpotTagRow>, Object {
     private static FSpotTagsV0Behavior instance;
-    
-    private FSpotTagsV0Behavior() {
+
+    private FSpotTagsV0Behavior () {
     }
-    
-    public static FSpotTagsV0Behavior get_instance() {
+
+    public static FSpotTagsV0Behavior get_instance () {
         if (instance == null)
-            instance = new FSpotTagsV0Behavior();
+            instance = new FSpotTagsV0Behavior ();
         return instance;
     }
-    
-    public string get_table_name() {
+
+    public string get_table_name () {
         return FSpotTagsTable.TABLE_NAME;
     }
 
-    public string[] list_columns() {
+    public string[] list_columns () {
         return { "id", "name", "category_id", "is_category", "sort_priority", "icon" };
     }
-    
-    public void build_row(Sqlite.Statement stmt, out FSpotTagRow row, int offset = 0) {
-        row = new FSpotTagRow();
-        row.tag_id = stmt.column_int64(offset + 0);
-        row.name = stmt.column_text(offset + 1);
-        row.category_id = stmt.column_int64(offset + 2);
-        row.is_category = (stmt.column_int(offset + 3) > 0);
-        row.sort_priority = stmt.column_int(offset + 4);
-        string icon_str = stmt.column_text(offset + 5);
-        if (icon_str != null && icon_str.has_prefix(FSpotTagsTable.PREFIX_STOCK_ICON))
+
+    public void build_row (Sqlite.Statement stmt, out FSpotTagRow row, int offset = 0) {
+        row = new FSpotTagRow ();
+        row.tag_id = stmt.column_int64 (offset + 0);
+        row.name = stmt.column_text (offset + 1);
+        row.category_id = stmt.column_int64 (offset + 2);
+        row.is_category = (stmt.column_int (offset + 3) > 0);
+        row.sort_priority = stmt.column_int (offset + 4);
+        string icon_str = stmt.column_text (offset + 5);
+        if (icon_str != null && icon_str.has_prefix (FSpotTagsTable.PREFIX_STOCK_ICON))
             row.stock_icon = icon_str;
         else
             row.stock_icon = "";

=== modified file 'plugins/shotwell-data-imports/shotwell-data-imports.vala'
--- plugins/shotwell-data-imports/shotwell-data-imports.vala	2013-01-21 21:16:09 +0000
+++ plugins/shotwell-data-imports/shotwell-data-imports.vala	2014-08-08 21:16:43 +0000
@@ -12,35 +12,35 @@
 
     // we need to get a module file handle because our pluggables have to load resources from the
     // module file directory
-    public ShotwellDataImportsCoreServices(GLib.File module_file) {
-        GLib.File resource_directory = module_file.get_parent();
-        
-        pluggables += new FSpotService(resource_directory);
-    }
-    
-    public unowned string get_module_name() {
-        return _("Core Data Import Services");
-    }
-    
-    public unowned string get_version() {
+    public ShotwellDataImportsCoreServices (GLib.File module_file) {
+        GLib.File resource_directory = module_file.get_parent ();
+
+        pluggables += new FSpotService (resource_directory);
+    }
+
+    public unowned string get_module_name () {
+        return _ ("Core Data Import Services");
+    }
+
+    public unowned string get_version () {
         return _VERSION;
     }
-    
-    public unowned string get_id() {
+
+    public unowned string get_id () {
         return "org.yorba.shotwell.data_imports.core_services";
     }
-    
-    public unowned Spit.Pluggable[]? get_pluggables() {
+
+    public unowned Spit.Pluggable[]? get_pluggables () {
         return pluggables;
     }
 }
 
 // This entry point is required for all SPIT modules.
-public Spit.Module? spit_entry_point(Spit.EntryPointParams *params) {
-    params->module_spit_interface = Spit.negotiate_interfaces(params->host_min_spit_interface,
-        params->host_max_spit_interface, Spit.CURRENT_INTERFACE);
-    
+public Spit.Module? spit_entry_point (Spit.EntryPointParams *params) {
+    params->module_spit_interface = Spit.negotiate_interfaces (params->host_min_spit_interface,
+                                    params->host_max_spit_interface, Spit.CURRENT_INTERFACE);
+
     return (params->module_spit_interface != Spit.UNSUPPORTED_INTERFACE)
-        ? new ShotwellDataImportsCoreServices(params->module_file) : null;
+           ? new ShotwellDataImportsCoreServices (params->module_file) : null;
 }
 

=== modified file 'plugins/shotwell-publishing-extras/TumblrPublishing.vala'
--- plugins/shotwell-publishing-extras/TumblrPublishing.vala	2014-01-15 19:51:09 +0000
+++ plugins/shotwell-publishing-extras/TumblrPublishing.vala	2014-08-08 21:16:43 +0000
@@ -6,33 +6,33 @@
  */
 
 
-extern string hmac_sha1(string key, string message);
+extern string hmac_sha1 (string key, string message);
 public class TumblrService : Object, Spit.Pluggable, Spit.Publishing.Service {
-   private const string ICON_FILENAME = "tumblr.png";
+    private const string ICON_FILENAME = "tumblr.png";
 
     private static Gdk.Pixbuf[] icon_pixbuf_set = null;
-    
-    public TumblrService(GLib.File resource_directory) {
+
+    public TumblrService (GLib.File resource_directory) {
         if (icon_pixbuf_set == null)
-            icon_pixbuf_set = Resources.load_icon_set(resource_directory.get_child(ICON_FILENAME));
-    }
-
-    public int get_pluggable_interface(int min_host_interface, int max_host_interface) {
-        return Spit.negotiate_interfaces(min_host_interface, max_host_interface,
-            Spit.Publishing.CURRENT_INTERFACE);
-    }
-    
-    public unowned string get_id() {
+            icon_pixbuf_set = Resources.load_icon_set (resource_directory.get_child (ICON_FILENAME));
+    }
+
+    public int get_pluggable_interface (int min_host_interface, int max_host_interface) {
+        return Spit.negotiate_interfaces (min_host_interface, max_host_interface,
+                                          Spit.Publishing.CURRENT_INTERFACE);
+    }
+
+    public unowned string get_id () {
         return "org.yorba.shotwell.publishing.tumblr";
     }
-    
-    public unowned string get_pluggable_name() {
+
+    public unowned string get_pluggable_name () {
         return "Tumblr";
     }
-    
-    public void get_info(ref Spit.PluggableInfo info) {
+
+    public void get_info (ref Spit.PluggableInfo info) {
         info.authors = "Jeroen Arnoldus";
-        info.copyright = _("Copyright 2012 BJA Electronics");
+        info.copyright = _ ("Copyright 2012 BJA Electronics");
         info.translators = Resources.TRANSLATORS;
         info.version = _VERSION;
         info.website_name = Resources.WEBSITE_NAME;
@@ -42,16 +42,16 @@
         info.icons = icon_pixbuf_set;
     }
 
-    public void activation(bool enabled) {
-    }
-
-    public Spit.Publishing.Publisher create_publisher(Spit.Publishing.PluginHost host) {
-        return new Publishing.Tumblr.TumblrPublisher(this, host);
-    }
-    
-    public Spit.Publishing.Publisher.MediaType get_supported_media() {
+    public void activation (bool enabled) {
+    }
+
+    public Spit.Publishing.Publisher create_publisher (Spit.Publishing.PluginHost host) {
+        return new Publishing.Tumblr.TumblrPublisher (this, host);
+    }
+
+    public Spit.Publishing.Publisher.MediaType get_supported_media () {
         return (Spit.Publishing.Publisher.MediaType.PHOTO |
-            Spit.Publishing.Publisher.MediaType.VIDEO);
+                Spit.Publishing.Publisher.MediaType.VIDEO);
     }
 }
 
@@ -61,28 +61,28 @@
 internal const string ENDPOINT_URL = "http://www.tumblr.com/";
 internal const string API_KEY = "NdXvXQuKVccOsCOj0H4k9HUJcbcjDBYSo2AkaHzXFECHGNuP9k";
 internal const string API_SECRET = "BN0Uoig0MwbeD27OgA0IwYlp3Uvonyfsrl9pf1cnnMj1QoEUvi";
-internal const string ENCODE_RFC_3986_EXTRA = "!*'();:@&=+$,/?%#[] \\";
+internal const string ENCODE_RFC_3986_EXTRA = "!*' ();:@&=+$,/?%#[] \\";
 internal const int ORIGINAL_SIZE = -1;
 
 
 
 private class BlogEntry {
-   public string blog;
-   public string url;
-   public BlogEntry(string creator_blog, string creator_url) {
-     blog = creator_blog;
-     url = creator_url;
-   }
+    public string blog;
+    public string url;
+    public BlogEntry (string creator_blog, string creator_url) {
+        blog = creator_blog;
+        url = creator_url;
+    }
 }
 
 private class SizeEntry {
-   public string title;
-   public int size;
+    public string title;
+    public int size;
 
-   public SizeEntry(string creator_title, int creator_size) {
-     title = creator_title;
-     size = creator_size;
-   }
+    public SizeEntry (string creator_title, int creator_size) {
+        title = creator_title;
+        size = creator_size;
+    }
 }
 
 public class TumblrPublisher : Spit.Publishing.Publisher, GLib.Object {
@@ -95,73 +95,73 @@
     private PublishingOptionsPane publishing_options_pane = null;
     private SizeEntry[] sizes = null;
     private BlogEntry[] blogs = null;
-	private string username = "";
-
-    
-    private SizeEntry[] create_sizes() {
+    private string username = "";
+
+
+    private SizeEntry[] create_sizes () {
         SizeEntry[] result = new SizeEntry[0];
 
-        result += new SizeEntry(_("500 x 375 pixels"), 500);
-        result += new SizeEntry(_("1024 x 768 pixels"), 1024);
-        result += new SizeEntry(_("1280 x 853 pixels"), 1280);
-//Larger images make no sense for Tumblr
-//        result += new SizeEntry(_("2048 x 1536 pixels"), 2048);
-//        result += new SizeEntry(_("4096 x 3072 pixels"), 4096);
-//        result += new SizeEntry(_("Original size"), ORIGINAL_SIZE);
+        result += new SizeEntry (_ ("500 x 375 pixels"), 500);
+        result += new SizeEntry (_ ("1024 x 768 pixels"), 1024);
+        result += new SizeEntry (_ ("1280 x 853 pixels"), 1280);
+        //Larger images make no sense for Tumblr
+        //        result += new SizeEntry(_("2048 x 1536 pixels"), 2048);
+        //        result += new SizeEntry(_("4096 x 3072 pixels"), 4096);
+        //        result += new SizeEntry(_("Original size"), ORIGINAL_SIZE);
 
         return result;
     }
 
-    private BlogEntry[] create_blogs() {
+    private BlogEntry[] create_blogs () {
         BlogEntry[] result = new BlogEntry[0];
 
 
         return result;
     }
 
-    public TumblrPublisher(Spit.Publishing.Service service,
-        Spit.Publishing.PluginHost host) {
-        debug("TumblrPublisher instantiated.");
+    public TumblrPublisher (Spit.Publishing.Service service,
+                            Spit.Publishing.PluginHost host) {
+        debug ("TumblrPublisher instantiated.");
         this.service = service;
         this.host = host;
-        this.session = new Session();
-		this.sizes = this.create_sizes();
-		this.blogs = this.create_blogs();
-        session.authenticated.connect(on_session_authenticated);
-    }
-    
-    ~TumblrPublisher() {
-        session.authenticated.disconnect(on_session_authenticated);
-    }
-    
-    private void invalidate_persistent_session() {
-        set_persistent_access_phase_token("");
-        set_persistent_access_phase_token_secret("");
+        this.session = new Session ();
+        this.sizes = this.create_sizes ();
+        this.blogs = this.create_blogs ();
+        session.authenticated.connect (on_session_authenticated);
+    }
+
+    ~TumblrPublisher () {
+        session.authenticated.disconnect (on_session_authenticated);
+    }
+
+    private void invalidate_persistent_session () {
+        set_persistent_access_phase_token ("");
+        set_persistent_access_phase_token_secret ("");
     }
     // Publisher interface implementation
-    
-    public Spit.Publishing.Service get_service() {
+
+    public Spit.Publishing.Service get_service () {
         return service;
     }
-    
-    public Spit.Publishing.PluginHost get_host() {
+
+    public Spit.Publishing.PluginHost get_host () {
         return host;
     }
 
-    public bool is_running() {
+    public bool is_running () {
         return running;
     }
 
-    private bool is_persistent_session_valid() {
-        string? access_phase_token = get_persistent_access_phase_token();
-        string? access_phase_token_secret = get_persistent_access_phase_token_secret();
+    private bool is_persistent_session_valid () {
+        string? access_phase_token = get_persistent_access_phase_token ();
+        string? access_phase_token_secret = get_persistent_access_phase_token_secret ();
 
         bool valid = ((access_phase_token != null) && (access_phase_token_secret != null));
 
         if (valid)
-            debug("existing Tumblr session found in configuration database; using it.");
+            debug ("existing Tumblr session found in configuration database; using it.");
         else
-            debug("no persisted Tumblr session exists.");
+            debug ("no persisted Tumblr session exists.");
 
         return valid;
     }
@@ -169,40 +169,40 @@
 
 
 
-    public string? get_persistent_access_phase_token() {
-        return host.get_config_string("token", null);
-    }
-    
-    private void set_persistent_access_phase_token(string? token) {
-        host.set_config_string("token", token);
-    } 
-    
-    public string? get_persistent_access_phase_token_secret() {
-        return host.get_config_string("token_secret", null);
-    }