Ejemplo n.º 1
0
        public static int Elimina(this List <M.ManzanaData> listado, M.ManzanaData itemBuscar)
        {
            int RowsDeleted = 0;

            try
            {
                //Revisa que ya se haya insertado esa polilinea
                RowsDeleted =
                    listado.RemoveAll(x => x.hndPlColindancia == itemBuscar.hndPlColindancia);

                //En dado caso que no encuentre Handle, busca si se repite alguna colindancia.
                if (RowsDeleted == 0)
                {
                    for (int i = listado.Count - 1; i == 0; i--)
                    {
                        if (listado[i].rumboActual == itemBuscar.rumboActual)
                        {
                            listado.RemoveAt(i);
                            RowsDeleted = 1;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                ex.Message.ToEditor();
            }

            return(RowsDeleted);
        }
Ejemplo n.º 2
0
        internal static int InsertoColindancia(this M.ManzanaData insertedData)
        {
            int sigPosicion = -1;

            //Inserto en la polilinea
            if (Met_Autodesk.InsertDictionary(insertedData.hndPlColindancia.toObjectId(),
                                              M.Constant.XRecordColindancia,
                                              insertedData.rumboActual,
                                              insertedData.textColindancia))
            {
                //Encapsulo en lista de colindancia
                M.Manzana.ColindanciaManzana.Add(insertedData);

                //Obtengo la siguiente posición de orientación de rumbo del listado
                sigPosicion = M.Manzana.OrientacionCalculada.LastIndexOf(insertedData.rumboActual) + 1;
            }

            return(sigPosicion);
        }
Ejemplo n.º 3
0
        internal static int ReasignoColindancia(this M.ManzanaData insertedData, bool PolilineaNueva, bool RumboNuevo)
        {
            //Si ya existe Polilinea en la lista con Rumbo Nuevo
            if (!PolilineaNueva && RumboNuevo)
            {
                //Elimino de la lista
                M.Manzana.ColindanciaManzana.
                RemoveAll(x => x.hndPlColindancia.Value == insertedData.hndPlColindancia.Value);
            }
            //Si es Nueva Polilinea en la lista con Rumbo ya insertado
            else if (PolilineaNueva && !RumboNuevo)
            {
                //Buscar Polilinea de Rumbo anterior y eliminarlo---------------
                //Polilinea repetida
                M.ManzanaData itemRepetido = new M.ManzanaData();

                itemRepetido = M.Manzana.ColindanciaManzana.
                               Where(x => x.rumboActual == insertedData.rumboActual).FirstOrDefault();

                Entity entPl = itemRepetido.hndPlColindancia.toObjectId().OpenEntity();

                DManager.RemoveXRecord(entPl.ExtensionDictionary, M.Constant.XRecordColindancia);
                //----------------------------------------------------------------

                //Eliminar de lista Rumbo
                M.Manzana.ColindanciaManzana.
                RemoveAll(x => x.rumboActual == insertedData.rumboActual);
            }
            //Si es Polilinea y Rumbo ya insertados en la lista
            else if (!PolilineaNueva && !RumboNuevo)
            {
                M.ManzanaData itemRumbo = new M.ManzanaData();

                //Calculo item de Polilinea--------------------------------------------------------
                //Elimino de la lista
                M.Manzana.ColindanciaManzana.
                RemoveAll(x => x.hndPlColindancia.Value == insertedData.hndPlColindancia.Value);
                //----------------------------------------------------------------------------------

                //Calculo item de Rumbo-------------------------------------------------------------
                itemRumbo = M.Manzana.ColindanciaManzana.
                            Where(x => x.rumboActual == insertedData.rumboActual).FirstOrDefault();

                if (itemRumbo != null)
                {
                    ObjectId idPl = new ObjectId();

                    idPl = itemRumbo.hndPlColindancia.toObjectId();

                    Entity entPl = idPl.OpenEntity();

                    DManager.RemoveXRecord(entPl.ExtensionDictionary, M.Constant.XRecordColindancia);

                    //Eliminar de lista Rumbo
                    M.Manzana.ColindanciaManzana.
                    RemoveAll(x => x.rumboActual == insertedData.rumboActual);
                    //----------------------------------------------------------------------------------
                }
            }

            return(insertedData.InsertoColindancia());
        }
        private void btnAdd_Click(object sender, RoutedEventArgs e)
        {
            ObjectId idtxtCol  = new ObjectId(),  //Id de Texto con el que Colinda
                     idLineCol = new ObjectId();  //Id de Linea/Polilinea con la que Colinda

            //Selecciono el Item
            string rumboSeleccionado = (cmbRumboActual.SelectedItem ?? "").ToString();

            //Si ya se selecciono algo en el combobox de tipo
            if (cmbTipo.SelectedIndex != -1)
            {
                this.WindowState = WindowState.Minimized;
                //Solicito que me hagan saber el texto que colinda
                if (Met_Autodesk.Entity("Selecciona la línea de colindancia al " + rumboSeleccionado + "\n",
                                        out idLineCol, M.Constant.TiposLineas) &&
                    Met_Autodesk.Entity("Selecciona la colindancia al " + rumboSeleccionado + "\n",
                                        out idtxtCol, typeof(DBText)))
                {
                    if (idLineCol.OpenEntity().Layer == M.Constant.LayerManzana)
                    {
                        //Obtengo el DBText seleccionado
                        DBText DBTextColindancia = idtxtCol.OpenEntity() as DBText;

                        //Texto del DB Text
                        string txtColindancia = DBTextColindancia.TextString.FormatString();

                        //Modelo los datos
                        M.ManzanaData insertedData = new M.ManzanaData()
                        {
                            hndPlColindancia  = idLineCol.Handle,
                            hndTxtColindancia = idtxtCol.Handle,
                            inicialRumbo      = (M.Constant.Orientaciones
                                                 [Met_Manzana.ObtengoPosicion(rumboSeleccionado, 0), 1]),
                            rumboActual     = rumboSeleccionado,
                            textColindancia = cmbTipo.SelectedIndex > 0 ? txtColindancia :
                                              "calle " + txtColindancia
                        };

                        bool PolilineaNueva = false,
                             RumboNuevo     = false;

                        int sigPosicion = 0;

                        //Si ya se había insertado esa polilinea
                        PolilineaNueva = M.Manzana.ColindanciaManzana.Where
                                             (x => x.hndPlColindancia.Value == insertedData.hndPlColindancia.Value).
                                         Count() > 0 ? false : true;

                        //Si ya se había insertado ese rumbo en la lista
                        RumboNuevo = M.Manzana.ColindanciaManzana.
                                     Where(x => x.rumboActual == insertedData.rumboActual).Count() > 0
                            ? false : true;

                        //Si es Nueva Polilinea y nuevo Rumbo
                        if (PolilineaNueva && RumboNuevo)
                        {
                            sigPosicion = insertedData.InsertoColindancia();
                        }
                        else
                        {
                            sigPosicion = insertedData.ReasignoColindancia(PolilineaNueva, RumboNuevo);
                        }

                        //Reviso que rumbo mostrará
                        SigColindancia(sigPosicion);

                        if (ListPrincipal.ItemsSource != null)
                        {
                            ListPrincipal.Items.Refresh();
                        }
                        else
                        {
                            ListPrincipal.ItemsSource = M.Manzana.ColindanciaManzana;
                        }
                    }
                    else
                    {
                        this.ShowMessageAsync("Layer Incorrecto", "La línea debe de estar en Layer " + M.Constant.LayerManzana);
                    }
                }
                this.WindowState = WindowState.Normal;
            }
            else
            {
                this.ShowMessageAsync("Datos no seleccionados", "Favor de seleccionar Tipo de Colindancia");
            }
        }