public AbstractModelLoader(string modelFileName)
        {
            m_Model = new ModelBase(modelFileName);

            m_ModelFileName = modelFileName;
            m_ModelPath = Path.GetDirectoryName(m_ModelFileName);
        }

		/// <summary>
		///   Serializes the <paramref name="model" />.
		/// </summary>
		private unsafe void SerializeModel(BinaryWriter writer, ModelBase model, Formula[] formulas)
		{
			// Collect all objects contained in the model
			var objectTable = CreateObjectTable(model, formulas);

			// Prepare the serialization of the model's initial state
			lock (_syncObject)
			{
				_stateVector = SerializationRegistry.Default.GetStateVectorLayout(model, objectTable, SerializationMode.Full);
				_deserializer = null;
			}

			var stateVectorSize = _stateVector.SizeInBytes;
			var serializer = _stateVector.CreateSerializer(objectTable);

			// Serialize the object table
			SerializeObjectTable(objectTable, writer);

			// Serialize the object identifier of the model itself and the formulas
			writer.Write(objectTable.GetObjectIdentifier(model));
			writer.Write(formulas.Length);
			foreach (var formula in formulas)
				writer.Write(objectTable.GetObjectIdentifier(formula));

			// Serialize the initial state
			var serializedState = stackalloc byte[stateVectorSize];
			serializer(serializedState);

			// Copy the serialized state to the stream
			writer.Write(stateVectorSize);
			for (var i = 0; i < stateVectorSize; ++i)
				writer.Write(serializedState[i]);
		}

 public void configure(int controllerID, ControllerBase controller, ModelBase model, ViewBase view)
 {
     addControllerRoute(new RouteBase(controllerID, controller));
     controller.configure(view, model);
     model.configure();
     view.configure(model);
 }

        public AbstractModelWriter(ModelBase model, string modelFileName)
        {
            m_Model = model;

            m_ModelFileName = modelFileName;
            m_ModelPath = Path.GetDirectoryName(m_ModelFileName);
        }

        public override void Populate(ModelBase obj)
        {
            CodigoIso newProps = obj as CodigoIso;

            Codigo = newProps.Codigo;
            Nome = newProps.Nome;
        }

 public DynamoNodeButton(ModelBase model, string eventName)
     : this()
 {
     this.model = model;
     this.eventName = eventName;
     Click += OnDynamoNodeButtonClick;
 }

		/// <param name="model">A copy of the original model the runtime model was generated from.</param>
		/// <param name="buffer">The buffer the model was deserialized from.</param>
		/// <param name="objectTable">The table of objects referenced by the model.</param>
		/// <param name="formulas">The formulas that are checked on the model.</param>
		internal SerializedRuntimeModel(ModelBase model, byte[] buffer, ObjectTable objectTable, Formula[] formulas)
		{
			Model = model;
			Buffer = buffer;
			ObjectTable = objectTable;
			Formulas = formulas;
		}

		/// <summary>
		///   Returns the serialized <paramref name="model" /> and the <paramref name="formulas" />.
		/// </summary>
		/// <param name="model">The model that should be serialized.</param>
		/// <param name="formulas">The formulas that should be serialized.</param>
		public static byte[] Save(ModelBase model, params Formula[] formulas)
		{
			var serializer = new RuntimeModelSerializer();
			serializer.Serialize(model, formulas);

			lock (serializer._syncObject)
				return serializer._serializedModel;
		}

		/// <summary>
		///   Initializes a new instance.
		/// </summary>
		/// <param name="model">The model that should be simulated.</param>
		/// <param name="formulas">The formulas that can be evaluated on the model.</param>
		public Simulator(ModelBase model, params Formula[] formulas)
		{
			Requires.NotNull(model, nameof(model));
			Requires.NotNull(formulas, nameof(formulas));

			_runtimeModel = RuntimeModel.Create(model, formulas);
			Reset();
		}

		/// <summary>
		///   Initizializes the model that should be analyzed.
		/// </summary>
		/// <param name="configuration">The configuration that should be used for the analyses.</param>
		/// <param name="model">The model that should be analyzed.</param>
		/// <param name="hazard">The hazard that should be analyzed.</param>
		internal void InitializeModel(AnalysisConfiguration configuration, ModelBase model, Formula hazard)
		{
			Model = model;
			ForcedFaults = new FaultSet(Model.Faults.Where(fault => fault.Activation == Activation.Forced));
			SuppressedFaults = new FaultSet(Model.Faults.Where(fault => fault.Activation == Activation.Suppressed));

			InitializeModel(configuration, hazard);
		}

		/// <summary>
		///   Initializes a new instance.
		/// </summary>
		/// <param name="model">The model the heuristic is created for.</param>
		/// <param name="cardinalityLevel">The cardinality level where the first suggestions should be made.</param>
		public MaximalSafeSetHeuristic(ModelBase model, uint cardinalityLevel = 3)
		{
			Requires.NotNull(model, nameof(model));

			_model = model;
			_cardinalityLevel = cardinalityLevel;
			_allFaults = new FaultSet(model.Faults.Where(fault => fault.Activation != Activation.Suppressed).ToArray());
		}

        public BookingView(BookingViews type, ModelBase model = null, bool IsDuplicate = false)
        {
            InitializeComponent();
            if (model != null)
                this.Header = "Edit Booking";
            DataContext = ViewModel = new BookingViewModel(type, model,IsDuplicate);

            Owner = Application.Current.MainWindow;
        }

		public void SetModel(ModelBase model, params Formula[] formulas)
		{
			_formulas = formulas;
			_model = model;

			foreach (var fault in _model.Faults)
				fault.Activation = Activation.Suppressed;

			SetSimulator(new Simulator(_model, formulas));
		}

 protected static void ExportTextureToPNG(string destDir, ModelBase.TextureDefBase texture)
 {
     try
     {
         ExportTextureToPNG(destDir, texture.m_ID, texture.GetBitmap());
     }
     catch (IOException)
     {
         Console.Write("Cannot write image for texture: " + texture.m_ID);
     }
 }

		/// <summary>
		///   Initializes a new instance.
		/// </summary>
		/// <param name="model">The <see cref="Model" /> instance the safety analysis was conducted for.</param>
		/// <param name="hazard">The hazard the analysis was conducated for.</param>
		/// <param name="suppressedFaults">The faults whose activations have been completely suppressed during analysis.</param>
		/// <param name="forcedFaults">The faults whose activations have been forced during analysis.</param>
		/// <param name="heuristics">The heuristics that are used during the analysis.</param>
		/// <param name="activationBehavior">The fault acitvation behavior used during the analysis.</param>
		internal SafetyAnalysisResults(ModelBase model, Formula hazard, IEnumerable<Fault> suppressedFaults,
									  IEnumerable<Fault> forcedFaults, IEnumerable<IFaultSetHeuristic> heuristics,
									  FaultActivationBehavior activationBehavior)
		{
			Model = model;
			Hazard = hazard;
			SuppressedFaults = suppressedFaults;
			ForcedFaults = forcedFaults;
			Heuristics = heuristics.ToArray(); // make a copy so that later changes to the heuristics don't affect the results
			FaultActivationBehavior = activationBehavior;
		}

        public ZoomValue(ListCollectionView view, ModelBase item)
        {
            _view = view;
            _item = item;

            InitializeComponent();

            this.DataContext = item;

            this.Loaded += OnEditTaskItemLoaded;
            this.Closed += new EventHandler(ZoomValue_Closed);
        }

        public BMDWriter(ModelBase model, ref NitroFile modelFile, BMDImporter.BMDExtraImportOptions extraOptions)
            : base(model, modelFile.m_Name)
        {
            m_ModelFile = modelFile;
            m_ConvertToTriangleStrips = extraOptions.m_ConvertToTriangleStrips;
            m_KeepVertexOrderDuringStripping = extraOptions.m_KeepVertexOrderDuringStripping;
            m_AlwaysWriteFullVertexCmd23h = extraOptions.m_AlwaysWriteFullVertexCmd23h;

            if (m_ConvertToTriangleStrips)
            {
                Stripify();
            }
        }

        public void AddScriptBrick(ModelBase scriptBrick, int firstViewIndex, int lastViewIndex)
        {
            //if (this.Count == lastViewIndex + 1 && GetAtIndex(lastViewIndex) is Script && )
            //{
            //  lastViewIndex++;
            //}

            if (scriptBrick is Brick) // Add brick at last visible end of a Script
            {
                var brick = scriptBrick as Brick;

                var scriptEndIndex = -1;
                Script lastFullScript = null;
                foreach (var script in Scripts)
                {
                    var scriptBeginIndex = scriptEndIndex + 1;
                    scriptEndIndex += script.Bricks.Count + 1;

                    // what does that do?
                    //if (scriptEndIndex > lastViewIndex && scriptBeginIndex >= firstViewIndex)
                    //{
                    //    break;
                    //}

                    lastFullScript = script;
                }

                if (lastFullScript == null)
                {
                    var startScript = new StartScript();
                    Scripts.Add(startScript);
                    lastFullScript = startScript;

                    OnScriptAdded(startScript, IndexOf(startScript));
                }

                lastFullScript.Bricks.Add(brick);

                //OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset)); // TODO: make faster and use method below instead
                OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, scriptBrick, IndexOf(scriptBrick)));
            }
            else if (scriptBrick is Script) // Add Script at end of all
            {
                var script = scriptBrick as Script;
                Scripts.Add(script);

                //OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset)); // TODO: make faster and use method below instead
                OnScriptAdded((Script) scriptBrick, IndexOf(scriptBrick));
            }
        }

        public TriangleStripper(ModelBase.FaceListDef faceList)
        {
            if (faceList.m_Type != ModelBase.PolyListType.Triangles)
            {
                bool tris = true;
                for (int i = 0; i < faceList.m_Faces.Count; i++)
                {
                    tris = (faceList.m_Faces[i].m_NumVertices == 3);
                    if (!tris)
                        throw new ArgumentException("The provided FaceListDef must be triangulated.");
                }
                faceList.m_Type = ModelBase.PolyListType.Triangles;
            }

            m_Vertices = new List<VertexLinked>();
            m_Triangles = new List<TriangleLinked>();
            m_TrianglesToProcess = new List<TriangleLinked>();

            for (int i = 0; i < faceList.m_Faces.Count; i++)
            {
                if (IsDegenerateFace(faceList.m_Faces[i]))
                {
                    faceList.m_Faces.RemoveAt(i);
                }
            }

            for (int i = 0; i < faceList.m_Faces.Count; i++)
            {
                m_Triangles.Add(new TriangleLinked(faceList.m_Faces[i]));
            }

            for (int i = 0; i < m_Triangles.Count; i++)
            {
                ModelBase.FaceDef triangle = m_Triangles[i].m_Triangle;

                for (int j = 0; j < triangle.m_NumVertices; j++)
                {
                    VertexLinked vertex = new VertexLinked(triangle.m_Vertices[j]);

                    int index = m_Vertices.IndexOf(vertex);
                    if (index == -1)
                    {
                        m_Vertices.Add(vertex);
                        index = m_Vertices.Count - 1;
                    }

                    m_Vertices[index].m_LinkedTriangles.Add(i);
                }
            }
        }

        protected void AddTexture(ModelBase.TextureDefBase texture, ModelBase.MaterialDef matDef)
        {
            matDef.m_TextureDefID = texture.m_ID;

            IEnumerable<ModelBase.TextureDefBase> matchingHash = m_Model.m_Textures.Values.Where(
                tex0 => tex0.m_ImgHash.Equals(texture.m_ImgHash));
            if (matchingHash.Count() > 0)
            {
                matDef.m_TextureDefID = matchingHash.ElementAt(0).m_ID;
                return;
            }

            m_Model.m_Textures.Add(texture.m_ID, texture);
        }