示例#1
0
        public static void AjustaPosicionamento(LinhaCompletaVisual lc)
        {
            ControleLivre _ctrlLivreAux = null;

            int _maiorX = 0;

            SuporteParalelo        _par     = null;
            List <SuporteParalelo> _lst_par = new List <SuporteParalelo>();

            int _ultTamY2ParaleloFinal = 0; // acumula o tamanho Y (pos+tam) do ultimo
            // VPI tratado dentro de um mesmo paralelo
            // seu valor e usado para informar
            // ao PF qual o seu tamanho Y

            int _tamY2DesenhoFundo = 0;

            // Variaveis auxiliares para posicionamento
            //  dos controles
            int _posX     = lc.posX; // auxiliar para posX
            int _posY     = lc.posY; // auxiliar para posY
            int _tamX     = lc.tamX; // auxiliar para tamX
            int _tamY     = lc.tamY; // auxiliar para tamY
            int _acumTamX = 0;       // usado para acumular o valor de X na sequencia
            // em que os simbolos sao montados
            int _acumTamY = lc.tamY; // auxiliar para tamY

            List <ControleLivre> _simbProxLinha = new List <ControleLivre>();

            _acumTamX += lc.tamX;

            foreach (ControleLivre simbAux in lc.simbolos)
            {
                // caso todos os paralelos abertos tenham sido
                // tratados forca paralelos tratados = 0
                if (_lst_par.Count == 0)
                {
                    if (_maiorX > 0)
                    {
                        _posX = _maiorX;
                    }

                    _maiorX = 0;
                }
                else
                {
                    if (_maiorX < (_posX + _tamX))
                    {
                        _maiorX = _posX + _tamX;
                    }
                }

                switch (simbAux.getCI())
                {
                case CodigosInterpretaveis.PARALELO_INICIAL:
                    _tamY = lc.tamY;     // restaura tamanho Y base
                    _posX = _acumTamX;
                    _tamX = lc.tamX / 3;

                    _par = new SuporteParalelo();
                    _lst_par.Add(_par);

                    _par._yAcum = _posY;
                    _par.maiorY = _posY;
                    _par.maiorX = _maiorX;
                    _par.par    = simbAux;

                    _acumTamX = _posX + _tamX;
                    break;

                case CodigosInterpretaveis.PARALELO_FINAL:
                    _tamX = lc.tamX / 3;
                    //                        _tamY = _par.ultimoVPI.Location.Y - _par.par.Location.Y + _par.ultimoVPI.Size.Height; // _ultTamY2ParaleloFinal;
                    _tamY = _par.ultimoVPI.posicaoXY.Y - _par.par.posicaoXY.Y + _par.ultimoVPI.tamanhoXY.Height;     // _ultTamY2ParaleloFinal;
                    _posY = _par.par.posicaoXY.Y;

                    if (_maiorX > _par.maiorX)
                    {
                        _par.maiorX = _maiorX;
                    }

                    _posX = _par.maiorX;

                    // Salva (por paralelo) o maior tamanho Y para os simbolos
                    // linha inicial / final e desenho de fundo
                    if (_ultTamY2ParaleloFinal > _tamY2DesenhoFundo)
                    {
                        _tamY2DesenhoFundo = _ultTamY2ParaleloFinal;
                    }

                    simbAux.SalvaVPI2PF(_par.lstVPI);

                    _par = null;
                    _lst_par.RemoveAt(_lst_par.Count - 1);

                    if (_lst_par.Count > 0)
                    {
                        _par = _lst_par[_lst_par.Count - 1];
                    }


                    // se tiver paralelo aberto
                    // salva nele o maior y processado dentro dele
                    if (_lst_par.Count > 0)
                    {
                        if (_ultTamY2ParaleloFinal > _par.maiorY)
                        {
                            _par.maiorY = _ultTamY2ParaleloFinal;
                        }
                    }

                    _acumTamX = _posX + _tamX;
                    break;

                case CodigosInterpretaveis.PARALELO_PROXIMO:
                    _tamY = lc.tamY;     // restaura tamanho Y base
                    _tamX = lc.tamX / 3; // tamanho X reduzido

                    if (_maiorX > _par.maiorX)
                    {
                        _par.maiorX = _maiorX;
                    }
                    _maiorX = 0;

                    _posX = _par.par.posicaoXY.X;

                    _par._yAcum = _par.maiorY;
                    _posY       = _par.maiorY + (lc.tamY * (_par.numVPITratados + 1));

                    // caso seja o primeiro VPI(NXB) atualiza o SIZE do PI(BST)
                    // caso seja o segundo VPI em diante, atualiza SIZE do VPI anterior
                    if (_par.numVPITratados > 0)
                    {
                        _ctrlLivreAux           = _par.ultimoVPI;
                        _ctrlLivreAux.UltimoVPI = false;
                    }
                    else
                    {
                        _ctrlLivreAux = _par.par;
                    }

                    _ctrlLivreAux.tamanhoXY = new Size(_ctrlLivreAux.tamanhoXY.Width, _posY - _ctrlLivreAux.posicaoXY.Y);

                    _par.numVPITratados   += 1;
                    _par.ultimoVPI         = simbAux;
                    _ultTamY2ParaleloFinal = _posY;

                    _par.lstVPI.Add(simbAux);

                    _acumTamX = _posX + _tamX;
                    break;

                default:
                    _tamY      = lc.tamY;
                    _tamX      = lc.tamX;
                    _posX      = _acumTamX;
                    _acumTamX += _tamX;
                    break;
                }

                // posiciona e dimensiona simbolo
                simbAux.posicaoXY = new Point(_posX, _posY);
                simbAux.tamanhoXY = new Size(_tamX, _tamY);

                simbAux.Location = new Point(_posX, _posY);
                simbAux.Size     = new Size(_tamX, _tamY);
            }

            _tamY2DesenhoFundo += lc.tamY;

            //--Inicio da linha
            lc.simboloInicioLinha.posicaoXY = new Point(lc.posX, lc.posY);
            lc.simboloInicioLinha.tamanhoXY = new Size(lc.tamX, _tamY2DesenhoFundo);

            //--Fim da linha
            DiagramaLadder dlFormAux = null;

            dlFormAux = (DiagramaLadder)lc.frmDiag;
            if (_acumTamX < (dlFormAux.Width - lc.tamX))
            {
                _acumTamX = (dlFormAux.Width - lc.tamX);
            }

            lc.simboloFimLinha.posicaoXY = new Point(_acumTamX, lc.posY);
            lc.simboloFimLinha.tamanhoXY = new Size(lc.tamX, _tamY2DesenhoFundo);

            //--Desenho de fundo
            lc.simboloFimLinha.posicaoXY = new Point(lc.posX, lc.posY);
            lc.simboloFimLinha.tamanhoXY = new Size(_acumTamX, _tamY2DesenhoFundo);

            RedimensionaSimbolos(lc);
        }
        public void AjustaPosicionamento()
        {
            ControleLivre _ctrlLivreAux = null;

            int _maiorX = 0;

            /// Variaveis para desenhar os simbolos de saida
            /// sempre no final da linha
            int _contaNumSimbolos = 0;
            int _guardaAcumXnoPrimeiroSimbSaida = 0;
            int _guardaAcumXnoMaiorSimbSaida    = 0;
            int _guardaTamSaida = 0;

            SuporteParalelo        _par     = null;
            List <SuporteParalelo> _lst_par = new List <SuporteParalelo>();

            /// acumula o tamanho Y (pos+tam) do ultimo
            /// VPI tratado dentro de um mesmo paralelo
            /// seu valor e usado para informar
            /// ao PF qual o seu tamanho Y
            int _ultTamY2ParaleloFinal = 0;

            int _tamY2DesenhoFundo = 0;

            /// Variaveis auxiliares para posicionamento
            ///  dos controles
            int _posX     = posX;      // auxiliar para posX
            int _posY     = posY;      // auxiliar para posY
            int _tamX     = this.tamX; // auxiliar para tamX
            int _tamY     = tamY;      // auxiliar para tamY
            int _acumTamX = 0;         // usado para acumular o valor de X na sequencia
            // em que os simbolos sao montados
            int _acumTamY = tamY;      // auxiliar para tamY

            _acumTamX += this.tamX;

            simbolos.AddRange(saida);

            foreach (ControleLivre simbAux in simbolos)
            {
                _contaNumSimbolos++;

                // caso todos os paralelos abertos tenham sido
                // tratados forca paralelos tratados = 0
                if (_lst_par.Count == 0)
                {
                    if (_maiorX > 0)
                    {
                        _posX = _maiorX;
                    }

                    _maiorX = 0;
                }
                else
                {
                    if (_maiorX < (_posX + _tamX))
                    {
                        _maiorX = _posX + _tamX;
                    }
                }

                switch (simbAux.getCI())
                {
                case CodigosInterpretaveis.PARALELO_INICIAL:
                    _tamY = tamY;     // restaura tamanho Y base
                    _posX = _acumTamX;
                    _tamX = this.tamX / 3;

                    _par = new SuporteParalelo();
                    _lst_par.Add(_par);

                    _par._yAcum = _posY;
                    _par.maiorY = _posY;
                    _par.maiorX = _maiorX;
                    _par.par    = simbAux;

                    _acumTamX = _posX + _tamX;
                    break;

                case CodigosInterpretaveis.PARALELO_FINAL:
                    _tamX = this.tamX / 3;
                    //                        _tamY = _par.ultimoVPI.Location.Y - _par.par.Location.Y + _par.ultimoVPI.Size.Height; // _ultTamY2ParaleloFinal;
                    _tamY = _par.ultimoVPI.posicaoXY.Y - _par.par.posicaoXY.Y + _par.ultimoVPI.tamanhoXY.Height;     // _ultTamY2ParaleloFinal;
                    _posY = _par.par.posicaoXY.Y;

                    if (_maiorX > _par.maiorX)
                    {
                        _par.maiorX = _maiorX;
                    }

                    _posX = _par.maiorX;

                    // Salva (por paralelo) o maior tamanho Y para os simbolos
                    // linha inicial / final e desenho de fundo
                    if (_ultTamY2ParaleloFinal > _tamY2DesenhoFundo)
                    {
                        _tamY2DesenhoFundo = _ultTamY2ParaleloFinal;
                    }

                    simbAux.SalvaVPI2PF(_par.lstVPI);

                    /// Faz os apontamentos de paralelo
                    ///  para facilitar futuras buscas de paralelos
                    simbAux.Aponta2PI            = _par.par;
                    _par.par.Aponta2PF           = simbAux;
                    _par.ultimoVPI.Aponta2proxPP = simbAux;

                    _par.ultimoVPI.UltimoVPI = true;

                    _par = null;
                    _lst_par.RemoveAt(_lst_par.Count - 1);

                    if (_lst_par.Count > 0)
                    {
                        _par = _lst_par[_lst_par.Count - 1];
                    }


                    // se tiver paralelo aberto
                    // salva nele o maior y processado dentro dele
                    if (_lst_par.Count > 0)
                    {
                        if (_ultTamY2ParaleloFinal > _par.maiorY)
                        {
                            _par.maiorY = _ultTamY2ParaleloFinal;
                        }
                    }

                    _acumTamX = _posX + _tamX;
                    break;

                case CodigosInterpretaveis.PARALELO_PROXIMO:
                    _tamY = tamY;          // restaura tamanho Y base
                    _tamX = this.tamX / 3; // tamanho X reduzido

                    if (_maiorX > _par.maiorX)
                    {
                        _par.maiorX = _maiorX;
                    }
                    _maiorX = 0;

                    _posX = _par.par.posicaoXY.X;

                    _par._yAcum = _par.maiorY;
                    _posY       = _par.maiorY + (tamY * (_par.numVPITratados + 1));

                    // caso seja o primeiro VPI(NXB) atualiza o SIZE do PI(BST)
                    // caso seja o segundo VPI em diante, atualiza SIZE do VPI anterior
                    if (_par.numVPITratados > 0)
                    {
                        _ctrlLivreAux           = _par.ultimoVPI;
                        _ctrlLivreAux.UltimoVPI = false;
                    }
                    else
                    {
                        _ctrlLivreAux = _par.par;
                    }

                    _ctrlLivreAux.tamanhoXY = new Size(_ctrlLivreAux.tamanhoXY.Width, _posY - _ctrlLivreAux.posicaoXY.Y);

                    /// PARA FACILITAR A BUSCA DO PROXIMO PONTO DE PARALELO
                    _ctrlLivreAux.Aponta2proxPP = simbAux;

                    _par.numVPITratados   += 1;
                    _par.ultimoVPI         = simbAux;
                    _ultTamY2ParaleloFinal = _posY;

                    _par.lstVPI.Add(simbAux);

                    _acumTamX = _posX + _tamX;
                    break;

                default:
                    _tamY      = tamY;
                    _tamX      = this.tamX;
                    _posX      = _acumTamX;
                    _acumTamX += _tamX;
                    break;
                }

                // posiciona e dimensiona simbolo
                simbAux.posicaoXY = new Point(_posX, _posY);
                simbAux.tamanhoXY = new Size(_tamX, _tamY);

                //simbAux.Location = new Point(_posX, _posY);
                //simbAux.Size = new Size(_tamX, _tamY);

                if ((saida.Count > 0) && (_contaNumSimbolos >= (simbolos.Count - saida.Count)))
                {
                    if (_contaNumSimbolos == (simbolos.Count - saida.Count))
                    {
                        _guardaAcumXnoPrimeiroSimbSaida = _acumTamX;
                    }

                    if (_guardaAcumXnoMaiorSimbSaida < _acumTamX)
                    {
                        _guardaAcumXnoMaiorSimbSaida = _acumTamX;
                    }
                }
            }

            //_guardaTamSaida = _guardaAcumXnoPrimeiroSimbSaida;
            _guardaTamSaida = (_guardaAcumXnoMaiorSimbSaida - _guardaAcumXnoPrimeiroSimbSaida);// -this.tamX;
            if (_guardaTamSaida == 0)
            {
                _guardaTamSaida = tamX;
            }

            /// Caso tenha ao menos 1 objeto de saida cria um espaco de meio simbolo
            /// entre o ultimo simbolo e o primeiro de saida
            simbolos.RemoveRange((simbolos.Count - saida.Count), saida.Count);

            _tamY2DesenhoFundo += tamY;

            if ((posY > tamY) && (_tamY2DesenhoFundo > posY))
            {
                _tamY2DesenhoFundo -= posY;
            }

            //--Inicio da linha
            simboloInicioLinha.posicaoXY = new Point(posX, posY);
            simboloInicioLinha.tamanhoXY = new Size(this.tamX, _tamY2DesenhoFundo);
            simboloInicioLinha.Location  = new Point(posX, posY);
            simboloInicioLinha.Size      = new Size(this.tamX, _tamY2DesenhoFundo);

            //--Fim da linha
            if (_acumTamX < (frmDiag.Width - this.tamX))
            {
                _acumTamX = (frmDiag.Width - this.tamX);
            }

            if (linhaAnterior != null)
            {
                if (_acumTamX < linhaAnterior.simboloFimLinha.posicaoXY.X)
                {
                    _acumTamX = linhaAnterior.simboloFimLinha.posicaoXY.X;
                }
            }

            posX2primeiroSimbSaida = _acumTamX - _guardaAcumXnoPrimeiroSimbSaida - (_guardaTamSaida);

            simboloFimLinha.posicaoXY = new Point(_acumTamX, posY);
            simboloFimLinha.tamanhoXY = new Size(this.tamX, _tamY2DesenhoFundo);
            simboloFimLinha.Location  = new Point(_acumTamX, posY);
            simboloFimLinha.Size      = new Size(this.tamX, _tamY2DesenhoFundo);

            //--Desenho de fundo
            simboloDesenhoFundo.posicaoXY = new Point(posX, posY);
            simboloDesenhoFundo.tamanhoXY = new Size(_acumTamX, _tamY2DesenhoFundo);
            simboloDesenhoFundo.Location  = new Point(posX, posY);
            simboloDesenhoFundo.Size      = new Size(_acumTamX, _tamY2DesenhoFundo);

            RedimensionaSimbolos();
        }