Extensions made easy: Adding custom commands, global commands and new command groups to the LightSwitch button ribbon.

One might think he already saw the title of this blog post before somewhere…  Aye, it is true, I blogged about this subject before…  But this time, it’s made easy… 

Adding global commands to my applications, is something I do almost every time.  The process, for me personally, is simple…

1. Try to code the commands.
2. Fail miserably, open my personal blog and find the post where I described how to do this.
3. Curse because the post is so lengthy, too lengthy even to include a code sample.
4. Download my own sample again.
5. Curse at the amount of code needed to implement a simple command.
6. Copy & paste the code.
7. Finish the application.
8. Start a new LightSwitch application.
9. Go to step 1.

Wait, did you read step 5?  For my personal development entertainment (and hopefully for yours too), I’m proud to announce: ExtensionsMadeEasy now includes EasyCommands!

Let’s whip up a quick sample together…

Prep work

Create a new LightSwitch application, or open an existing one.  I opened my TheminTestArea, the project I use to test development the ExtensionsMadeEasy extension.

Download the latest version of ExtensionsMadeEasy (you can use the ExtensionManager for this), which at the time of writing is 1.4, and activate it.

Select your LightSwitch application in the solution explorer and flip to File View.

Adding the commands

This is what we'll make...

 

Lets start by adding a global command (“Kill em all!”).

If you remember how the ExtensionsMadeEasy work, you can already guess we’re going to make a CommandExporter here.

Right-click your client project and add a new class.

    public class CloseAllWithoutSavingCommand : ExtensionsMadeEasy.ClientAPI.Commands.EasyCommandExporter // 1.
    {
        public CloseAllWithoutSavingCommand() :
        base(
            "Kill em all!", // 2.
            "Close all open screens without saving", //3. 
            "Quickies...",  //4.
            new Uri(@"/TheminTestArea.Client;component/Images/Save.png", UriKind.Relative) //5.
            ) { }

        public override void Execute(Microsoft.LightSwitch.Client.IScreenObject currentScreen)
        {
            // 6.
            foreach (IActiveScreen activeScreen in Application.Current.ActiveScreens)
            {
                activeScreen.Close(false);
            }
        }
    }

1. The class inherits an abstract base class EasyCommandExporter, located in the ExtensionsMadeEasy extension.  It’s an abstract class, has a constructor that takes 4 arguments, has one abstract method, and one virtual one…
2. The first argument of the constructor, is the label (aka. name) of the command
3. The second argument will be used for the tooltip.
4. The name of the group in which our command should be displayed.  Note that we use a string here, not some kind of complex CommandGroup object, because Easy is what we love.
5. Last of the constructor arguments, the image to display on the command.
6. The final step to complete this class, is to implement the ExecuteMethod method.  For this example, we’re not even going to use the currently active screen object, passed as an argument.  This time, we’re going to loop through all of the screens that are open (ActiveScreens) and kill them all.  Passing false as an argument to the close method, suppresses the question to save pending changes by the way, we want to KILL the open screens, not gracefully close them if her majesty pleases.

Before we forget, add a new folder to your LightSwitch.client project called images, and add an image to it called save.png.

We’re now ready to launch our example, and if all goes well, you’ll find your first EasyCommand in the ribbon bar.

While we’re on a roll, let’s immediately proceed to our second EasyCommand.  Add another class to your LightSwitch.client project.

    public class CloseWithoutSavingCommand : ExtensionsMadeEasy.ClientAPI.Commands.EasyCommandExporter
    {
        public CloseWithoutSavingCommand() :
        base("Close Now!", "Close without saving", "Quickies...", // 1.
        new Uri(@"/TheminTestArea.Client;component/Images/Save.png", UriKind.Relative))
        {
        }

        public override void Execute(Microsoft.LightSwitch.Client.IScreenObject currentScreen)
        {
            if (currentScreen != null) // 2.
            {
                currentScreen.Close(false);
            }
        }

        public override bool IsCommandActiveForScreen(Microsoft.LightSwitch.Client.IScreenObject currentScreen)
        {
            return currentScreen != null; //3.
        }
    }

Noteworthy things in this code:

1. Those constructor arguments.  We are using the same group (“Quickies…”), same images (I’m lazy), but of course a different name and tooltip.
2.  This time, we’re only going to close one screen: the currently selected one (passed as an argument).
3. Note that this second command also overrides the virtual method IsCommandActiveForScreen.   If you don’t, your command will be “global”, meaning displayed for all screens.  However, sometimes you’ll want to finetune that a bit, as an example here I’ll only show my command if there actually is an active screen.

All done.  Hit F5 to mess around a bit, and let me know if you find anything bad, or need anything good!

So what does the ExtensionsMadeEasy do?

• It collects all commands you wrote, such as the two above.
• It creates the IShellCommandGroups, as per the LightSwitch requirement.
• It creates IShellCommands, full-blown objects, and their IExcecutableObjects.
• It takes care of Threading.  As you may have noticed yourself, threading is a pain.  Therefore, your “Execute” methods will already be marshalled to the UI thread where possible.
• It’s Easy!