Page History

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).

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.Commands
{
    internal class AddInputDataToVolumeModelCommand outline

{color:#000000}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.{color}


h2. 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 add the following code:

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

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

        public bool Enabled
 Name
        {
            get { return Gui"Add != null && Gui.SelectedModel is Models.VolumeModelinput data"; }
        }

        public Image Image { get; set; }

/// <summary>
        /// Ensures the gui command publicis boolenabled Checkedfor {volume get; set; }
models only
        public IGui Gui { get; set; }
/// </summary>
        public void Execute(params object[] arguments)bool Enabled
        {
            //get Obtain{ thereturn selectedGui volume!= model
null && Gui.Selection is Models.VolumeModel; }
       var volumeModel = (Models.VolumeModel)Gui.SelectedModel; }

            /// Create<summary>
 a WaterML2 time series importer
   /// The image of the gui command
   var waterMl2TimeSeriesImporter = new WaterML2TimeSeriesImporter();

   /// </summary>
        public Image varImage fileDialog{ =get; newset; OpenFileDialog}

        /// <summary>
       {
 /// Whether or not the gui command is checked
           Title = "Choose precipitation time series",
       /// </summary>
        /// <remarks>Not relevant in this tutorial</remarks>
        public bool Checked { get; Filter = "WaterML2 files|*.XML",
set; }

        /// <summary>
        /// A reference to the MultiselectDelta =Shell false
gui (automatically set by Delta Shell logic)
          };
/// </summary>
        public IGui Gui { if (fileDialog.ShowDialog() != DialogResult.OK)get; set; }

            {/// <summary>
        /// The action that should be performed while return;
executing the gui command
         }

/// </summary>
        public void Execute(params  // Import a WaterML2 file to the precipitation time series of the volume model
object[] arguments)
        {
            // Obtain the selected  waterMl2TimeSeriesImporter.ImportItem(fileDialog.FileName, volumeModel.Precipitation)volume model
            var volumeModel = (Models.VolumeModel) Gui.SelectedModel;

            // Create Try to obtain a precipitation file via a catchmentfile importerdialog
            var catchmentsImporterfileDialog = new CatchmentFromGisImporterOpenFileDialog
            {
    {
            FileBasedFeatureProviders = new List<IFileBasedFeatureProvider>
     Title = "Choose precipitation time series",
      {
              Filter = "WaterML2 files|*.XML",
   new  ShapeFile()
               Multiselect }= false
                };

            if (fileDialog.ShowDialog() != new OpenFileDialog
 DialogResult.OK)
            {
                Title = "Choose basin shape file",return;
            }

    Filter = "Shape files|*.shp",
     // Create a WaterML2 time series importer
     Multiselect = false
     var waterML2TimeSeriesImporter =     }new WaterML2TimeSeriesImporter();

            if (fileDialog.ShowDialog() != DialogResult.OK)
    // Import the data from the precipitation file
        {
    waterML2TimeSeriesImporter.ImportItem(fileDialog.FileName, volumeModel.Precipitation);

           return;
 // Try to obtain a shape file via a file  }dialog

            //fileDialog Configure= thenew catchmentOpenFileDialog
 importer
            var catchmentImporterSettings = catchmentsImporter.FeatureFromGisImporterSettings;
{
               catchmentImporterSettings.Path = fileDialog.FileName;     Title = "Choose basin shape file",
            catchmentImporterSettings.PropertiesMapping.First(property => property.PropertyName == "Name").MappingColumn.ColumnName     Filter = "GM_NAAM";

Shape files|*.shp",
              // Import a shape file to theMultiselect basin= offalse
 the volume model
            catchmentsImporter.ImportItem(null, volumeModel.Basin) };

        }

    if (fileDialog.ShowDialog() != DialogResult.OK)
          public void Unexecute(){
        {
        return;
        }
    }
}
{code}


h2. Fixme

{color:#ff0000}*\[TODO\]*{color} {color:#ff0000}Fixme{color}

h2. Exercise results

{color:#ff0000}*\[TODO\]*{color} {color:#ff0000}Description of the exercise results{color}\\
\\
\\
\\
\\
1. Add a new folder to the project named "Commands"

2. Create a new class named "AddInputDataToVolumeModelCommand"

3. Add the following contents to this class:


4. Create a new WPF user control named "VolumeModelRibbon"
\\
\\  !NewWPFControl .png!\\

5. Add the following xaml code:

{code}
<UserControl x:Class="DeltaShell.Plugin.VolumeModel.VolumeModelRibbon"

            // Create a catchment importer
            var catchmentsImporter = new CatchmentFromGisImporter
                {
                   xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
     FileBasedFeatureProviders = new List<IFileBasedFeatureProvider>
         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"new ShapeFile()
             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">
    // Configure the catchment importer
     <!--Create a ribbon tab-->
    var    <fluent:RibbonTabItem Header="Volume model" fluent:KeyTip.Keys="E">catchmentImporterSettings = catchmentsImporter.FeatureFromGisImporterSettings;
            <!--Create a ribbon group box-->
catchmentImporterSettings.Path = fileDialog.FileName;
            catchmentImporterSettings.PropertiesMapping.First(property  <fluent:RibbonGroupBox Header="Demo">
  => property.PropertyName == "Name").MappingColumn.ColumnName = "GM_NAAM";

              <!--Create a ribbon button-->
   // Import the data from the shape file
             <fluent:Button x:Name="ButtonAddDemoDataToVolumeModel"catchmentsImporter.ImportItem(null, volumeModel.Basin);
        }

        /// <summary>
        /// The action that should be Header="Add demo data"
        performed in order to undo execute actions of the gui command
        /// </summary>
        /// <remarks>Not relevant in this  ToolTip="Add demo data to the selected volume model"
  tutorial</remarks>
        public void Unexecute()
        {

                     Click="ButtonAddDemoDataToVolumeModel_OnClick"}
                               Size="Middle"
  }
}

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.

<UserControl x:Class="DeltaShell.Plugins.VolumeModel.Ribbon.VolumeModelRibbon"
             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>

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).

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; }
        }

        SizeDefinition="Middle,Small,Small"/>/// <summary>
        /// Actions to be performed after clicking </fluent:RibbonGroupBox>
the AddInputDataToVolumeModel button
        /// </summary>
         </fluent:RibbonTabItem>
    </fluent:Ribbon>
</UserControl>
{code}

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

{code}
using System.Collections.Generic;
using System.Windows;
using DelftTools.Controls;
using DelftTools.Shell.Gui;
using DelftTools.Shell.Gui.Forms;
using DeltaShell.Plugin.VolumeModel.Commands;

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

        public VolumeModelRibbon()
        {
            InitializeComponent();
        }

        public object GetRibbonControl()
        {
            return VolumeModelRibbonControl;
        }

        public void ValidateItems()
        {
            ButtonAddDemoDataToVolumeModel.IsEnabled = addDemoDataCommand.Enabled;
        }

        public bool IsConextualTabVisible(string tabGroupName, string tabName)
        {
            return false;
        }

        public IEnumerable<ICommand> Commands
        {
            get { yield return addDemoDataCommand; }
        }

        private void ButtonAddDemoDataToVolumeModel_OnClick(object sender, RoutedEventArgs e)
        {
            addDemoDataCommand.Execute();
        }
    }
}
{code}

7. 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\]
\\
\\
\\
private void ButtonAddInputDataToVolumeModel_OnClick(object sender, RoutedEventArgs e)
        {
            addInputDataToVolumeModelCommand.Execute();
        }
    }
}

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.

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

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