Plug-in Error occured - Messagebox from Windows Live Writer

It only shows the exception message, not the stack trace or any other information which helps to find the exception. For debugging, you need to attach the Windows Live writer to Visual Studio(we may need to run visual studio as Administrator) using Attach Process feature of Visual Studio from Debug menu.

Attach Windows Live Writer to Visual Studio

Happy Programming.

First we need to inform Live Writer that the plugin has settings, which can be done using HasEditableOptions=true in plugin attributes. Now we will create the settings form, which will be like the following.

Plugin settings - Design View

Live writer will invoke the EditOptions method in the Plugin class for displaying the settings, so we need to override the method for displaying the form.

public override void EditOptions(IWin32Window dialogOwner)
{
    Settings settings = new Settings(_pluginSettings);
    settings.ShowDialog();
}

For implementing plugin settings we can use IProperties, which helps plugin to read/write the settings. The Live writer understands the basic types, like string, int, float, bool and decimal. IProperties exposes methods to get and set the values. Like this

private IProperties _properties;
public bool UseBlank
{
    get
    {
        return _properties.GetBoolean("UseBlank", true);
    }
    set
    {
        _properties.SetBoolean("UseBlank", value);
    }
}

To save and retrieve the setting the following methods of IProperties class can be used.

private PluginSettings _settings;
private void cmdSave_Click(object sender, EventArgs e)
{
	_settings.UseBlank = chkBlankTarget.Checked;
	_settings.Provider = ddlProvider.SelectedItem.ToString();
	Close();
}
//Constructor of the Settings Form.
public Settings(PluginSettings settings)
{
    InitializeComponent();
    _settings = settings;
    chkBlankTarget.Checked = _settings.UseBlank;
	ddlProvider.SelectedItem = _settings.Provider;
}

For accessing settings in the Plugin, we need to override the Initialize() method of the Plugin class, which takes the IProperties as parameter, LiveWriter will invoke the plugin with the settings.

private PluginSettings _pluginSettings;
public override void Initialize(IProperties pluginOptions)
{
    base.Initialize(pluginOptions);
    _pluginSettings = new PluginSettings(pluginOptions);
}

Build the project, launch the Windows Live Writer, click on the Plugin options, which will show the Plugin options dialog.

Live Writer - Plugin Options

Next select Link shortener plugin and click on Options button, which will display the plugin settings dialog we designed.

Live writer Plugin - Settings

Change the settings and Save the changes, try run the plugin and verify the results.

Happy Programming. Next post will be about debugging Live writer plugin.

So first create a class library, make sure you are selecting the target framework as .Net 2.0, otherwise it may not work. The add refernce of Live Writer API(WindowsLive.Writer.Api.dll), which will be available in C:\Program Files (x86)\Windows Live\Writer. Inherit from ContentSource class or SmartContentSource class. In this post I am using ContentSource class, both of them can be used to create the Plugin. Override the CreateContent method, this method will be invoked when users click on the Plugin in LiveWriter. Create a Windows Form, with one textbox and two buttons.

Link shortner - Windows Form Design View

And add following attributes to the plugin class which helps live writer to identify the Plugin properties.

[InsertableContentSource("Link shortner")]
[WriterPlugin("9E560094-F1BA-433D-9FB7-4DEA9A4C3F2F",
	"Link shortner",
	PublisherUrl = "www.dotnetthoughts.net",
	Description = "Helps to insert shorten links.",
	HasEditableOptions = false,
	ImagePath = "wlwicon.png")]
public class LinkShortner : ContentSource
{
}

HasEditableOptions parameter, helps to provide settings for the live writer plugin. And the ImagePath parameter helps to provide Icon for the plugin. The size should be 16×16. And it should added and Build action should be Embedded Resource.

And here is the overriden CreateContent() method.

public override DialogResult CreateContent(IWin32Window dialogOwner, ref string content)
{
    using (Editor editor = new Editor())
    {
        editor.StartPosition = FormStartPosition.CenterParent;
        DialogResult result = editor.ShowDialog(dialogOwner);
        if (result == DialogResult.OK)
        {
			//This function will convert long
			//url to short url using bit.ly REST API.
			//Editor.Url property returns the
			//text of the textbox control.
			string resultUrl = CreateShortUrl(editor.Url);
			string url = string.Format
				("<a href="\"http://{0}/\"">{0}</a>", resultUrl);
            content = url;
        }
        return result;
    }
}

Thats it. We are done with the creation of live writer plugin. Now the next part is deployment. Change the project output path to C:\Program Files (x86)\Windows Live\Writer\Plugins location, you may need to run Visual Studio as Administrator. Now launch the Windows Live Writer, you can see the plugin loaded .

Link Shortner - Windows Live Writer Plugin

Clicking on it will popup the Windows form, with textbox, and clicking on Shorten button will insert a link on the post.

Link shortner in Windows Live writer - Running

Next part I will post about how to create settings for plugin. Happy Blogging

The process class supports redirection of output, error and input to streams instead of normal console output stream. Process class also supports events, which will be raised on error or output data received.

And here is the implementation, which invokes the regasm.exe in .Net Framework location, and executes regasm.exe without any command line argument, which will write the help text to the Text box.

string app = @"C:\Windows\Microsoft.NET\Framework\v4.0.30319\regasm.exe";
Process process = Process.Start(app);

process.EnableRaisingEvents = true;
process.OutputDataReceived += (o, dre) =>
{
    //To avoid cross thread exceptions.
    if (txtOutput.InvokeRequired)
    {
        this.txtOutput.BeginInvoke((Action)
            delegate { this.txtOutput.Text += dre.Data + Environment.NewLine; });
    }
    else
    {
        this.txtOutput.Text += dre.Data + Environment.NewLine;
    }
};
process.StartInfo.RedirectStandardError = true;
process.StartInfo.RedirectStandardInput = true;
process.StartInfo.RedirectStandardOutput = true;
process.StartInfo.CreateNoWindow = true;
process.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
process.StartInfo.UseShellExecute = false;
process.Start();
process.BeginOutputReadLine();
process.WaitForExit();

The external tools option in Visual Studio works in similar fashion. You can use this technique for creating user interface for command line tools you use frequently.

Happy coding

public class SortableList : BindingList
{
    protected override bool SupportsSortingCore
    {
        get
        {
            return true;
        }
    }

    protected override void ApplySortCore(PropertyDescriptor prop, ListSortDirection direction)
    {
        var sortProperty = prop;
        var sortDirection = direction;

        var list = Items as List;
        list.Sort((T item1, T item2) =>
        {
            var item1Value = item1 == null ? null : sortProperty.GetValue(item1);
            var item2Value = item2 == null ? null : sortProperty.GetValue(item2);
            int result;
            if (item1Value == null)
            {
                result = -1;
            }
            else if (item2Value == null)
            {
                result = 1;
            }
            else
            {
                result = Comparer.Default.Compare(item1Value, item2Value);
            }
            if (sortDirection == ListSortDirection.Descending)
            {
                result = -result;
            }
            return result;
        });
    }
}

This post I wrote long back and it was in draft mode, and today I thought of publishing it

Happy Coding