Markdown and Textile formatters are built into ecto, so that when you preview your post the text is correctly converted to HTML. You can, however, create custom formatters for any formats that your blog system uses but isn't handled by ecto (e.g. MathML).

To get you going, I have made the source code of the Markdown formatter available.

Once you've downloaded and unpacked the sample, rename the project. Ideally, you'd use the name of the format provided by your blog system. Let's assume your formatter will be called MathML. In the Finder, rename "Markdown.xcodeproj" to "MathML.xcodeproj". Double-click the file to open it. Make sure to use the Release build configuration. In the Groups & Files list, click on "Markdown" under the "Targets" section. Select File → Get Info. Under "Build", find the values for "Product Name" and "Prefix Header" and rename them. Under "Properties", assign a unique identifier, e.g. com.thirdparty.ecto_mathml and change the principal class to "MathML". Close the Get Info window.

Back in Groups & Files, rename any files containing "Markdown" so that they contain "MathML". You will then have to rename the class names inside those files as well. In other words, class Markdown becomes MathML, and so forth.

Do NOT rename "FormatterInterface.h" and do NOT rename the "ECTOFormatterProtocol" protocol name.

In Markdown.m, you will also need to change the code for "-(NSString*)formatterKey", "-(NSString*)formatterDescription" and "-(BOOL)willHandleFormat".

The formatter plug-in has one entry point: "- (NSString*)formatText:(NSString*)source". That's where the conversion to HTML happens. For Markdown, I used Perl scripts, which are accessed via a pipe. See the code for details.

Some blog systems, such as WordPress, do not provide a list of formatters. When you preview posts in ecto written for these blog systems, ecto uses a special built-in formatter, Generic.formatter. It analyzes the text and will format accordingly (it recognizes Markdown and Textile). You could write your own Generic.formatter and install it into ~/Library/Application Support/ecto3/formatters/ and it would override the built-in version.

If you have any questions about writing a formatter, please visit the Developer support forum.

x-blogpost://6449f44a102fde848669bdd9eb6b76fa@ff4d5bd026cb03f18a557ba2b651722b

The URL has two components separated by an '@' sign. The first one is the MD5 of the draft's identifier and the second is the MD5 of the account this draft belongs to. You can use either 'x-blogpost:' or 'x-blogpost://', although the latter works better with Safari.

To create a URL reference to a draft, the easiest way is to drag and drop an item from the main window's list of drafts into an editing area. This works in TextEdit as well, for example. Clicking a x-blogpost: URL will open the corresponding draft in ecto.

UPDATE: After discussion with ecto users and Daniel Jalkut from Red Sweater, the plan is to use x-blogpost: (instead of my original draft:) to avoid possible collisions and to allow for use by other blog clients as an unofficial standard.

You can get the URL via AppleScript as well. Example:

tell application "ecto"
  set account_list to accounts whose name is "foo.com"
  set a to first item of account_list
  properties of a
  set blogs_list to blogs of a
  set b to first item of blogs_list
  properties of b
  tell b
    set entry_list to entries of b
    set e to first item of entry_list
    tell e
      get href
    end tell
  end tell
end tell

Alex Hung will continue developing ecto for Windows under a new name from his own mineblogging.com domain. He has some good changes planned that will benefit Windows users greatly. The new Windows support forum is at http://mineblogging.com/support.

ecto for Mac itself will enjoy a 100% dedication.

Although our software partnership has ended, I gain a good friend in Alex Hung, which is more important.

Update: Localization in progress for languages:

• Finnish
  
• French
• Russian
• Spanish

Update: Localization included in latest beta for:

• Arabic
• Chinese
• Danish
• German
• Japanese
• Korean
• Portuguese
• Taiwanese

Thanks much all!

The meat of the code is one call the add-on gets from ecto:

- (void)processNotification:(int)type data:(id)data

The various types and the data you can expect is documented right in the code. If you're familiar with Objective-C and Cocoa, the project should be easy study material. If you have questions, pose them in the Developer Forum or contact me directly. I'd be more than happy to provide pointers.

Smart observers will note that the add-on header file also applies to ecto3 add-ons that let you manipulate or insert text (the Amazon and Flickr Helper add-ons are using this). I'll release a sample for this type of add-on soon.

You can search for tags anytime, but if you want to search in the other options, you will need to authorize first. You can do that via the Tools & Add-ons settings. I recommended logging into your Flickr account via the browser first before authorizing the Flickr Helper add-on.

Other than that, using Flickr Helper is pretty straight-forward. If you have questions, feel free to ask in the Support Forum.

The image browser in the add-on is an implementation of a simplified version of MUPhotoView.

activate application "ecto"
tell application "System Events"
  tell process "ecto"
    tell menu bar 1
      tell menu bar item 2
        tell menu 1
          tell menu item 3
            tell menu 1
              tell menu item 3
                click
              end tell
            end tell
          end tell
        end tell
      end tell
    end tell
  end tell
end tell

It all depends on what systems powers your blogs. I've written before about how desktop blog clients talk to blog systems. It's all about sending text formatted as XML over simple HTTP. There's a specific way to format dates so both blog system and blog client can read it, the ISO8601 format. For example, 2008-01-12T13:09Z gives date and time (separated by a 'T'). The 'Z' suffix means that the date is in GMT.

The Atom publishing protocol gets this right. It requires that dates sent and received specify the timezone. There's no need to configure ecto as it knows Atom is a good boy. The problem is with XML-RPC. It does not have that requirement, and each blog system interprets dates differently.

The cheap way out for a blog client to talk to a blog system using XML-RPC is not to specify a date so that the blog system will use the current date and time. That does not always work. When sending an edit of an already published blog post the date will reset to current. In addition, sometimes the user may want to specify a different date for a post. In those cases, the lack of timezone information in the XML transferred can lead to unwanted time offsets.

Some blog systems, like MovableType, parse ISO8601 dates with the Z suffix correctly, but still return dates without a timezone specification. In those cases, ecto needs to be told what timezone the blog is in. WordPress, on the other hand, has a custom field for GMT dates, so does not need special handling.

I ran into trouble with TextPattern, though, and have not been able to work around it elegantly. I looked in the xmlrpc.php file of TextPattern and it not only ignores the timezone suffix of the received date (in this case, 'Z'), it also adjusts the date by the offset of the blog's timezone from GMT. If the server hosting TextPattern is set to a different timezone, that offset is also included. The only work-around is to send dates without a GMT specification and ignore any errors ecto pops up about mismatched dates. It's an issue for TextPattern to fix.

#!/usr/bin/env perl
# Confluencer.pl
use HTML::WikiConverter;
my $wc = new HTML::WikiConverter( dialect => 'Confluence' );

my $ecto = do { local $/; <> };
print $wc->html2wiki( $ecto );

Save the code to a file ending in '.pl' and put the file in ~/Library/Application Support/ecto3/scripts/. Restart ecto and you'll find it under the Scripts submenu of the Tools menu.

Usage
Once the addon is installed, launch ecto. Go to Settings under the ecto menu and choose the Weblog… menu item. Click the "Editing" tab and then the "Defaults" sub-tab. Turn on "Send notifications".

Usage
Once the addon is installed, launch ecto. Go to Settings under the ecto menu and choose the Tools & Addons… menu item. Select the settings pane for Twitter. Enter your login credentials and a twitter template (you can leave it blank to use the default template). Then, go to the Settings menu again and choose the Weblog… menu item. Click the "Editing" tab and then the "Defaults" sub-tab. Turn on "Send notifications" so that the Twitter add-on will be invoked when you publish a blog post.

The first step would be to download and unpack the sample uploader. It actually does not upload, but gives you a basic framework to work with. Once you've unpacked the sample, it's a good idea to rename the project. Let's assume your uploader will be called MyUploader. In the Finder, rename "SampleUploader.xcodeproj" to "MyUploader.xcodeproj". Double-click the file to open it. In the Groups & Files list, click on "SampleUploader" under the "Targets" section. Select File → Get Info. Under "Build", find the values for "Product Name" and "Prefix Header" and rename them. Under "Properties", assign a unique identifier, e.g. com.thirdparty.ecto_myuploader and change the principal class to "MyUploader". Close the Get Info window.

Back in Groups & Files, rename any files containing "SampleUploader" so that they contain "MyUploader". Rename the "SSUUploadWorker" files to something different as well. You will then have to rename the class names inside those files as well. In other words, class SampleUploader becomes MyUploader, and so forth.

Do NOT rename "UploaderInterface.h" and do NOT rename the "ECTOUploaderProtocol" protocol name.

In SampleUploader.m, you will also need to change the return value for "-(NSString*)uploaderKey" and "-(NSString*)uploaderDescription".

The uploader plug-in has two entry points. The first one is a method called when the user is accessing settings for a given attachment that uses the uploader: "-(id)uploaderRequested:(NSMutableDictionary*)settings". You can use this to allow users to specify a variety of general preferences (which you would store in NSUserDefaults) or attachment-specific settings, which are stored in the provided dictionary. See SampleUploaderSettings.m for an example.

The actual upload happens with a call to -(void)uploadData:(NSDictionary*)data delegate:(id)del errorSelector:(SEL)err endSelector:(SEL)end statusSelector:(SEL)stat. All the data you need for upload is provided in the "data" dictionary, which also includes any of the settings stored in the previously discussed method. The SampleUploader.m file lists the various available keys and how you can use them. It allocates an SUUploadWorker class, which does the actual upload. Once this object has done its job, a delegate call is made back to ecto to inform of the result. See -(void)upload for an example of what you need to return to ecto.

The most simple adaptation would only require changing -(void)upload in SUUploadWorker.m and writing code for the actual upload in there.

If you have any questions about writing an uploader, please visit the Developer support forum.