示例#1
0
        private void MetroWindow_Loaded(object sender, RoutedEventArgs e)
        {
            //Comienzo transacción minimizando
            this.WindowState = WindowState.Minimized;

            tb1GridColindancia.ItemsSource = M.Colindante.MainData;

            //Crea Layers en dado caso que no exista
            int cantLayers = Met_Colindante.CreateAdjacencyLayers();

            //Lo muestro en el editor del plano activo
            if (cantLayers > 0)
            {
                string.Format("Creó {0} Layers \n", cantLayers).ToEditor();
            }

            //Encuentro segmentos
            CreateAndValidatePolyline();

            #region Si es Macrolote
            //Solamente cuando sea Macrolote leo los Macrolotes--------------------------------------
            if (M.Manzana.EsMacrolote)
            {
                AdaptView();
            }
            //--------------------------------------------------------------------
            #endregion

            BindingOperations.EnableCollectionSynchronization(M.Colindante.ListadoErrores, M.Colindante.Lock);

            this.WindowState = WindowState.Normal;

            FillControlsData();

            if (M.Colindante.MainData.Count > 0)
            {
                AssignMainData();
            }
        }
示例#2
0
        private async void tb1Clear_Click(object sender, RoutedEventArgs e)
        {
            if (tb1GridColindancia.Items.Count > 0)
            {
                MessageDialogResult dg = await this.ShowMessageAsync("Eliminar Datos",
                                                                     "¿Desea Eliminar Puntos Calculados?", MessageDialogStyle.AffirmativeAndNegative, M.Constant.DialogMetroSettings);

                if (dg == MessageDialogResult.Affirmative)
                {
                    this.WindowState = WindowState.Minimized;

                    Met_Colindante.DeleteAdjacencyObjects();

                    tb1GridColindancia.ItemsSource = null;

                    M.Colindante.MainData.Clear();

                    this.tb1GridColindancia.Items.Refresh();

                    this.WindowState = WindowState.Normal;
                }
            }
        }
示例#3
0
 private void RollBackPoints()
 {
     Met_Colindante.DeleteAdjacencyObjects();
 }
示例#4
0
        //Paso 3
        private void tb1CalPuntos_Click(object sender, RoutedEventArgs e)
        {
            int cont = 0;

            tb1CalPuntos.IsEnabled         = false;
            tb1GridColindancia.ItemsSource = null;
            M.Colindante.MainData.Clear();

            this.WindowState = WindowState.Minimized;

            var stWatch = Stopwatch.StartNew();

            #region Si Es Macrolote
            if (M.Manzana.EsMacrolote)
            {
                M.Colindante.LastPoint = 0;

                if (Met_Colindante.CreatePointsMacroset(M.Colindante.IdTipo, "Edificio Tipo"))
                {
                    cont++;

                    bool siGeneroTodo = true;

                    foreach (ObjectId idIrregular in M.Colindante.IdsIrregulares)
                    {
                        cont++;
                        if (!Met_Colindante.CreatePointsMacroset(idIrregular, "Edificio Irregular"))
                        {
                            RollBackPoints();
                            siGeneroTodo = false;
                            this.ShowMessageAsync("Error al Crear Puntos",
                                                  "No se crearon los puntos de manera correcta");
                            break;
                        }
                    }

                    if (siGeneroTodo)
                    {
                        if (Met_Colindante.GenerateBuildingCornerPoints())
                        {
                            //Genero Descripción de Área Común
                            if (Met_Colindante.GenerateMacroCommonArea())
                            {
                                //Genero los Edificios restantes que son regulares
                                if (Met_Colindante.GenerateAllSets(M.Manzana.EsMacrolote))
                                {
                                    if (Met_Colindante.ReadApartmentPoints())
                                    {
                                        AssignMainData();
                                    }
                                    else
                                    {
                                        RollBackPoints();

                                        this.ShowMessageAsync("Error al Crear Puntos",
                                                              "No se crearon los puntos de manera correcta");
                                    }
                                }
                                else
                                {
                                    RollBackPoints();

                                    this.ShowMessageAsync("Error al Crear Puntos",
                                                          "No se crearon los puntos de manera correcta");
                                }
                            }
                            else
                            {
                                RollBackPoints();

                                this.ShowMessageAsync("Error al Crear Puntos",
                                                      "No se crearon los puntos de manera correcta");
                            }
                        }
                        else
                        {
                            RollBackPoints();

                            this.ShowMessageAsync("Error al Crear Puntos",
                                                  "No se crearon los puntos de manera correcta");
                        }
                    }
                }
                else
                {
                    RollBackPoints();

                    this.ShowMessageAsync("Error al Crear Puntos",
                                          "No se crearon los puntos de manera correcta");
                }
            }
            #endregion
            #region LOTE
            else //Si es LOTE
            {
                if (Met_Colindante.CreatePointsSet(M.Colindante.IdTipo, "Lote Tipo"))
                {
                    cont++;
                    bool siGeneroTodo = true;
                    foreach (ObjectId idIrregular in M.Colindante.IdsIrregulares)
                    {
                        cont++;
                        if (!Met_Colindante.CreatePointsSet(idIrregular, "Lote Irregular"))
                        {
                            RollBackPoints();
                            siGeneroTodo = false;
                            this.ShowMessageAsync("Error al Crear Puntos",
                                                  "No se crearon los puntos de manera correcta");
                            break;
                        }
                    }

                    if (siGeneroTodo)
                    {
                        if (Met_Colindante.GenerateAllSets(M.Manzana.EsMacrolote))
                        {
                            AssignMainData();
                        }
                        else
                        {
                            RollBackPoints();

                            this.ShowMessageAsync("Error al Crear Puntos",
                                                  "No se crearon los puntos de manera correcta");
                        }
                    }
                }
                else
                {
                    RollBackPoints();

                    this.ShowMessageAsync("Error al Crear Puntos",
                                          "No se crearon los puntos de manera correcta");
                }
            }
            #endregion

            tb1CalPuntos.IsEnabled = true;

            stWatch.Stop();

            this.WindowState = WindowState.Normal;

            //this.ShowMessageAsync("Tiempo tomado", "Minutos: " + stWatch.Elapsed.TotalMinutes.Trunc(3)
            //    + "\nSegundos: " + stWatch.Elapsed.TotalSeconds.Trunc(3) +string.Format("con  {0} Viviendas", cont));
        }
示例#5
0
        //PASO 0
        private void tb1SelMacrolote_Click(object sender, RoutedEventArgs e)
        {
            ObjectId idPl = new ObjectId();

            string msgAreaComun = "";

            this.WindowState = WindowState.Minimized;

            //Valido que se haya obtenido de manera correcta una Polilínea
            if (Met_Autodesk.Entity("Selecciona Macrolote: ", out idPl,
                                    typeof(Autodesk.AutoCAD.DatabaseServices.Polyline)))
            {
                //Reviso que la polilínea este dentro del mismo layer
                if (idPl.OpenEntity().Layer == M.Constant.LayerLote)
                {
                    //Reviso que este dentro de los Lotes Leídos al Inicio
                    if (M.Colindante.Lotes.OfType <M.Lote>()
                        .Select(x => new Handle(x._long).toObjectId()).Contains(idPl))
                    {
                        //Busco Edificios y Apartamentos dentro de Macrolote
                        if (!Met_Colindante.noEstaEnEdificios(idPl))
                        {
                            //Dependiendo de cuantos edificios encuentre los asigno en lbl
                            lblGnEdificios.Text = string.Format("{0} Edificios", M.Colindante.Edificios.Count);

                            //Asigno Número de Lote
                            lblMacrolote.Text = M.Colindante.Lotes.Search(idPl.Handle.Value).numLote.ToString();

                            //Inicializo Obtención de Área Común
                            M.Colindante.ListCommonArea = new List <M.AreaComun>();

                            //Obtengo Área Común
                            if (!Met_Colindante.GetCommonArea(idPl, out msgAreaComun))
                            {
                                this.ShowMessageAsync("Área Común", msgAreaComun);
                            }

                            //Asigno el nombre del Área Común
                            if (M.Colindante.ListCommonArea.Count > 0)
                            {
                                M.Colindante.NomAreaComun = M.Colindante.ListCommonArea[0].NombreAreaComun;
                            }
                            else
                            {
                                M.Colindante.NomAreaComun = "Área Común";
                            }

                            //Muestro Número de Lote en el paso
                            lblMacrolote.Visibility = System.Windows.Visibility.Visible;

                            //Asigno ID Macrolote encontrado
                            M.Colindante.IdMacrolote = idPl;

                            //Muestro siguiente paso
                            tb1Paso1.IsEnabled = true;
                        }
                        else
                        {
                            this.ShowMessageAsync("Selección de Edificios",
                                                  "Hay un problema dentro del Macrolote, ir a Detalle...");
                        }
                    }
                    else
                    {
                        this.ShowMessageAsync("Error de selección",
                                              "El lote seleccionado esta afuera de la Manzana");
                    }
                }
                else
                {
                    this.ShowMessageAsync("Error de selección",
                                          string.Format("El lote seleccionado no tiene el layer {0}", M.Constant.LayerLote));
                }
            }
            else
            {
                M.Colindante.ListadoErrores.Add(new M.Error()
                {
                    error       = "Error de Selección",
                    description = "No se seleccionó Polilínea válida o se canceló",
                    timeError   = DateTime.Now.ToString(),
                    tipoError   = M.TipoError.Advertencia,
                    longObject  = 0,
                    metodo      = "ModuloColindante-tb1SelMacrolote_Click"
                });
            }

            this.WindowState = WindowState.Normal;
        }
        internal static void ClearData(bool clearM1 = true, bool clearM2 = true, bool clearM3 = true, bool clearM4 = true)
        {
            try
            {
                //Datos almacenados en Módulo Inicial
                if (clearM1)
                {
                    M.Inicio.ResultFraccs    = null;
                    M.Inicio.ResultTipoVivs  = null;
                    M.Inicio.Fraccionamiento = new M.Fraccionamiento();
                    M.Inicio.Estado          = "";
                    M.Inicio.Municipio       = "";
                    M.Inicio.Sector          = "";
                    M.Inicio.Region          = "";
                    M.Inicio.EncMachote      = new M.EncabezadoMachote();
                }

                //Datos almacenados en el Módulo Manzana
                if (clearM2)
                {
                    //Datos almacenados en Módulo Manzana
                    M.Manzana.OrientacionCalculada = new List <string>();
                    M.Manzana.ColindanciaManzana   = new List <M.ManzanaData>();
                    M.Manzana.NoManzana            = 0;
                    M.Manzana.RumboFrente          = new M.ManzanaData();
                    M.Manzana.EsMacrolote          = false;

                    //Elimino los Xrecord guardados
                    C.Met_Manzana.EliminaColindancias();
                }

                //Datos almacenados en Módulo Colindancia
                if (clearM3)
                {
                    M.Colindante.IdTipo            = new cadDB.ObjectId();
                    M.Colindante.IdsIrregulares    = new cadDB.ObjectIdCollection();
                    M.Colindante.Edificios         = new List <M.InEdificios>();
                    M.Colindante.IdMacrolote       = new cadDB.ObjectId();
                    M.Colindante.Lotes             = new List <M.Lote>();
                    M.Colindante.ListadoErrores    = new ObservableCollection <M.Error>();
                    M.Colindante.MainData          = new List <M.ColindanciaData>();
                    M.Colindante.OrderedApartments = new List <M.Apartments>();
                    M.Colindante.PtsVertex         = new Point3dCollection();
                    M.Colindante.ListCommonArea    = new List <M.AreaComun>();
                    M.Colindante.LastPoint         = 0;
                    M.Colindante.NomAreaComun      = "";

                    //Debo de eliminar la polilínea creada al cargar Módulo Colindante
                    if (M.Colindante.IdPolManzana.IsValid)
                    {
                        M.Colindante.IdPolManzana.GetAndRemove();
                    }

                    //Eliminar todos los puntos creados
                    Met_Colindante.DeleteAdjacencyObjects();
                }

                //Datos de Módulo de Tabla
                if (clearM4)
                {
                    M.InfoTabla.MedidasGlobales    = new ObservableCollection <M.Medidas>();
                    M.InfoTabla.LotesSelected      = new ObservableCollection <M.Checked <M.LoteItem> >();
                    M.InfoTabla.AllProperties      = new List <M.DataColumns>();
                    M.InfoTabla.RumboInverso       = new M.ManzanaData();
                    M.InfoTabla.TotalesTabla       = new M.TotalesMedidas();
                    M.InfoTabla.LotesBase          = new Dictionary <long, bool>();
                    M.InfoTabla.ResultadoBloques   = new List <M.Bloques>();
                    M.InfoTabla.ResultadoVariables = new List <M.Variables>();
                }
            }
            catch (Autodesk.AutoCAD.Runtime.Exception ex)
            {
                ("AUTODESK: " + ex.Message).ToEditor();
            }
            catch (Exception ex)
            {
                ex.Message.ToEditor();
            }
        }