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
1. Add a new folder to the project named "Commands"

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

3. Add the following contents to this class:

{code}
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 AddDemoDataToVolumeModelCommand : IGuiCommand
    {
        public string Name/// <summary>
        {
/// The name of the gui command
      get { return "Add demo data"; }/// </summary>
        }

        public boolstring EnabledName
        {
            get { return Gui"Add != null && Gui.SelectedModel is VolumeModelinput data"; }
        }

        public Image Image { get; set; }

        public bool Checked { get; set; }

 /// <summary>
        /// Ensures the gui command is enabled for volume models only
        /// </summary>
  public IGui Gui { get; set; }

public bool Enabled
      public void Execute(params object[] arguments)
 {
            get {
 return Gui != null && Gui.Selection is Models.VolumeModel; }
   // Obtain the selected volume model}

        /// <summary>
    var volumeModel = (VolumeModel) Gui.SelectedModel;

     /// The image of the gui command
        /// Create</summary>
 a WaterML2 time series importer
   public Image Image { get; set;  }

  var waterMl2TimeSeriesImporter = new WaterML2TimeSeriesImporter();

   /// <summary>
        /// ImportWhether aor WaterML2 filenot to the precipitationgui timecommand series of the volume modelis checked
        /// </summary>
   waterMl2TimeSeriesImporter.ImportItem(@"..\..\precipitation_waterml.XML", volumeModel.Precipitation);

    /// <remarks>Not relevant in this tutorial</remarks>
   // Create a catchment importer
 public bool Checked { get; set; }

     var catchmentsImporter = new/// CatchmentFromGisImporter<summary>
        /// A reference to {
the Delta Shell gui (automatically set by Delta Shell  logic)
      FileBasedFeatureProviders = new List<IFileBasedFeatureProvider>/// </summary>
        public IGui Gui { get;    {set; }

        /// <summary>
        /// The action new ShapeFile()
       that should be performed while executing the gui command
         }/// </summary>
        public void Execute(params  };
object[] arguments)
        {
            // ConfigureObtain the selected catchmentvolume importermodel
            var catchmentImporterSettingsvolumeModel = catchmentsImporter.FeatureFromGisImporterSettings;
 (Models.VolumeModel) Gui.SelectedModel;

            // Try catchmentImporterSettings.Pathto = @"D:\deltashell\Workshop\SoftwareDaysNov2013\Gemeenten.shp";
      obtain a precipitation file via a file dialog
      catchmentImporterSettings.PropertiesMapping.First(property => property.PropertyName == "Name").MappingColumn.ColumnName = "GM_NAAM";

     var fileDialog = new OpenFileDialog
         // Import a shape file to the basin{
 of the volume model
            catchmentsImporter.ImportItem(null, volumeModel.Basin);
   Title = "Choose precipitation time }

   series",
     public void Unexecute()
        {

     Filter =  }"WaterML2 files|*.XML",
    }
}
{code}

4. Create a new WPF user control named "DemoAppRibbon"&nbsp;\[TODO: Image\]

5. Add the following xaml code:

{code}
<UserControl x:Class="DeltaShell.Plugin.DemoApp.DemoAppRibbon"
                Multiselect = false
                xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
};

            if  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
(fileDialog.ShowDialog() != DialogResult.OK)
            {
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
return;
            }

     xmlns:fluent="clr-namespace:Fluent;assembly=Fluent"
       // Create a WaterML2 time  mc:Ignorable="d"series importer
            var d:DesignHeight="300" d:DesignWidth="300">waterML2TimeSeriesImporter = new WaterML2TimeSeriesImporter();

    <!--Create a ribbon control-->
    <fluent:Ribbon Name="DemoAppRibbonControl" x:FieldModifier="private">
        <!--Create a ribbon tab-->
 // Import the data from the precipitation file
             <fluent:RibbonTabItem Header="Volume model" fluent:KeyTip.Keys="E">waterML2TimeSeriesImporter.ImportItem(fileDialog.FileName, volumeModel.Precipitation);

            <!--Create a ribbon group box-->
      // Try to obtain a shape file via a file dialog
      <fluent:RibbonGroupBox Header="Demo">
     fileDialog = new OpenFileDialog
        <!--Create a ribbon button-->
     {
           <fluent:Button x:Name="ButtonAddDemoDataToVolumeModel"
        Title = "Choose basin shape file",
                    HeaderFilter = "Add demo data"Shape files|*.shp",
                    Multiselect = false
         ToolTip="Add demo data to the selected volume model"};

            if (fileDialog.ShowDialog()   != DialogResult.OK)
            {
   Click="ButtonAddDemoDataToVolumeModel_OnClick"
             return;
            }

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

{code}

6. Additionally, add the following interactionFileBasedFeatureProviders 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.DemoApp.Commands;

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

        public DemoAppRibbon()
        {
   }
         InitializeComponent();
        };

        public object GetRibbonControl()
  // Configure the catchment importer
  {
          var catchmentImporterSettings return= DemoAppRibbonControlcatchmentsImporter.FeatureFromGisImporterSettings;
        }

    catchmentImporterSettings.Path    public void ValidateItems()= fileDialog.FileName;
        {
    catchmentImporterSettings.PropertiesMapping.First(property => property.PropertyName      ButtonAddDemoDataToVolumeModel.IsEnabled = addDemoDataCommand.Enabled;
== "Name").MappingColumn.ColumnName = "GM_NAAM";

        }

    // Import the data publicfrom boolthe IsConextualTabVisible(string tabGroupName, string tabName)shape file
        {
            return falsecatchmentsImporter.ImportItem(null, volumeModel.Basin);
        }

        public IEnumerable<ICommand> Commands/// <summary>
        {
/// The action that should be performed in order to undo execute getactions {of yieldthe return addDemoDataCommand; }gui command
        }
/// </summary>
        private/// void ButtonAddDemoDataToVolumeModel_OnClick(object sender, RoutedEventArgs e)<remarks>Not relevant in this tutorial</remarks>
        {
public void Unexecute()
          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\]

\\

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

        /// <summary>
        /// Actions to be performed after clicking the AddInputDataToVolumeModel button
        /// </summary>
        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(); }
        }