├── AddMaterials
    ├── Resources
    │   └── delete.png
    ├── Properties
    │   ├── ._AssemblyInfo.cs
    │   ├── AssemblyInfo.cs
    │   ├── Resources.Designer.cs
    │   └── Resources.resx
    ├── ViewModel
    │   ├── Enum
    │   │   └── Status.cs
    │   ├── Events
    │   │   └── DialogCloseEventArgs.cs
    │   ├── ViewModelLocator.cs
    │   ├── FillPatternViewModel.cs
    │   ├── MaterialViewModel.cs
    │   ├── FillPatternsViewModel.cs
    │   └── MaterialBrowserViewModel.cs
    ├── View
    │   ├── FillPatternsView.xaml.cs
    │   ├── Converters
    │   │   ├── StatusToErrorSignVisibilityConverter.cs
    │   │   ├── InversedStatusToErrorSignVisibilityConverter.cs
    │   │   ├── StatusToErrorMessageConverter.cs
    │   │   ├── BitmapToImageSourceConverter.cs
    │   │   └── BitmapSourceConverter.cs
    │   ├── MaterialsView.xaml.cs
    │   ├── Controls
    │   │   ├── FillPatternViewerControlWpf.xaml
    │   │   └── FillPatternViewerControlWpf.xaml.cs
    │   ├── Commands
    │   │   └── RelayCommand.cs
    │   ├── FillPatternsView.xaml
    │   └── MaterialsView.xaml
    ├── AddMaterials.addin
    ├── FillPatternBenchmarkCommand.cs
    ├── AddMaterials.csproj
    └── Command.cs
├── AddMaterials.sln
├── README.md
├── .gitignore
└── LICENSE


/AddMaterials/Resources/delete.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jeremytammik/AddMaterials/HEAD/AddMaterials/Resources/delete.png


--------------------------------------------------------------------------------
/AddMaterials/Properties/._AssemblyInfo.cs:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jeremytammik/AddMaterials/HEAD/AddMaterials/Properties/._AssemblyInfo.cs


--------------------------------------------------------------------------------
/AddMaterials/ViewModel/Enum/Status.cs:
--------------------------------------------------------------------------------
 1 | namespace AddMaterials.ViewModel.Enum
 2 | {
 3 |     public enum Status
 4 |     {
 5 |         Normal,
 6 | 
 7 |         BaseMaterialClassNotFound,
 8 | 
 9 |         ProjectAlreadyContainsMaterialWithTheSameName
10 |     }
11 | }


--------------------------------------------------------------------------------
/AddMaterials/ViewModel/Events/DialogCloseEventArgs.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace AddMaterials.ViewModel.Events
 4 | {
 5 |     public class DialogCloseEventArgs : EventArgs
 6 |     {
 7 |         private readonly bool? result;
 8 | 
 9 |         public DialogCloseEventArgs(bool? result)
10 |         {
11 |             this.result = result;
12 |         }
13 | 
14 |         public bool? Result
15 |         {
16 |             get { return result; }
17 |         }
18 |     }
19 | }


--------------------------------------------------------------------------------
/AddMaterials/ViewModel/ViewModelLocator.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace AddMaterials.ViewModel
 4 | {
 5 |     public class ViewModelLocator
 6 |     {
 7 |         private static readonly Lazy<ViewModelLocator> InstanceObj =
 8 |             new Lazy<ViewModelLocator>(() => new ViewModelLocator());
 9 | 
10 |         public static ViewModelLocator Instance
11 |         {
12 |             get { return InstanceObj.Value; }
13 |         }
14 | 
15 |         private ViewModelLocator()
16 |         {
17 |             
18 |         }
19 |     }
20 | }


--------------------------------------------------------------------------------
/AddMaterials/ViewModel/FillPatternViewModel.cs:
--------------------------------------------------------------------------------
 1 | using Autodesk.Revit.DB;
 2 | 
 3 | namespace AddMaterials.ViewModel
 4 | {
 5 |     public class FillPatternViewModel
 6 |     {
 7 |         private readonly FillPattern _fillPattern;
 8 | 
 9 |         public FillPatternViewModel(FillPattern fillPattern)
10 |         {
11 |             _fillPattern = fillPattern;
12 |         }
13 | 
14 |         public FillPattern FillPattern
15 |         {
16 |             get { return _fillPattern; }
17 |         }
18 | 
19 |         public string Name
20 |         {
21 |             get { return _fillPattern.Name; }
22 |         }
23 |     }
24 | }


--------------------------------------------------------------------------------
/AddMaterials/ViewModel/MaterialViewModel.cs:
--------------------------------------------------------------------------------
 1 | using AddMaterials.ViewModel.Enum;
 2 | using Autodesk.Revit.DB;
 3 | 
 4 | namespace AddMaterials.ViewModel
 5 | {
 6 |     public class MaterialViewModel
 7 |     {
 8 |         public string Name { get; set; }
 9 | 
10 |         public string BaseMaterialClass { get; set; }
11 | 
12 |         public FillPattern SurfacePattern { get; set; }
13 | 
14 |         public FillPattern CutPattern { get; set; }
15 | 
16 |         public Color Color { get; set; }
17 | 
18 |         public double Transparency { get; set; }
19 | 
20 |         public Status Status { get; set; }
21 | 
22 |         public bool AddToProject { get; set; }
23 |     }
24 | }


--------------------------------------------------------------------------------
/AddMaterials/ViewModel/FillPatternsViewModel.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections;
 2 | using System.Collections.Generic;
 3 | using System.Collections.ObjectModel;
 4 | 
 5 | namespace AddMaterials.ViewModel
 6 | {
 7 |     public class FillPatternsViewModel
 8 |     {
 9 |         private ReadOnlyCollection<FillPatternViewModel> _fillPatterns;
10 | 
11 |         public FillPatternsViewModel(IEnumerable<FillPatternViewModel> fillPatterns)
12 |         {
13 |             _fillPatterns = new ReadOnlyCollection<FillPatternViewModel>(new List<FillPatternViewModel>(fillPatterns));
14 |         }
15 | 
16 |         public ReadOnlyCollection<FillPatternViewModel> FillPatterns
17 |         {
18 |             get { return _fillPatterns; }
19 |         }
20 |     }
21 | }


--------------------------------------------------------------------------------
/AddMaterials/View/FillPatternsView.xaml.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Linq;
 4 | using System.Text;
 5 | using System.Windows;
 6 | using System.Windows.Controls;
 7 | using System.Windows.Data;
 8 | using System.Windows.Documents;
 9 | using System.Windows.Input;
10 | using System.Windows.Media;
11 | using System.Windows.Media.Imaging;
12 | using System.Windows.Navigation;
13 | using System.Windows.Shapes;
14 | 
15 | namespace AddMaterials.View
16 | {
17 |     /// <summary>
18 |     /// Interaction logic for FillPatternsView.xaml
19 |     /// </summary>
20 |     public partial class FillPatternsView 
21 |     {
22 |         public FillPatternsView()
23 |         {
24 |             InitializeComponent();
25 |         }
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/AddMaterials/View/Converters/StatusToErrorSignVisibilityConverter.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Globalization;
 3 | using System.Windows;
 4 | using System.Windows.Data;
 5 | using AddMaterials.ViewModel.Enum;
 6 | 
 7 | namespace AddMaterials.View.Converters
 8 | {
 9 |     public class StatusToErrorSignVisibilityConverter : IValueConverter
10 |     {
11 |         public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
12 |         {
13 |             if (!(value is Status))
14 |                 return Visibility.Collapsed;
15 |             var status = (Status) value;
16 | 
17 |             return status != Status.Normal ? Visibility.Visible : Visibility.Collapsed;
18 |         }
19 | 
20 |         public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
21 |         {
22 |             throw new NotSupportedException();
23 |         }
24 |     }
25 | }


--------------------------------------------------------------------------------
/AddMaterials/View/Converters/InversedStatusToErrorSignVisibilityConverter.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Globalization;
 3 | using System.Windows;
 4 | using System.Windows.Data;
 5 | 
 6 | namespace AddMaterials.View.Converters
 7 | {
 8 |     public class InversedStatusToErrorSignVisibilityConverter : IValueConverter
 9 |     {
10 |         public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
11 |         {
12 |             var converter = new StatusToErrorSignVisibilityConverter();
13 |             var converted = (Visibility)converter.Convert(value, targetType, parameter, culture);
14 |             return converted == Visibility.Visible ? Visibility.Collapsed : Visibility.Visible;
15 |         }
16 | 
17 |         public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
18 |         {
19 |             throw new NotSupportedException();
20 |         }
21 |     }
22 | }


--------------------------------------------------------------------------------
/AddMaterials.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 11.00
 3 | # Visual Studio 2010
 4 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AddMaterials", "AddMaterials\AddMaterials.csproj", "{CC6FB9CE-8D9C-494C-BA77-29961459647B}"
 5 | EndProject
 6 | Global
 7 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 8 | 		Debug|Any CPU = Debug|Any CPU
 9 | 		Release|Any CPU = Release|Any CPU
10 | 	EndGlobalSection
11 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
12 | 		{CC6FB9CE-8D9C-494C-BA77-29961459647B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
13 | 		{CC6FB9CE-8D9C-494C-BA77-29961459647B}.Debug|Any CPU.Build.0 = Debug|Any CPU
14 | 		{CC6FB9CE-8D9C-494C-BA77-29961459647B}.Release|Any CPU.ActiveCfg = Release|Any CPU
15 | 		{CC6FB9CE-8D9C-494C-BA77-29961459647B}.Release|Any CPU.Build.0 = Release|Any CPU
16 | 	EndGlobalSection
17 | 	GlobalSection(SolutionProperties) = preSolution
18 | 		HideSolutionNode = FALSE
19 | 	EndGlobalSection
20 | EndGlobal
21 | 


--------------------------------------------------------------------------------
/AddMaterials/AddMaterials.addin:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <RevitAddIns>
 3 |   <AddIn Type="Command">
 4 |     <Text>AddMaterials</Text>
 5 |     <Description>Some description for AddMaterials</Description>
 6 |     <Assembly>AddMaterials.dll</Assembly>
 7 |     <FullClassName>AddMaterials.Command</FullClassName>
 8 |     <ClientId>a9ec88c8-33a3-4a4d-bb91-e0cb54623b34</ClientId>
 9 |     <VendorId>TBC_</VendorId>
10 |     <VendorDescription>The Building Coder, http://thebuildingcoder.typepad.com</VendorDescription>
11 |   </AddIn>
12 |   <AddIn Type="Command">
13 |     <Text>AddMaterials Fill Pattern benchmark</Text>
14 |     <Description>Some description for AddMaterials</Description>
15 |     <Assembly>AddMaterials.dll</Assembly>
16 |     <FullClassName>AddMaterials.FillPatternBenchmarkCommand</FullClassName>
17 |     <ClientId>ff23fb73-8f11-4c93-b867-9a599a73dd53</ClientId>
18 |     <VendorId>TBC_</VendorId>
19 |     <VendorDescription>The Building Coder, http://thebuildingcoder.typepad.com</VendorDescription>
20 |   </AddIn>
21 | </RevitAddIns>
22 | 


--------------------------------------------------------------------------------
/AddMaterials/View/MaterialsView.xaml.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Windows;
 3 | using AddMaterials.ViewModel;
 4 | using AddMaterials.ViewModel.Events;
 5 | 
 6 | namespace AddMaterials.View
 7 | {
 8 |     /// <summary>
 9 |     /// Interaction logic for MaterialsView.xaml
10 |     /// </summary>
11 |     public partial class MaterialsView
12 |     {
13 |         public MaterialsView()
14 |         {
15 |             InitializeComponent();
16 |             DataContextChanged += OnDataContextChanged;
17 |         }
18 | 
19 |         private void OnDataContextChanged(object sender, DependencyPropertyChangedEventArgs e)
20 |         {
21 |             var materialBrowser = e.NewValue as MaterialBrowserViewModel;
22 |             if (materialBrowser != null)
23 |                 materialBrowser.RequestClose += OnRequestClose;
24 |         }
25 | 
26 |         private void OnRequestClose(object sender, DialogCloseEventArgs e)
27 |         {
28 |             try
29 |             {
30 |                 DialogResult = e.Result;
31 |             }
32 |             catch (InvalidOperationException)
33 |             {
34 |                 Close();
35 |             }
36 |         }
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/AddMaterials/View/Converters/StatusToErrorMessageConverter.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Globalization;
 3 | using System.Windows.Data;
 4 | using AddMaterials.ViewModel.Enum;
 5 | 
 6 | namespace AddMaterials.View.Converters
 7 | {
 8 |     public class StatusToErrorMessageConverter : IValueConverter
 9 |     {
10 |         public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
11 |         {
12 |             if (!(value is Status))
13 |                 return string.Empty;
14 |             var status = (Status) value;
15 |             switch (status)
16 |             {
17 |                 case Status.ProjectAlreadyContainsMaterialWithTheSameName:
18 |                     return "Project already contains material with the same name";
19 |                 case Status.BaseMaterialClassNotFound:
20 |                     return "Base material class not found in the project";
21 |                 default:
22 |                     return string.Empty;
23 |             }
24 |         }
25 | 
26 |         public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
27 |         {
28 |             throw new NotSupportedException();
29 |         }
30 |     }
31 | }


--------------------------------------------------------------------------------
/AddMaterials/View/Controls/FillPatternViewerControlWpf.xaml:
--------------------------------------------------------------------------------
 1 | <UserControl
 2 |   x:Class="AddMaterials.View.Controls.FillPatternViewerControlWpf"
 3 |   xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 4 |   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 5 |   xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
 6 |   xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
 7 |   xmlns:Converters="clr-namespace:AddMaterials.View.Converters"
 8 |   mc:Ignorable="d"
 9 |   d:DesignHeight="300" d:DesignWidth="300">
10 | 
11 |   <Grid Name="_grid"
12 |         ToolTip="{Binding Path=FillPattern.Name, 
13 |           RelativeSource={RelativeSource 
14 |             AncestorType={x:Type UserControl}}}">
15 | 
16 |     <Grid.Resources>
17 |       <Converters:BitmapToImageSourceConverter
18 |         x:Key="BitmapToImageSourceConverter"/>
19 | 
20 |     </Grid.Resources>
21 |     <Image Source="{Binding Path=FillPatternImage, 
22 |              RelativeSource={RelativeSource 
23 |              AncestorType={x:Type UserControl}},                 
24 |              Converter={StaticResource BitmapToImageSourceConverter}}"
25 |            Stretch="None"/>
26 | 
27 |   </Grid>
28 | </UserControl>
29 | 


--------------------------------------------------------------------------------
/AddMaterials/ViewModel/MaterialBrowserViewModel.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Windows.Input;
 4 | using AddMaterials.View.Commands;
 5 | using AddMaterials.ViewModel.Events;
 6 | 
 7 | namespace AddMaterials.ViewModel
 8 | {
 9 |     public class MaterialBrowserViewModel
10 |     {
11 |         public event EventHandler<DialogCloseEventArgs> RequestClose;
12 | 
13 |         protected void OnRequestClose(DialogCloseEventArgs e)
14 |         {
15 |             EventHandler<DialogCloseEventArgs> handler = RequestClose;
16 |             if (handler != null) handler(this, e);
17 |         }
18 | 
19 |         protected void Close(bool? result)
20 |         {
21 |             OnRequestClose(new DialogCloseEventArgs(result));
22 |         }
23 | 
24 |         public IEnumerable<MaterialViewModel> Materials { get; set; }
25 | 
26 |         private ICommand okCommand;
27 |         public ICommand OkCommand
28 |         {
29 |             get { return okCommand ?? (okCommand = new RelayCommand(o => Close(true))); }
30 |         }
31 | 
32 |         private ICommand cancelCommand;
33 |         public ICommand CancelCommand
34 |         {
35 |             get { return cancelCommand ?? (cancelCommand = new RelayCommand(o => Close(false))); }
36 |         }
37 |     }
38 | }


--------------------------------------------------------------------------------
/AddMaterials/View/Converters/BitmapToImageSourceConverter.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Drawing;
 3 | using System.Globalization;
 4 | using System.Windows.Data;
 5 | 
 6 | namespace AddMaterials.View.Converters
 7 | {
 8 |     public class BitmapToImageSourceConverter : IValueConverter
 9 |     {
10 |         private static readonly Lazy<BitmapToImageSourceConverter> InstanceObj =
11 |            new Lazy<BitmapToImageSourceConverter>(() => new BitmapToImageSourceConverter());
12 | 
13 |         public static BitmapToImageSourceConverter Instance
14 |         {
15 |             get { return InstanceObj.Value; }
16 |         }
17 | 
18 |         public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
19 |         {
20 |             var bmp = value as Bitmap;
21 |             if (bmp == null)
22 |             {
23 |                 var defaultBmp = parameter as Bitmap;
24 |                 if (defaultBmp != null)
25 |                     return BitmapSourceConverter.ConvertFromImage(defaultBmp);
26 |             }
27 | 
28 |             return bmp == null ? null : BitmapSourceConverter.ConvertFromImage(bmp);
29 |         }
30 | 
31 |         public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
32 |         {
33 |             throw new NotSupportedException();
34 |         }
35 |     }
36 | }


--------------------------------------------------------------------------------
/AddMaterials/FillPatternBenchmarkCommand.cs:
--------------------------------------------------------------------------------
 1 | using System.Linq;
 2 | using System.Windows.Input;
 3 | using AddMaterials.View;
 4 | using AddMaterials.ViewModel;
 5 | using Autodesk.Revit.Attributes;
 6 | using Autodesk.Revit.DB;
 7 | using Autodesk.Revit.UI;
 8 | 
 9 | namespace AddMaterials
10 | {
11 |   [Transaction( TransactionMode.ReadOnly )]
12 |   public class FillPatternBenchmarkCommand 
13 |     : IExternalCommand
14 |   {
15 |     public Result Execute( 
16 |       ExternalCommandData commandData,
17 |       ref string message,
18 |       ElementSet elements )
19 |     {
20 |       var doc = commandData.Application
21 |         .ActiveUIDocument.Document;
22 | 
23 |       var fillPatternElements 
24 |         = new FilteredElementCollector( doc )
25 |           .OfClass( typeof( FillPatternElement ) )
26 |           .OfType<FillPatternElement>()
27 |           .OrderBy( fp => fp.Name )
28 |           .ToList();
29 | 
30 |       var fillPatterns 
31 |         = fillPatternElements.Select( 
32 |           fpe => fpe.GetFillPattern() );
33 | 
34 |       FillPatternsViewModel fillPatternsViewModel 
35 |         = new FillPatternsViewModel( fillPatterns
36 |           .Select( x => new FillPatternViewModel( 
37 |             x ) ) );
38 | 
39 |       FillPatternsView fillPatternsView 
40 |         = new FillPatternsView()
41 |       {
42 |         DataContext = fillPatternsViewModel
43 |       };
44 | 
45 |       fillPatternsView.ShowDialog();
46 | 
47 |       return Result.Succeeded;
48 |     }
49 |   }
50 | }
51 | 


--------------------------------------------------------------------------------
/AddMaterials/View/Commands/RelayCommand.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Diagnostics;
 3 | using System.Windows.Input;
 4 | 
 5 | 
 6 | namespace AddMaterials.View.Commands
 7 | {
 8 |     public class RelayCommand : ICommand
 9 |     {
10 |         private readonly Action<object> execute;
11 |         private readonly Predicate<object> canExecute;
12 | 
13 |         /// <summary>
14 |         /// Creates a new command that can always execute.
15 |         /// </summary>
16 |         /// <param name="execute">The execution logic.</param>
17 |         public RelayCommand(Action<object> execute)
18 |             : this(execute, null)
19 |         {
20 |         }
21 | 
22 |         /// <summary>
23 |         /// Creates a new command.
24 |         /// </summary>
25 |         /// <param name="execute">The execution logic.</param>
26 |         /// <param name="canExecute">The execution status logic.</param>
27 |         public RelayCommand(Action<object> execute, Predicate<object> canExecute)
28 |         {
29 |             if (execute == null)
30 |                 throw new ArgumentNullException("execute");
31 | 
32 |             this.execute = execute;
33 |             this.canExecute = canExecute;
34 |         }
35 | 
36 |         [DebuggerStepThrough]
37 |         public bool CanExecute(object parameter)
38 |         {
39 |             return canExecute == null || canExecute(parameter);
40 |         }
41 | 
42 |         public event EventHandler CanExecuteChanged
43 |         {
44 |             add { CommandManager.RequerySuggested += value; }
45 |             remove { CommandManager.RequerySuggested -= value; }
46 |         }
47 | 
48 |         public void Execute(object parameter)
49 |         {
50 |             execute(parameter);
51 |         }
52 |     }
53 | }


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # AddMaterials
 2 | 
 3 | Revit add-in to add materials from a list of properties defined in Excel.
 4 | 
 5 | For more information, please refer to [The Building Coder](http://thebuildingcoder.typepad.com):
 6 | 
 7 | - [Original implementation for Revit 2011](http://thebuildingcoder.typepad.com/blog/2010/08/add-new-materials-from-list.html#2)
 8 | - [Reimplementation for Revit 2014](http://thebuildingcoder.typepad.com/blog/2014/03/adding-new-materials-from-list-updated.html)
 9 | - [Improved error messages and reporting](http://thebuildingcoder.typepad.com/blog/2014/03/adding-new-materials-from-list-updated-again.html)
10 | - [WPF FillPattern viewer control](http://thebuildingcoder.typepad.com/blog/2014/04/wpf-fill-pattern-viewer-control.html)
11 | - [Check for already loaded materials](http://thebuildingcoder.typepad.com/blog/2014/04/getting-serious-adding-new-materials-from-list.html)
12 | - [FillPattern viewer benchmarking](http://thebuildingcoder.typepad.com/blog/2014/04/wpf-fill-pattern-viewer-control-benchmark.html)
13 | - [Fill Pattern Viewer Fix and Add Materials for 2016](http://thebuildingcoder.typepad.com/blog/2015/11/fill-pattern-viewer-fix-and-add-materials-2016.html)
14 | 
15 | ## Authors
16 | 
17 | - Jinsol Kim
18 | - Luke
19 | - Victor Chekalin, Виктор Чекалин
20 | - Alexander Ignatovich, Александр Игнатович
21 | - [@kfpopeye](https://github.com/kfpopeye)
22 | - Jeremy Tammik,
23 | [The Building Coder](http://thebuildingcoder.typepad.com) and
24 | [The 3D Web Coder](http://the3dwebcoder.typepad.com),
25 | [ADN](http://www.autodesk.com/adn)
26 | [Open](http://www.autodesk.com/adnopen),
27 | [Autodesk Inc.](http://www.autodesk.com)
28 | 
29 | 
30 | ## License
31 | 
32 | This sample is licensed under the terms of the [Apache License](http://www.apache.org/licenses).
33 | Please see the [LICENSE](LICENSE) file for full details.
34 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | # Build Folders (you can keep bin if you'd like, to store dlls and pdbs)
  2 | [Bb]in/
  3 | [Oo]bj/
  4 | 
  5 | # mstest test results
  6 | TestResults
  7 | 
  8 | ## Ignore Visual Studio temporary files, build results, and
  9 | ## files generated by popular Visual Studio add-ons.
 10 | 
 11 | # User-specific files
 12 | *.suo
 13 | *.user
 14 | *.sln.docstates
 15 | 
 16 | # Build results
 17 | [Dd]ebug/
 18 | [Rr]elease/
 19 | x64/
 20 | *_i.c
 21 | *_p.c
 22 | *.ilk
 23 | *.meta
 24 | *.obj
 25 | *.pch
 26 | *.pdb
 27 | *.pgc
 28 | *.pgd
 29 | *.rsp
 30 | *.sbr
 31 | *.tlb
 32 | *.tli
 33 | *.tlh
 34 | *.tmp
 35 | *.log
 36 | *.vspscc
 37 | *.vssscc
 38 | .builds
 39 | 
 40 | # Visual C++ cache files
 41 | ipch/
 42 | *.aps
 43 | *.ncb
 44 | *.opensdf
 45 | *.sdf
 46 | 
 47 | # Visual Studio profiler
 48 | *.psess
 49 | *.vsp
 50 | *.vspx
 51 | 
 52 | # Guidance Automation Toolkit
 53 | *.gpState
 54 | 
 55 | # ReSharper is a .NET coding add-in
 56 | _ReSharper*
 57 | 
 58 | # NCrunch
 59 | *.ncrunch*
 60 | .*crunch*.local.xml
 61 | 
 62 | # Installshield output folder 
 63 | [Ee]xpress
 64 | 
 65 | # DocProject is a documentation generator add-in
 66 | DocProject/buildhelp/
 67 | DocProject/Help/*.HxT
 68 | DocProject/Help/*.HxC
 69 | DocProject/Help/*.hhc
 70 | DocProject/Help/*.hhk
 71 | DocProject/Help/*.hhp
 72 | DocProject/Help/Html2
 73 | DocProject/Help/html
 74 | 
 75 | # Click-Once directory
 76 | publish
 77 | 
 78 | # Publish Web Output
 79 | *.Publish.xml
 80 | 
 81 | # NuGet Packages Directory
 82 | packages
 83 | 
 84 | # Windows Azure Build Output
 85 | csx
 86 | *.build.csdef
 87 | 
 88 | # Windows Store app package directory
 89 | AppPackages/
 90 | 
 91 | # Others
 92 | [Bb]in
 93 | [Oo]bj
 94 | sql
 95 | TestResults
 96 | [Tt]est[Rr]esult*
 97 | *.Cache
 98 | ClientBin
 99 | [Ss]tyle[Cc]op.*
100 | ~$*
101 | *.dbmdl
102 | Generated_Code #added for RIA/Silverlight projects
103 | 
104 | # Backup & report files from converting an old project file to a newer
105 | # Visual Studio version. Backup files are not needed, because we have git ;-)
106 | _UpgradeReport_Files/
107 | Backup*/
108 | UpgradeLog*.XML
109 | 


--------------------------------------------------------------------------------
/AddMaterials/View/Converters/BitmapSourceConverter.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Drawing;
 3 | using System.Windows;
 4 | using System.Windows.Interop;
 5 | using System.Windows.Media.Imaging;
 6 | namespace AddMaterials.View.Converters
 7 | {
 8 |     public class BitmapSourceConverter
 9 |     {
10 |         [System.Runtime.InteropServices.DllImport("gdi32.dll")]
11 |         private static extern bool DeleteObject(IntPtr hObject);
12 | 
13 |         public static BitmapSource ConvertFromImage(Bitmap image)
14 |         {
15 |             lock (image)
16 |             {
17 |                 IntPtr hBitmap = image.GetHbitmap();
18 |                 try
19 |                 {
20 |                     var bs = Imaging.CreateBitmapSourceFromHBitmap(
21 |                         hBitmap,
22 |                         IntPtr.Zero,
23 |                         Int32Rect.Empty,
24 |                         BitmapSizeOptions.FromEmptyOptions());
25 | 
26 |                     return bs;
27 |                 }
28 |                 finally
29 |                 {
30 |                     // ReSharper disable UnusedVariable
31 |                     var res = DeleteObject(hBitmap);
32 |                     // ReSharper restore UnusedVariable
33 |                 }
34 |             }
35 |         }
36 | 
37 |         public static BitmapSource ConvertFromIcon(Icon icon)
38 |         {
39 | 
40 |             try
41 |             {
42 |                 var bs = Imaging
43 |                     .CreateBitmapSourceFromHIcon(icon.Handle,
44 |                                                  new Int32Rect(0, 0, icon.Width, icon.Height),
45 |                                                  BitmapSizeOptions.FromWidthAndHeight(icon.Width,
46 |                                                                                       icon.Height));
47 |                 return bs;
48 |             }
49 |             finally
50 |             {
51 |                 DeleteObject(icon.Handle);
52 |                 icon.Dispose();
53 |                 // ReSharper disable RedundantAssignment
54 |                 icon = null;
55 |                 // ReSharper restore RedundantAssignment
56 |             }
57 |         }
58 |     }
59 | }


--------------------------------------------------------------------------------
/AddMaterials/Properties/AssemblyInfo.cs:
--------------------------------------------------------------------------------
 1 | using System.Reflection;
 2 | using System.Runtime.CompilerServices;
 3 | using System.Runtime.InteropServices;
 4 | 
 5 | // General Information about an assembly is controlled through the following
 6 | // set of attributes. Change these attribute values to modify the information
 7 | // associated with an assembly.
 8 | [assembly: AssemblyTitle( "Revit AddMaterials Add-In" )]
 9 | [assembly: AssemblyDescription( "Add materials from Excel spreadsheet to Revit project" )]
10 | [assembly: AssemblyConfiguration( "" )]
11 | [assembly: AssemblyCompany( "Autodesk Inc." )]
12 | [assembly: AssemblyProduct( "Revit AddMaterials Add-In" )]
13 | [assembly: AssemblyCopyright( "Copyright 2014 © Jeremy Tammik Autodesk Inc." )]
14 | [assembly: AssemblyTrademark( "" )]
15 | [assembly: AssemblyCulture( "" )]
16 | 
17 | // Setting ComVisible to false makes the types in this assembly not visible
18 | // to COM components.  If you need to access a type in this assembly from
19 | // COM, set the ComVisible attribute to true on that type.
20 | [assembly: ComVisible( false )]
21 | 
22 | // The following GUID is for the ID of the typelib if this project is exposed to COM
23 | [assembly: Guid( "321044f7-b0b2-4b1c-af18-e71a19252be0" )]
24 | 
25 | // Version information for an assembly consists of the following four values:
26 | //
27 | //      Major Version
28 | //      Minor Version
29 | //      Build Number
30 | //      Revision
31 | //
32 | // You can specify all the values or you can default the Build and Revision Numbers
33 | // by using the '*' as shown below:
34 | // [assembly: AssemblyVersion("1.0.*")]
35 | // 2014-03-20 2014.0.0.0 migrated from Revit 2011 to Revit 2014
36 | // 2014-03-29 2014.0.0.1 error message and reporting enhancements
37 | // 2014-04-02 2014.0.0.2 usability enhancements by Alexander Ignatovich
38 | // 2014-04-20 2015.0.0.2 migrated to Revit 2015
39 | // 2014-04-20 2015.0.0.3 integrated fill pattern viewer benchmark
40 | // 2015-11-04 2015.0.0.4 updated FillPatternViewerControlWpf.xaml.cs, merged pull request #1 by @kfpopeye
41 | // 2015-11-04 2015.0.0.5 updated FillPatternViewerControlWpf.xaml.cs, merged pull request #3 by @kfpopeye
42 | // 2015-11-04 2016.0.0.0 tested and migrated to Revit 2016
43 | // 2019-06-07 2016.0.0.1 integrated pull request #4 by @ridespirals -- handle 0 or negative DashPatterns
44 | // 2019-06-12 2020.0.0.0 flat migration to Revit 2020
45 | // 2019-06-12 2020.0.0.1 implemented suggestion by Александр Пекшев: Replace FillPattern = "{Binding CutPattern}" with FillPattern = "{Binding CutPattern, IsAsync=True}" and drawing thumbnails can get even faster
46 | //
47 | [assembly: AssemblyVersion( "2020.0.0.1" )]
48 | [assembly: AssemblyFileVersion( "2020.0.0.1" )]
49 | 


--------------------------------------------------------------------------------
/AddMaterials/View/FillPatternsView.xaml:
--------------------------------------------------------------------------------
 1 | <Window x:Class="AddMaterials.View.FillPatternsView"
 2 |              xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 3 |              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 4 |              xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
 5 |              xmlns:d="http://schemas.microsoft.com/expression/blend/2008"             
 6 |              xmlns:ViewModel="clr-namespace:AddMaterials.ViewModel"
 7 |              xmlns:Controls="clr-namespace:AddMaterials.View.Controls"
 8 |              xmlns:Converters="clr-namespace:AddMaterials.View.Converters"
 9 |              xmlns:Properties="clr-namespace:AddMaterials.Properties"
10 |              mc:Ignorable="d" 
11 |              Width="300"
12 |              d:DesignHeight="300" d:DesignWidth="300">
13 | 
14 |     <Window.Resources>
15 |         <ResourceDictionary>
16 |             <Converters:BitmapToImageSourceConverter x:Key="bitmapToImageSourceConverter" />
17 |             <Converters:StatusToErrorSignVisibilityConverter x:Key="statusToErrorSignVisibilityConverter" />
18 |             <Converters:InversedStatusToErrorSignVisibilityConverter x:Key="inversedStatusToErrorSignVisibilityConverter" />
19 |             <Converters:StatusToErrorMessageConverter x:Key="statusToErrorMessageConverter" />
20 |         </ResourceDictionary>
21 |     </Window.Resources>
22 | 
23 |     <Grid>
24 |         <ListView ItemsSource="{Binding FillPatterns}">
25 |             <ListView.View>
26 |                 <GridView AllowsColumnReorder="False">
27 |                     <GridViewColumn Header="Pattern Name" 
28 |                                     DisplayMemberBinding="{Binding Name}"/>
29 |                     <GridViewColumn Header="Surface"
30 |                           Width="80">
31 |                         <GridViewColumn.CellTemplate>
32 |                             <DataTemplate DataType
33 |                                 ="{x:Type ViewModel:FillPatternViewModel}">
34 | 
35 |                                 <Border CornerRadius="2" 
36 |                                     BorderThickness="1" 
37 |                                     BorderBrush="Gray">
38 | 
39 |                                     <Controls:FillPatternViewerControlWpf 
40 |                                         HorizontalAlignment="Stretch"
41 |                                         Height="30"
42 |                                         Margin="1,3" 
43 |                                         FillPattern="{Binding FillPattern}"/>
44 | 
45 |                                 </Border>
46 |                             </DataTemplate>
47 |                         </GridViewColumn.CellTemplate>
48 |                     </GridViewColumn>
49 |                 </GridView>
50 |             </ListView.View>
51 |         </ListView>
52 |     </Grid>
53 | </Window>
54 | 


--------------------------------------------------------------------------------
/AddMaterials/Properties/Resources.Designer.cs:
--------------------------------------------------------------------------------
 1 | //------------------------------------------------------------------------------
 2 | // <auto-generated>
 3 | //     This code was generated by a tool.
 4 | //     Runtime Version:4.0.30319.42000
 5 | //
 6 | //     Changes to this file may cause incorrect behavior and will be lost if
 7 | //     the code is regenerated.
 8 | // </auto-generated>
 9 | //------------------------------------------------------------------------------
10 | 
11 | namespace AddMaterials.Properties {
12 |     using System;
13 |     
14 |     
15 |     /// <summary>
16 |     ///   A strongly-typed resource class, for looking up localized strings, etc.
17 |     /// </summary>
18 |     // This class was auto-generated by the StronglyTypedResourceBuilder
19 |     // class via a tool like ResGen or Visual Studio.
20 |     // To add or remove a member, edit your .ResX file then rerun ResGen
21 |     // with the /str option, or rebuild your VS project.
22 |     [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
23 |     [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
24 |     [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
25 |     public class Resources {
26 |         
27 |         private static global::System.Resources.ResourceManager resourceMan;
28 |         
29 |         private static global::System.Globalization.CultureInfo resourceCulture;
30 |         
31 |         [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
32 |         internal Resources() {
33 |         }
34 |         
35 |         /// <summary>
36 |         ///   Returns the cached ResourceManager instance used by this class.
37 |         /// </summary>
38 |         [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
39 |         public static global::System.Resources.ResourceManager ResourceManager {
40 |             get {
41 |                 if (object.ReferenceEquals(resourceMan, null)) {
42 |                     global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("AddMaterials.Properties.Resources", typeof(Resources).Assembly);
43 |                     resourceMan = temp;
44 |                 }
45 |                 return resourceMan;
46 |             }
47 |         }
48 |         
49 |         /// <summary>
50 |         ///   Overrides the current thread's CurrentUICulture property for all
51 |         ///   resource lookups using this strongly typed resource class.
52 |         /// </summary>
53 |         [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
54 |         public static global::System.Globalization.CultureInfo Culture {
55 |             get {
56 |                 return resourceCulture;
57 |             }
58 |             set {
59 |                 resourceCulture = value;
60 |             }
61 |         }
62 |         
63 |         /// <summary>
64 |         ///   Looks up a localized resource of type System.Drawing.Bitmap.
65 |         /// </summary>
66 |         public static System.Drawing.Bitmap Error {
67 |             get {
68 |                 object obj = ResourceManager.GetObject("Error", resourceCulture);
69 |                 return ((System.Drawing.Bitmap)(obj));
70 |             }
71 |         }
72 |     }
73 | }
74 | 


--------------------------------------------------------------------------------
/AddMaterials/View/MaterialsView.xaml:
--------------------------------------------------------------------------------
  1 | <Window x:Class="AddMaterials.View.MaterialsView"
  2 |         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  3 |         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
  4 |         xmlns:ViewModel="clr-namespace:AddMaterials.ViewModel"
  5 |         xmlns:Controls="clr-namespace:AddMaterials.View.Controls"
  6 |         xmlns:Converters="clr-namespace:AddMaterials.View.Converters"
  7 |         xmlns:Properties="clr-namespace:AddMaterials.Properties" Height="400" Width="600"
  8 |         Title="Materials to import"
  9 |         ResizeMode="NoResize">
 10 | 
 11 |   <Window.Resources>
 12 |     <ResourceDictionary>
 13 |       <Converters:BitmapToImageSourceConverter x:Key="bitmapToImageSourceConverter" />
 14 |       <Converters:StatusToErrorSignVisibilityConverter x:Key="statusToErrorSignVisibilityConverter" />
 15 |       <Converters:InversedStatusToErrorSignVisibilityConverter x:Key="inversedStatusToErrorSignVisibilityConverter" />
 16 |       <Converters:StatusToErrorMessageConverter x:Key="statusToErrorMessageConverter" />
 17 |     </ResourceDictionary>
 18 |   </Window.Resources>
 19 | 
 20 |   <Grid>
 21 |     <Grid.RowDefinitions>
 22 |       <RowDefinition Height="*" />
 23 |       <RowDefinition Height="Auto" />
 24 |     </Grid.RowDefinitions>
 25 |     <ListView ItemsSource="{Binding Materials}" Margin="3">
 26 |       <ListView.View>
 27 |         <GridView>
 28 |           <GridViewColumn Width ="30">
 29 |             <GridViewColumn.CellTemplate>
 30 |               <DataTemplate DataType="{x:Type ViewModel:MaterialViewModel}">
 31 |                 <StackPanel Orientation="Horizontal">
 32 |                   <Image Source="{Binding Source={x:Static Properties:Resources.Error},Converter={StaticResource bitmapToImageSourceConverter}}"
 33 |                                            Stretch="None" 
 34 |                                            Visibility="{Binding Status,Converter={StaticResource statusToErrorSignVisibilityConverter}}">
 35 |                     <Image.ToolTip>
 36 |                       <ToolTip>
 37 |                         <TextBlock Text="{Binding Status,Converter={StaticResource statusToErrorMessageConverter}}" />
 38 |                       </ToolTip>
 39 |                     </Image.ToolTip>
 40 |                   </Image>
 41 |                   <CheckBox IsChecked="{Binding AddToProject,Mode=TwoWay}"
 42 |                                               Visibility="{Binding Status,Converter={StaticResource inversedStatusToErrorSignVisibilityConverter}}" />
 43 |                 </StackPanel>
 44 |               </DataTemplate>
 45 |             </GridViewColumn.CellTemplate>
 46 |           </GridViewColumn>
 47 |           <GridViewColumn Header="Material"
 48 |                                     Width="200">
 49 |             <GridViewColumn.CellTemplate>
 50 |               <DataTemplate DataType="{x:Type ViewModel:MaterialViewModel}">
 51 |                 <TextBlock Text="{Binding Name}"
 52 |                                            TextWrapping="Wrap"></TextBlock>
 53 |               </DataTemplate>
 54 |             </GridViewColumn.CellTemplate>
 55 |           </GridViewColumn>
 56 | 
 57 |           <GridViewColumn Header="Surface"
 58 |                           Width="80">
 59 |             
 60 |             <GridViewColumn.CellTemplate>
 61 |               <DataTemplate DataType
 62 |                 ="{x:Type ViewModel:MaterialViewModel}">
 63 |                 
 64 |                 <Border CornerRadius="2" 
 65 |                         BorderThickness="1" 
 66 |                         BorderBrush="Gray">
 67 |                   
 68 |                   <Controls:FillPatternViewerControlWpf 
 69 |                     HorizontalAlignment="Stretch"
 70 |                     Height="30"
 71 |                     Margin="1,3" 
 72 |                     FillPattern="{Binding SurfacePattern}"/>
 73 |                   
 74 |                 </Border>
 75 |               </DataTemplate>
 76 |             </GridViewColumn.CellTemplate>
 77 |           </GridViewColumn>
 78 | 
 79 |           <GridViewColumn Header="Cut"
 80 |                           Width="80">
 81 |             
 82 |             <GridViewColumn.CellTemplate>
 83 |               <DataTemplate DataType
 84 |                 ="{x:Type ViewModel:MaterialViewModel}">
 85 |                 
 86 |                 <Border CornerRadius="2" 
 87 |                         BorderThickness="1" 
 88 |                         BorderBrush="Gray">
 89 |                   
 90 |                   <Controls:FillPatternViewerControlWpf 
 91 |                     HorizontalAlignment="Stretch" 
 92 |                     Height="30" 
 93 |                     Margin="1,3" 
 94 |                     FillPattern="{Binding CutPattern, IsAsync=True}"/>
 95 |                   
 96 |                 </Border>
 97 |               </DataTemplate>
 98 |             </GridViewColumn.CellTemplate>
 99 |           </GridViewColumn>
100 | 
101 |           <GridViewColumn Header="Transparency"
102 |                                     Width="50" DisplayMemberBinding="{Binding Transparency}"></GridViewColumn>
103 | 
104 |           <GridViewColumn Header="Base class"
105 |                                     Width="200">
106 |             <GridViewColumn.CellTemplate>
107 |               <DataTemplate DataType="{x:Type ViewModel:MaterialViewModel}">
108 |                 <TextBlock Text="{Binding BaseMaterialClass}"
109 |                                            TextWrapping="Wrap"></TextBlock>
110 |               </DataTemplate>
111 |             </GridViewColumn.CellTemplate>
112 |           </GridViewColumn>
113 | 
114 |         </GridView>
115 |       </ListView.View>
116 |     </ListView>
117 | 
118 |     <StackPanel Orientation="Horizontal"
119 |                     HorizontalAlignment="Right"
120 |                     Grid.Row="1">
121 |       <Button Content="OK"
122 |                     Width="75"
123 |                     Height="23"
124 |                     TextOptions.TextFormattingMode="Display"
125 |                     Command="{Binding OkCommand}" />
126 |       <Button Content="Cancel"
127 |                     Margin="7"
128 |                     Width="75"
129 |                     Height="23"
130 |                     TextOptions.TextFormattingMode="Display"     
131 |                     Command="{Binding CancelCommand}" />
132 |     </StackPanel>
133 |   </Grid>
134 | </Window>
135 | 


--------------------------------------------------------------------------------
/AddMaterials/Properties/Resources.resx:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <root>
  3 |   <!-- 
  4 |     Microsoft ResX Schema 
  5 |     
  6 |     Version 2.0
  7 |     
  8 |     The primary goals of this format is to allow a simple XML format 
  9 |     that is mostly human readable. The generation and parsing of the 
 10 |     various data types are done through the TypeConverter classes 
 11 |     associated with the data types.
 12 |     
 13 |     Example:
 14 |     
 15 |     ... ado.net/XML headers & schema ...
 16 |     <resheader name="resmimetype">text/microsoft-resx</resheader>
 17 |     <resheader name="version">2.0</resheader>
 18 |     <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
 19 |     <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
 20 |     <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
 21 |     <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
 22 |     <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
 23 |         <value>[base64 mime encoded serialized .NET Framework object]</value>
 24 |     </data>
 25 |     <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
 26 |         <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
 27 |         <comment>This is a comment</comment>
 28 |     </data>
 29 |                 
 30 |     There are any number of "resheader" rows that contain simple 
 31 |     name/value pairs.
 32 |     
 33 |     Each data row contains a name, and value. The row also contains a 
 34 |     type or mimetype. Type corresponds to a .NET class that support 
 35 |     text/value conversion through the TypeConverter architecture. 
 36 |     Classes that don't support this are serialized and stored with the 
 37 |     mimetype set.
 38 |     
 39 |     The mimetype is used for serialized objects, and tells the 
 40 |     ResXResourceReader how to depersist the object. This is currently not 
 41 |     extensible. For a given mimetype the value must be set accordingly:
 42 |     
 43 |     Note - application/x-microsoft.net.object.binary.base64 is the format 
 44 |     that the ResXResourceWriter will generate, however the reader can 
 45 |     read any of the formats listed below.
 46 |     
 47 |     mimetype: application/x-microsoft.net.object.binary.base64
 48 |     value   : The object must be serialized with 
 49 |             : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
 50 |             : and then encoded with base64 encoding.
 51 |     
 52 |     mimetype: application/x-microsoft.net.object.soap.base64
 53 |     value   : The object must be serialized with 
 54 |             : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
 55 |             : and then encoded with base64 encoding.
 56 | 
 57 |     mimetype: application/x-microsoft.net.object.bytearray.base64
 58 |     value   : The object must be serialized into a byte array 
 59 |             : using a System.ComponentModel.TypeConverter
 60 |             : and then encoded with base64 encoding.
 61 |     -->
 62 |   <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
 63 |     <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
 64 |     <xsd:element name="root" msdata:IsDataSet="true">
 65 |       <xsd:complexType>
 66 |         <xsd:choice maxOccurs="unbounded">
 67 |           <xsd:element name="metadata">
 68 |             <xsd:complexType>
 69 |               <xsd:sequence>
 70 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" />
 71 |               </xsd:sequence>
 72 |               <xsd:attribute name="name" use="required" type="xsd:string" />
 73 |               <xsd:attribute name="type" type="xsd:string" />
 74 |               <xsd:attribute name="mimetype" type="xsd:string" />
 75 |               <xsd:attribute ref="xml:space" />
 76 |             </xsd:complexType>
 77 |           </xsd:element>
 78 |           <xsd:element name="assembly">
 79 |             <xsd:complexType>
 80 |               <xsd:attribute name="alias" type="xsd:string" />
 81 |               <xsd:attribute name="name" type="xsd:string" />
 82 |             </xsd:complexType>
 83 |           </xsd:element>
 84 |           <xsd:element name="data">
 85 |             <xsd:complexType>
 86 |               <xsd:sequence>
 87 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
 88 |                 <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
 89 |               </xsd:sequence>
 90 |               <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
 91 |               <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
 92 |               <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
 93 |               <xsd:attribute ref="xml:space" />
 94 |             </xsd:complexType>
 95 |           </xsd:element>
 96 |           <xsd:element name="resheader">
 97 |             <xsd:complexType>
 98 |               <xsd:sequence>
 99 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
100 |               </xsd:sequence>
101 |               <xsd:attribute name="name" type="xsd:string" use="required" />
102 |             </xsd:complexType>
103 |           </xsd:element>
104 |         </xsd:choice>
105 |       </xsd:complexType>
106 |     </xsd:element>
107 |   </xsd:schema>
108 |   <resheader name="resmimetype">
109 |     <value>text/microsoft-resx</value>
110 |   </resheader>
111 |   <resheader name="version">
112 |     <value>2.0</value>
113 |   </resheader>
114 |   <resheader name="reader">
115 |     <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
116 |   </resheader>
117 |   <resheader name="writer">
118 |     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
119 |   </resheader>
120 |   <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
121 |   <data name="Error" type="System.Resources.ResXFileRef, System.Windows.Forms">
122 |     <value>..\Resources\delete.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
123 |   </data>
124 | </root>


--------------------------------------------------------------------------------
/AddMaterials/AddMaterials.csproj:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  3 |   <PropertyGroup>
  4 |     <ResolveAssemblyWarnOrErrorOnTargetArchitectureMismatch>
  5 |       None
  6 |     </ResolveAssemblyWarnOrErrorOnTargetArchitectureMismatch>
  7 |     <TargetFrameworkProfile />
  8 |   </PropertyGroup>
  9 |   <PropertyGroup>
 10 |     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
 11 |     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
 12 |     <ProductVersion>
 13 |     </ProductVersion>
 14 |     <SchemaVersion>
 15 |     </SchemaVersion>
 16 |     <ProjectGuid>{CC6FB9CE-8D9C-494C-BA77-29961459647B}</ProjectGuid>
 17 |     <OutputType>Library</OutputType>
 18 |     <AppDesignerFolder>Properties</AppDesignerFolder>
 19 |     <RootNamespace>AddMaterials</RootNamespace>
 20 |     <TargetFrameworkVersion>v4.7</TargetFrameworkVersion>
 21 |     <FileAlignment>512</FileAlignment>
 22 |   </PropertyGroup>
 23 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
 24 |     <DebugSymbols>true</DebugSymbols>
 25 |     <DebugType>full</DebugType>
 26 |     <Optimize>false</Optimize>
 27 |     <OutputPath>bin\Debug\</OutputPath>
 28 |     <DefineConstants>DEBUG;TRACE</DefineConstants>
 29 |     <ErrorReport>prompt</ErrorReport>
 30 |     <WarningLevel>4</WarningLevel>
 31 |     <StartAction>Program</StartAction>
 32 |     <StartProgram>$(ProgramW6432)\Autodesk\Revit 2014\Revit.exe</StartProgram>
 33 |     <Prefer32Bit>false</Prefer32Bit>
 34 |   </PropertyGroup>
 35 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
 36 |     <DebugType>pdbonly</DebugType>
 37 |     <Optimize>true</Optimize>
 38 |     <OutputPath>bin\Release\</OutputPath>
 39 |     <DefineConstants>TRACE</DefineConstants>
 40 |     <ErrorReport>prompt</ErrorReport>
 41 |     <WarningLevel>4</WarningLevel>
 42 |     <StartAction>Program</StartAction>
 43 |     <StartProgram>$(ProgramW6432)\Autodesk\Revit 2014\Revit.exe</StartProgram>
 44 |     <Prefer32Bit>false</Prefer32Bit>
 45 |   </PropertyGroup>
 46 |   <ItemGroup>
 47 |     <Reference Include="Microsoft.CSharp" />
 48 |     <Reference Include="Microsoft.Office.Interop.Excel1">
 49 |       <HintPath>..\..\..\lib\revit\2020\SDK\Samples\FireRating\VB.NET\Microsoft.Office.Interop.Excel.dll</HintPath>
 50 |       <EmbedInteropTypes>True</EmbedInteropTypes>
 51 |     </Reference>
 52 |     <Reference Include="PresentationCore" />
 53 |     <Reference Include="PresentationFramework" />
 54 |     <Reference Include="RevitAPI">
 55 |       <HintPath>..\..\..\..\Program Files\Autodesk\Revit 2020\RevitAPI.dll</HintPath>
 56 |       <Private>False</Private>
 57 |     </Reference>
 58 |     <Reference Include="RevitAPIUI">
 59 |       <HintPath>..\..\..\..\Program Files\Autodesk\Revit 2020\RevitAPIUI.dll</HintPath>
 60 |       <Private>False</Private>
 61 |     </Reference>
 62 |     <Reference Include="System" />
 63 |     <Reference Include="System.Windows.Forms" />
 64 |     <Reference Include="System.Data" />
 65 |     <Reference Include="System.Deployment" />
 66 |     <Reference Include="System.Drawing" />
 67 |     <Reference Include="System.Windows.Forms" />
 68 |     <Reference Include="System.Xaml" />
 69 |     <Reference Include="System.Xml" />
 70 |     <Reference Include="System.Core" />
 71 |     <Reference Include="WindowsBase" />
 72 |   </ItemGroup>
 73 |   <ItemGroup>
 74 |     <Compile Include="Command.cs" />
 75 |     <Compile Include="FillPatternBenchmarkCommand.cs" />
 76 |     <Compile Include="Properties\AssemblyInfo.cs" />
 77 |     <Compile Include="Properties\Resources.Designer.cs">
 78 |       <AutoGen>True</AutoGen>
 79 |       <DesignTime>True</DesignTime>
 80 |       <DependentUpon>Resources.resx</DependentUpon>
 81 |     </Compile>
 82 |     <Compile Include="ViewModel\Enum\Status.cs" />
 83 |     <Compile Include="ViewModel\Events\DialogCloseEventArgs.cs" />
 84 |     <Compile Include="ViewModel\FillPatternsViewModel.cs" />
 85 |     <Compile Include="ViewModel\FillPatternViewModel.cs" />
 86 |     <Compile Include="ViewModel\MaterialBrowserViewModel.cs" />
 87 |     <Compile Include="ViewModel\MaterialViewModel.cs" />
 88 |     <Compile Include="ViewModel\ViewModelLocator.cs" />
 89 |     <Compile Include="View\Commands\RelayCommand.cs" />
 90 |     <Compile Include="View\Controls\FillPatternViewerControlWpf.xaml.cs">
 91 |       <DependentUpon>FillPatternViewerControlWpf.xaml</DependentUpon>
 92 |     </Compile>
 93 |     <Compile Include="View\Converters\BitmapSourceConverter.cs" />
 94 |     <Compile Include="View\Converters\BitmapToImageSourceConverter.cs" />
 95 |     <Compile Include="View\Converters\InversedStatusToErrorSignVisibilityConverter.cs" />
 96 |     <Compile Include="View\Converters\StatusToErrorMessageConverter.cs" />
 97 |     <Compile Include="View\Converters\StatusToErrorSignVisibilityConverter.cs" />
 98 |     <Compile Include="View\FillPatternsView.xaml.cs">
 99 |       <DependentUpon>FillPatternsView.xaml</DependentUpon>
100 |     </Compile>
101 |     <Compile Include="View\MaterialsView.xaml.cs">
102 |       <DependentUpon>MaterialsView.xaml</DependentUpon>
103 |     </Compile>
104 |   </ItemGroup>
105 |   <ItemGroup>
106 |     <None Include="AddMaterials.addin" />
107 |   </ItemGroup>
108 |   <ItemGroup />
109 |   <ItemGroup>
110 |     <EmbeddedResource Include="Properties\Resources.resx">
111 |       <Generator>PublicResXFileCodeGenerator</Generator>
112 |       <LastGenOutput>Resources.Designer.cs</LastGenOutput>
113 |     </EmbeddedResource>
114 |   </ItemGroup>
115 |   <ItemGroup>
116 |     <None Include="Resources\delete.png" />
117 |   </ItemGroup>
118 |   <ItemGroup>
119 |     <Page Include="View\Controls\FillPatternViewerControlWpf.xaml">
120 |       <SubType>Designer</SubType>
121 |       <Generator>MSBuild:Compile</Generator>
122 |     </Page>
123 |     <Page Include="View\FillPatternsView.xaml">
124 |       <SubType>Designer</SubType>
125 |       <Generator>MSBuild:Compile</Generator>
126 |     </Page>
127 |     <Page Include="View\MaterialsView.xaml">
128 |       <SubType>Designer</SubType>
129 |       <Generator>MSBuild:Compile</Generator>
130 |     </Page>
131 |   </ItemGroup>
132 |   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
133 |   <Target Name="AfterClean">
134 |     <Delete Files="$(AppData)\Autodesk\REVIT\Addins\2014\AddMaterials.addin" />
135 |     <Delete Files="$(AppData)\Autodesk\REVIT\Addins\2014\AddMaterials.dll" />
136 |   </Target>
137 |   <PropertyGroup>
138 |     <PostBuildEvent>copy "$(ProjectDir)AddMaterials.addin" "$(AppData)\Autodesk\REVIT\Addins\2016"
139 | copy "$(ProjectDir)bin\debug\AddMaterials.dll" "$(AppData)\Autodesk\REVIT\Addins\2016"</PostBuildEvent>
140 |   </PropertyGroup>
141 | </Project>


--------------------------------------------------------------------------------
/AddMaterials/Command.cs:
--------------------------------------------------------------------------------
  1 | #region Namespaces
  2 | using System;
  3 | using System.Collections.Generic;
  4 | using System.Linq;
  5 | using AddMaterials.View;
  6 | using AddMaterials.ViewModel;
  7 | using AddMaterials.ViewModel.Enum;
  8 | using Autodesk.Revit.ApplicationServices;
  9 | using Autodesk.Revit.Attributes;
 10 | using Autodesk.Revit.DB;
 11 | using Autodesk.Revit.UI;
 12 | using Excel = Microsoft.Office.Interop.Excel;
 13 | #endregion
 14 | 
 15 | namespace AddMaterials
 16 | {
 17 |   [Transaction( TransactionMode.Manual )]
 18 |   public class Command : IExternalCommand
 19 |   {
 20 |     private const string _not_available = "N/A";
 21 | 
 22 |     //const string _input_file_name = "C:/RevitAPI/MaterialList.xlsx";
 23 |     //private const string _input_file_name = "C:/tmp/MaterialList.xlsx";
 24 |     //const string _input_file_name = "Z:/a/doc/revit/blog/zip/MaterialList.xlsx";
 25 |     
 26 |     const string _input_file_name = "Z:/a/doc/revit/tbc/zip/MaterialList.xlsx";
 27 | 
 28 |     private static string PluralSuffix( int i )
 29 |     {
 30 |       return 1 == i ? "" : "s";
 31 |     }
 32 | 
 33 |     public Result Execute(
 34 |         ExternalCommandData commandData,
 35 |         ref string message,
 36 |         ElementSet elements )
 37 |     {
 38 |       UIApplication uiapp = commandData.Application;
 39 |       UIDocument uidoc = uiapp.ActiveUIDocument;
 40 |       Document doc = uidoc.Document;
 41 | 
 42 |       // Create dictionary of existing 
 43 |       // materials keyed by their name.
 44 | 
 45 |       Dictionary<string, Material> materials
 46 |         = new FilteredElementCollector( doc )
 47 |           .OfClass( typeof( Material ) )
 48 |           .Cast<Material>()
 49 |           .ToDictionary<Material, string>(
 50 |             e => e.Name );
 51 | 
 52 |       // Ditto for fill patterns.
 53 | 
 54 |       Dictionary<string, FillPatternElement> fillPatterns
 55 |         = new FilteredElementCollector( doc )
 56 |           .OfClass( typeof( FillPatternElement ) )
 57 |           .Cast<FillPatternElement>()
 58 |           .ToDictionary<FillPatternElement, string>(
 59 |             e => e.Name );
 60 | 
 61 |       try
 62 |       {
 63 |         var materialsToImport = ReadMaterialsFromXlsx( materials, fillPatterns ).ToList();
 64 |         var browser = new MaterialBrowserViewModel { Materials = materialsToImport };
 65 |         var window = new MaterialsView { DataContext = browser };
 66 |         var res = window.ShowDialog();
 67 |         if( !res.HasValue || !res.Value )
 68 |           return Result.Cancelled;
 69 | 
 70 |         var materialsToAdd = browser.Materials.Where( x => x.AddToProject ).ToList();
 71 |         if( !materialsToAdd.Any() )
 72 |           return Result.Cancelled;
 73 | 
 74 |         using( var tx = new Transaction( doc ) )
 75 |         {
 76 |           tx.Start( "Add Materials" );
 77 |           foreach( var materialViewModel in materialsToAdd )
 78 |           {
 79 |             var materialCSI = materials[materialViewModel.BaseMaterialClass];
 80 |             var myMaterial = materialCSI.Duplicate( materialViewModel.Name );
 81 |             myMaterial.Color = materialViewModel.Color;
 82 |             myMaterial.Transparency = (int) materialViewModel.Transparency;
 83 |             if( materialViewModel.SurfacePattern != null )
 84 |             {
 85 |               myMaterial.SurfaceForegroundPatternId
 86 |                 = fillPatterns[materialViewModel.SurfacePattern.Name].Id;
 87 |             }
 88 |             if( materialViewModel.CutPattern != null )
 89 |             {
 90 |               myMaterial.CutForegroundPatternId
 91 |                 = fillPatterns[materialViewModel.CutPattern.Name].Id;
 92 |             }
 93 |           }
 94 |           tx.Commit();
 95 |         }
 96 | 
 97 |         string msg = string.Format(
 98 |           "{0} row{1} successfully parsed and "
 99 |           + "{2} material{3} added:",
100 |           materialsToImport.Count, 
101 |           PluralSuffix( materialsToImport.Count ),
102 |           materialsToAdd.Count, 
103 |           PluralSuffix( materialsToAdd.Count ) );
104 | 
105 |         TaskDialog dlg = new TaskDialog(
106 |             "Revit AddMaterials" );
107 | 
108 |         dlg.MainInstruction = msg;
109 | 
110 |         dlg.MainContent = string.Join( ", ", 
111 |           materialsToAdd.Select( x => x.Name ) ) + ".";
112 | 
113 |         dlg.Show();
114 |       }
115 |       catch( Exception ex )
116 |       {
117 |         message 
118 |           = "Revit AddMaterials Exception:\n" + ex;
119 | 
120 |         return Result.Failed;
121 |       }
122 |       return Result.Succeeded;
123 |     }
124 | 
125 |     private IEnumerable<MaterialViewModel> ReadMaterialsFromXlsx( 
126 |       Dictionary<string, Material> materials,
127 |       Dictionary<string, 
128 |       FillPatternElement> fillPatterns )
129 |     {
130 |       Excel.Application excel
131 |         = new Excel.Application();
132 | 
133 |       excel.Visible = false;
134 | 
135 |       Excel.Workbook workbook = excel.Workbooks.Open(
136 |         _input_file_name, 0, true, 5, "", "", true,
137 |         Excel.XlPlatform.xlWindows, "\t", false,
138 |         false, 0, true, 1, 0 );
139 | 
140 |       Excel.Worksheet worksheet = (Excel.Worksheet)
141 |                                   workbook.Worksheets.get_Item( 1 );
142 | 
143 |       Excel.Range range = worksheet.UsedRange;
144 | 
145 |       int iRow = 5;
146 | 
147 |       while( null != range.Cells[iRow, 1].Value2 )
148 |       {
149 |         string matName = (string) range.Cells[iRow, 1].Value2;
150 |         matName += " " + (string) range.Cells[iRow, 2].Value2;
151 |         matName += " " + (string) range.Cells[iRow, 3].Value2;
152 |         if( !string.IsNullOrEmpty( matName ) )
153 |         {
154 |           double red = (double) range.Cells[iRow, 4].Value2;
155 |           double green = (double) range.Cells[iRow, 5].Value2;
156 |           double blue = (double) range.Cells[iRow, 6].Value2;
157 |           double transparency = (double) range.Cells[iRow, 8].Value2;
158 |           string surPatternName = (string) range.Cells[iRow, 9].Value2;
159 |           string cutPatternName = (string) range.Cells[iRow, 10].Value2;
160 |           string csi = (string) range.Cells[iRow, 11].Value2;
161 | 
162 |           FillPatternElement fillPatternElement;
163 |           FillPattern surfacePattern = null, cutPattern = null;
164 |           if( fillPatterns.TryGetValue( surPatternName, out fillPatternElement ) )
165 |             surfacePattern = fillPatternElement.GetFillPattern();
166 | 
167 |           if( fillPatterns.TryGetValue( cutPatternName, out fillPatternElement ) )
168 |             cutPattern = fillPatternElement.GetFillPattern();
169 | 
170 |           var status = Status.Normal;
171 |           if( !materials.ContainsKey( csi ) )
172 |             status = Status.BaseMaterialClassNotFound;
173 |           if( materials.ContainsKey( matName ) )
174 |             status = Status.ProjectAlreadyContainsMaterialWithTheSameName;
175 | 
176 |           yield return new MaterialViewModel
177 |           {
178 |             Name = matName,
179 |             BaseMaterialClass = csi,
180 |             Color = new Color(
181 |               Byte.Parse( red.ToString() ),
182 |               Byte.Parse( green.ToString() ),
183 |               Byte.Parse( blue.ToString() ) ),
184 |             Transparency = transparency,
185 |             SurfacePattern = surfacePattern,
186 |             CutPattern = cutPattern,
187 |             Status = status,
188 |             AddToProject = status == Status.Normal
189 |           };
190 |         }
191 |         ++iRow;
192 |       }
193 |       workbook.Close( true, null, null );
194 |       excel.Quit();
195 |     }
196 |   }
197 | }
198 | 
199 | // Z:\a\rvt\add_material_csi_03.rvt
200 | // Z:\a\rvt\fill_pattern_viewer.rvt
201 | 
202 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 | Apache License
  2 |                            Version 2.0, January 2004
  3 |                         http://www.apache.org/licenses/
  4 | 
  5 |    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
  6 | 
  7 |    1. Definitions.
  8 | 
  9 |       "License" shall mean the terms and conditions for use, reproduction,
 10 |       and distribution as defined by Sections 1 through 9 of this document.
 11 | 
 12 |       "Licensor" shall mean the copyright owner or entity authorized by
 13 |       the copyright owner that is granting the License.
 14 | 
 15 |       "Legal Entity" shall mean the union of the acting entity and all
 16 |       other entities that control, are controlled by, or are under common
 17 |       control with that entity. For the purposes of this definition,
 18 |       "control" means (i) the power, direct or indirect, to cause the
 19 |       direction or management of such entity, whether by contract or
 20 |       otherwise, or (ii) ownership of fifty percent (50%) or more of the
 21 |       outstanding shares, or (iii) beneficial ownership of such entity.
 22 | 
 23 |       "You" (or "Your") shall mean an individual or Legal Entity
 24 |       exercising permissions granted by this License.
 25 | 
 26 |       "Source" form shall mean the preferred form for making modifications,
 27 |       including but not limited to software source code, documentation
 28 |       source, and configuration files.
 29 | 
 30 |       "Object" form shall mean any form resulting from mechanical
 31 |       transformation or translation of a Source form, including but
 32 |       not limited to compiled object code, generated documentation,
 33 |       and conversions to other media types.
 34 | 
 35 |       "Work" shall mean the work of authorship, whether in Source or
 36 |       Object form, made available under the License, as indicated by a
 37 |       copyright notice that is included in or attached to the work
 38 |       (an example is provided in the Appendix below).
 39 | 
 40 |       "Derivative Works" shall mean any work, whether in Source or Object
 41 |       form, that is based on (or derived from) the Work and for which the
 42 |       editorial revisions, annotations, elaborations, or other modifications
 43 |       represent, as a whole, an original work of authorship. For the purposes
 44 |       of this License, Derivative Works shall not include works that remain
 45 |       separable from, or merely link (or bind by name) to the interfaces of,
 46 |       the Work and Derivative Works thereof.
 47 | 
 48 |       "Contribution" shall mean any work of authorship, including
 49 |       the original version of the Work and any modifications or additions
 50 |       to that Work or Derivative Works thereof, that is intentionally
 51 |       submitted to Licensor for inclusion in the Work by the copyright owner
 52 |       or by an individual or Legal Entity authorized to submit on behalf of
 53 |       the copyright owner. For the purposes of this definition, "submitted"
 54 |       means any form of electronic, verbal, or written communication sent
 55 |       to the Licensor or its representatives, including but not limited to
 56 |       communication on electronic mailing lists, source code control systems,
 57 |       and issue tracking systems that are managed by, or on behalf of, the
 58 |       Licensor for the purpose of discussing and improving the Work, but
 59 |       excluding communication that is conspicuously marked or otherwise
 60 |       designated in writing by the copyright owner as "Not a Contribution."
 61 | 
 62 |       "Contributor" shall mean Licensor and any individual or Legal Entity
 63 |       on behalf of whom a Contribution has been received by Licensor and
 64 |       subsequently incorporated within the Work.
 65 | 
 66 |    2. Grant of Copyright License. Subject to the terms and conditions of
 67 |       this License, each Contributor hereby grants to You a perpetual,
 68 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 69 |       copyright license to reproduce, prepare Derivative Works of,
 70 |       publicly display, publicly perform, sublicense, and distribute the
 71 |       Work and such Derivative Works in Source or Object form.
 72 | 
 73 |    3. Grant of Patent License. Subject to the terms and conditions of
 74 |       this License, each Contributor hereby grants to You a perpetual,
 75 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 76 |       (except as stated in this section) patent license to make, have made,
 77 |       use, offer to sell, sell, import, and otherwise transfer the Work,
 78 |       where such license applies only to those patent claims licensable
 79 |       by such Contributor that are necessarily infringed by their
 80 |       Contribution(s) alone or by combination of their Contribution(s)
 81 |       with the Work to which such Contribution(s) was submitted. If You
 82 |       institute patent litigation against any entity (including a
 83 |       cross-claim or counterclaim in a lawsuit) alleging that the Work
 84 |       or a Contribution incorporated within the Work constitutes direct
 85 |       or contributory patent infringement, then any patent licenses
 86 |       granted to You under this License for that Work shall terminate
 87 |       as of the date such litigation is filed.
 88 | 
 89 |    4. Redistribution. You may reproduce and distribute copies of the
 90 |       Work or Derivative Works thereof in any medium, with or without
 91 |       modifications, and in Source or Object form, provided that You
 92 |       meet the following conditions:
 93 | 
 94 |       (a) You must give any other recipients of the Work or
 95 |           Derivative Works a copy of this License; and
 96 | 
 97 |       (b) You must cause any modified files to carry prominent notices
 98 |           stating that You changed the files; and
 99 | 
100 |       (c) You must retain, in the Source form of any Derivative Works
101 |           that You distribute, all copyright, patent, trademark, and
102 |           attribution notices from the Source form of the Work,
103 |           excluding those notices that do not pertain to any part of
104 |           the Derivative Works; and
105 | 
106 |       (d) If the Work includes a "NOTICE" text file as part of its
107 |           distribution, then any Derivative Works that You distribute must
108 |           include a readable copy of the attribution notices contained
109 |           within such NOTICE file, excluding those notices that do not
110 |           pertain to any part of the Derivative Works, in at least one
111 |           of the following places: within a NOTICE text file distributed
112 |           as part of the Derivative Works; within the Source form or
113 |           documentation, if provided along with the Derivative Works; or,
114 |           within a display generated by the Derivative Works, if and
115 |           wherever such third-party notices normally appear. The contents
116 |           of the NOTICE file are for informational purposes only and
117 |           do not modify the License. You may add Your own attribution
118 |           notices within Derivative Works that You distribute, alongside
119 |           or as an addendum to the NOTICE text from the Work, provided
120 |           that such additional attribution notices cannot be construed
121 |           as modifying the License.
122 | 
123 |       You may add Your own copyright statement to Your modifications and
124 |       may provide additional or different license terms and conditions
125 |       for use, reproduction, or distribution of Your modifications, or
126 |       for any such Derivative Works as a whole, provided Your use,
127 |       reproduction, and distribution of the Work otherwise complies with
128 |       the conditions stated in this License.
129 | 
130 |    5. Submission of Contributions. Unless You explicitly state otherwise,
131 |       any Contribution intentionally submitted for inclusion in the Work
132 |       by You to the Licensor shall be under the terms and conditions of
133 |       this License, without any additional terms or conditions.
134 |       Notwithstanding the above, nothing herein shall supersede or modify
135 |       the terms of any separate license agreement you may have executed
136 |       with Licensor regarding such Contributions.
137 | 
138 |    6. Trademarks. This License does not grant permission to use the trade
139 |       names, trademarks, service marks, or product names of the Licensor,
140 |       except as required for reasonable and customary use in describing the
141 |       origin of the Work and reproducing the content of the NOTICE file.
142 | 
143 |    7. Disclaimer of Warranty. Unless required by applicable law or
144 |       agreed to in writing, Licensor provides the Work (and each
145 |       Contributor provides its Contributions) on an "AS IS" BASIS,
146 |       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
147 |       implied, including, without limitation, any warranties or conditions
148 |       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
149 |       PARTICULAR PURPOSE. You are solely responsible for determining the
150 |       appropriateness of using or redistributing the Work and assume any
151 |       risks associated with Your exercise of permissions under this License.
152 | 
153 |    8. Limitation of Liability. In no event and under no legal theory,
154 |       whether in tort (including negligence), contract, or otherwise,
155 |       unless required by applicable law (such as deliberate and grossly
156 |       negligent acts) or agreed to in writing, shall any Contributor be
157 |       liable to You for damages, including any direct, indirect, special,
158 |       incidental, or consequential damages of any character arising as a
159 |       result of this License or out of the use or inability to use the
160 |       Work (including but not limited to damages for loss of goodwill,
161 |       work stoppage, computer failure or malfunction, or any and all
162 |       other commercial damages or losses), even if such Contributor
163 |       has been advised of the possibility of such damages.
164 | 
165 |    9. Accepting Warranty or Additional Liability. While redistributing
166 |       the Work or Derivative Works thereof, You may choose to offer,
167 |       and charge a fee for, acceptance of support, warranty, indemnity,
168 |       or other liability obligations and/or rights consistent with this
169 |       License. However, in accepting such obligations, You may act only
170 |       on Your own behalf and on Your sole responsibility, not on behalf
171 |       of any other Contributor, and only if You agree to indemnify,
172 |       defend, and hold each Contributor harmless for any liability
173 |       incurred by, or claims asserted against, such Contributor by reason
174 |       of your accepting any such warranty or additional liability.
175 | 
176 |    END OF TERMS AND CONDITIONS
177 | 
178 |    APPENDIX: How to apply the Apache License to your work.
179 | 
180 |       To apply the Apache License to your work, attach the following
181 |       boilerplate notice, with the fields enclosed by brackets "{}"
182 |       replaced with your own identifying information. (Don't include
183 |       the brackets!)  The text should be enclosed in the appropriate
184 |       comment syntax for the file format. We also recommend that a
185 |       file or class name and description of purpose be included on the
186 |       same "printed page" as the copyright notice for easier
187 |       identification within third-party archives.
188 | 
189 |    Copyright {yyyy} {name of copyright owner}
190 | 
191 |    Licensed under the Apache License, Version 2.0 (the "License");
192 |    you may not use this file except in compliance with the License.
193 |    You may obtain a copy of the License at
194 | 
195 |        http://www.apache.org/licenses/LICENSE-2.0
196 | 
197 |    Unless required by applicable law or agreed to in writing, software
198 |    distributed under the License is distributed on an "AS IS" BASIS,
199 |    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
200 |    See the License for the specific language governing permissions and
201 |    limitations under the License.


--------------------------------------------------------------------------------
/AddMaterials/View/Controls/FillPatternViewerControlWpf.xaml.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.ComponentModel;
  3 | using System.Diagnostics;
  4 | using System.Drawing;
  5 | using System.Linq;
  6 | using System.Windows;
  7 | using Autodesk.Revit.DB;
  8 | using Image = System.Drawing.Image;
  9 | using Matrix = System.Drawing.Drawing2D.Matrix;
 10 | using Rectangle = System.Drawing.Rectangle;
 11 | 
 12 | namespace AddMaterials.View.Controls
 13 | {
 14 |   /// <summary>
 15 |   /// Interaction logic for FillPatternViewerControlWpf.xaml
 16 |   /// </summary>
 17 |   public partial class FillPatternViewerControlWpf 
 18 |     : INotifyPropertyChanged
 19 |   {
 20 |     private const float Scale = 50;
 21 |     private const float LENGTH = 100;
 22 |     private Bitmap fillPatternImg;
 23 | 
 24 |     #region FillPattern DependencyProperty
 25 |     public static readonly 
 26 |       DependencyProperty FillPatternProperty 
 27 |         = DependencyProperty.RegisterAttached( 
 28 |           "FillPattern",
 29 |           typeof( FillPattern ),
 30 |           typeof( FillPatternViewerControlWpf ),
 31 |           new UIPropertyMetadata( null, 
 32 |             OnFillPatternChanged ) );
 33 | 
 34 |     private static void OnFillPatternChanged(
 35 |       DependencyObject d,
 36 |       DependencyPropertyChangedEventArgs e )
 37 |     {
 38 |       var FillPatternViewerControlWpfControl
 39 |         = d as FillPatternViewerControlWpf;
 40 | 
 41 |       if( FillPatternViewerControlWpfControl == null ) return;
 42 | 
 43 |       FillPatternViewerControlWpfControl.OnPropertyChanged(
 44 |         "FillPattern" );
 45 | 
 46 |       FillPatternViewerControlWpfControl.CreateFillPatternImage();
 47 |     }
 48 | 
 49 |     public FillPattern FillPattern
 50 |     {
 51 |       get
 52 |       {
 53 |         return (FillPattern) GetValue(
 54 |           FillPatternProperty );
 55 |       }
 56 |       set
 57 |       {
 58 |         SetValue( FillPatternProperty, value );
 59 |       }
 60 |     }
 61 | 
 62 |     public FillPattern GetFillPattern(
 63 |       DependencyObject obj )
 64 |     {
 65 |       return (FillPattern) obj.GetValue(
 66 |         FillPatternProperty );
 67 |     }
 68 | 
 69 |     public void SetFillPattern(
 70 |       DependencyObject obj,
 71 |       FillPattern value )
 72 |     {
 73 |       obj.SetValue( FillPatternProperty, value );
 74 |     }
 75 |     #endregion
 76 | 
 77 |     public void Regenerate()
 78 |     {
 79 |       CreateFillPatternImage();
 80 |     }
 81 | 
 82 |     public FillPatternViewerControlWpf()
 83 |     {
 84 |       InitializeComponent();
 85 |     }
 86 | 
 87 |     public event PropertyChangedEventHandler
 88 |       PropertyChanged;
 89 | 
 90 |     //[NotifyPropertyChangedInvocator]
 91 |     protected virtual void OnPropertyChanged(
 92 |       string propertyName )
 93 |     {
 94 |       var handler = PropertyChanged;
 95 |       if( handler != null )
 96 |       {
 97 |         handler( this,
 98 |           new PropertyChangedEventArgs( 
 99 |             propertyName ) );
100 |       }
101 |     }
102 | 
103 |     public Image FillPatternImage
104 |     {
105 |       get
106 |       {
107 |         if( fillPatternImg == null )
108 |           CreateFillPatternImage();
109 |         return fillPatternImg;
110 |       }
111 |     }
112 | 
113 |     private void CreateFillPatternImage()
114 |     {
115 |       var width 
116 |         = ( ActualWidth == 0 ? Width : ActualWidth ) == 0
117 |           ? 100
118 |           : ( ActualWidth == 0 ? Width : ActualWidth );
119 | 
120 |       if( double.IsNaN( width ) )
121 |         width = 100;
122 | 
123 |       var height 
124 |         = ( ActualHeight == 0 ? Height : ActualHeight ) == 0
125 |           ? 30
126 |           : ( ActualHeight == 0 ? Height : ActualHeight );
127 | 
128 |       if( double.IsNaN( height ) )
129 |         height = 30;
130 | 
131 |       fillPatternImg = new Bitmap(
132 |         (int) width, (int) height );
133 | 
134 |       using( var g = Graphics.FromImage(
135 |         fillPatternImg ) )
136 |       {
137 |         var rect = new Rectangle( 
138 |           0, 0, (int) width, (int) height );
139 |         g.FillRectangle( Brushes.White, rect );
140 |         DrawFillPattern( g );
141 |       }
142 | 
143 |       OnPropertyChanged( "FillPatternImage" );
144 |     }
145 | 
146 |     private void DrawFillPattern( Graphics g )
147 |     {
148 |       Stopwatch sw = Stopwatch.StartNew();
149 |       float matrixScale;
150 |       var fillPattern = FillPattern;
151 |       if( fillPattern == null )
152 |         return;
153 | 
154 |       if( fillPattern.Target == FillPatternTarget.Model )
155 |         matrixScale = Scale;
156 |       else
157 |         matrixScale = Scale * 10;
158 | 
159 |       try
160 |       {
161 |         var width 
162 |           = ( ActualWidth == 0 ? Width : ActualWidth ) == 0
163 |             ? 100
164 |             : ( ActualWidth == 0 ? Width : ActualWidth );
165 | 
166 |         if( double.IsNaN( width ) )
167 |           width = 100;
168 | 
169 |         var height 
170 |           = ( ActualHeight == 0 ? Height : ActualHeight ) == 0
171 |             ? 30
172 |             : ( ActualHeight == 0 ? Height : ActualHeight );
173 | 
174 |         if( double.IsNaN( height ) )
175 |           height = 30;
176 | 
177 |         var viewRect = new Rectangle( 
178 |           0, 0, (int) width, (int) height );
179 | 
180 |         var centerX = ( viewRect.Left 
181 |           + viewRect.Left + viewRect.Width ) / 2;
182 | 
183 |         var centerY = ( viewRect.Top 
184 |           + viewRect.Top + viewRect.Height ) / 2;
185 | 
186 |         g.TranslateTransform( centerX, centerY );
187 | 
188 |         var rectF = new Rectangle( -1, -1, 2, 2 );
189 |         g.FillRectangle( Brushes.Blue, rectF ); //draw a small rectangle in the center of the image
190 | 
191 |         g.ResetTransform();
192 | 
193 |         var fillGrids = fillPattern.GetFillGrids();
194 | 
195 |         Debug.Print( new string( '-', 100 ) );
196 |         Debug.Print( "FilPattern name: {0}", fillPattern.Name );
197 |         if( fillPattern.Target == FillPatternTarget.Model )
198 |           Debug.Print( "FillPattern type: Model" );
199 |         else
200 |           Debug.Print( "FillPattern type: Drafting" );
201 |         Debug.Print( "Matrix scale: {0}", matrixScale );
202 |         Debug.Print( "Grids count: {0}", fillGrids.Count );
203 |         Debug.Print( "Len\\Area: {0}", fillPattern.LengthPerArea );
204 |         Debug.Print( "Lines\\Len: {0}", fillPattern.LinesPerLength );
205 |         Debug.Print( "Strokes\\Area: {0}", fillPattern.StrokesPerArea );
206 | 
207 |         foreach( var fillGrid in fillGrids )
208 |         {
209 |           var degreeAngle = (float) RadianToGradus( fillGrid.Angle );
210 |           Debug.Print( new string( '-', 50 ) );
211 |           Debug.Print( "Origin: U:{0} V:{1}", 
212 |             fillGrid.Origin.U, fillGrid.Origin.V );
213 |           Debug.Print( "Offset: {0}", fillGrid.Offset );
214 |           Debug.Print( "Angle: {0}", degreeAngle );
215 |           Debug.Print( "Shift: {0}", fillGrid.Shift );
216 | 
217 |           var pen = new Pen( System.Drawing.Color.Black )
218 |           {
219 |             Width = 1f / matrixScale
220 |           };
221 | 
222 |           float dashLength = 1;
223 |           var segments = fillGrid.GetSegments();
224 | 
225 |           if( segments.Count > 0 )
226 |           {
227 |             pen.DashPattern = segments
228 |               .Select(s => Math.Max(float.Epsilon, Convert.ToSingle(s)) )
229 |               .ToArray();
230 | 
231 |             Debug.Print( "\tSegments:" );
232 |             foreach( var segment in segments )
233 |             {
234 |               Debug.Print( "\t\t{0}", segment );
235 |             }
236 |             dashLength = pen.DashPattern.Sum();
237 |           }
238 |           g.ResetTransform();
239 |           var rotateMatrix = new Matrix();
240 |           rotateMatrix.Rotate( degreeAngle );
241 |           var matrix = new Matrix( 
242 |             1, 0, 0, -1, centerX, centerY ); //-1 reflects about x-axis
243 |           matrix.Scale( matrixScale, matrixScale );
244 |           matrix.Translate( (float) fillGrid.Origin.U, 
245 |             (float) fillGrid.Origin.V );
246 |           var backMatrix = matrix.Clone();
247 |           backMatrix.Multiply( rotateMatrix );
248 |           matrix.Multiply( rotateMatrix );
249 | 
250 |           var offset = ( -10 ) * dashLength;
251 |           matrix.Translate( offset, 0 );
252 |           backMatrix.Translate( offset, 0 );
253 |           Debug.Print( "Offset: {0}", offset );
254 | 
255 | 
256 |           bool moving_forward = true;
257 |           bool moving_back = true;
258 |           int safety = 500;
259 |           double alternator = 0;
260 |           while( moving_forward || moving_back ) // draw segments shifting and offsetting each time
261 |           {
262 |             Debug.Write( "*" );
263 |             var rectF1 = new RectangleF( 
264 |               -2 / matrixScale, -2 / matrixScale, 
265 |               4 / matrixScale, 4 / matrixScale );
266 | 
267 |             if( moving_forward && LineIntersectsRect( 
268 |               matrix, viewRect ) )
269 |             {
270 |               g.Transform = matrix;
271 |               g.DrawLine( pen, new PointF( 0, 0 ), 
272 |                 new PointF( LENGTH, 0 ) );
273 |             }
274 |             else
275 |             {
276 |               moving_forward = false;
277 |               Debug.Print( "\n----> Matrix does not intersect view" );
278 |             }
279 | 
280 |             if( moving_back && LineIntersectsRect( 
281 |               backMatrix, viewRect ) )
282 |             {
283 |               g.Transform = backMatrix;
284 |               g.DrawLine( pen, new PointF( 0, 0 ), 
285 |                 new PointF( LENGTH, 0 ) );
286 |             }
287 |             else
288 |             {
289 |               moving_back = false;
290 |               Debug.Print( "\n----> Back matrix does not intersect view" );
291 |             }
292 | 
293 |             if( safety == 0 )
294 |             {
295 |               Debug.Print( "\n--------> Safety limit exceeded" );
296 |               break;
297 |             }
298 |             else
299 |               --safety;
300 | 
301 |             matrix.Translate( (float) fillGrid.Shift, 
302 |               (float) fillGrid.Offset );
303 |             backMatrix.Translate( -(float) fillGrid.Shift, 
304 |               -(float) fillGrid.Offset );
305 | 
306 |             alternator += fillGrid.Shift;
307 |             if( Math.Abs( alternator ) > Math.Abs( offset ) )
308 |             {
309 |               Debug.Print( "\n----> Alternating" );
310 |               matrix.Translate( offset, 0 );
311 |               backMatrix.Translate( offset, 0 );
312 |               alternator = 0d;
313 |             }
314 |           }
315 |         }
316 |         sw.Stop();
317 |         g.ResetTransform();
318 | 
319 | #if DEBUG
320 |         g.DrawString( string.Format( 
321 |           "{0} ms", sw.ElapsedMilliseconds ), 
322 |           System.Drawing.SystemFonts.DefaultFont, 
323 |           Brushes.Red, 0, 0 );
324 | #endif
325 | 
326 |         Debug.Print( new string( '-', 50 ) );
327 | 
328 |         Pen p = new Pen( System.Drawing.Color.Black );
329 |         p.Width = 1f / matrixScale;
330 |         Debug.Print( "Finished" );
331 |       }
332 |       catch( Exception ex )
333 |       {
334 |         Debug.Print( ex.ToString() );
335 |       }
336 |     }
337 | 
338 |     public bool LineIntersectsRect( Matrix rayMatrix, Rectangle r )
339 |     {
340 |       Matrix m = rayMatrix.Clone();
341 |       m.Translate( 200, 0 );
342 |       return LineIntersectsRect(
343 |         new System.Drawing.Point( (int) rayMatrix.OffsetX, 
344 |           (int) rayMatrix.OffsetY ),
345 |         new System.Drawing.Point( (int) m.OffsetX, 
346 |           (int) m.OffsetY ),
347 |         r );
348 |     }
349 | 
350 |     public bool LineIntersectsRect( 
351 |       System.Drawing.Point p1, 
352 |       System.Drawing.Point p2, 
353 |       Rectangle r )
354 |     {
355 |       return LineIntersectsLine( p1, p2, new System.Drawing.Point( r.X, r.Y ), new System.Drawing.Point( r.X + r.Width, r.Y ) ) 
356 |         || LineIntersectsLine( p1, p2, new System.Drawing.Point( r.X + r.Width, r.Y ), new System.Drawing.Point( r.X + r.Width, r.Y + r.Height ) ) 
357 |         || LineIntersectsLine( p1, p2, new System.Drawing.Point( r.X + r.Width, r.Y + r.Height ), new System.Drawing.Point( r.X, r.Y + r.Height ) ) 
358 |         || LineIntersectsLine( p1, p2, new System.Drawing.Point( r.X, r.Y + r.Height ), new System.Drawing.Point( r.X, r.Y ) ) 
359 |         || ( r.Contains( p1 ) && r.Contains( p2 ) );
360 |     }
361 | 
362 |     private bool LineIntersectsLine( 
363 |       System.Drawing.Point l1p1, 
364 |       System.Drawing.Point l1p2, 
365 |       System.Drawing.Point l2p1, 
366 |       System.Drawing.Point l2p2 )
367 |     {
368 |       try
369 |       {
370 |         Int64 d = ( l1p2.X - l1p1.X ) * ( l2p2.Y - l2p1.Y ) - ( l1p2.Y - l1p1.Y ) * ( l2p2.X - l2p1.X );
371 |         if( d == 0 ) return false;
372 | 
373 |         Int64 q = ( l1p1.Y - l2p1.Y ) * ( l2p2.X - l2p1.X ) - ( l1p1.X - l2p1.X ) * ( l2p2.Y - l2p1.Y );
374 |         Int64 r = q / d;
375 | 
376 |         Int64 q1 = (Int64) ( l1p1.Y - l2p1.Y ) * (Int64) ( l1p2.X - l1p1.X );
377 |         Int64 q2 = (Int64) ( l1p1.X - l2p1.X ) * (Int64) ( l1p2.Y - l1p1.Y );
378 | 
379 |         q = q1 - q2;
380 |         Int64 s = q / d;
381 | 
382 |         if( r < 0 || r > 1 || s < 0 || s > 1 )
383 |           return false;
384 | 
385 |         return true;
386 |       }
387 |       catch( OverflowException err )
388 |       {
389 |         Debug.Print( "----------------------------------" );
390 |         Debug.Print( err.Message );
391 |         Debug.Print( l1p1.ToString() );
392 |         Debug.Print( l1p2.ToString() );
393 |         Debug.Print( l2p1.ToString() );
394 |         Debug.Print( l2p2.ToString() );
395 |         return false;
396 |       }
397 |     }
398 | 
399 |     private double GetDistance( PointF point1, PointF point2 )
400 |     {
401 |       // Pythagorean theorem c^2 = a^2 + b^2
402 |       // thus c = square root(a^2 + b^2)
403 | 
404 |       double a = (double) ( point2.X - point1.X );
405 |       double b = (double) ( point2.Y - point1.Y );
406 | 
407 |       return Math.Sqrt( a * a + b * b );
408 |     }
409 | 
410 |     private double RadianToGradus( double radian )
411 |     {
412 |       return radian * 180 / Math.PI;
413 |     }
414 |   }
415 | }
416 | 


--------------------------------------------------------------------------------