/// <summary>
		/// Initializes a new instance of the <see cref="SharpNav.AreaGenerator"/> class.
		/// </summary>
		/// <param name="verts">collection of Triangles.</param>
		/// <param name="triCount">The number of triangles to enumerate..</param>
		/// <param name="defaultArea">Default area.</param>
		private AreaGenerator(IEnumerable<Triangle3> verts, int triCount, Area defaultArea)
		{
			this.tris = verts;
			this.triCount = triCount;
			this.defaultArea = defaultArea;
			conditions = new List<Tuple<Func<Triangle3, bool>, Area>>();
		}

        public void SetUp()
        {
            var placeholder1 = new Placeholder("area 1");
            var placeholder2 = new Placeholder("area 2");
            var widgetSpecification = new WidgetSpecification("widget");
            widgetSpecification.Insert(0, placeholder1);
            widgetSpecification.Insert(1, placeholder2);

            var area = new Area("area 1");
            var widget = new Widget("widget", new[] { area });

            var buildContext = new BuildData(Enumerable.Empty<IContextItem>());

            var builder = new Builder(RenderingInstructions.BuildForPreview(), w => widgetSpecification, null);

            var instance = widget.Build(builder, new[] { 0 }, buildContext);

            var rendererFactory = MockRepository.GenerateStub<IRendererFactory>();
            this.viewHelper = MockRepository.GenerateStub<IViewHelper>();
            var multiRenderer = new MultiRenderer(rendererFactory);

            KolaConfigurationRegistry.RegisterRenderer(multiRenderer);

            this.result = instance.Render(multiRenderer);
        }

        public NinePatchImage(Texture2D texture)
        {
            _texture = texture;
            XnaColor[] data = new XnaColor[texture.Width * texture.Height];
            texture.GetData(data);
            Stretch = new Area(
                vertical: GetLine(texture, data, 0, 1, 0, 0),
                horizontal: GetLine(texture, data, 1, 0, 0, 0));
            Content = new Area(
                vertical: GetLine(texture, data, 0, 1, _texture.Width - 1, 0),
                horizontal: GetLine(texture, data, 1, 0, 0, _texture.Height - 1));

            Width = _texture.Width - 2;
            Height = _texture.Height - 2;

            _leftTop = new XnaRectangle(1, 1, Stretch.Horizontal.Start, Stretch.Vertical.Start);
            _leftCenter = new XnaRectangle(1, Stretch.Vertical.Start, Stretch.Horizontal.Start, Stretch.Vertical.Size);
            _leftBottom = new XnaRectangle(1, Stretch.Vertical.End, Stretch.Horizontal.Start, texture.Height - 1 - Stretch.Vertical.End);
            _centerTop = new XnaRectangle(Stretch.Horizontal.Start, 1, Stretch.Horizontal.Size, Stretch.Vertical.Start);
            _center = new XnaRectangle(Stretch.Horizontal.Start, Stretch.Vertical.Start, Stretch.Horizontal.Size, Stretch.Vertical.Size);
            _centerBottom = new XnaRectangle(Stretch.Horizontal.Start, Stretch.Vertical.End, Stretch.Horizontal.Size, texture.Height - 1 - Stretch.Vertical.End);
            _rightTop = new XnaRectangle(Stretch.Horizontal.End, 1, texture.Width - 1 - Stretch.Horizontal.End, Stretch.Vertical.Start);
            _rightCenter = new XnaRectangle(Stretch.Horizontal.End, Stretch.Vertical.Start, texture.Width - 1 - Stretch.Horizontal.End, Stretch.Vertical.Size);
            _rightBottom = new XnaRectangle(Stretch.Horizontal.End, Stretch.Vertical.End, texture.Width - 1 - Stretch.Horizontal.End, texture.Height - 1 - Stretch.Vertical.End);
        }

    public void GenerateMinThresholdInRegion(Area region, float minThreshold, float strength)
    {
        lastMinThreshold = minThreshold;

        int x_min = region.botLeft.x;
        int z_min = region.botLeft.z;

        int x_max = region.topRight.x;
        int z_max = region.topRight.z;

        for (int x = x_min; x < x_max; x++)
        {
            for (int z = z_min; z < z_max; z++)
            {
                if (!globalMinThresholdC.IsDefined(x, z))
                {
                    float height = lt.gt.GetHeight(x, z);

                    if (height < minThreshold)
                    {
                        fg.SetGlobalValue(x, z, -Mathf.Log(Mathf.Abs(height - minThreshold)+1, strength), false, globalMinThresholdC);
                    }
                }
            }
        }
    }

        public Wander(Entity o, IWorld map)
            : base(o)
        {
            WorldMap = map;

            curDest = WorldMap.GetArea(random.Next(10), random.Next(10));
        }

 // RimWorld.AreaAllowedGUI
 private static void DoAreaSelector( Rect rect, ref Area areaAllowed, Area area )
 {
     rect = rect.ContractedBy( 1f );
     GUI.DrawTexture( rect, area == null ? BaseContent.GreyTex : area.ColorTexture );
     Text.Anchor = TextAnchor.MiddleLeft;
     string text = AreaUtility.AreaAllowedLabel_Area( area );
     Rect rect2 = rect;
     rect2.xMin += 3f;
     rect2.yMin += 2f;
     Widgets.Label( rect2, text );
     if ( areaAllowed == area )
     {
         Widgets.DrawBox( rect, 2 );
     }
     if ( Mouse.IsOver( rect ) )
     {
         if ( area != null )
         {
             area.MarkForDraw();
         }
         if ( Input.GetMouseButton( 0 ) &&
              areaAllowed != area )
         {
             areaAllowed = area;
             SoundDefOf.DesignateDragStandardChanged.PlayOneShotOnCamera();
         }
     }
     TooltipHandler.TipRegion( rect, text );
 }

        public Color[,] Render(Size resolution, Area viewPort)
        {
            _log.InfoFormat("Starting to render ({0:N0}x{1:N0})", resolution.Width, resolution.Height);

            viewPort.LogViewport();

            var output = new Color[resolution.Width, resolution.Height];

            _log.Debug("Rendering points");

            var allPointsWithEscapeTimes =
                resolution
                .GetAllPoints()
                .AsParallel()
                .WithDegreeOfParallelism(GlobalArguments.DegreesOfParallelism)
                .Select(p => Tuple.Create(p, PickColor(FindEscapeTime(viewPort.GetNumberFromPoint(resolution, p)))))
                .AsEnumerable();

            foreach (var result in allPointsWithEscapeTimes)
            {
                output[result.Item1.X, result.Item1.Y] = result.Item2;
            }

            return output;
        }

        public override void Up()
        {
            var ccb = new Area
            {
                Nome = "CCB",
                Ativo = true,
                Abreviacao = "CCB",
                Parent = null,
                Segura = false
            }.Persistir();

            var administrador = new Perfil
            {
                Nome = "Administrador",
                Ativo = true
            }.Persistir();

            new Usuario
            {
                Area = ccb,
                Perfil = administrador,
                Senha = new HashString().Do("pwd123"),
                Login = "admin",
                Nome = "Administrador do sistema",
                Email = "[email protected]",
                Ativo = true,
                Expira = false
            }.Persistir();
        }

        public virtual JsonResult Crear(Area entidad)
        {
            var jsonResponse = new JsonResponse { Success = false };

            if (ModelState.IsValid)
            {
                try
                {
                    entidad.UsuarioCreacion = UsuarioActual.IdUsuario.ToString();
                    entidad.UsuarioModificacion = UsuarioActual.IdUsuario.ToString();
                    AreaBL.Instancia.Add(entidad);

                    jsonResponse.Success = true;
                    jsonResponse.Message = "Se Proceso con éxito";
                }
                catch (Exception ex)
                {
                    logger.Error(string.Format("Mensaje: {0} Trace: {1}", ex.Message, ex.StackTrace));
                    jsonResponse.Message = "Ocurrio un error, por favor intente de nuevo o más tarde.";
                }
            }
            else
            {
                jsonResponse.Message = "Por favor ingrese todos los campos requeridos";
            }
            return Json(jsonResponse, JsonRequestBehavior.AllowGet);
        }

 public void SetArea(Area area)
 {
     var adjs =
         from a in area.Adjacent
         where a.Province == area.Province
         select a;
     this.SuspendLayout();
     {
         int btm = 35;
         foreach (var a in adjs)
         {
             btm += 23;
             var button = new Button {
                 Text = a.Name,
                 Dock = DockStyle.Top,
                 Tag = a
             };
             button.Click += this.ButtonClick;
             this.Controls.Add(button);
         }
         this.Controls.Remove(_label);
         this.Controls.Add(_label);
         this.ClientSize = new Size(this.ClientSize.Width, btm);
     }
     this.ResumeLayout();
 }

    public int Import(string UPICode, string AreaName, string Description, int RegionId)
    {
        try
        {
            if (CheckExistedArea(AreaName) == false)
            {
                Area o = new Area();
                o.UpiCode = UPICode;
                o.AreaName = AreaName;
                o.Description = Description;
                o.RegionId = RegionId;
                db.Areas.InsertOnSubmit(o);
                db.SubmitChanges();
                return o.Id;
            }

            var area = (from a in db.Areas where a.AreaName == AreaName select a).SingleOrDefault();

            if (area != null) return area.Id;

            return -1;
        }
        catch
        {
            return -1;
        }
    }

        public Area ReloadWithSeat(Area area, out IEnumerable<IArrangeSeatRule> availableOrganizations)
        {
            var result = _areaRepository.Get(area.Id);
            var exists = _areaRepository.GetOrganizationSeatingArea(area.Id).ToDictionary(o => o.Object);

            var all = new List<IArrangeSeatRule>();

            var defaultTargetSeat = result.Seats.FirstOrDefault();

            foreach (var item in ((Campaign)result.Campaign).Organizations)
            {
              
                if (exists.ContainsKey(item))
                {
                    all.Add(exists[item]);
                }
                else
                {
                    var o = defaultTargetSeat == null ? null : _entityFactory.Create<OrganizationSeatingArea>(new Dictionary<string, object> { { "Area", result }, { "Object", item }, { "TargetSeat", defaultTargetSeat } });
                    if (o != null)
                    {
                        _areaRepository.MakePersistent(o);
                        all.Add(o);
                    }
                }
            }

            availableOrganizations = all.ToRebuildPriorityList<IArrangeSeatRule, IArrangeSeatRule>(true, null);
            return result;
        }

        public void PointToNumberToPointTest()
        {
            const int xRange = 500;
            const int yRange = 500;

            var resolution = new Size(xRange * 2, yRange * 2);

            const int xLower = -1 * xRange;
            const int xUpper = xRange;
            const int yLower = -1 * yRange;
            const int yUpper = yRange;

            var area = new Area(new InclusiveRange(xLower, xUpper), new InclusiveRange(yLower, yUpper));
            for (int x = xLower; x < xUpper; x++)
            {
                for (int y = yLower; y < yUpper; y++)
                {
                    var point = new Point(x, y);

                    var calculatedNumber = area.GetNumberFromPoint(resolution, point);
                    var calculatedPoint = area.GetPointFromNumber(resolution, calculatedNumber);

                    Assert.AreEqual(point, calculatedPoint);
                }
            }
        }

 public bool InitRoutine(Area area)
 {
     this.area = area;
     ArrayList possibleRoutines = new ArrayList();
      		if (canWalk){
         possibleRoutines.Add(new GenericWanderAction(gameObject, area.wanderWaypointParent));
     }
     if (canSitOnChair && area.chairParent != null){
         possibleRoutines.Add(new GenericSitAction(gameObject, "chair", "sit_chair", area.chairParent));
     }
     if (canEat && area.chairParent != null){
         possibleRoutines.Add(new GenericSitAction(gameObject, "chair", "eat", area.chairParent));
     }
     if (canSitOnLounger && area.loungerParent != null){
         possibleRoutines.Add(new GenericSitAction(gameObject, "lounger", "sit_lounger", area.loungerParent));
     }
     if (canSitOnDeckChair && area.deckChairParent != null){
         possibleRoutines.Add(new GenericSitAction(gameObject, "deck_chair", "sit_deck_chair", area.deckChairParent));
     }
     if (canDance && area.name.Equals("Disco")){
     //	possibleRoutines.Add(new GenericDanceAction());
     }
     if (possibleRoutines.Count == 0){
         routine = new GenericSelfDestructAction(gameObject);
         return false;
     } else {
         routine = (Action)possibleRoutines[Random.Range(0, possibleRoutines.Count)];
         //Debug.Log("Chosen routine: " + routine + " for " + name);
         return true;
     }
 }

        public void DoNotApplyDoorLocationToRoomDoors()
        {
            var areaFromHall = new Area();
            areaFromHall.Type = "area type";
            areaFromHall.Width = 1;

            mockAreaPercentileSelector.Setup(s => s.SelectFrom(TableNameConstants.DungeonAreaFromDoor)).Returns(areaFromHall);

            var mockAreaGenerator = new Mock<AreaGenerator>();
            mockAreaGeneratorFactory.Setup(f => f.HasSpecificGenerator("area type")).Returns(true);
            mockAreaGeneratorFactory.Setup(f => f.Build("area type")).Returns(mockAreaGenerator.Object);

            var specificArea = new Area();
            var otherSpecificArea = new Area { Type = AreaTypeConstants.Door };
            otherSpecificArea.Descriptions = new[] { "strong", "wood" };

            mockAreaGenerator.Setup(g => g.Generate(9266, 90210, "temperature")).Returns(new[] { specificArea, otherSpecificArea });

            var areas = dungeonGenerator.GenerateFromDoor(9266, 90210, "temperature");
            Assert.That(areas, Contains.Item(specificArea));
            Assert.That(areas, Contains.Item(otherSpecificArea));
            Assert.That(areas.Count(), Is.EqualTo(2));

            var last = areas.Last();
            Assert.That(last, Is.EqualTo(otherSpecificArea));
            Assert.That(otherSpecificArea.Descriptions, Contains.Item("strong"));
            Assert.That(otherSpecificArea.Descriptions, Contains.Item("wood"));
            Assert.That(otherSpecificArea.Descriptions.Count(), Is.EqualTo(2));
        }

        ObjectModMeta DeleteAreaAuthorization(Area obj)
        {
            var meta = SetModDetailsOnPrincipalAndStopModIfNegativeReputationAndReturnObjectModMeta(obj);

            if (obj.Type == CfType.Province)
            {
                //-- Would be good to move this out of the method? W.I.F.??
                if (!currentUser.IsGodUser) { throw new AccessViolationException("DeleteArea: Only god users can delete provinces."); }
            }

            if (meta.CQR > 7 && !currentUser.IsInRole("ModAdmin"))
            {
                throw new AccessViolationException("DeleteArea: Only Admin Moderators can delete places with CQR higher than 7");
            }
            else if (meta.CQR > 1 && !currentUser.IsInRole("ModAdmin,ModSenior"))
            {
                throw new AccessViolationException("DeleteArea: Only Senior Moderators can delete places with CQR higher than 1");
            }
            else if (!currentUser.IsInRole("ModAdmin,ModSenior,ModCommunity"))
            {
                throw new AccessViolationException("DeleteArea: You must be Moderator to delete places");
            }

            return meta;
        }

 public static Area DoAllowedAreaSelectors( Rect rect, Area areaIn,
                                            AllowedAreaMode mode = AllowedAreaMode.Humanlike, float lrMargin = 0 )
 {
     Area areaIO = areaIn;
     DoAllowedAreaSelectors( rect, ref areaIO, mode, lrMargin );
     return areaIO;
 }

 public void AreaRange_Range_NineRepeated()
 {
     Area<string> Area = new Area<string>("a", 99999999999L);
      Assert.AreEqual("a", Area.Id);
      Assert.AreEqual(0.99999999999m, Area.Start);
      Assert.AreEqual(1m, Area.End);
 }

		public AreaRegion(Area area, MathMLElement element, float x, float y)
		{
			this.Area = area;
			this.Element = element;
			this.X = x;
			this.Y = y;
		}

 public void AreaRange_Range_Zero()
 {
     Area<string> Area = new Area<string>("a", 0);
      Assert.AreEqual("a", Area.Id);
      Assert.AreEqual(0m, Area.Start);
      Assert.AreEqual(0.1m, Area.End);
 }