public LinhaCompletaVisual(DiagramaLadder _frmDiag, LinhaCompleta _linhaBase)
        {
            frmDiag   = _frmDiag;
            linhaBase = _linhaBase;

            InicializaSimbolosFixosDaLinha();
        }
示例#2
0
        public void AbreDiagramaLadder()
        {
            DiagramaLadder childDiagramaForm = new DiagramaLadder(this.programa);

            childDiagramaForm.linkProjeto = this;
            childDiagramaForm.MdiParent   = this.MdiParent;

            frmDiagLadder = childDiagramaForm;

            childDiagramaForm.ReorganizandoLinhas();

            childDiagramaForm.Show();
        }
示例#3
0
        /// <summary>
        /// Construtor da classe do programa de linhas da visao (controlelivre)
        /// </summary>
        /// <param name="_prgBasico">link para o programa basico (simbolobasico)</param>
        public ProgramaVisual(ProgramaBasico _prgBasico, DiagramaLadder _frmDiag)
        {
            prgBasico = _prgBasico;
            frmDiag   = _frmDiag;

            if (prgBasico.linhas.Count > 0)
            {
                foreach (LinhaCompleta _lc in prgBasico.linhas)
                {
                    LinhaCompletaVisual _lcL = PreparaLinhaQueSeraCriada(_lc);
                    InsereLinhaNoFinal(_lcL);
                }
            }
        }
示例#4
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);
        }