Page History

Panelscrollbar

Panel

borderStyle	solid

Contents

Page Tree

root	TOOLS:Tutorial
startDepth	3

...

Exercise outline

The goal of this exercise is to add a Ribbon button for volume models. As a result, it should be possible to configure the input data of volume models in just a couple of clicks.

Create a new gui command

Add a new folder to the plugin project named Commands. In this folder, create a new class named AddInputDataToVolumeModelCommand.cs and adapt the contents as shown below.

Note
A reference to DeltaShell.Plugins.NetworkEditor needs to be added in order to successfully build the code below (right click the References folder of the project in the Solution Explorer \| Add Reference... \| Browse... \| Select D:\VolumeModel\packages\DeltaShell.1.0.0\delta-shell\plugins\DeltaShell.Plugins.NetworkEditor\DeltaShell.Plugins.NetworkEditor.dll).

Code Block


using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Windows.Forms;
using DelftTools.Shell.Gui;
using DeltaShell.Plugins.VolumeModel.Importers;
using DeltaShell.Plugins.NetworkEditor.Import;
using SharpMap.Api;
using SharpMap.Data.Providers;

namespace DeltaShell.Plugins.VolumeModel

Wiki Markup
2. Create a new class named "AddDemoDataToVolumeModelCommand" \[TODO: Image\]

3. Add the following contents to this class:

Code Block


using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using DelftTools.Shell.Gui;
using DeltaShell.Plugin.DemoApp.Importers;
using DeltaShell.Plugin.DemoApp.Models;
using DeltaShell.Plugins.NetworkEditor.Import;
using SharpMap.Api;
using SharpMap.Data.Providers;

namespace DeltaShell.Plugin.DemoApp.Commands
{
    internal class AddDemoDataToVolumeModelCommandAddInputDataToVolumeModelCommand : IGuiCommand
    {
        public string Name/// <summary>
        {
/// The name of the gui command
        get { return "Add demo data"; }/// </summary>
        public string Name
        }
{
        public bool Enabled
  get { return "Add input data"; {}
        }

    get { return Gui != null && Gui.SelectedModel is VolumeModel; }
/// <summary>
        /// Ensures the gui command }

is enabled for volume models only
   public Image Image { get; set; }
 /// </summary>
        public bool CheckedEnabled
  { get; set; }

   {
     public IGui Gui { get; set; }

 get { return Gui != null && publicGui.Selection void Execute(params object[] arguments)is Models.VolumeModel; }
        {}

        /// <summary>
   // Obtain the selected volume model
/// The image of the gui command
      var volumeModel = (VolumeModel) Gui.SelectedModel;
/// </summary>
        public Image Image { // Create a WaterML2 time series importer
get; set; }

        /// <summary>
        var/// waterMl2TimeSeriesImporterWhether =or new WaterML2TimeSeriesImporter();

    not the gui command is checked
        /// Import</summary>
  a WaterML2 file to the precipitation time/// series<remarks>Not ofrelevant thein volumethis modeltutorial</remarks>
        public bool Checked  waterMl2TimeSeriesImporter.ImportItem(@"..\..\precipitation_waterml.XML", volumeModel.Precipitation);{ get; set; }

        /// <summary>
   // Create a catchment importer
 /// A reference to the Delta Shell gui (automatically set by varDelta catchmentsImporterShell =logic)
 new CatchmentFromGisImporter
      /// </summary>
     {
   public IGui Gui { get; set; }

       FileBasedFeatureProviders = new List<IFileBasedFeatureProvider>/// <summary>
        /// The action that should be performed while {
executing the gui command
        /// </summary>
        newpublic void ShapeFile(Execute(params object[] arguments)
        {
        }
    // Obtain the selected     };
volume model
            //var ConfigurevolumeModel the catchment importer= (Models.VolumeModel) Gui.SelectedModel;

            var catchmentImporterSettings = catchmentsImporter.FeatureFromGisImporterSettings;// Try to obtain a precipitation file via a file dialog
            catchmentImporterSettings.Pathvar fileDialog = @"D:\deltashell\Workshop\SoftwareDaysNov2013\Gemeenten.shp"; new OpenFileDialog
            catchmentImporterSettings.PropertiesMapping.First(property => property.PropertyName == "Name").MappingColumn.ColumnName = "GM_NAAM";

 {
              // Import a shape file to theTitle basin= of"Choose theprecipitation volumetime modelseries",
              catchmentsImporter.ImportItem(null, volumeModel.Basin);      Filter = "WaterML2 files|*.XML",
        }

        public void Unexecute()
  Multiselect = false
    {

        }
    };
}

...

5. Add the following xaml code:

Code Block


<UserControl x:Class="DeltaShell.Plugin.DemoApp.DemoAppRibbon"     if (fileDialog.ShowDialog() != DialogResult.OK)
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
{
                xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
return;
            }

      xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
      // Create a WaterML2 time series  xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
importer
            var waterML2TimeSeriesImporter xmlns:fluent="clr-namespace:Fluent;assembly=Fluent"= new WaterML2TimeSeriesImporter();

             mc:Ignorable="d"
      // Import the data from the precipitation file
       d:DesignHeight="300" d:DesignWidth="300">
    <!--Create a ribbon control-->
waterML2TimeSeriesImporter.ImportItem(fileDialog.FileName, volumeModel.Precipitation);

      <fluent:Ribbon Name="DemoAppRibbonControl" x:FieldModifier="private">
    // Try   <!--Createto obtain a ribbon tab-->
    shape file via a file dialog
     <fluent:RibbonTabItem Header="Volume model" fluent:KeyTip.Keys="E">
    fileDialog = new OpenFileDialog
     <!--Create a ribbon group box-->
       {
     <fluent:RibbonGroupBox Header="Demo">
              Title  <!--Create a ribbon button-->= "Choose basin shape file",
                <fluent:Button x:Name="ButtonAddDemoDataToVolumeModel"
   Filter = "Shape files|*.shp",
                        Multiselect Header="Add demo data" false
                };

            if   ToolTip="Add demo data to the selected volume model"
(fileDialog.ShowDialog() != DialogResult.OK)
            {
                return;
         Click="ButtonAddDemoDataToVolumeModel_OnClick"
   }

            // Create a catchment importer
            Size="Middle"
    var catchmentsImporter = new CatchmentFromGisImporter
                {
               SizeDefinition="Middle,Small,Small"/>     FileBasedFeatureProviders = new List<IFileBasedFeatureProvider>
            </fluent:RibbonGroupBox>        {
        </fluent:RibbonTabItem>
    </fluent:Ribbon>
</UserControl>

6. Additionally, add the following interaction logic in DemoAppRibbon.xaml.cs:

Code Block


using System.Collections.Generic;
using System.Windows;
using DelftTools.Controls;
using DelftTools.Shell.Gui;
using DelftTools.Shell.Gui.Forms;
using DeltaShell.Plugin.DemoApp.Commands;

namespace DeltaShell.Plugin.DemoApp
{
    /// <summary>            new ShapeFile()
    /// Interaction logic for DemoAppRibbon.xaml
    /// </summary>
    public partial class DemoAppRibbon : IRibbonCommandHandler}
    {
        private readonly IGuiCommand addDemoDataCommand = new AddDemoDataToVolumeModelCommand() };

        public DemoAppRibbon()
   // Configure the catchment importer
  {
          var catchmentImporterSettings  InitializeComponent()= catchmentsImporter.FeatureFromGisImporterSettings;
        }

    catchmentImporterSettings.Path = fileDialog.FileName;
  public object GetRibbonControl()
        {
      catchmentImporterSettings.PropertiesMapping.First(property => property.PropertyName == "Name").MappingColumn.ColumnName = "GM_NAAM";

      return DemoAppRibbonControl;
     // Import the }

data from the shape file
    public void ValidateItems()       catchmentsImporter.ImportItem(null, volumeModel.Basin);
        {}

        /// <summary>
   ButtonAddDemoDataToVolumeModel.IsEnabled = addDemoDataCommand.Enabled;
   /// The action that should }

be performed in order to undo execute actions publicof boolthe IsConextualTabVisible(string tabGroupName, string tabName)
gui command
          {/// </summary>
        /// <remarks>Not relevant in return false;
        }
this tutorial</remarks>
        public IEnumerable<ICommand>void CommandsUnexecute()
        {

        }
    get { yield return addDemoDataCommand; }
        }

        private void ButtonAddDemoDataToVolumeModel_OnClick(object sender, RoutedEventArgs e)
        {}
}

Info

The command is derived from the IGuiCommand interface in order to obtain a reference to the Delta Shell gui (which is automatically set by the Delta Shell framework).

The comments in the code explain the different parts of the gui command implementation.

Create a new Ribbon control

Add a new folder to the plugin project named Ribbon. In this folder, create a new WPF user control named VolumeModelRibbon.xaml and adapt the contents (in the designer) as shown below:

Code Block


<UserControl x:Class="DeltaShell.Plugins.VolumeModel.Ribbon.VolumeModelRibbon"
            addDemoDataCommand.Execute();
        }
    }
}

    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
             xmlns:fluent="clr-namespace:Fluent;assembly=Fluent"
    mc:Ignorable="d" Height="145" Width="632">
    <!--Create a ribbon control-->
    <fluent:Ribbon Name="VolumeModelRibbonControl" x:FieldModifier="private">
        <!--Create a ribbon tab-->
        <fluent:RibbonTabItem Header="Volume model" fluent:KeyTip.Keys="E">
            <!--Create a ribbon group box-->
            <fluent:RibbonGroupBox Header="Input">
                <!--Create a ribbon button-->
                <fluent:Button x:Name="ButtonAddInputDataToVolumeModel"
                               Header="Add input data"
                               ToolTip="Add input data to the selected volume model"
                               Click="ButtonAddInputDataToVolumeModel_OnClick"
                               Size="Middle"
                               SizeDefinition="Middle,Small,Small"/>
            </fluent:RibbonGroupBox>
        </fluent:RibbonTabItem>
    </fluent:Ribbon>
</UserControl>

Additionally, adapt the contents of VolumeModelRibbon.xaml.cs as shown below (right click the class | View Code).

Note
A reference to System.Xaml needs to be added in order to successfully build the code below (right click the References folder of the project in the Solution Explorer \| Add Reference... \| Assemblies \| Framework \| Select System.Xaml).

Code Block


using System.Collections.Generic;
using System.Windows;
using DelftTools.Controls;
using DelftTools.Shell.Gui;
using DelftTools.Shell.Gui.Forms;
using DeltaShell.Plugins.VolumeModel.Commands;

namespace DeltaShell.Plugins.VolumeModel.Ribbon
{
    /// <summary>
    /// Interaction logic for VolumeModelRibbon.xaml
    /// </summary>
    public partial class VolumeModelRibbon : IRibbonCommandHandler
    {
        private readonly IGuiCommand addInputDataToVolumeModelCommand = new AddInputDataToVolumeModelCommand(); // Instance of the implemented gui command

        /// <summary>
        /// Creates the Ribbon control
        /// </summary>
        public VolumeModelRibbon()
        {
            // Initialize the control (standard user control logic)
            InitializeComponent();
        }

        /// <summary>
        /// Returns the volume model Ribbon control
        /// </summary>
        public object GetRibbonControl()
        {
            return VolumeModelRibbonControl;
        }

        /// <summary>
        /// Enabling/disabling actions to be performed while validating the Ribbon items (triggered by Delta Shell logic)
        /// </summary>
        public void ValidateItems()
        {
            ButtonAddInputDataToVolumeModel.IsEnabled = addInputDataToVolumeModelCommand.Enabled;
        }

        /// <summary>
        /// Whether or not the contextual tab should be visible
        /// </summary>
        public bool IsConextualTabVisible(string tabGroupName, string tabName)
        {
            return false;
        }

        /// <summary>
        /// The (gui) commands of the Ribbon control
        /// </summary>
        public IEnumerable<ICommand> Commands
        {
            get { yield return addInputDataToVolumeModelCommand; }
        }

        /// <summary>
        /// Actions to be performed after clicking the AddInputDataToVolumeModel button
        /// </summary>
        private void ButtonAddInputDataToVolumeModel_OnClick(object sender, RoutedEventArgs e)
        {
            addInputDataToVolumeModelCommand.Execute();
        }
    }
}

Info

The Ribbon control is derived from the IRibbonCommandHandler interface so that it can be registered in the gui plugin.

The comments in the code should explain the different parts of the Ribbon control implementation.

Register the Ribbon control in the gui plugin class

Register the Ribbon control in the gui plugin by adding the following code to VolumeModelGuiPlugin.cs:

Code Block
using DelftTools.Shell.Gui.Forms; using DeltaShell.Plugins.VolumeModel.Ribbon;

and

Code Block
public override IRibbonCommandHandler RibbonCommandHandler { get { return new VolumeModelRibbon(); } }

Delta Shell should now automatically add the new Ribbon control to its Ribbon bar during the application startup.

Exercise results

First of all, download the following WaterML2 XML file: WaterML2_precipitation_data.XML. Also download and unzip the shape files contained in the following archive: Gemeenten.zip. You will use all these data along the exercise.

Next, run the application and check that a volume Ribbon button has been added to the Ribbon bar:

Image Added

Then create a new volume model item (right click on project | Add | New Model ...), click the volume Ribbon button and, sequentially, select the previously downloaded WaterML2 XML file and shape files in the file selection dialogs.

Afterwards, verify that the input data has been correctly added to the volume model by opening the data views or by running the model:

Image Added Wiki Markup7. Run the application, create a volume model and click the newly created Ribbon button: ensure input data is added correctly to the volume model by opening the data views or by running the model \[TODO: Image\]

scrollbar

Child pages

Versions Compared

Old Version 24

New Version Current

Key

Exercise outline

Create a new gui command

Create a new Ribbon control

Register the Ribbon control in the gui plugin class

Exercise results