From 42d79006a2ed9e32d77288aa6c82b523fbc04302 Mon Sep 17 00:00:00 2001 From: lnarolski Date: Wed, 30 Oct 2019 20:58:05 +0100 Subject: [PATCH] =?UTF-8?q?Dodanie=20kod=C3=B3w=20=C5=BAr=C3=B3d=C5=82owyc?= =?UTF-8?q?h=20aplikacji=20PLCino=20pozwalaj=C4=85cej=20na=20programowanie?= =?UTF-8?q?=20uk=C5=82ad=C3=B3w=20Arduino=20za=20pomoc=C4=85=20kodu=20drab?= =?UTF-8?q?inkowego?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- PLCino.pro | 67 + dodawanie_zmiennej.cpp | 77 + dodawanie_zmiennej.h | 35 + dodawanie_zmiennej.ui | 202 +++ edycja_specjalna.cpp | 101 ++ edycja_specjalna.h | 176 ++ elementy_drabinki.cpp | 103 ++ elementy_drabinki.h | 22 + elementy_schematu.h | 22 + main.cpp | 21 + model_drabinka.cpp | 361 ++++ model_drabinka.h | 31 + model_uzywane_zmienne.cpp | 92 + model_uzywane_zmienne.h | 35 + plcino.cpp | 3461 +++++++++++++++++++++++++++++++++++++ plcino.h | 130 ++ plcino.ui | 519 ++++++ typy_wyliczeniowe.h | 62 + uzywane_zmienne.cpp | 66 + uzywane_zmienne.h | 37 + uzywane_zmienne.ui | 49 + wybor_portu.cpp | 54 + wybor_portu.h | 30 + wybor_portu.ui | 48 + zasoby.qrc | 11 + zmienna_w_arduino.h | 10 + 26 files changed, 5822 insertions(+) create mode 100644 PLCino.pro create mode 100644 dodawanie_zmiennej.cpp create mode 100644 dodawanie_zmiennej.h create mode 100644 dodawanie_zmiennej.ui create mode 100644 edycja_specjalna.cpp create mode 100644 edycja_specjalna.h create mode 100644 elementy_drabinki.cpp create mode 100644 elementy_drabinki.h create mode 100644 elementy_schematu.h create mode 100644 main.cpp create mode 100644 model_drabinka.cpp create mode 100644 model_drabinka.h create mode 100644 model_uzywane_zmienne.cpp create mode 100644 model_uzywane_zmienne.h create mode 100644 plcino.cpp create mode 100644 plcino.h create mode 100644 plcino.ui create mode 100644 typy_wyliczeniowe.h create mode 100644 uzywane_zmienne.cpp create mode 100644 uzywane_zmienne.h create mode 100644 uzywane_zmienne.ui create mode 100644 wybor_portu.cpp create mode 100644 wybor_portu.h create mode 100644 wybor_portu.ui create mode 100644 zasoby.qrc create mode 100644 zmienna_w_arduino.h diff --git a/PLCino.pro b/PLCino.pro new file mode 100644 index 0000000..381f178 --- /dev/null +++ b/PLCino.pro @@ -0,0 +1,67 @@ +#------------------------------------------------- +# +# Project created by QtCreator 2017-08-02T12:27:50 +# +#------------------------------------------------- + +QT += core gui +QT += serialport + +greaterThan(QT_MAJOR_VERSION, 4): QT += widgets + +TARGET = PLCino +TEMPLATE = app + +# The following define makes your compiler emit warnings if you use +# any feature of Qt which as been marked as deprecated (the exact warnings +# depend on your compiler). Please consult the documentation of the +# deprecated API in order to know how to port your code away from it. +DEFINES += QT_DEPRECATED_WARNINGS + +# You can also make your code fail to compile if you use deprecated APIs. +# In order to do so, uncomment the following line. +# You can also select to disable deprecated APIs only up to a certain version of Qt. +#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000 # disables all the APIs deprecated before Qt 6.0.0 + + +SOURCES += \ + main.cpp \ + plcino.cpp \ + elementy_drabinki.cpp \ + uzywane_zmienne.cpp \ + dodawanie_zmiennej.cpp \ + model_uzywane_zmienne.cpp \ + model_drabinka.cpp \ + wybor_portu.cpp \ + edycja_specjalna.cpp + +HEADERS += \ + plcino.h \ + elementy_drabinki.h \ + typy_wyliczeniowe.h \ + uzywane_zmienne.h \ + dodawanie_zmiennej.h \ + model_uzywane_zmienne.h \ + model_drabinka.h \ + wybor_portu.h \ + zmienna_w_arduino.h \ + edycja_specjalna.h \ + elementy_schematu.h + +FORMS += \ + plcino.ui \ + uzywane_zmienne.ui \ + dodawanie_zmiennej.ui \ + wybor_portu.ui + +DISTFILES += \ + C:/Users/Łukasz/Box Sync/Inżynierka/Ikony/dodaj_kolumne.png \ + C:/Users/Łukasz/Box Sync/Inżynierka/Ikony/dodaj_wiersz.png \ + C:/Users/Łukasz/Box Sync/Inżynierka/Ikony/nowa_linia.png \ + C:/Users/Łukasz/Box Sync/Inżynierka/Ikony/rsz_dodaj_wiersz.png \ + C:/Users/Łukasz/Box Sync/Inżynierka/Ikony/usun_kolumne.png \ + C:/Users/Łukasz/Box Sync/Inżynierka/Ikony/usun_linie.png \ + C:/Users/Łukasz/Box Sync/Inżynierka/Ikony/usun_wiersz.png + +RESOURCES += \ + zasoby.qrc diff --git a/dodawanie_zmiennej.cpp b/dodawanie_zmiennej.cpp new file mode 100644 index 0000000..0f4e233 --- /dev/null +++ b/dodawanie_zmiennej.cpp @@ -0,0 +1,77 @@ +#include "dodawanie_zmiennej.h" +#include "ui_dodawanie_zmiennej.h" +#include +#include + +dodawanie_zmiennej::dodawanie_zmiennej(QMap *lista, model_uzywane_zmienne *model, QString nazwa_zmiennej, QString *adres_nazwy_zmiennej_z_modelu_drabinki, QString numer_pinu, quint32 rodzaj_zmiennej, quint32 typ_pinu, QWidget *parent) : + QDialog(parent), + ui(new Ui::dodawanie_zmiennej) +{ + ui->setupUi(this); + lista_uzywanych_zmiennych = lista; + model_temp = model; + ui->nazwa_zmiennej->setText(nazwa_zmiennej); + ui->numer_pinu->setText(numer_pinu); + ui->rodzaj_zmiennej_comboBox->setCurrentIndex(rodzaj_zmiennej); + ui->typ_pinu_comboBox->setCurrentIndex(typ_pinu); + nazwa_wybranej_zmiennej = adres_nazwy_zmiennej_z_modelu_drabinki; + + if(lista_uzywanych_zmiennych->contains(nazwa_zmiennej)) + ui->nazwa_zmiennej->setReadOnly(true); + else + ui->nazwa_zmiennej->setReadOnly(false); +} + +dodawanie_zmiennej::~dodawanie_zmiennej() +{ + delete ui; +} + +void dodawanie_zmiennej::on_buttonBox_accepted() +{ + if(ui->nazwa_zmiennej->text().isEmpty()) { + QMessageBox msgBox; + msgBox.setText("Pole nazwy zmiennej nie może być puste!!!"); + msgBox.setIcon(QMessageBox::Critical); + msgBox.exec(); + } + else if(lista_uzywanych_zmiennych->contains(ui->nazwa_zmiennej->text())) { + if (ui->nazwa_zmiennej->isReadOnly()) { + lista_uzywanych_zmiennych->insert(ui->nazwa_zmiennej->text(), {ui->numer_pinu->text(), ui->rodzaj_zmiennej_comboBox->currentIndex() + 1, ui->typ_pinu_comboBox->currentIndex() + 1}); + QMessageBox msgBox; + msgBox.setText("Dokonano edycji zmiennej"); + msgBox.setIcon(QMessageBox::Information); + msgBox.exec(); + } + else { + QMessageBox msgBox; + msgBox.setText("Istnieje już taka zmienna!!!"); + msgBox.setIcon(QMessageBox::Critical); + msgBox.exec(); + } + } + else { + if(model_temp != NULL) + model_temp->dodaj_zmienna(ui->nazwa_zmiennej->text(), {ui->numer_pinu->text(), ui->rodzaj_zmiennej_comboBox->currentIndex() + 1, ui->typ_pinu_comboBox->currentIndex() + 1}); //index'y dopasowane do wartości z definicji dla danych zmiennych z pliku typy_wyliczeniowe.h + else + lista_uzywanych_zmiennych->insert(ui->nazwa_zmiennej->text(), {ui->numer_pinu->text(), ui->rodzaj_zmiennej_comboBox->currentIndex() + 1, ui->typ_pinu_comboBox->currentIndex() + 1}); //index'y dopasowane do wartości z definicji dla danych zmiennych z pliku typy_wyliczeniowe.h + if (nazwa_wybranej_zmiennej != NULL) { + *nazwa_wybranej_zmiennej = ui->nazwa_zmiennej->text(); + nazwa_wybranej_zmiennej = NULL; + } + ui->nazwa_zmiennej->clear(); + ui->numer_pinu->clear(); + ui->rodzaj_zmiennej_comboBox->setCurrentIndex(0); + ui->typ_pinu_comboBox->setCurrentIndex(0); + this->hide(); + QMessageBox msgBox; + msgBox.setText("Pomyślnie dodano zmienną."); + msgBox.setIcon(QMessageBox::Information); + msgBox.exec(); + } +} + +void dodawanie_zmiennej::on_buttonBox_rejected() +{ + this->hide(); +} diff --git a/dodawanie_zmiennej.h b/dodawanie_zmiennej.h new file mode 100644 index 0000000..4bac326 --- /dev/null +++ b/dodawanie_zmiennej.h @@ -0,0 +1,35 @@ +#ifndef DODAWANIE_ZMIENNEJ_H +#define DODAWANIE_ZMIENNEJ_H + +#include +#include +#include +#include "model_uzywane_zmienne.h" +#include + +namespace Ui { +class dodawanie_zmiennej; +} + +class dodawanie_zmiennej : public QDialog +{ + Q_OBJECT + +public: + explicit dodawanie_zmiennej(QMap *lista, model_uzywane_zmienne *model, QString nazwa_zmiennej = "", QString *adres_nazwy_zmiennej_z_modelu_drabinki = NULL, QString numer_pinu = "", quint32 rodzaj_zmiennej = 0, quint32 typ_pinu = 0, QWidget *parent = 0); + ~dodawanie_zmiennej(); + +private slots: + void on_buttonBox_accepted(); + + void on_buttonBox_rejected(); + +public: + Ui::dodawanie_zmiennej *ui; +private: + QMap *lista_uzywanych_zmiennych; //adres do listy używanych zmiennych w głównej klasie + model_uzywane_zmienne *model_temp; //adres do modelu danych używanego przez listę używanych zmiennych + QString* nazwa_wybranej_zmiennej; +}; + +#endif // DODAWANIE_ZMIENNEJ_H diff --git a/dodawanie_zmiennej.ui b/dodawanie_zmiennej.ui new file mode 100644 index 0000000..a24de90 --- /dev/null +++ b/dodawanie_zmiennej.ui @@ -0,0 +1,202 @@ + + + dodawanie_zmiennej + + + Qt::WindowModal + + + + 0 + 0 + 400 + 188 + + + + Dodaj nową zmienną + + + false + + + + + + Qt::Horizontal + + + QDialogButtonBox::Cancel|QDialogButtonBox::Ok + + + + + + + QLayout::SetDefaultConstraint + + + + + + 0 + 0 + + + + Podaj nazwę zmiennej: + + + + + + + Qt::Vertical + + + + 20 + 40 + + + + + + + + + + + + Rodzaj zmiennej: + + + Qt::AlignCenter + + + + + + + + Nie dotyczy + + + + + Dyskretna + + + + + Analogowa + + + + + + + + + + + + Typ pinu: + + + Qt::AlignCenter + + + + + + + + Nie dotyczy + + + + + Wejście + + + + + Wyjście + + + + + + + + + + + + + + + + 0 + 0 + + + + Podaj numer pinu: + + + + + + + false + + + + + + + + + nazwa_zmiennej + numer_pinu + rodzaj_zmiennej_comboBox + typ_pinu_comboBox + + + + + buttonBox + accepted() + dodawanie_zmiennej + accept() + + + 257 + 178 + + + 157 + 187 + + + + + buttonBox + rejected() + dodawanie_zmiennej + reject() + + + 325 + 178 + + + 286 + 187 + + + + + diff --git a/edycja_specjalna.cpp b/edycja_specjalna.cpp new file mode 100644 index 0000000..574dfaa --- /dev/null +++ b/edycja_specjalna.cpp @@ -0,0 +1,101 @@ +#include "edycja_specjalna.h" + +edycja_specjalna::edycja_specjalna(elementy_drabinki *temp) +{ + adres_temp = temp; + + switch (adres_temp->rodzaj) { + case blok_funkcyjny: + switch (adres_temp->rodzaj2) { + case LICZNIK: + this->addPage(edycja_licznika()); + break; + case TIMER: + this->addPage(edycja_timera()); + break; + default: + break; + } + break; + case operator_porownania: + this->addPage(edycja_operatora_porownania()); + break; + default: + break; + } +} + +void edycja_specjalna::accept() +{ + switch (adres_temp->rodzaj) { + case blok_funkcyjny: + switch (adres_temp->rodzaj2) { + case LICZNIK: + adres_temp->zmienna = field("podanie_zmiennej_QLineEdit").toString(); + adres_temp->parametry.insert(PV, field("podanie_wartosci_QLineEdit").toString()); + adres_temp->parametry.insert(ZMIENNA_RESETUJACA, field("podanie_zmiennej_resetujacej_QLineEdit").toString()); + this->hide(); + break; + case TIMER: + adres_temp->zmienna = field("podanie_zmiennej_QLineEdit").toString(); + adres_temp->parametry.insert(PV, field("podanie_wartosci_QLineEdit").toString()); + this->hide(); + break; + default: + break; + } + break; + case operator_porownania: + adres_temp->parametry.insert(ELEMENT1, field("podanie_element1_QLineEdit").toString()); + adres_temp->parametry.insert(ELEMENT2, field("podanie_element2_QLineEdit").toString()); + this->hide(); + break; + default: + break; + } +} + +QWizardPage *edycja_specjalna::edycja_licznika() +{ + QWizardPage *strona_okna = new licznik_strona(adres_temp); + + this->setWindowTitle("Edycja licznika"); + + return strona_okna; +} + +QWizardPage *edycja_specjalna::edycja_timera() +{ + QWizardPage *strona_okna = new timer_strona(adres_temp); + + this->setWindowTitle("Edycja timera"); + + return strona_okna; +} + +QWizardPage *edycja_specjalna::edycja_MOVE() +{ + QWizardPage *strona_okna = new move_strona(adres_temp); + + this->setWindowTitle("Edycja bloku MOVE"); + + return strona_okna; +} + +QWizardPage *edycja_specjalna::edycja_operatora_matematycznego() +{ + QWizardPage *strona_okna = new operator_matematyczny_strona(adres_temp); + + this->setWindowTitle("Edycja bloku operatora matematycznego"); + + return strona_okna; +} + +QWizardPage *edycja_specjalna::edycja_operatora_porownania() +{ + QWizardPage *strona_okna = new operator_porownania_strona(adres_temp); + + this->setWindowTitle("Edycja bloku operatora porownania"); + + return strona_okna; +} diff --git a/edycja_specjalna.h b/edycja_specjalna.h new file mode 100644 index 0000000..f1b24cd --- /dev/null +++ b/edycja_specjalna.h @@ -0,0 +1,176 @@ +#ifndef EDYCJA_SPECJALNA_H +#define EDYCJA_SPECJALNA_H + +#include +#include +#include +#include +#include +#include + + +class edycja_specjalna : public QWizard +{ +public: + edycja_specjalna(elementy_drabinki *temp); + + void accept() override; + +private: + elementy_drabinki *adres_temp; + + QWizardPage *edycja_licznika(); + QWizardPage *edycja_timera(); + QWizardPage *edycja_MOVE(); + QWizardPage *edycja_operatora_matematycznego(); + QWizardPage *edycja_operatora_porownania(); +}; + +class licznik_strona : public QWizardPage +{ +public: + licznik_strona(elementy_drabinki *temp) { + adres_temp = temp; + + QLabel *podanie_zmiennej = new QLabel("Podaj zmienną licznika:"); + QLineEdit *podanie_zmiennej_QLineEdit = new QLineEdit(); + podanie_zmiennej_QLineEdit->setText(adres_temp->zmienna); + QLabel *podanie_wartosci = new QLabel("Podaj PV:"); + QLineEdit *podanie_wartosci_QLineEdit = new QLineEdit(); + podanie_wartosci_QLineEdit->setInputMask("99999"); + podanie_wartosci_QLineEdit->setText(adres_temp->parametry.value(PV)); + QLabel *podanie_zmiennej_resetujacej = new QLabel("Podaj zmienną resetujacą:"); + QLineEdit *podanie_zmiennej_resetujacej_QLineEdit = new QLineEdit(); + podanie_zmiennej_resetujacej_QLineEdit->setText(adres_temp->parametry.value(ZMIENNA_RESETUJACA)); + + QVBoxLayout *layout = new QVBoxLayout; + layout->addWidget(podanie_zmiennej); + layout->addWidget(podanie_zmiennej_QLineEdit); + layout->addWidget(podanie_wartosci); + layout->addWidget(podanie_wartosci_QLineEdit); + layout->addWidget(podanie_zmiennej_resetujacej); + layout->addWidget(podanie_zmiennej_resetujacej_QLineEdit); + this->setLayout(layout); + + this->registerField("podanie_zmiennej_QLineEdit", podanie_zmiennej_QLineEdit); + this->registerField("podanie_wartosci_QLineEdit", podanie_wartosci_QLineEdit); + this->registerField("podanie_zmiennej_resetujacej_QLineEdit", podanie_zmiennej_resetujacej_QLineEdit); + } + + elementy_drabinki *adres_temp; +}; + +class timer_strona : public QWizardPage +{ +public: + timer_strona(elementy_drabinki *temp) { + adres_temp = temp; + + QLabel *podanie_zmiennej = new QLabel("Podaj zmienną timera:"); + QLineEdit *podanie_zmiennej_QLineEdit = new QLineEdit(); + podanie_zmiennej_QLineEdit->setText(adres_temp->zmienna); + QLabel *podanie_wartosci = new QLabel("Podaj PT(ms):"); + QLineEdit *podanie_wartosci_QLineEdit = new QLineEdit(); + podanie_wartosci_QLineEdit->setInputMask("99999"); + podanie_wartosci_QLineEdit->setText(adres_temp->parametry.value(PV)); + + QVBoxLayout *layout = new QVBoxLayout; + layout->addWidget(podanie_zmiennej); + layout->addWidget(podanie_zmiennej_QLineEdit); + layout->addWidget(podanie_wartosci); + layout->addWidget(podanie_wartosci_QLineEdit); + this->setLayout(layout); + + this->registerField("podanie_zmiennej_QLineEdit", podanie_zmiennej_QLineEdit); + this->registerField("podanie_wartosci_QLineEdit", podanie_wartosci_QLineEdit); + } + + elementy_drabinki *adres_temp; +}; + +class move_strona : public QWizardPage +{ +public: + move_strona(elementy_drabinki *temp) { + adres_temp = temp; + + QLabel *podanie_wartosci = new QLabel("Podaj element do przeniesienia:"); + QLineEdit *podanie_wartosci_QLineEdit = new QLineEdit(); + podanie_wartosci_QLineEdit->setText(adres_temp->parametry.value(ELEMENT_DO_PRZENIESIENIA)); + QLabel *podanie_zmiennej_docelowej = new QLabel("Podaj zmienną docelową:"); + QLineEdit *podanie_zmiennej_docelowej_QLineEdit = new QLineEdit(); + podanie_zmiennej_docelowej_QLineEdit->setText(adres_temp->parametry.value(ZMIENNA_DOCELOWA)); + + QVBoxLayout *layout = new QVBoxLayout; + layout->addWidget(podanie_wartosci); + layout->addWidget(podanie_wartosci_QLineEdit); + layout->addWidget(podanie_zmiennej_docelowej); + layout->addWidget(podanie_zmiennej_docelowej_QLineEdit); + this->setLayout(layout); + + this->registerField("podanie_wartosci_QLineEdit", podanie_wartosci_QLineEdit); + this->registerField("podanie_zmiennej_docelowej_QLineEdit", podanie_zmiennej_docelowej_QLineEdit); + } + + elementy_drabinki *adres_temp; +}; + +class operator_porownania_strona : public QWizardPage +{ +public: + operator_porownania_strona(elementy_drabinki *temp) { + adres_temp = temp; + + QLabel *napis_informacyjny = new QLabel("Blok porównuje pierwszy element z drugim."); + QLabel *podanie_element1 = new QLabel("Podaj pierwszy element:"); + QLineEdit *podanie_element1_QLineEdit = new QLineEdit(); + podanie_element1_QLineEdit->setText(adres_temp->parametry.value(ELEMENT1)); + QLabel *podanie_element2 = new QLabel("Podaj drugi element:"); + QLineEdit *podanie_element2_QLineEdit = new QLineEdit(); + podanie_element2_QLineEdit->setText(adres_temp->parametry.value(ELEMENT2)); + + QVBoxLayout *layout = new QVBoxLayout; + layout->addWidget(napis_informacyjny); + layout->addWidget(podanie_element1); + layout->addWidget(podanie_element1_QLineEdit); + layout->addWidget(podanie_element2); + layout->addWidget(podanie_element2_QLineEdit); + this->setLayout(layout); + + this->registerField("podanie_element1_QLineEdit", podanie_element1_QLineEdit); + this->registerField("podanie_element2_QLineEdit", podanie_element2_QLineEdit); + } + + elementy_drabinki *adres_temp; +}; + +class operator_matematyczny_strona : public QWizardPage +{ +public: + operator_matematyczny_strona(elementy_drabinki *temp) { + adres_temp = temp; + + QLabel *napis_informacyjny = new QLabel("Blok przeprowadza działanie matematyczne i zapisuje jego wynik w miejscu pierwszego elementu."); + QLabel *podanie_element1 = new QLabel("Podaj pierwszy element:"); + QLineEdit *podanie_element1_QLineEdit = new QLineEdit(); + podanie_element1_QLineEdit->setText(adres_temp->parametry.value(ELEMENT1)); + QLabel *podanie_element2 = new QLabel("Podaj drugi element:"); + QLineEdit *podanie_element2_QLineEdit = new QLineEdit(); + podanie_element2_QLineEdit->setText(adres_temp->parametry.value(ELEMENT2)); + + QVBoxLayout *layout = new QVBoxLayout; + layout->addWidget(napis_informacyjny); + layout->addWidget(podanie_element1); + layout->addWidget(podanie_element1_QLineEdit); + layout->addWidget(podanie_element2); + layout->addWidget(podanie_element2_QLineEdit); + this->setLayout(layout); + + this->registerField("podanie_element1_QLineEdit", podanie_element1_QLineEdit); + this->registerField("podanie_element2_QLineEdit", podanie_element2_QLineEdit); + } + + elementy_drabinki *adres_temp; +}; + +#endif // EDYCJA_SPECJALNA_H diff --git a/elementy_drabinki.cpp b/elementy_drabinki.cpp new file mode 100644 index 0000000..c5109f5 --- /dev/null +++ b/elementy_drabinki.cpp @@ -0,0 +1,103 @@ +#include "elementy_drabinki.h" + +elementy_drabinki::elementy_drabinki(elementy rodzaj, quint32 rodzaj2) +{ + this->rodzaj = rodzaj; + this->rodzaj2 = rodzaj2; + switch (rodzaj) { + case cewka: + switch (rodzaj2) { + case ZWYKLA: + nazwa = "\n-( )\n"; + break; + default: + nazwa = "\n-(/)\n"; + break; + } + break; + case styk: + switch (rodzaj2) { + case ZWYKLY: + nazwa = "\n-| |-\n"; + break; + default: + nazwa = "\n-|/|-\n"; + break; + } + break; + case operator_porownania: + switch (rodzaj2) { + case ROWNY: + nazwa = "\n-| = |-\n"; + break; + case ROZNY: + nazwa = "\n-| != |-\n"; + break; + case WIEKSZY: + nazwa = "\n-| > |-\n"; + break; + case WIEKSZY_BADZ_ROWNY: + nazwa = "\n-| >= |-\n"; + break; + case MNIEJSZY: + nazwa = "\n-| < |-\n"; + break; + default: + nazwa = "\n-| <= |-\n"; + break; + } + break; + case blok_funkcyjny: + switch (rodzaj2) { + case TIMER: + nazwa = "\n-|TON|\n"; + break; + default: + nazwa = "\n-|CTU|\n"; + parametry.insert(PV, ""); + parametry.insert(ZMIENNA_RESETUJACA, ""); + break; + } + break; + case lacznik: + switch (rodzaj2) { + case LEWO_PRAWO: + nazwa = "\n─\n"; + break; + case GORA_DOL: + nazwa = "\n│\n"; + break; + case DOL_PRAWO: + nazwa = "\n┌\n"; + break; + case DOL_LEWO: + nazwa = "\n┐\n"; + break; + case GORA_PRAWO: + nazwa = "\n└\n"; + break; + case GORA_LEWO: + nazwa = "\n┘\n"; + break; + case GORA_PRAWO_DOL: + nazwa = "\n├\n"; + break; + case GORA_LEWO_DOL: + nazwa = "\n┤\n"; + break; + case LEWO_DOL_PRAWO: + nazwa = "\n┬\n"; + break; + case LEWO_GORA_PRAWO: + nazwa = "\n┴\n"; + break; + default: + nazwa = "\n┼\n"; + break; + } + break; + default: + nazwa = "\n\n\n"; + break; + } +} diff --git a/elementy_drabinki.h b/elementy_drabinki.h new file mode 100644 index 0000000..4310755 --- /dev/null +++ b/elementy_drabinki.h @@ -0,0 +1,22 @@ +#ifndef ELEMENTY_DRABINKI_H +#define ELEMENTY_DRABINKI_H + +#include +#include +#include +#include +#include + +class elementy_drabinki +{ +public: + elementy rodzaj; //rodzaj na podstawie typu wyliczeniowego + quint32 rodzaj2; //"podrodzaj" elementu - na podstawie stałych preprocesora + QString zmienna; //nazwa zmiennej do ktorej obiekt sie odwoluje + QString nazwa; //symboliczna nazwa elementu + + elementy_drabinki(elementy rodzaj = pusty, quint32 rodzaj2 = 0); //konstruktor + QMap parametry; +}; + +#endif // ELEMENTY_DRABINKI_H diff --git a/elementy_schematu.h b/elementy_schematu.h new file mode 100644 index 0000000..0ded032 --- /dev/null +++ b/elementy_schematu.h @@ -0,0 +1,22 @@ +#ifndef KOMPILATOR_H +#define KOMPILATOR_H + +class elementy_schematu +{ +public: + elementy_schematu(elementy_drabinki* a, int linia, int kolumna, int wiersz) { + element = a; + numer_linii = linia; + numer_kolumny = kolumna; + numer_wiersza = wiersz; + } + + elementy_drabinki* element; + QList wejscia_elementu; + QList wyjscia_elementu; + int numer_linii; + int numer_kolumny; + int numer_wiersza; +}; + +#endif // KOMPILATOR_H diff --git a/main.cpp b/main.cpp new file mode 100644 index 0000000..fc69d70 --- /dev/null +++ b/main.cpp @@ -0,0 +1,21 @@ +#include "plcino.h" +#include +#include +#include +#include + +int main(int argc, char *argv[]) +{ + QApplication a(argc, argv); +#ifndef QT_NO_TRANSLATION + QString translatorFileName = QLatin1String("qt_"); + translatorFileName += QLocale::system().name(); + QTranslator *translator = new QTranslator(&a); + if (translator->load(translatorFileName, QLibraryInfo::location(QLibraryInfo::TranslationsPath))) + a.installTranslator(translator); +#endif + PLCino w; + w.show(); + + return a.exec(); +} diff --git a/model_drabinka.cpp b/model_drabinka.cpp new file mode 100644 index 0000000..1921a89 --- /dev/null +++ b/model_drabinka.cpp @@ -0,0 +1,361 @@ +#include "model_drabinka.h" +#include "QDebug" +#include +#include +#include + +model_drabinka::model_drabinka(QObject *parent, int x, int y) : + QAbstractTableModel(parent) +{ + for(int i = 0; i < y; ++i) { + model_dane.append(new QList); + for (int j = 0; j < x; ++j) { + model_dane[i]->append(new elementy_drabinki(pusty)); + } + } + kolumny_temp = 0; +} + +int model_drabinka::rowCount(const QModelIndex & /*parent*/) const +{ + return model_dane.count(); +} + +int model_drabinka::columnCount(const QModelIndex & /*parent*/) const +{ + if (model_dane.count()) { + return model_dane.at(0)->count(); + } + else { + return 0; + } +} + +bool model_drabinka::insertRow(int row, const QModelIndex &parent) +{ + beginResetModel(); + beginInsertRows(parent, row, row); + int ograniczenie; + if (!model_dane.count()) + ograniczenie = kolumny_temp; + else + ograniczenie = model_dane.at(0)->count(); + model_dane.insert(row, new QList); + for(int i = 0; i < ograniczenie; ++i) { + model_dane.at(row)->insert(i, new elementy_drabinki(pusty)); + } + endInsertRows(); + endResetModel(); + return true; +} + +bool model_drabinka::insertColumn(int column, const QModelIndex &parent) +{ + beginInsertColumns(parent, column, column); + for(int i = 0; i < model_dane.count(); ++i) { + model_dane.at(i)->insert(column, new elementy_drabinki(pusty)); + } + endInsertColumns(); + return true; +} + +bool model_drabinka::removeRow(int row, const QModelIndex &parent) +{ + beginResetModel(); + if (model_dane.count() == 1) + kolumny_temp = model_dane.at(0)->count(); + beginRemoveRows(parent, row, row); + while(model_dane.at(row)->size()) { + model_dane.at(row)->removeLast(); + } + model_dane.removeAt(row); + endRemoveRows(); + endResetModel(); + return true; +} + +bool model_drabinka::removeColumn(int column, const QModelIndex &parent) +{ + beginRemoveColumns(parent, column, column); + for(int i = 0; i < model_dane.count(); ++i) { + model_dane.at(i)->removeAt(column); + } + endRemoveColumns(); + return true; +} + +bool model_drabinka::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent) +{ + if (action == Qt::IgnoreAction) + return true; + if (!data->hasFormat("application/x-qabstractitemmodeldatalist")) //gdy nie zgadza się typ MIME z tym używanym w programie + return false; + if (parent.row() < 0 || parent.column() < 0) //jeśli nie upuszczono w którejś z komórek tabeli + return false; + QByteArray dane_mime = data->data("application/x-qabstractitemmodeldatalist"); + QString upuszczony_element; + + //Aby pozbyć się znaków '\0' z "dane_mime" : + QDataStream stream(&dane_mime, QIODevice::ReadOnly); + QMap dane_mime_QMap; + while (!stream.atEnd()) + { + int row_temp, col_temp; + stream >> row_temp >> col_temp >> dane_mime_QMap; + } + upuszczony_element = dane_mime_QMap[0].toString(); + // + if (upuszczony_element == "Zwykła -( )-") { + model_dane.at(parent.row())->replace(parent.column(), new elementy_drabinki(cewka, ZWYKLA)); + } + else if (upuszczony_element == "Zanegowana -(/)-") { + model_dane.at(parent.row())->replace(parent.column(), new elementy_drabinki(cewka, ZANEGOWANA)); + } + else if (upuszczony_element == "Zwykły -| |-") { + model_dane.at(parent.row())->replace(parent.column(), new elementy_drabinki(styk, ZWYKLY)); + } + else if (upuszczony_element == "Zanegowany -|/|-") { + model_dane.at(parent.row())->replace(parent.column(), new elementy_drabinki(styk, ZANEGOWANY)); + } + else if (upuszczony_element == "Timer TON") { + model_dane.at(parent.row())->replace(parent.column(), new elementy_drabinki(blok_funkcyjny, TIMER)); + } + else if (upuszczony_element == "Licznik CTU") { + model_dane.at(parent.row())->replace(parent.column(), new elementy_drabinki(blok_funkcyjny, LICZNIK)); + } + else if (upuszczony_element == "─") { + model_dane.at(parent.row())->replace(parent.column(), new elementy_drabinki(lacznik, LEWO_PRAWO)); + } + else if (upuszczony_element == "│") { + model_dane.at(parent.row())->replace(parent.column(), new elementy_drabinki(lacznik, GORA_DOL)); + } + else if (upuszczony_element == "┌") { + model_dane.at(parent.row())->replace(parent.column(), new elementy_drabinki(lacznik, DOL_PRAWO)); + } + else if (upuszczony_element == "┐") { + model_dane.at(parent.row())->replace(parent.column(), new elementy_drabinki(lacznik, DOL_LEWO)); + } + else if (upuszczony_element == "└") { + model_dane.at(parent.row())->replace(parent.column(), new elementy_drabinki(lacznik, GORA_PRAWO)); + } + else if (upuszczony_element == "┘") { + model_dane.at(parent.row())->replace(parent.column(), new elementy_drabinki(lacznik, GORA_LEWO)); + } + else if (upuszczony_element == "├") { + model_dane.at(parent.row())->replace(parent.column(), new elementy_drabinki(lacznik, GORA_PRAWO_DOL)); + } + else if (upuszczony_element == "┤") { + model_dane.at(parent.row())->replace(parent.column(), new elementy_drabinki(lacznik, GORA_LEWO_DOL)); + } + else if (upuszczony_element == "┬") { + model_dane.at(parent.row())->replace(parent.column(), new elementy_drabinki(lacznik, LEWO_DOL_PRAWO)); + } + else if (upuszczony_element == "┴") { + model_dane.at(parent.row())->replace(parent.column(), new elementy_drabinki(lacznik, LEWO_GORA_PRAWO)); + } + else if (upuszczony_element == "┼") { + model_dane.at(parent.row())->replace(parent.column(), new elementy_drabinki(lacznik, GORA_DOL_LEWO_PRAWO)); + } + else if (upuszczony_element == "Większe >") { + model_dane.at(parent.row())->replace(parent.column(), new elementy_drabinki(operator_porownania, WIEKSZY)); + } + else if (upuszczony_element == "Większe bądź równe >=") { + model_dane.at(parent.row())->replace(parent.column(), new elementy_drabinki(operator_porownania, WIEKSZY_BADZ_ROWNY)); + } + else if (upuszczony_element == "Mniejsze <") { + model_dane.at(parent.row())->replace(parent.column(), new elementy_drabinki(operator_porownania, MNIEJSZY)); + } + else if (upuszczony_element == "Mniejsze bądź równe <=") { + model_dane.at(parent.row())->replace(parent.column(), new elementy_drabinki(operator_porownania, MNIEJSZY_BADZ_ROWNY)); + } + else if (upuszczony_element == "Równe ==") { + model_dane.at(parent.row())->replace(parent.column(), new elementy_drabinki(operator_porownania, ROWNY)); + } + else if (upuszczony_element == "Różne !=") { + model_dane.at(parent.row())->replace(parent.column(), new elementy_drabinki(operator_porownania, ROZNY)); + } + return true; +} + +Qt::DropActions model_drabinka::supportedDropActions() const +{ + return Qt::CopyAction; +} + +Qt::ItemFlags model_drabinka::flags(const QModelIndex &index) const +{ + return Qt::ItemIsDropEnabled | Qt::ItemIsSelectable | Qt::ItemIsEnabled; +} + +QVariant model_drabinka::data(const QModelIndex &index, int role) const +{ + if (role == Qt::FontRole) + return QFont("MS Shell Dlg 2", 12, QFont::Normal); + if (role == Qt::TextAlignmentRole ) + return Qt::AlignCenter; + if (role == Qt::DecorationRole) { + return generowanie_grafik(model_dane.at(index.row())->at(index.column())); + } +// if (role == Qt::DisplayRole) +// { +// if (model_dane.at(index.row())->at(index.column())->rodzaj != pusty) +// if (model_dane.at(index.row())->at(index.column())->rodzaj != operator_porownania) +// return model_dane.at(index.row())->at(index.column())->zmienna + "\n" + model_dane.at(index.row())->at(index.column())->nazwa + "\n"; +// else +// return model_dane.at(index.row())->at(index.column())->parametry.value(ELEMENT1) + "\n" + model_dane.at(index.row())->at(index.column())->nazwa + "\n" + model_dane.at(index.row())->at(index.column())->parametry.value(ELEMENT2); +// else +// return model_dane.at(index.row())->at(index.column())->nazwa; +// } + return QVariant(); +} + +QPixmap model_drabinka::generowanie_grafik(elementy_drabinki *element) const +{ + QPixmap grafika(100,100); + QPainter painter(&grafika); + painter.setBrush(Qt::white); + painter.setPen(Qt::white); + painter.drawRect(0,0,100,100); + painter.setPen(Qt::black); + switch (element->rodzaj) { + case lacznik: + switch (element->rodzaj2) { + case LEWO_PRAWO: + painter.drawLine(0,50,100,50); + break; + case GORA_DOL: + painter.drawLine(50,0,50,100); + break; + case DOL_PRAWO: + painter.drawLine(50,50,100,50); + painter.drawLine(50,50,50,100); + break; + case DOL_LEWO: + painter.drawLine(50,50,50,100); + painter.drawLine(50,50,0,50); + break; + case GORA_PRAWO: + painter.drawLine(50,50,100,50); + painter.drawLine(50,50,50,0); + break; + case GORA_LEWO: + painter.drawLine(50,50,50,0); + painter.drawLine(50,50,0,50); + break; + case GORA_PRAWO_DOL: + painter.drawLine(50,0,50,100); + painter.drawLine(50,50,100,50); + break; + case GORA_LEWO_DOL: + painter.drawLine(50,0,50,100); + painter.drawLine(50,50,0,50); + break; + case LEWO_DOL_PRAWO: + painter.drawLine(0,50,100,50); + painter.drawLine(50,50,50,100); + break; + case LEWO_GORA_PRAWO: + painter.drawLine(0,50,100,50); + painter.drawLine(50,50,50,0); + break; + case GORA_DOL_LEWO_PRAWO: + painter.drawLine(0,50,100,50); + painter.drawLine(50,0,50,100); + break; + default: + break; + } + break; + case cewka: + painter.drawLine(0,50,30,50); +// painter.drawLine(70,50,100,50); + painter.drawArc(30,30,10,40,16 * 90, 16 * 180); + painter.drawArc(50,30,10,40,16 * -90, 16 * 180); + painter.drawText(0,2,100,15,Qt::AlignCenter,element->zmienna); + switch (element->rodzaj2) { + case ZWYKLA: + break; + case ZANEGOWANA: + painter.drawLine(40,70,50,30); + break; + default: + break; + } + break; + case styk: + painter.drawLine(0,50,30,50); + painter.drawLine(70,50,100,50); + painter.drawLine(30,30,30,70); + painter.drawLine(70,30,70,70); + painter.drawText(0,2,100,15,Qt::AlignCenter,element->zmienna); + switch (element->rodzaj2) { + case ZWYKLY: + break; + case ZANEGOWANY: + painter.drawLine(35,70,65,30); + break; + default: + break; + } + break; + case operator_porownania: + painter.drawLine(0,50,30,50); + painter.drawLine(70,50,100,50); + painter.drawLine(30,30,30,70); + painter.drawLine(70,30,70,70); + painter.drawText(0,10,100,15,Qt::AlignCenter,element->parametry.value(ELEMENT1)); + painter.drawText(0,80,100,15,Qt::AlignCenter,element->parametry.value(ELEMENT2)); + switch (element->rodzaj2) { + case ROWNY: + painter.drawText(30,45,40,10,Qt::AlignCenter,"=="); + case ROZNY: + painter.drawText(30,45,40,10,Qt::AlignCenter,"!="); + break; + case WIEKSZY: + painter.drawText(30,45,40,10,Qt::AlignCenter,">"); + break; + case WIEKSZY_BADZ_ROWNY: + painter.drawText(30,45,40,10,Qt::AlignCenter,">="); + break; + case MNIEJSZY: + painter.drawText(30,45,40,10,Qt::AlignCenter,"<"); + break; + case MNIEJSZY_BADZ_ROWNY: + painter.drawText(30,45,40,10,Qt::AlignCenter,"<="); + break; + default: + break; + } + break; + case blok_funkcyjny: + painter.drawRect(35,15,55,80); + painter.drawLine(0,50,35,50); + painter.drawText(0,2,100,10,Qt::AlignCenter,element->zmienna); + switch (element->rodzaj2) { + case TIMER: + painter.drawText(20,15,70,15,Qt::AlignRight,"TON"); + painter.drawText(40,45,70,15,Qt::AlignLeft,"IN"); + painter.drawText(20,80,70,15,Qt::AlignRight,"1 ms"); + painter.drawLine(30,75,35,75); + painter.drawText(40,70,55,15,Qt::AlignLeft,"PT"); + painter.drawText(0,70,35,10,Qt::AlignCenter,element->parametry.value(PV)); + break; + case LICZNIK: + painter.drawText(20,15,70,15,Qt::AlignRight,"CTU"); + painter.drawText(40,45,70,15,Qt::AlignLeft,"CU"); + painter.drawLine(30,65,35,65); + painter.drawText(40,60,70,15,Qt::AlignLeft,"R"); + painter.drawText(0,60,35,10,Qt::AlignCenter,element->parametry.value(ZMIENNA_RESETUJACA)); + painter.drawLine(30,80,35,80); + painter.drawText(40,75,70,15,Qt::AlignLeft,"PV"); + painter.drawText(0,75,35,10,Qt::AlignCenter,element->parametry.value(PV)); + break; + default: + break; + } + break; + default: + break; + } + return grafika; +} diff --git a/model_drabinka.h b/model_drabinka.h new file mode 100644 index 0000000..c681cb2 --- /dev/null +++ b/model_drabinka.h @@ -0,0 +1,31 @@ +#ifndef MODEL_DRABINKA_H +#define MODEL_DRABINKA_H + +#include +#include +#include +#include +#include + +class model_drabinka : public QAbstractTableModel +{ + Q_OBJECT +public: + explicit model_drabinka(QObject *parent = 0, int x = 2, int y = 2); //konstruktor z początkową liczbą kolumn(x) i wierszy(y) + int rowCount(const QModelIndex &parent = QModelIndex()) const ; + int columnCount(const QModelIndex &parent = QModelIndex()) const; + bool insertRow(int row, const QModelIndex & parent = QModelIndex()); + bool insertColumn(int column, const QModelIndex & parent = QModelIndex()); + bool removeRow(int row, const QModelIndex & parent = QModelIndex()); + bool removeColumn(int column, const QModelIndex & parent = QModelIndex()); + bool dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent); //reakcja modelu na upuszczenie elementu podczas drag&drop + Qt::DropActions supportedDropActions() const; //obługiwane akcje w tabeli związane z drag&drop + Qt::ItemFlags flags(const QModelIndex &index) const; //flagi dla każdej komórki w tabeli + QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const; //sposób prezentacji danych w każdej z komórek + + int kolumny_temp; //tymczasowa liczba kolumn używana, gdy usuwany jest ostatni wiersz(bo wtedy się bugowało) + QList*> model_dane; //model danych z obiektami z elementy_drabinki.h w postaci tabeli(lista list) + QPixmap generowanie_grafik(elementy_drabinki* element) const; +}; + +#endif // MODEL_DRABINKA_H diff --git a/model_uzywane_zmienne.cpp b/model_uzywane_zmienne.cpp new file mode 100644 index 0000000..9b5add3 --- /dev/null +++ b/model_uzywane_zmienne.cpp @@ -0,0 +1,92 @@ +#include "model_uzywane_zmienne.h" + +model_uzywane_zmienne::model_uzywane_zmienne(QObject *parent) : + QAbstractTableModel(parent) +{ + _map = NULL; +} + +int model_uzywane_zmienne::rowCount(const QModelIndex& parent) const +{ + if (_map) + return _map->count(); + return 0; +} + +int model_uzywane_zmienne::columnCount(const QModelIndex & parent) const +{ + return 4; +} + +QVariant model_uzywane_zmienne::data(const QModelIndex& index, int role) const +{ + if (!_map) + return QVariant(); + if (index.row() < 0 || + index.row() >= _map->count() || + role != Qt::DisplayRole) { + return QVariant(); + } + if (index.column() == 0) + return _map->keys().at(index.row()); + if (index.column() == 1) + return _map->values().at(index.row()).numer_pinu; + if (index.column() == 2) + return typ_zmiennej_QString(_map->values().at(index.row()).typ_zmiennej); + if (index.column() == 3) + return rodzaj_pinu_QString(_map->values().at(index.row()).rodzaj_pinu); + return QVariant(); +} + +void model_uzywane_zmienne::dodaj_zmienna(QString nazwa, zmienna_w_arduino zmienna) { + beginInsertRows(QModelIndex(), rowCount(), rowCount()); + _map->insert(nazwa, {zmienna.numer_pinu, zmienna.typ_zmiennej, zmienna.rodzaj_pinu}); + endInsertRows(); +} + +void model_uzywane_zmienne::usun_zmienna(QString nazwa) { + beginResetModel(); + beginRemoveRows(QModelIndex(), rowCount(), rowCount()); + _map->remove(nazwa); + endRemoveRows(); + endResetModel(); +} + +QVariant model_uzywane_zmienne::headerData(int section, Qt::Orientation orientation, int role) const { + + if (role == Qt::DisplayRole && orientation == Qt::Horizontal) { + if (section == 0) + return QString("Nazwa zmiennej"); + else if (section == 1) + return QString("Numer pinu"); + else if (section == 2) + return QString("Typ zmiennej"); + else if (section == 3) + return QString("Rodzaj pinu"); + } + return QAbstractItemModel::headerData(section, orientation, role); +} + +QString model_uzywane_zmienne::typ_zmiennej_QString(quint32 zmienna) const // "const" ?????????????????????????????? +{ + switch (zmienna) { + case NIE_DOTYCZY: + return "Nie dotyczy"; + case DYSKRETNA: + return "Dyskretna"; + default: + return "Analogowa"; + } +} + +QString model_uzywane_zmienne::rodzaj_pinu_QString(quint32 zmienna) const +{ + switch (zmienna) { + case NIE_DOTYCZY: + return "Nie dotyczy"; + case WEJSCIE: + return "Wejście"; + default: + return "Wyjście"; + } +} diff --git a/model_uzywane_zmienne.h b/model_uzywane_zmienne.h new file mode 100644 index 0000000..123ae2c --- /dev/null +++ b/model_uzywane_zmienne.h @@ -0,0 +1,35 @@ +#ifndef MODEL_UZYWANE_ZMIENNE_H +#define MODEL_UZYWANE_ZMIENNE_H + +#include +#include +#include +#include + +class model_uzywane_zmienne : public QAbstractTableModel +{ + Q_OBJECT +public: + + enum MapRoles { + KeyRole = Qt::UserRole + 1, + ValueRole + }; + + explicit model_uzywane_zmienne(QObject *parent = 0); + int rowCount(const QModelIndex& parent = QModelIndex()) const; + int columnCount(const QModelIndex& parent = QModelIndex()) const; + QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const; + inline void setMap(QMap* map) { _map = map; } + void dodaj_zmienna(QString nazwa, zmienna_w_arduino zmienna); + void usun_zmienna(QString nazwa); + QVariant headerData(int section, Qt::Orientation orientation, int role) const; //metoda odpowiedzialna za nadawanie nazw nagłówków + +private: + QMap* _map; //adres do listy używanych zmiennych z głównej klasy PLCino + + QString typ_zmiennej_QString(quint32 zmienna) const; + QString rodzaj_pinu_QString(quint32 zmienna) const; +}; + +#endif // MODEL_UZYWANE_ZMIENNE_H diff --git a/plcino.cpp b/plcino.cpp new file mode 100644 index 0000000..fe39bf2 --- /dev/null +++ b/plcino.cpp @@ -0,0 +1,3461 @@ +#define PROJEKT 0 +#define KOMPILACJA 1 +#define ROZMIAR_BUFORA 10240 + +#include "plcino.h" +#include "ui_plcino.h" +#include "elementy_drabinki.h" +#include + + +PLCino::PLCino(QWidget *parent) : + QMainWindow(parent), + ui(new Ui::PLCino) +{ + ui->setupUi(this); + okno_edycji_zmiennych = NULL; + okno_wyboru_portu = NULL; + okno_dodawanie_zmiennej = NULL; + okno_edycji_specjalnej = NULL; + //maksymalizacja okna aplikacji i blokada zmiany rozmiaru + this->setWindowState(Qt::WindowMaximized); //maksymalizacja okna + this->setFixedSize(QDesktopWidget().availableGeometry(this).size()); //ustawienie stałego rozmiaru okna programu + this->konfiguracja.wybrana_plytka = brak; +} + +PLCino::~PLCino() +{ + delete ui; +} + +void PLCino::on_actionNowy_obwod_triggered() +{ + lista_obwodow.insert(lista_obwodow.size(), new QTableView(this)); + lista_modeli.insert(lista_modeli.size(), new model_drabinka(this)); + lista_obwodow[lista_obwodow.size() - 1]->setModel(lista_modeli[lista_modeli.size() - 1]); + lista_obwodow[lista_obwodow.size() - 1]->setAcceptDrops(true); + lista_obwodow[lista_obwodow.size() - 1]->setDropIndicatorShown(true); + lista_obwodow[lista_obwodow.size() - 1]->setDragDropOverwriteMode(true); + lista_obwodow[lista_obwodow.size() - 1]->setSelectionMode(QAbstractItemView::SingleSelection); //możliwość zaznaczenia tylko jednej komórki + lista_obwodow[lista_obwodow.size() - 1]->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Fixed); + lista_obwodow[lista_obwodow.size() - 1]->setMinimumHeight(400); + lista_obwodow[lista_obwodow.size() - 1]->verticalHeader()->setSectionResizeMode(QHeaderView::Fixed); + lista_obwodow[lista_obwodow.size() - 1]->verticalHeader()->setDefaultSectionSize(100); + lista_obwodow[lista_obwodow.size() - 1]->horizontalHeader()->setSectionResizeMode(QHeaderView::Fixed); + lista_obwodow[lista_obwodow.size() - 1]->horizontalHeader()->setDefaultSectionSize(100); + ui->verticalLayout->addWidget(lista_obwodow[lista_obwodow.size() - 1],0); + connect(lista_obwodow[lista_obwodow.size() - 1], SIGNAL(doubleClicked(const QModelIndex &)), this, SLOT(edycja_wlasciwosci(const QModelIndex &))); //podłączenie sygnału podwójnego kliknięcia do metody edycja_wlasciwosci +// statusBar()->showMessage("Liczba linii: " + QString::number(lista_linii.size()) + " LayoutStretch: " + QString::number(ui->verticalLayout->stretch(lista_linii.size()-1))); //DEBUG +} + +void PLCino::on_actionUsun_obwod_triggered() +{ + for (int i = 0; i < lista_obwodow.size(); i++) { + if(lista_obwodow[i]->hasFocus()) { + QLayoutItem *element_layout = ui->verticalLayout->takeAt(i); //OGARNĄĆ CO TU SIĘ DZIEJE + delete element_layout->widget(); + delete element_layout; + lista_obwodow.removeAt(i); + lista_modeli.removeAt(i); + break; + } + } +} + +void PLCino::on_actionDodaj_kolumne_triggered() +{ + for (int i = 0; i < lista_obwodow.size(); i++) { + if(lista_obwodow[i]->hasFocus()) { + QModelIndexList zaznaczenie = lista_obwodow[i]->selectionModel()->selectedIndexes(); + if(zaznaczenie.length() != 0) + lista_modeli[i]->insertColumn(zaznaczenie[0].column()+1); + else + lista_modeli[i]->insertColumn(0); + } + } +} + +void PLCino::on_actionUsun_kolumne_triggered() +{ + for (int i = 0; i < lista_obwodow.size(); i++) { + if(lista_obwodow[i]->hasFocus()) { + QModelIndexList zaznaczenie = lista_obwodow[i]->selectionModel()->selectedIndexes(); + if(zaznaczenie.length() != 0) + lista_modeli[i]->removeColumn(zaznaczenie[0].column()); + } + } +} + +void PLCino::on_actionDodaj_wiersz_triggered() +{ + for (int i = 0; i < lista_obwodow.size(); i++) { + if(lista_obwodow[i]->hasFocus()) { + QModelIndexList zaznaczenie = lista_obwodow[i]->selectionModel()->selectedIndexes(); + if(zaznaczenie.length() != 0) + lista_modeli[i]->insertRow(zaznaczenie[0].row()+1); + else + lista_modeli[i]->insertRow(0); + } + } +} + + +void PLCino::on_actionUsun_wiersz_triggered() +{ + for (int i = 0; i < lista_obwodow.size(); i++) { + if(lista_obwodow[i]->hasFocus()) { + QModelIndexList zaznaczenie = lista_obwodow[i]->selectionModel()->selectedIndexes(); + if(zaznaczenie.length() != 0) + lista_modeli[i]->removeRow(zaznaczenie[0].row()); + } + } +} + +void PLCino::on_actionUzywane_zmienne_triggered() +{ + if (okno_edycji_zmiennych == NULL) { + okno_edycji_zmiennych = new uzywane_zmienne(&lista_uzywanych_zmiennych, this); + okno_edycji_zmiennych->show(); + } + else { + delete okno_edycji_zmiennych; + okno_edycji_zmiennych = new uzywane_zmienne(&lista_uzywanych_zmiennych, this); + okno_edycji_zmiennych->show(); + } +} + +void PLCino::on_actionPort_triggered() +{ + if(okno_wyboru_portu == NULL) { + okno_wyboru_portu = new Wybor_portu(this, &konfiguracja.nazwa_wybranego_portu); + okno_wyboru_portu->show(); + } + else { + okno_wyboru_portu->show(); + } +} + +void PLCino::edycja_wlasciwosci(const QModelIndex ModelIndex) +{ + if(ModelIndex.isValid()) { + for (int i = 0; i < lista_obwodow.size(); i++) { + if(lista_obwodow[i]->hasFocus()) { + if (lista_modeli[i]->model_dane.at(ModelIndex.row())->at(ModelIndex.column())->rodzaj != pusty && lista_modeli[i]->model_dane.at(ModelIndex.row())->at(ModelIndex.column())->rodzaj != lacznik) { + if (lista_modeli[i]->model_dane.at(ModelIndex.row())->at(ModelIndex.column())->rodzaj != cewka && lista_modeli[i]->model_dane.at(ModelIndex.row())->at(ModelIndex.column())->rodzaj != styk) { + if (okno_edycji_specjalnej == NULL) { + okno_edycji_specjalnej = new edycja_specjalna(lista_modeli[i]->model_dane.at(ModelIndex.row())->at(ModelIndex.column())); + } + else { + delete okno_edycji_specjalnej; + okno_edycji_specjalnej = new edycja_specjalna(lista_modeli[i]->model_dane.at(ModelIndex.row())->at(ModelIndex.column())); + } + okno_edycji_specjalnej->exec(); + } + else { + bool ok; //wciśnięcie przycisku OK w oknie dialogowym + QString zmienna; + zmienna = QInputDialog::getText(this, tr("Wprowadzanie nazwy zmiennej"), + tr("Podaj nazwę zmiennej:"), QLineEdit::Normal, "", &ok); + if (ok) { + if (!lista_uzywanych_zmiennych.contains(zmienna)) { + bool zmienna_jest_liczba; + if (zmienna.toInt(&zmienna_jest_liczba)) { + lista_modeli[i]->model_dane.at(ModelIndex.row())->at(ModelIndex.column())->zmienna = zmienna; + } + else { + if (okno_dodawanie_zmiennej == NULL) + okno_dodawanie_zmiennej = new dodawanie_zmiennej(&lista_uzywanych_zmiennych, NULL, zmienna, &lista_modeli[i]->model_dane.at(ModelIndex.row())->at(ModelIndex.column())->zmienna); + else { + delete okno_dodawanie_zmiennej; + okno_dodawanie_zmiennej = new dodawanie_zmiennej(&lista_uzywanych_zmiennych, NULL, zmienna, &lista_modeli[i]->model_dane.at(ModelIndex.row())->at(ModelIndex.column())->zmienna); + } + // okno_dodawanie_zmiennej->show(); + okno_dodawanie_zmiennej->exec(); //aby nie było można kliknąć niczego poza obszarem okna + } + } + else { + lista_modeli[i]->model_dane.at(ModelIndex.row())->at(ModelIndex.column())->zmienna = zmienna; + } + } + } + } + } + } + } +} + +void PLCino::on_actionLeonadro_triggered() +{ + konfiguracja.wybrana_plytka = leonardo; + ui->actionMega->setChecked(false); + ui->actionNano->setChecked(false); + ui->actionLeonadro->setChecked(true); +} + +void PLCino::on_actionMega_triggered() +{ + konfiguracja.wybrana_plytka = mega; + ui->actionLeonadro->setChecked(false); + ui->actionNano->setChecked(false); + ui->actionMega->setChecked(true); +} + +void PLCino::on_actionNano_triggered() +{ + konfiguracja.wybrana_plytka = nano; + ui->actionMega->setChecked(false); + ui->actionLeonadro->setChecked(false); + ui->actionNano->setChecked(true); +} + +void PLCino::on_actionNowy_triggered() +{ + QMessageBox msgBox; + msgBox.setText("Czy na pewno zamknąć stary projekt?"); + msgBox.setStandardButtons(QMessageBox::Ok | QMessageBox::Cancel); + msgBox.setIcon(QMessageBox::Question); + msgBox.setDefaultButton(QMessageBox::Ok); + int wybrany_przycisk = msgBox.exec(); + if (wybrany_przycisk == QMessageBox::Ok) { + QLayoutItem *element_layout; + while ((element_layout = ui->verticalLayout->takeAt(0)) != 0) { //OGARNĄĆ CO TU SIĘ DZIEJE + delete element_layout->widget(); + delete element_layout; + } + lista_obwodow.clear(); + lista_modeli.clear(); + lista_uzywanych_zmiennych.clear(); + konfiguracja.wybrana_plytka = brak; + } +} + +void PLCino::on_actionZamknij_triggered() +{ + exit(0); +} + +int PLCino::kompilator() +{ + QList liczniki; + QList timery; + QList cewki; + QList rozdzielacze; + QList*> przetworzone_obwody; + QList*> poczatki; + QList*> konce; + + //ROZPOCZĘCIE ANALIZY KOLEJNYCH LINII(poszukiwanie elementów "wykonawczych" i rozdzielaczy) + for (int i = 0; i < lista_modeli.count(); ++i) { + przetworzone_obwody.append(new QList ); + poczatki.append(new QList ); + konce.append(new QList ); + for (int j = 0; j < lista_modeli[i]->model_dane.count(); ++j) { + for (int k = 0; k < lista_modeli[i]->model_dane.at(j)->count(); ++k) { + switch (lista_modeli[i]->model_dane.at(j)->at(k)->rodzaj) { + case lacznik: + switch (lista_modeli[i]->model_dane.at(j)->at(k)->rodzaj2) { + case GORA_PRAWO_DOL: + rozdzielacze.append(new elementy_schematu(lista_modeli[i]->model_dane.at(j)->at(k), i, k, j)); + break; + case GORA_LEWO_DOL: + rozdzielacze.append(new elementy_schematu(lista_modeli[i]->model_dane.at(j)->at(k), i, k, j)); + break; + case LEWO_DOL_PRAWO: + rozdzielacze.append(new elementy_schematu(lista_modeli[i]->model_dane.at(j)->at(k), i, k, j)); + break; + case LEWO_GORA_PRAWO: + rozdzielacze.append(new elementy_schematu(lista_modeli[i]->model_dane.at(j)->at(k), i, k, j)); + break; + case GORA_DOL_LEWO_PRAWO: + rozdzielacze.append(new elementy_schematu(lista_modeli[i]->model_dane.at(j)->at(k), i, k, j)); + break; + default: + break; + } + break; + case blok_funkcyjny: + switch (lista_modeli[i]->model_dane.at(j)->at(k)->rodzaj2) { + case LICZNIK: + liczniki.append(new elementy_schematu(lista_modeli[i]->model_dane.at(j)->at(k), i, k, j)); + przetworzone_obwody[i]->append(new elementy_schematu(lista_modeli[i]->model_dane.at(j)->at(k), i, k, j)); + break; + case TIMER: + timery.append(new elementy_schematu(lista_modeli[i]->model_dane.at(j)->at(k), i, k, j)); + przetworzone_obwody[i]->append(new elementy_schematu(lista_modeli[i]->model_dane.at(j)->at(k), i, k, j)); + default: + break; + } + //przetworzone_linie[i]->append(new elementy_schematu(lista_modeli[i]->model_dane.at(j)->at(k), i, k, j)); + konce[i]->append(new elementy_schematu(lista_modeli[i]->model_dane.at(j)->at(k), i, k, j)); + break; + case cewka: + cewki.append(new elementy_schematu(lista_modeli[i]->model_dane.at(j)->at(k), i, k, j)); + przetworzone_obwody[i]->append(new elementy_schematu(lista_modeli[i]->model_dane.at(j)->at(k), i, k, j)); + konce[i]->append(new elementy_schematu(lista_modeli[i]->model_dane.at(j)->at(k), i, k, j)); + break; + case styk: + przetworzone_obwody[i]->append(new elementy_schematu(lista_modeli[i]->model_dane.at(j)->at(k), i, k, j)); + break; + case operator_porownania: + przetworzone_obwody[i]->append(new elementy_schematu(lista_modeli[i]->model_dane.at(j)->at(k), i, k, j)); + break; + default: + break; + } + } + } + } + //UPRASZCZENIE SCHEMATÓW + for(int i = rozdzielacze.count() - 1; i >= 0; --i) { //wykrywanie do czego są podłączone rozdzielacze + switch (rozdzielacze.at(i)->element->rodzaj2) { + case GORA_PRAWO_DOL: + for (int j = 0; j < 3; ++j) { + int x = rozdzielacze.at(i)->numer_kolumny, y = rozdzielacze.at(i)->numer_wiersza, x_poprz = rozdzielacze.at(i)->numer_kolumny, y_poprz = rozdzielacze.at(i)->numer_wiersza; + bool koniec = false; + switch (j) { + case 0: //GÓRA + --y; + while(!koniec) { + switch (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj) { + case lacznik: + if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_PRAWO_DOL || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_LEWO_DOL || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_DOL_PRAWO || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_GORA_PRAWO || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_DOL_LEWO_PRAWO) { + if (!sprawdz_czy_jest_na_wejsciu_lub_wyjsciu(lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x), rozdzielacze.at(i))) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(rozdzielacze, lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + //znajdz_element_drabinki(rozdzielacze, rozdzielacze.at(i)->element)->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_PRAWO) { + if (x_poprz > x) { //RUCH W LEWO + if (x == 0) { //PIERWSZA KOLUMNA + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + --x_poprz; + } + } + else { //RUCH W PRAWO + ++x; + ++x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_DOL) { + if (y_poprz > y) { //RUCH W GÓRĘ + --y; + --y_poprz; + } + else { //RUCH W DOŁ + ++y; + ++y_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == DOL_PRAWO) { + if (y_poprz > y) { //ZMIANA KIERUNKU W PRAWO + ++x; + ++y_poprz; + } + else { //ZMIANA KIERUNKU W DÓŁ + --y; + --x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == DOL_LEWO) { + if (y_poprz > y) { //ZMIANA KIERUNKU W LEWO + if (x == 0) { + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + ++y_poprz; + } + } + else { //ZMIANA KIERUNKU W DÓŁ + ++y; + ++x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_PRAWO) { + if (y > y_poprz) { //ZMIANA KIERUNKU W PRAWO + ++x; + y_poprz++; + } + else { //ZMIANA KIERUNKU W GÓRĘ + --y; + --x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_LEWO) { + if (y > y_poprz) { //ZMIANA KIERUNKU W LEWO + if (x == 0) { + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + ++y_poprz; + } + } //ZMIANA KIERUNKU DO GÓRY + else { + --y; + ++x_poprz; + } + } + break; + case cewka: + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + break; + case styk: + if (x > x_poprz) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + } + else { + rozdzielacze[i]->wejscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wyjscia_elementu.append(rozdzielacze[i]); + } + koniec = true; + break; + case operator_porownania: + if (x > x_poprz) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + } + else { + rozdzielacze[i]->wejscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wyjscia_elementu.append(rozdzielacze[i]); + } + koniec = true; + break; + case blok_funkcyjny: + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + break; + default: + break; + } + } + break; + case 1: //PRAWO + ++x; + while(!koniec) { + switch (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj) { + case lacznik: + if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_PRAWO_DOL || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_LEWO_DOL || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_DOL_PRAWO || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_GORA_PRAWO || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_DOL_LEWO_PRAWO) { + if (!sprawdz_czy_jest_na_wejsciu_lub_wyjsciu(lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x), rozdzielacze.at(i))) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(rozdzielacze, lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + //znajdz_element_drabinki(rozdzielacze, rozdzielacze.at(i)->element)->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_PRAWO) { + if (x_poprz > x) { //RUCH W LEWO + if (x == 0) { //PIERWSZA KOLUMNA + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + --x_poprz; + } + } + else { //RUCH W PRAWO + ++x; + ++x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_DOL) { + if (y_poprz > y) { //RUCH W GÓRĘ + --y; + --y_poprz; + } + else { //RUCH W DOŁ + ++y; + ++y_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == DOL_PRAWO) { + if (y_poprz > y) { //ZMIANA KIERUNKU W PRAWO + ++x; + ++y_poprz; + } + else { //ZMIANA KIERUNKU W DÓŁ + --y; + --x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == DOL_LEWO) { + if (y_poprz > y) { //ZMIANA KIERUNKU W LEWO + if (x == 0) { + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + ++y_poprz; + } + } + else { //ZMIANA KIERUNKU W DÓŁ + ++y; + ++x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_PRAWO) { + if (y > y_poprz) { //ZMIANA KIERUNKU W PRAWO + ++x; + y_poprz++; + } + else { //ZMIANA KIERUNKU W GÓRĘ + --y; + --x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_LEWO) { + if (y > y_poprz) { //ZMIANA KIERUNKU W LEWO + if (x == 0) { + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + ++y_poprz; + } + } //ZMIANA KIERUNKU DO GÓRY + else { + --y; + ++x_poprz; + } + } + break; + case cewka: + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + break; + case styk: + if (x > x_poprz) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + } + else { + rozdzielacze[i]->wejscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wyjscia_elementu.append(rozdzielacze[i]); + } + koniec = true; + break; + case operator_porownania: + if (x > x_poprz) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + } + else { + rozdzielacze[i]->wejscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wyjscia_elementu.append(rozdzielacze[i]); + } + koniec = true; + break; + case blok_funkcyjny: + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + break; + default: + break; + } + } + break; + case 2: //DÓŁ + ++y; + while(!koniec) { + switch (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj) { + case lacznik: + if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_PRAWO_DOL || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_LEWO_DOL || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_DOL_PRAWO || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_GORA_PRAWO || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_DOL_LEWO_PRAWO) { + if (!sprawdz_czy_jest_na_wejsciu_lub_wyjsciu(lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x), rozdzielacze.at(i))) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(rozdzielacze, lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + //znajdz_element_drabinki(rozdzielacze, rozdzielacze.at(i)->element)->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_PRAWO) { + if (x_poprz > x) { //RUCH W LEWO + if (x == 0) { //PIERWSZA KOLUMNA + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + --x_poprz; + } + } + else { //RUCH W PRAWO + ++x; + ++x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_DOL) { + if (y_poprz > y) { //RUCH W GÓRĘ + --y; + --y_poprz; + } + else { //RUCH W DOŁ + ++y; + ++y_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == DOL_PRAWO) { + if (y_poprz > y) { //ZMIANA KIERUNKU W PRAWO + ++x; + ++y_poprz; + } + else { //ZMIANA KIERUNKU W DÓŁ + --y; + --x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == DOL_LEWO) { + if (y_poprz > y) { //ZMIANA KIERUNKU W LEWO + if (x == 0) { + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + ++y_poprz; + } + } + else { //ZMIANA KIERUNKU W DÓŁ + ++y; + ++x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_PRAWO) { + if (y > y_poprz) { //ZMIANA KIERUNKU W PRAWO + ++x; + y_poprz++; + } + else { //ZMIANA KIERUNKU W GÓRĘ + --y; + --x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_LEWO) { + if (y > y_poprz) { //ZMIANA KIERUNKU W LEWO + if (x == 0) { + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + ++y_poprz; + } + } //ZMIANA KIERUNKU DO GÓRY + else { + --y; + ++x_poprz; + } + } + break; + case cewka: + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + break; + case styk: + if (x > x_poprz) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + } + else { + rozdzielacze[i]->wejscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wyjscia_elementu.append(rozdzielacze[i]); + } + koniec = true; + break; + case operator_porownania: + if (x > x_poprz) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + } + else { + rozdzielacze[i]->wejscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wyjscia_elementu.append(rozdzielacze[i]); + } + koniec = true; + break; + case blok_funkcyjny: + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + break; + default: + break; + } + } + break; + default: + break; + } + } + break; + case GORA_LEWO_DOL: + for (int j = 0; j < 3; ++j) { + int x = rozdzielacze.at(i)->numer_kolumny, y = rozdzielacze.at(i)->numer_wiersza, x_poprz = rozdzielacze.at(i)->numer_kolumny, y_poprz = rozdzielacze.at(i)->numer_wiersza; + bool koniec = false; + switch (j) { + case 0: //GÓRA + --y; + while(!koniec) { + switch (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj) { + case lacznik: + if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_PRAWO_DOL || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_LEWO_DOL || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_DOL_PRAWO || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_GORA_PRAWO || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_DOL_LEWO_PRAWO) { + if (!sprawdz_czy_jest_na_wejsciu_lub_wyjsciu(lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x), rozdzielacze.at(i))) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(rozdzielacze, lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + //znajdz_element_drabinki(rozdzielacze, rozdzielacze.at(i)->element)->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_PRAWO) { + if (x_poprz > x) { //RUCH W LEWO + if (x == 0) { //PIERWSZA KOLUMNA + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + --x_poprz; + } + } + else { //RUCH W PRAWO + ++x; + ++x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_DOL) { + if (y_poprz > y) { //RUCH W GÓRĘ + --y; + --y_poprz; + } + else { //RUCH W DOŁ + ++y; + ++y_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == DOL_PRAWO) { + if (y_poprz > y) { //ZMIANA KIERUNKU W PRAWO + ++x; + ++y_poprz; + } + else { //ZMIANA KIERUNKU W DÓŁ + --y; + --x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == DOL_LEWO) { + if (y_poprz > y) { //ZMIANA KIERUNKU W LEWO + if (x == 0) { + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + ++y_poprz; + } + } + else { //ZMIANA KIERUNKU W DÓŁ + ++y; + ++x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_PRAWO) { + if (y > y_poprz) { //ZMIANA KIERUNKU W PRAWO + ++x; + y_poprz++; + } + else { //ZMIANA KIERUNKU W GÓRĘ + --y; + --x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_LEWO) { + if (y > y_poprz) { //ZMIANA KIERUNKU W LEWO + if (x == 0) { + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + ++y_poprz; + } + } //ZMIANA KIERUNKU DO GÓRY + else { + --y; + ++x_poprz; + } + } + break; + case cewka: + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + break; + case styk: + if (x > x_poprz) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + } + else { + rozdzielacze[i]->wejscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wyjscia_elementu.append(rozdzielacze[i]); + } + koniec = true; + break; + case operator_porownania: + if (x > x_poprz) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + } + else { + rozdzielacze[i]->wejscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wyjscia_elementu.append(rozdzielacze[i]); + } + koniec = true; + break; + case blok_funkcyjny: + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + break; + default: + break; + } + } + break; + case 1: //LEWO (SPRAWDZIĆ CZY X == 0) + if (x == 0) { + + } + else { + --x; + while(!koniec) { + switch (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj) { + case lacznik: + if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_PRAWO_DOL || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_LEWO_DOL || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_DOL_PRAWO || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_GORA_PRAWO || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_DOL_LEWO_PRAWO) { + if (!sprawdz_czy_jest_na_wejsciu_lub_wyjsciu(lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x), rozdzielacze.at(i))) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(rozdzielacze, lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + //znajdz_element_drabinki(rozdzielacze, rozdzielacze.at(i)->element)->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_PRAWO) { + if (x_poprz > x) { //RUCH W LEWO + if (x == 0) { //PIERWSZA KOLUMNA + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + --x_poprz; + } + } + else { //RUCH W PRAWO + ++x; + ++x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_DOL) { + if (y_poprz > y) { //RUCH W GÓRĘ + --y; + --y_poprz; + } + else { //RUCH W DOŁ + ++y; + ++y_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == DOL_PRAWO) { + if (y_poprz > y) { //ZMIANA KIERUNKU W PRAWO + ++x; + ++y_poprz; + } + else { //ZMIANA KIERUNKU W DÓŁ + --y; + --x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == DOL_LEWO) { + if (y_poprz > y) { //ZMIANA KIERUNKU W LEWO + if (x == 0) { + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + ++y_poprz; + } + } + else { //ZMIANA KIERUNKU W DÓŁ + ++y; + ++x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_PRAWO) { + if (y > y_poprz) { //ZMIANA KIERUNKU W PRAWO + ++x; + y_poprz++; + } + else { //ZMIANA KIERUNKU W GÓRĘ + --y; + --x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_LEWO) { + if (y > y_poprz) { //ZMIANA KIERUNKU W LEWO + if (x == 0) { + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + ++y_poprz; + } + } //ZMIANA KIERUNKU DO GÓRY + else { + --y; + ++x_poprz; + } + } + break; + case cewka: + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + break; + case styk: + if (x > x_poprz) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + } + else { + rozdzielacze[i]->wejscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wyjscia_elementu.append(rozdzielacze[i]); + } + koniec = true; + break; + case operator_porownania: + if (x > x_poprz) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + } + else { + rozdzielacze[i]->wejscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wyjscia_elementu.append(rozdzielacze[i]); + } + koniec = true; + break; + case blok_funkcyjny: + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + break; + default: + break; + } + } + } + break; + case 2: //DÓŁ + ++y; + while(!koniec) { + switch (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj) { + case lacznik: + if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_PRAWO_DOL || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_LEWO_DOL || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_DOL_PRAWO || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_GORA_PRAWO || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_DOL_LEWO_PRAWO) { + if (!sprawdz_czy_jest_na_wejsciu_lub_wyjsciu(lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x), rozdzielacze.at(i))) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(rozdzielacze, lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + //znajdz_element_drabinki(rozdzielacze, rozdzielacze.at(i)->element)->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_PRAWO) { + if (x_poprz > x) { //RUCH W LEWO + if (x == 0) { //PIERWSZA KOLUMNA + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + --x_poprz; + } + } + else { //RUCH W PRAWO + ++x; + ++x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_DOL) { + if (y_poprz > y) { //RUCH W GÓRĘ + --y; + --y_poprz; + } + else { //RUCH W DOŁ + ++y; + ++y_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == DOL_PRAWO) { + if (y_poprz > y) { //ZMIANA KIERUNKU W PRAWO + ++x; + ++y_poprz; + } + else { //ZMIANA KIERUNKU W DÓŁ + --y; + --x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == DOL_LEWO) { + if (y_poprz > y) { //ZMIANA KIERUNKU W LEWO + if (x == 0) { + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + ++y_poprz; + } + } + else { //ZMIANA KIERUNKU W DÓŁ + ++y; + ++x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_PRAWO) { + if (y > y_poprz) { //ZMIANA KIERUNKU W PRAWO + ++x; + y_poprz++; + } + else { //ZMIANA KIERUNKU W GÓRĘ + --y; + --x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_LEWO) { + if (y > y_poprz) { //ZMIANA KIERUNKU W LEWO + if (x == 0) { + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + ++y_poprz; + } + } //ZMIANA KIERUNKU DO GÓRY + else { + --y; + ++x_poprz; + } + } + break; + case cewka: + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + break; + case styk: + if (x > x_poprz) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + } + else { + rozdzielacze[i]->wejscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wyjscia_elementu.append(rozdzielacze[i]); + } + koniec = true; + break; + case operator_porownania: + if (x > x_poprz) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + } + else { + rozdzielacze[i]->wejscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wyjscia_elementu.append(rozdzielacze[i]); + } + koniec = true; + break; + case blok_funkcyjny: + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + break; + default: + break; + } + } + break; + default: + break; + } + } + break; + case LEWO_DOL_PRAWO: + for (int j = 0; j < 3; ++j) { + int x = rozdzielacze.at(i)->numer_kolumny, y = rozdzielacze.at(i)->numer_wiersza, x_poprz = rozdzielacze.at(i)->numer_kolumny, y_poprz = rozdzielacze.at(i)->numer_wiersza; + bool koniec = false; + switch (j) { + case 0: //PRAWO + ++x; + while(!koniec) { + switch (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj) { + case lacznik: + if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_PRAWO_DOL || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_LEWO_DOL || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_DOL_PRAWO || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_GORA_PRAWO || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_DOL_LEWO_PRAWO) { + if (!sprawdz_czy_jest_na_wejsciu_lub_wyjsciu(lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x), rozdzielacze.at(i))) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(rozdzielacze, lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + //znajdz_element_drabinki(rozdzielacze, rozdzielacze.at(i)->element)->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_PRAWO) { + if (x_poprz > x) { //RUCH W LEWO + if (x == 0) { //PIERWSZA KOLUMNA + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + --x_poprz; + } + } + else { //RUCH W PRAWO + ++x; + ++x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_DOL) { + if (y_poprz > y) { //RUCH W GÓRĘ + --y; + --y_poprz; + } + else { //RUCH W DOŁ + ++y; + ++y_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == DOL_PRAWO) { + if (y_poprz > y) { //ZMIANA KIERUNKU W PRAWO + ++x; + ++y_poprz; + } + else { //ZMIANA KIERUNKU W DÓŁ + --y; + --x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == DOL_LEWO) { + if (y_poprz > y) { //ZMIANA KIERUNKU W LEWO + if (x == 0) { + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + ++y_poprz; + } + } + else { //ZMIANA KIERUNKU W DÓŁ + ++y; + ++x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_PRAWO) { + if (y > y_poprz) { //ZMIANA KIERUNKU W PRAWO + ++x; + y_poprz++; + } + else { //ZMIANA KIERUNKU W GÓRĘ + --y; + --x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_LEWO) { + if (y > y_poprz) { //ZMIANA KIERUNKU W LEWO + if (x == 0) { + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + ++y_poprz; + } + } //ZMIANA KIERUNKU DO GÓRY + else { + --y; + ++x_poprz; + } + } + break; + case cewka: + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + break; + case styk: + if (x > x_poprz) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + } + else { + rozdzielacze[i]->wejscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wyjscia_elementu.append(rozdzielacze[i]); + } + koniec = true; + break; + case operator_porownania: + if (x > x_poprz) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + } + else { + rozdzielacze[i]->wejscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wyjscia_elementu.append(rozdzielacze[i]); + } + koniec = true; + break; + case blok_funkcyjny: + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + break; + default: + break; + } + } + break; + case 1: //LEWO + if (x == 0) { + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + while(!koniec) { + switch (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj) { + case lacznik: + if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_PRAWO_DOL || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_LEWO_DOL || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_DOL_PRAWO || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_GORA_PRAWO || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_DOL_LEWO_PRAWO) { + if (!sprawdz_czy_jest_na_wejsciu_lub_wyjsciu(lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x), rozdzielacze.at(i))) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(rozdzielacze, lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + //znajdz_element_drabinki(rozdzielacze, rozdzielacze.at(i)->element)->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_PRAWO) { + if (x_poprz > x) { //RUCH W LEWO + if (x == 0) { //PIERWSZA KOLUMNA + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + --x_poprz; + } + } + else { //RUCH W PRAWO + ++x; + ++x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_DOL) { + if (y_poprz > y) { //RUCH W GÓRĘ + --y; + --y_poprz; + } + else { //RUCH W DOŁ + ++y; + ++y_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == DOL_PRAWO) { + if (y_poprz > y) { //ZMIANA KIERUNKU W PRAWO + ++x; + ++y_poprz; + } + else { //ZMIANA KIERUNKU W DÓŁ + --y; + --x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == DOL_LEWO) { + if (y_poprz > y) { //ZMIANA KIERUNKU W LEWO + if (x == 0) { + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + ++y_poprz; + } + } + else { //ZMIANA KIERUNKU W DÓŁ + ++y; + ++x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_PRAWO) { + if (y > y_poprz) { //ZMIANA KIERUNKU W PRAWO + ++x; + y_poprz++; + } + else { //ZMIANA KIERUNKU W GÓRĘ + --y; + --x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_LEWO) { + if (y > y_poprz) { //ZMIANA KIERUNKU W LEWO + if (x == 0) { + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + ++y_poprz; + } + } //ZMIANA KIERUNKU DO GÓRY + else { + --y; + ++x_poprz; + } + } + break; + case cewka: + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + break; + case styk: + if (x > x_poprz) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + } + else { + rozdzielacze[i]->wejscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wyjscia_elementu.append(rozdzielacze[i]); + } + koniec = true; + break; + case operator_porownania: + if (x > x_poprz) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + } + else { + rozdzielacze[i]->wejscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wyjscia_elementu.append(rozdzielacze[i]); + } + koniec = true; + break; + case blok_funkcyjny: + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + break; + default: + break; + } + } + } + break; + case 2: //DÓŁ + ++y; + while(!koniec) { + switch (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj) { + case lacznik: + if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_PRAWO_DOL || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_LEWO_DOL || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_DOL_PRAWO || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_GORA_PRAWO || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_DOL_LEWO_PRAWO) { + if (!sprawdz_czy_jest_na_wejsciu_lub_wyjsciu(lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x), rozdzielacze.at(i))) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(rozdzielacze, lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + //znajdz_element_drabinki(rozdzielacze, rozdzielacze.at(i)->element)->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_PRAWO) { + if (x_poprz > x) { //RUCH W LEWO + if (x == 0) { //PIERWSZA KOLUMNA + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + --x_poprz; + } + } + else { //RUCH W PRAWO + ++x; + ++x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_DOL) { + if (y_poprz > y) { //RUCH W GÓRĘ + --y; + --y_poprz; + } + else { //RUCH W DOŁ + ++y; + ++y_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == DOL_PRAWO) { + if (y_poprz > y) { //ZMIANA KIERUNKU W PRAWO + ++x; + ++y_poprz; + } + else { //ZMIANA KIERUNKU W DÓŁ + --y; + --x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == DOL_LEWO) { + if (y_poprz > y) { //ZMIANA KIERUNKU W LEWO + if (x == 0) { + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + ++y_poprz; + } + } + else { //ZMIANA KIERUNKU W DÓŁ + ++y; + ++x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_PRAWO) { + if (y > y_poprz) { //ZMIANA KIERUNKU W PRAWO + ++x; + y_poprz++; + } + else { //ZMIANA KIERUNKU W GÓRĘ + --y; + --x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_LEWO) { + if (y > y_poprz) { //ZMIANA KIERUNKU W LEWO + if (x == 0) { + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + ++y_poprz; + } + } //ZMIANA KIERUNKU DO GÓRY + else { + --y; + ++x_poprz; + } + } + break; + case cewka: + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + break; + case styk: + if (x > x_poprz) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + } + else { + rozdzielacze[i]->wejscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wyjscia_elementu.append(rozdzielacze[i]); + } + koniec = true; + break; + case operator_porownania: + if (x > x_poprz) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + } + else { + rozdzielacze[i]->wejscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wyjscia_elementu.append(rozdzielacze[i]); + } + koniec = true; + break; + case blok_funkcyjny: + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + break; + default: + break; + } + } + break; + default: + break; + } + } + break; + case LEWO_GORA_PRAWO: + for (int j = 0; j < 3; ++j) { + int x = rozdzielacze.at(i)->numer_kolumny, y = rozdzielacze.at(i)->numer_wiersza, x_poprz = rozdzielacze.at(i)->numer_kolumny, y_poprz = rozdzielacze.at(i)->numer_wiersza; + bool koniec = false; + switch (j) { + case 0: //GÓRA + --y; + while(!koniec) { + switch (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj) { + case lacznik: + if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_PRAWO_DOL || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_LEWO_DOL || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_DOL_PRAWO || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_GORA_PRAWO || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_DOL_LEWO_PRAWO) { + if (!sprawdz_czy_jest_na_wejsciu_lub_wyjsciu(lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x), rozdzielacze.at(i))) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(rozdzielacze, lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + //znajdz_element_drabinki(rozdzielacze, rozdzielacze.at(i)->element)->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_PRAWO) { + if (x_poprz > x) { //RUCH W LEWO + if (x == 0) { //PIERWSZA KOLUMNA + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + --x_poprz; + } + } + else { //RUCH W PRAWO + ++x; + ++x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_DOL) { + if (y_poprz > y) { //RUCH W GÓRĘ + --y; + --y_poprz; + } + else { //RUCH W DOŁ + ++y; + ++y_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == DOL_PRAWO) { + if (y_poprz > y) { //ZMIANA KIERUNKU W PRAWO + ++x; + ++y_poprz; + } + else { //ZMIANA KIERUNKU W DÓŁ + --y; + --x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == DOL_LEWO) { + if (y_poprz > y) { //ZMIANA KIERUNKU W LEWO + if (x == 0) { + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + ++y_poprz; + } + } + else { //ZMIANA KIERUNKU W DÓŁ + ++y; + ++x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_PRAWO) { + if (y > y_poprz) { //ZMIANA KIERUNKU W PRAWO + ++x; + y_poprz++; + } + else { //ZMIANA KIERUNKU W GÓRĘ + --y; + --x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_LEWO) { + if (y > y_poprz) { //ZMIANA KIERUNKU W LEWO + if (x == 0) { + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + ++y_poprz; + } + } //ZMIANA KIERUNKU DO GÓRY + else { + --y; + ++x_poprz; + } + } + break; + case cewka: + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + break; + case styk: + if (x > x_poprz) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + } + else { + rozdzielacze[i]->wejscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wyjscia_elementu.append(rozdzielacze[i]); + } + koniec = true; + break; + case operator_porownania: + if (x > x_poprz) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + } + else { + rozdzielacze[i]->wejscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wyjscia_elementu.append(rozdzielacze[i]); + } + koniec = true; + break; + case blok_funkcyjny: + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + break; + default: + break; + } + } + break; + case 1: //LEWO + if (x == 0) { + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + while(!koniec) { + switch (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj) { + case lacznik: + if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_PRAWO_DOL || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_LEWO_DOL || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_DOL_PRAWO || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_GORA_PRAWO || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_DOL_LEWO_PRAWO) { + if (!sprawdz_czy_jest_na_wejsciu_lub_wyjsciu(lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x), rozdzielacze.at(i))) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(rozdzielacze, lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + //znajdz_element_drabinki(rozdzielacze, rozdzielacze.at(i)->element)->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_PRAWO) { + if (x_poprz > x) { //RUCH W LEWO + if (x == 0) { //PIERWSZA KOLUMNA + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + --x_poprz; + } + } + else { //RUCH W PRAWO + ++x; + ++x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_DOL) { + if (y_poprz > y) { //RUCH W GÓRĘ + --y; + --y_poprz; + } + else { //RUCH W DOŁ + ++y; + ++y_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == DOL_PRAWO) { + if (y_poprz > y) { //ZMIANA KIERUNKU W PRAWO + ++x; + ++y_poprz; + } + else { //ZMIANA KIERUNKU W DÓŁ + --y; + --x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == DOL_LEWO) { + if (y_poprz > y) { //ZMIANA KIERUNKU W LEWO + if (x == 0) { + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + ++y_poprz; + } + } + else { //ZMIANA KIERUNKU W DÓŁ + ++y; + ++x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_PRAWO) { + if (y > y_poprz) { //ZMIANA KIERUNKU W PRAWO + ++x; + y_poprz++; + } + else { //ZMIANA KIERUNKU W GÓRĘ + --y; + --x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_LEWO) { + if (y > y_poprz) { //ZMIANA KIERUNKU W LEWO + if (x == 0) { + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + ++y_poprz; + } + } //ZMIANA KIERUNKU DO GÓRY + else { + --y; + ++x_poprz; + } + } + break; + case cewka: + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + break; + case styk: + if (x > x_poprz) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + } + else { + rozdzielacze[i]->wejscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wyjscia_elementu.append(rozdzielacze[i]); + } + koniec = true; + break; + case operator_porownania: + if (x > x_poprz) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + } + else { + rozdzielacze[i]->wejscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wyjscia_elementu.append(rozdzielacze[i]); + } + koniec = true; + break; + case blok_funkcyjny: + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + break; + default: + break; + } + } + } + break; + case 2: //PRAWO + ++x; + while(!koniec) { + switch (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj) { + case lacznik: + if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_PRAWO_DOL || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_LEWO_DOL || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_DOL_PRAWO || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_GORA_PRAWO || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_DOL_LEWO_PRAWO) { + if (!sprawdz_czy_jest_na_wejsciu_lub_wyjsciu(lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x), rozdzielacze.at(i))) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(rozdzielacze, lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + //znajdz_element_drabinki(rozdzielacze, rozdzielacze.at(i)->element)->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_PRAWO) { + if (x_poprz > x) { //RUCH W LEWO + if (x == 0) { //PIERWSZA KOLUMNA + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + --x_poprz; + } + } + else { //RUCH W PRAWO + ++x; + ++x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_DOL) { + if (y_poprz > y) { //RUCH W GÓRĘ + --y; + --y_poprz; + } + else { //RUCH W DOŁ + ++y; + ++y_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == DOL_PRAWO) { + if (y_poprz > y) { //ZMIANA KIERUNKU W PRAWO + ++x; + ++y_poprz; + } + else { //ZMIANA KIERUNKU W DÓŁ + --y; + --x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == DOL_LEWO) { + if (y_poprz > y) { //ZMIANA KIERUNKU W LEWO + if (x == 0) { + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + ++y_poprz; + } + } + else { //ZMIANA KIERUNKU W DÓŁ + ++y; + ++x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_PRAWO) { + if (y > y_poprz) { //ZMIANA KIERUNKU W PRAWO + ++x; + y_poprz++; + } + else { //ZMIANA KIERUNKU W GÓRĘ + --y; + --x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_LEWO) { + if (y > y_poprz) { //ZMIANA KIERUNKU W LEWO + if (x == 0) { + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + ++y_poprz; + } + } //ZMIANA KIERUNKU DO GÓRY + else { + --y; + ++x_poprz; + } + } + break; + case cewka: + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + break; + case styk: + if (x > x_poprz) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + } + else { + rozdzielacze[i]->wejscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wyjscia_elementu.append(rozdzielacze[i]); + } + koniec = true; + break; + case operator_porownania: + if (x > x_poprz) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + } + else { + rozdzielacze[i]->wejscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wyjscia_elementu.append(rozdzielacze[i]); + } + koniec = true; + break; + case blok_funkcyjny: + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + break; + default: + break; + } + } + break; + default: + break; + } + } + break; + case GORA_DOL_LEWO_PRAWO: + for (int j = 0; j < 4; ++j) { + int x = rozdzielacze.at(i)->numer_kolumny, y = rozdzielacze.at(i)->numer_wiersza, x_poprz = rozdzielacze.at(i)->numer_kolumny, y_poprz = rozdzielacze.at(i)->numer_wiersza; + bool koniec = false; + switch (j) { + case 0: //GÓRA + --y; + while(!koniec) { + switch (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj) { + case lacznik: + if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_PRAWO_DOL || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_LEWO_DOL || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_DOL_PRAWO || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_GORA_PRAWO || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_DOL_LEWO_PRAWO) { + if (!sprawdz_czy_jest_na_wejsciu_lub_wyjsciu(lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x), rozdzielacze.at(i))) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(rozdzielacze, lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + //znajdz_element_drabinki(rozdzielacze, rozdzielacze.at(i)->element)->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_PRAWO) { + if (x_poprz > x) { //RUCH W LEWO + if (x == 0) { //PIERWSZA KOLUMNA + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + --x_poprz; + } + } + else { //RUCH W PRAWO + ++x; + ++x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_DOL) { + if (y_poprz > y) { //RUCH W GÓRĘ + --y; + --y_poprz; + } + else { //RUCH W DOŁ + ++y; + ++y_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == DOL_PRAWO) { + if (y_poprz > y) { //ZMIANA KIERUNKU W PRAWO + ++x; + ++y_poprz; + } + else { //ZMIANA KIERUNKU W DÓŁ + --y; + --x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == DOL_LEWO) { + if (y_poprz > y) { //ZMIANA KIERUNKU W LEWO + if (x == 0) { + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + ++y_poprz; + } + } + else { //ZMIANA KIERUNKU W DÓŁ + ++y; + ++x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_PRAWO) { + if (y > y_poprz) { //ZMIANA KIERUNKU W PRAWO + ++x; + y_poprz++; + } + else { //ZMIANA KIERUNKU W GÓRĘ + --y; + --x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_LEWO) { + if (y > y_poprz) { //ZMIANA KIERUNKU W LEWO + if (x == 0) { + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + ++y_poprz; + } + } //ZMIANA KIERUNKU DO GÓRY + else { + --y; + ++x_poprz; + } + } + break; + case cewka: + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + break; + case styk: + if (x > x_poprz) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + } + else { + rozdzielacze[i]->wejscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wyjscia_elementu.append(rozdzielacze[i]); + } + koniec = true; + break; + case operator_porownania: + if (x > x_poprz) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + } + else { + rozdzielacze[i]->wejscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wyjscia_elementu.append(rozdzielacze[i]); + } + koniec = true; + break; + case blok_funkcyjny: + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + break; + default: + break; + } + } + break; + case 1: //LEWO + if (x == 0) { + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + while(!koniec) { + switch (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj) { + case lacznik: + if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_PRAWO_DOL || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_LEWO_DOL || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_DOL_PRAWO || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_GORA_PRAWO || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_DOL_LEWO_PRAWO) { + if (!sprawdz_czy_jest_na_wejsciu_lub_wyjsciu(lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x), rozdzielacze.at(i))) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(rozdzielacze, lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + //znajdz_element_drabinki(rozdzielacze, rozdzielacze.at(i)->element)->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_PRAWO) { + if (x_poprz > x) { //RUCH W LEWO + if (x == 0) { //PIERWSZA KOLUMNA + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + --x_poprz; + } + } + else { //RUCH W PRAWO + ++x; + ++x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_DOL) { + if (y_poprz > y) { //RUCH W GÓRĘ + --y; + --y_poprz; + } + else { //RUCH W DOŁ + ++y; + ++y_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == DOL_PRAWO) { + if (y_poprz > y) { //ZMIANA KIERUNKU W PRAWO + ++x; + ++y_poprz; + } + else { //ZMIANA KIERUNKU W DÓŁ + --y; + --x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == DOL_LEWO) { + if (y_poprz > y) { //ZMIANA KIERUNKU W LEWO + if (x == 0) { + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + ++y_poprz; + } + } + else { //ZMIANA KIERUNKU W DÓŁ + ++y; + ++x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_PRAWO) { + if (y > y_poprz) { //ZMIANA KIERUNKU W PRAWO + ++x; + y_poprz++; + } + else { //ZMIANA KIERUNKU W GÓRĘ + --y; + --x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_LEWO) { + if (y > y_poprz) { //ZMIANA KIERUNKU W LEWO + if (x == 0) { + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + ++y_poprz; + } + } //ZMIANA KIERUNKU DO GÓRY + else { + --y; + ++x_poprz; + } + } + break; + case cewka: + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + break; + case styk: + if (x > x_poprz) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + } + else { + rozdzielacze[i]->wejscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wyjscia_elementu.append(rozdzielacze[i]); + } + koniec = true; + break; + case operator_porownania: + if (x > x_poprz) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + } + else { + rozdzielacze[i]->wejscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wyjscia_elementu.append(rozdzielacze[i]); + } + koniec = true; + break; + case blok_funkcyjny: + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + break; + default: + break; + } + } + } + break; + case 2: //DÓŁ + ++y; + while(!koniec) { + switch (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj) { + case lacznik: + if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_PRAWO_DOL || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_LEWO_DOL || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_DOL_PRAWO || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_GORA_PRAWO || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_DOL_LEWO_PRAWO) { + if (!sprawdz_czy_jest_na_wejsciu_lub_wyjsciu(lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x), rozdzielacze.at(i))) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(rozdzielacze, lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + //znajdz_element_drabinki(rozdzielacze, rozdzielacze.at(i)->element)->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_PRAWO) { + if (x_poprz > x) { //RUCH W LEWO + if (x == 0) { //PIERWSZA KOLUMNA + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + --x_poprz; + } + } + else { //RUCH W PRAWO + ++x; + ++x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_DOL) { + if (y_poprz > y) { //RUCH W GÓRĘ + --y; + --y_poprz; + } + else { //RUCH W DOŁ + ++y; + ++y_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == DOL_PRAWO) { + if (y_poprz > y) { //ZMIANA KIERUNKU W PRAWO + ++x; + ++y_poprz; + } + else { //ZMIANA KIERUNKU W DÓŁ + --y; + --x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == DOL_LEWO) { + if (y_poprz > y) { //ZMIANA KIERUNKU W LEWO + if (x == 0) { + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + ++y_poprz; + } + } + else { //ZMIANA KIERUNKU W DÓŁ + ++y; + ++x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_PRAWO) { + if (y > y_poprz) { //ZMIANA KIERUNKU W PRAWO + ++x; + y_poprz++; + } + else { //ZMIANA KIERUNKU W GÓRĘ + --y; + --x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_LEWO) { + if (y > y_poprz) { //ZMIANA KIERUNKU W LEWO + if (x == 0) { + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + ++y_poprz; + } + } //ZMIANA KIERUNKU DO GÓRY + else { + --y; + ++x_poprz; + } + } + break; + case cewka: + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + break; + case styk: + if (x > x_poprz) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + } + else { + rozdzielacze[i]->wejscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wyjscia_elementu.append(rozdzielacze[i]); + } + koniec = true; + break; + case operator_porownania: + if (x > x_poprz) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + } + else { + rozdzielacze[i]->wejscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wyjscia_elementu.append(rozdzielacze[i]); + } + koniec = true; + break; + case blok_funkcyjny: + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + break; + default: + break; + } + } + break; + case 3: //PRAWO + ++x; + while(!koniec) { + switch (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj) { + case lacznik: + if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_PRAWO_DOL || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_LEWO_DOL || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_DOL_PRAWO || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_GORA_PRAWO || lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_DOL_LEWO_PRAWO) { + if (!sprawdz_czy_jest_na_wejsciu_lub_wyjsciu(lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x), rozdzielacze.at(i))) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(rozdzielacze, lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + //znajdz_element_drabinki(rozdzielacze, rozdzielacze.at(i)->element)->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_PRAWO) { + if (x_poprz > x) { //RUCH W LEWO + if (x == 0) { //PIERWSZA KOLUMNA + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + --x_poprz; + } + } + else { //RUCH W PRAWO + ++x; + ++x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_DOL) { + if (y_poprz > y) { //RUCH W GÓRĘ + --y; + --y_poprz; + } + else { //RUCH W DOŁ + ++y; + ++y_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == DOL_PRAWO) { + if (y_poprz > y) { //ZMIANA KIERUNKU W PRAWO + ++x; + ++y_poprz; + } + else { //ZMIANA KIERUNKU W DÓŁ + --y; + --x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == DOL_LEWO) { + if (y_poprz > y) { //ZMIANA KIERUNKU W LEWO + if (x == 0) { + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + ++y_poprz; + } + } + else { //ZMIANA KIERUNKU W DÓŁ + ++y; + ++x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_PRAWO) { + if (y > y_poprz) { //ZMIANA KIERUNKU W PRAWO + ++x; + y_poprz++; + } + else { //ZMIANA KIERUNKU W GÓRĘ + --y; + --x_poprz; + } + } + else if (lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x)->rodzaj2 == GORA_LEWO) { + if (y > y_poprz) { //ZMIANA KIERUNKU W LEWO + if (x == 0) { + rozdzielacze[i]->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + ++y_poprz; + } + } //ZMIANA KIERUNKU DO GÓRY + else { + --y; + ++x_poprz; + } + } + break; + case cewka: + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + break; + case styk: + if (x > x_poprz) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + } + else { + rozdzielacze[i]->wejscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wyjscia_elementu.append(rozdzielacze[i]); + } + koniec = true; + break; + case operator_porownania: + if (x > x_poprz) { + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + } + else { + rozdzielacze[i]->wejscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wyjscia_elementu.append(rozdzielacze[i]); + } + koniec = true; + break; + case blok_funkcyjny: + rozdzielacze[i]->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], lista_modeli[rozdzielacze.at(i)->numer_linii]->model_dane.at(y)->at(x))->wejscia_elementu.append(rozdzielacze[i]); + koniec = true; + break; + default: + break; + } + } + break; + default: + break; + } + } + break; + default: + break; + + } + } + for (int i = 0; i < przetworzone_obwody.count(); ++i) { //analiza "nierozdzielaczy" + for (int j = 0; j < przetworzone_obwody[i]->count(); ++j) { + if (przetworzone_obwody[i]->at(j)->wejscia_elementu.count() == 0) { //WEJŚCIA ELEMENTÓW + if (przetworzone_obwody[i]->at(j)->numer_kolumny == 0) { + przetworzone_obwody[i]->at(j)->wejscia_elementu.append(NULL); + } + else { + bool koniec = false; + int x = przetworzone_obwody[i]->at(j)->numer_kolumny, y = przetworzone_obwody[i]->at(j)->numer_wiersza, y_poprz = przetworzone_obwody[i]->at(j)->numer_wiersza, x_poprz = przetworzone_obwody[i]->at(j)->numer_kolumny; + while(!koniec) { + --x; + switch (lista_modeli[i]->model_dane.at(y)->at(x)->rodzaj) { + case lacznik: + if (lista_modeli[i]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_PRAWO) { + if (x_poprz > x) { //RUCH W LEWO + if (x == 0) { //PIERWSZA KOLUMNA + przetworzone_obwody[i]->at(j)->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + --x_poprz; + } + } + else { //RUCH W PRAWO + ++x; + ++x_poprz; + } + } + else if (lista_modeli[i]->model_dane.at(y)->at(x)->rodzaj2 == GORA_DOL) { + if (y_poprz > y) { //RUCH W GÓRĘ + --y; + --y_poprz; + } + else { //RUCH W DOŁ + ++y; + ++y_poprz; + } + } + else if (lista_modeli[i]->model_dane.at(y)->at(x)->rodzaj2 == DOL_PRAWO) { + if (y_poprz > y) { //ZMIANA KIERUNKU W PRAWO + ++x; + ++y_poprz; + } + else { //ZMIANA KIERUNKU W DÓŁ + --y; + --x_poprz; + } + } + else if (lista_modeli[i]->model_dane.at(y)->at(x)->rodzaj2 == DOL_LEWO) { + if (y_poprz > y) { //ZMIANA KIERUNKU W LEWO + if (x == 0) { + przetworzone_obwody[i]->at(j)->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + ++y_poprz; + } + } + else { //ZMIANA KIERUNKU W DÓŁ + ++y; + ++x_poprz; + } + } + else if (lista_modeli[i]->model_dane.at(y)->at(x)->rodzaj2 == GORA_PRAWO) { + if (y > y_poprz) { //ZMIANA KIERUNKU W PRAWO + ++x; + y_poprz++; + } + else { //ZMIANA KIERUNKU W GÓRĘ + --y; + --x_poprz; + } + } + else if (lista_modeli[i]->model_dane.at(y)->at(x)->rodzaj2 == GORA_LEWO) { + if (y > y_poprz) { //ZMIANA KIERUNKU W LEWO + if (x == 0) { + przetworzone_obwody[i]->at(j)->wejscia_elementu.append(NULL); + koniec = true; + } + else { + --x; + ++y_poprz; + } + } //ZMIANA KIERUNKU DO GÓRY + else { + --y; + ++x_poprz; + } + } + break; + case styk: + przetworzone_obwody[i]->at(j)->wejscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[i], lista_modeli[i]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[i], lista_modeli[i]->model_dane.at(y)->at(x))->wyjscia_elementu.append(przetworzone_obwody[i]->at(j)); + koniec = true; + break; + case operator_porownania: + przetworzone_obwody[i]->at(j)->wejscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[i], lista_modeli[i]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[i], lista_modeli[i]->model_dane.at(y)->at(x))->wyjscia_elementu.append(przetworzone_obwody[i]->at(j)); + koniec = true; + break; + default: + break; + } + } + } + } + if (przetworzone_obwody[i]->at(j)->wyjscia_elementu.count() == 0) { //WYJŚCIA ELEMENTÓW + if (przetworzone_obwody[i]->at(j)->element->rodzaj != cewka && przetworzone_obwody[i]->at(j)->element->rodzaj != blok_funkcyjny) { + bool koniec = false; + int x = przetworzone_obwody[i]->at(j)->numer_kolumny, y = przetworzone_obwody[i]->at(j)->numer_wiersza, y_poprz = przetworzone_obwody[i]->at(j)->numer_wiersza, x_poprz = przetworzone_obwody[i]->at(j)->numer_kolumny; + while(!koniec) { + ++x; + switch (lista_modeli[i]->model_dane.at(y)->at(x)->rodzaj) { + case lacznik: + if (lista_modeli[i]->model_dane.at(y)->at(x)->rodzaj2 == LEWO_PRAWO) { + if (x_poprz > x) { //RUCH W LEWO + --x; + --x_poprz; + } + else { //RUCH W PRAWO + ++x; + ++x_poprz; + } + } + else if (lista_modeli[i]->model_dane.at(y)->at(x)->rodzaj2 == GORA_DOL) { + if (y_poprz > y) { //RUCH W GÓRĘ + --y; + --y_poprz; + } + else { //RUCH W DOŁ + ++y; + ++y_poprz; + } + } + else if (lista_modeli[i]->model_dane.at(y)->at(x)->rodzaj2 == DOL_PRAWO) { + if (y_poprz > y) { //ZMIANA KIERUNKU W PRAWO + ++x; + ++y_poprz; + } + else { //ZMIANA KIERUNKU W DÓŁ + --y; + --x_poprz; + } + } + else if (lista_modeli[i]->model_dane.at(y)->at(x)->rodzaj2 == DOL_LEWO) { + if (y_poprz > y) { //ZMIANA KIERUNKU W LEWO + --x; + ++y_poprz; + } + else { //ZMIANA KIERUNKU W DÓŁ + ++y; + ++x_poprz; + } + } + else if (lista_modeli[i]->model_dane.at(y)->at(x)->rodzaj2 == GORA_PRAWO) { + if (y > y_poprz) { //ZMIANA KIERUNKU W PRAWO + ++x; + y_poprz++; + } + else { //ZMIANA KIERUNKU W GÓRĘ + --y; + --x_poprz; + } + } + else if (lista_modeli[i]->model_dane.at(y)->at(x)->rodzaj2 == GORA_LEWO) { + if (y > y_poprz) { //ZMIANA KIERUNKU W LEWO + --x; + ++y_poprz; + } //ZMIANA KIERUNKU DO GÓRY + else { + --y; + ++x_poprz; + } + } + break; + case cewka: + przetworzone_obwody[i]->at(j)->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[i], lista_modeli[i]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[i], lista_modeli[i]->model_dane.at(y)->at(x))->wejscia_elementu.append(przetworzone_obwody[i]->at(j)); + koniec = true; + break; + case blok_funkcyjny: + przetworzone_obwody[i]->at(j)->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[i], lista_modeli[i]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[i], lista_modeli[i]->model_dane.at(y)->at(x))->wejscia_elementu.append(przetworzone_obwody[i]->at(j)); + koniec = true; + break; + case styk: + przetworzone_obwody[i]->at(j)->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[i], lista_modeli[i]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[i], lista_modeli[i]->model_dane.at(y)->at(x))->wejscia_elementu.append(przetworzone_obwody[i]->at(j)); + koniec = true; + break; + case operator_porownania: + przetworzone_obwody[i]->at(j)->wyjscia_elementu.append(znajdz_element_drabinki(*przetworzone_obwody[i], lista_modeli[i]->model_dane.at(y)->at(x))); + znajdz_element_drabinki(*przetworzone_obwody[i], lista_modeli[i]->model_dane.at(y)->at(x))->wejscia_elementu.append(przetworzone_obwody[i]->at(j)); + koniec = true; + break; + default: + break; + } + } + } + } + } + } + while(rozdzielacze.count() != 0) { //redukcja kilku połączonych ze sobą rozdzielaczy do jednego + for(int i = rozdzielacze.count() - 1; i >= 0; --i) { + bool zakoncz = false; + for (int j = 0; !zakoncz && j < rozdzielacze[i]->wyjscia_elementu.count(); ++j) { + if (rozdzielacze[i]->wyjscia_elementu[j]->element->rodzaj == lacznik) { + for (int k = 0; k < rozdzielacze[i]->wejscia_elementu.count(); ++k) { + rozdzielacze[i]->wyjscia_elementu[j]->wejscia_elementu.append(rozdzielacze[i]->wejscia_elementu[k]); + rozdzielacze[i]->wejscia_elementu[k]->wyjscia_elementu.replace(rozdzielacze[i]->wejscia_elementu[k]->wyjscia_elementu.indexOf(rozdzielacze[i]), rozdzielacze[i]->wyjscia_elementu[j]); + } + for (int k = 0; k < rozdzielacze[i]->wyjscia_elementu.count(); ++k) { + if (rozdzielacze[i]->wyjscia_elementu[k] == rozdzielacze[i]->wyjscia_elementu[j]) + continue; + rozdzielacze[i]->wyjscia_elementu[j]->wyjscia_elementu.append(rozdzielacze[i]->wyjscia_elementu[k]); + if (rozdzielacze[i]->wyjscia_elementu[k]->element->rodzaj != lacznik) + rozdzielacze[i]->wyjscia_elementu[k]->wejscia_elementu.replace(rozdzielacze[i]->wyjscia_elementu[k]->wejscia_elementu.indexOf(rozdzielacze[i]), rozdzielacze[i]->wyjscia_elementu[j]); + else + rozdzielacze[i]->wyjscia_elementu[k]->wyjscia_elementu.replace(rozdzielacze[i]->wyjscia_elementu[k]->wyjscia_elementu.indexOf(rozdzielacze[i]), rozdzielacze[i]->wyjscia_elementu[j]); + } + rozdzielacze[i]->wyjscia_elementu[j]->wyjscia_elementu.removeAll(rozdzielacze[i]); + delete rozdzielacze[i]; + rozdzielacze.removeAt(i); + zakoncz = true; + } + } + if (!zakoncz) { + for (int j = 0; j < rozdzielacze[i]->wejscia_elementu.count(); ++j) { + if (rozdzielacze[i]->wejscia_elementu[j] != NULL) { + for (int k = 0; k < rozdzielacze[i]->wyjscia_elementu.count(); ++k) { + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], rozdzielacze[i]->wejscia_elementu[j]->element)->wyjscia_elementu.append(rozdzielacze[i]->wyjscia_elementu[k]); + } + rozdzielacze[i]->wejscia_elementu[j]->wyjscia_elementu.removeAll(rozdzielacze[i]); + } + } + for (int j = 0; j < rozdzielacze[i]->wyjscia_elementu.count(); ++j) { + for (int k = 0; k < rozdzielacze[i]->wejscia_elementu.count(); ++k) { + znajdz_element_drabinki(*przetworzone_obwody[rozdzielacze[i]->numer_linii], rozdzielacze[i]->wyjscia_elementu[j]->element)->wejscia_elementu.append(rozdzielacze[i]->wejscia_elementu[k]); + } + rozdzielacze[i]->wyjscia_elementu[j]->wejscia_elementu.removeAll(rozdzielacze[i]); + } + delete rozdzielacze[i]; + rozdzielacze.removeAt(i); + } + } + } + for (int i = 0; i < przetworzone_obwody.count(); ++i) { //znajdowanie początkowych elementów + for (int j = 0; j < przetworzone_obwody[i]->count(); ++j) { + if (sprawdz_czy_jest_na_liscie(NULL, przetworzone_obwody[i]->at(j)->wejscia_elementu)) { + poczatki[i]->append(przetworzone_obwody[i]->at(j)); + } + } + } + //ROZPOCZĘCIE KOMPILACJI + QFile plik_z_projektem(konfiguracja.sciezka_zapisu_kompilacja); + if (!plik_z_projektem.open(QIODevice::WriteOnly)){ + QMessageBox msgBox; + msgBox.setText("Nie udało się zapisać pliku!"); + msgBox.setIcon(QMessageBox::Critical); + msgBox.exec(); + return -1; + } + QTextStream out(&plik_z_projektem); + if (timery.count() > 0) { + out<<"class timer {\n" + "public:\n" + "timer(unsigned long a) {\n" + "czas = 0;\n" + "prog_zalaczenia = a;\n" + "stan = false;\n" + "}\n\n" + + "void wykonanie() {\n" + "if (czas == 0)\n" + "czas = millis();\n" + "if (!stan && millis() - czas >= prog_zalaczenia)\n" + "stan = true;\n" + "}\n" + "void reset() {\n" + "stan = false;\n" + "czas = 0;\n" + "}\n\n" + + "unsigned long czas;\n" + "unsigned long prog_zalaczenia;\n" + "bool stan;\n" + "};\n\n"; } + if (liczniki.count() > 0) { + out<<"class licznik {\n" + "public:\n" + "licznik(unsigned long a) {\n" + "prog_zalaczenia = a;\n" + "aktualna_liczba = 0;\n" + "poprzednie_wejscie = false;\n" + "}\n" + + "void wykonanie() {\n" + "if (aktualna_liczba != prog_zalaczenia && poprzednie_wejscie == false) {\n" + "aktualna_liczba += 1;\n" + "poprzednie_wejscie = true;\n" + "}\n" + "if (aktualna_liczba == prog_zalaczenia) {\n" + "stan = true;\n" + "}\n" + "}\n" + + "void zmiana_wejscia() {\n" + "poprzednie_wejscie = false;\n" + "}\n" + + "void reset() {\n" + "aktualna_liczba = 0;\n" + "stan = false;\n" + "}\n" + + "unsigned long prog_zalaczenia;\n" + "unsigned long aktualna_liczba;\n" + "bool poprzednie_wejscie;\n" + "bool stan;\n" + "};\n"; } + QMapIterator i(lista_uzywanych_zmiennych); + while (i.hasNext()) { + i.next(); + if (i.value().typ_zmiennej != NIE_DOTYCZY) { + if (i.value().rodzaj_pinu != NIE_DOTYCZY) { + out<<"int "<element->zmienna<<"("<element->parametry.value(PV)<<");\n"; + } + for (int i = 0; i < liczniki.count(); ++i) { + out<<"licznik "<element->zmienna<<"("<element->parametry.value(PV)<<");\n"; + } + out<<"\nvoid setup() {\n"; + i.toFront(); + while (i.hasNext()) { + i.next(); + if (i.value().typ_zmiennej == DYSKRETNA && i.value().rodzaj_pinu != NIE_DOTYCZY) { + out<<"pinMode("<count(); ++k) { + if (k == 0) + out<<"if ("; + warunek.clear(); + tworzenie_warunkow(out, poczatki[j]->at(k), warunek, liczniki, timery); + warunek.chop(4); + if (k == 0 && poczatki[j]->count() > 1) + warunek += " || "; + out<count() - 1) + out<<") {\n"; + + } + for (int k = 0; k < konce[j]->count(); k++) { + switch (konce[j]->at(k)->element->rodzaj) { + case cewka: + switch (konce[j]->at(k)->element->rodzaj2) { + case ZWYKLA: + out<at(k)->element->zmienna<<" = true;\n"; + break; + case ZANEGOWANA: + out<at(k)->element->zmienna<<" = false;\n"; + break; + default: + break; + } + break; + case blok_funkcyjny: + out<at(k)->element->zmienna<<".wykonanie();\n"; + default: + break; + } + } + for (int k = 0; k < konce[j]->count(); k++) { + if (k == 0) + out<<"}\n" + "else {\n"; + switch (konce[j]->at(k)->element->rodzaj) { + case cewka: + switch (konce[j]->at(k)->element->rodzaj2) { + case ZWYKLA: + out<at(k)->element->zmienna<<" = false;\n"; + break; + case ZANEGOWANA: + out<at(k)->element->zmienna<<" = true;\n"; + break; + default: + break; + } + break; + case blok_funkcyjny: + switch (konce[j]->at(k)->element->rodzaj2) { + case TIMER: + out<at(k)->element->zmienna<<".reset();\n"; + break; + case LICZNIK: + out<at(k)->element->zmienna<<".zmiana_wejscia();\n"; + break; + default: + break; + } + default: + break; + } + if (k == konce[j]->count() - 1) + out<<"}\n"; + } + } + for (int j = 0; j < liczniki.count(); j++) { + if (sprawdz_czy_jest_na_liscie(liczniki[j]->element->parametry.value(ZMIENNA_RESETUJACA), liczniki, timery)) { + out<<"if ("<element->parametry.value(ZMIENNA_RESETUJACA)<<".stan) {"; + out<element->zmienna<<".reset();\n" + "}\n"; + } + else { + out<<"if ("<element->parametry.value(ZMIENNA_RESETUJACA)<<") {"; + out<element->zmienna<<".reset();\n" + "}\n"; + } + } + i.toFront(); + while (i.hasNext()) { //zapis wartości do pinów na końcu działania pętli(jak w przyszłości będzie potrzeba sterowania analogowymi wyjściami to tutaj dodać potrzebne definicje) + i.next(); + if (i.value().rodzaj_pinu == WYJSCIE) { + if (i.value().typ_zmiennej == DYSKRETNA) { + out<<"digitalWrite("<count(); ++k) { + delete przetworzone_obwody[j]->at(k); + } + delete przetworzone_obwody[j]; + delete poczatki[j]; + delete konce[j]; + } + for (int j = 0; j < liczniki.count(); ++j) { + delete liczniki[j]; + } + for (int j = 0; j < timery.count(); ++j) { + delete timery[j]; + } + return 0; +} + +int PLCino::wybranie_sciezki_zapisu(int rodzaj_zapisu) +{ + QString sciezka_pliku; + if (rodzaj_zapisu == PROJEKT) + sciezka_pliku = QFileDialog::getSaveFileName(this, tr("Zapisz"), + QDir::currentPath(), + tr("Projekty (*.plc)")); + else + sciezka_pliku = QFileDialog::getSaveFileName(this, tr("Zapisz"), + QDir::currentPath(), + tr("Kod źródłowy Arduino (*.ino)")); + if(sciezka_pliku.isEmpty()) + return -1; + if (rodzaj_zapisu == PROJEKT) + konfiguracja.sciezka_zapisu_projektu = sciezka_pliku; + else + konfiguracja.sciezka_zapisu_kompilacja = sciezka_pliku; + return 0; +} + +bool PLCino::sprawdz_czy_jest_na_liscie(elementy_drabinki *a, QList *b) +{ + for (int i = 0; i < b->count(); ++i) { + if (b->at(i)->element == a) + return true; + } + return false; +} + +bool PLCino::sprawdz_czy_jest_na_liscie(elementy_schematu *a, QList b) +{ + for (int i = 0; i < b.count(); ++i) { + if (b.at(i) == a) + return true; + } + return false; +} + +bool PLCino::sprawdz_czy_jest_na_liscie(QString a, QList liczniki, QList timery) +{ + for (int i = 0; i < liczniki.count(); ++i) { + if (QString::compare(liczniki[i]->element->zmienna, a, Qt::CaseInsensitive) == 0) { + return true; + } + } + for (int i = 0; i < timery.count(); ++i) { + if (QString::compare(timery[i]->element->zmienna, a, Qt::CaseInsensitive) == 0) { + return true; + } + } + return false; +} + +bool PLCino::sprawdz_czy_jest_na_wejsciu_lub_wyjsciu(elementy_drabinki *a, elementy_schematu *b) +{ + for (int i = 0; i < b->wejscia_elementu.count(); ++i) { + if (b->wejscia_elementu.at(i)->element == a) + return true; + } + for (int i = 0; i < b->wyjscia_elementu.count(); ++i) { + if (b->wyjscia_elementu.at(i)->element == a) + return true; + } + return false; +} + +elementy_schematu *PLCino::znajdz_element_drabinki(QList lista, elementy_drabinki *a) +{ + for(int i = 0; i < lista.count(); ++i) { + if(lista[i]->element == a) + return lista[i]; + } + return NULL; +} + +bool PLCino::czy_styk_nalezy_do_bloku_funkcyjnego(QString nazwa_zmiennej, QList liczniki, QList timery) +{ + for (int i = 0; i < liczniki.count(); ++i) { + if (QString::compare(liczniki[i]->element->zmienna, nazwa_zmiennej) == 0) + return true; + } + for (int i = 0; i < timery.count(); ++i) { + if (QString::compare(timery[i]->element->zmienna, nazwa_zmiennej) == 0) + return true; + } + return false; +} + +void PLCino::tworzenie_warunkow(QTextStream &out, elementy_schematu *element, QString string, QList liczniki, QList timery) +{ + QString warunek_kopia = string; + if (element->element->rodzaj == cewka || element->element->rodzaj == blok_funkcyjny) { //warunek, gdy w obwodzie znajduje się tylko cewka lub blok funkcyjny, który się zawsze wykonuje + warunek += " true "; + return; + } + switch (element->element->rodzaj) { + case styk: + switch (element->element->rodzaj2) { + case ZWYKLY: + if (czy_styk_nalezy_do_bloku_funkcyjnego(element->element->zmienna, liczniki, timery)) { + warunek_kopia += " " + element->element->zmienna + ".stan "; + } + else { + warunek_kopia += " " + element->element->zmienna + " "; + } + break; + case ZANEGOWANY: + if (czy_styk_nalezy_do_bloku_funkcyjnego(element->element->zmienna, liczniki, timery)) { + warunek_kopia += " !" + element->element->zmienna + ".stan "; + } + else { + warunek_kopia += " !" + element->element->zmienna + " "; + } + break; + default: + break; + } + break; + case operator_porownania: + switch (element->element->rodzaj2) { + case WIEKSZY_BADZ_ROWNY: + warunek_kopia += " " + element->element->parametry.value(ELEMENT1) + " >= " + element->element->parametry.value(ELEMENT2) + " "; + break; + case WIEKSZY: + warunek_kopia += " " + element->element->parametry.value(ELEMENT1) + " > " + element->element->parametry.value(ELEMENT2) + " "; + break; + case MNIEJSZY_BADZ_ROWNY: + warunek_kopia += " " + element->element->parametry.value(ELEMENT1) + " <= " + element->element->parametry.value(ELEMENT2) + " "; + break; + case MNIEJSZY: + warunek_kopia += " " + element->element->parametry.value(ELEMENT1) + " < " + element->element->parametry.value(ELEMENT2) + " "; + break; + case ROWNY: + warunek_kopia += " " + element->element->parametry.value(ELEMENT1) + " == " + element->element->parametry.value(ELEMENT2) + " "; + break; + case ROZNY: + warunek_kopia += " " + element->element->parametry.value(ELEMENT1) + " != " + element->element->parametry.value(ELEMENT2) + " "; + break; + default: + break; + } + default: + break; + } + if (element->wyjscia_elementu[0]->element->rodzaj != cewka && element->wyjscia_elementu[0]->element->rodzaj != blok_funkcyjny) { + warunek_kopia += "&&"; + } + for (int i = 0; i < element->wyjscia_elementu.count(); ++i) { + if (element->wyjscia_elementu[i]->element->rodzaj == cewka || element->wyjscia_elementu[i]->element->rodzaj == blok_funkcyjny) { + if (element->wyjscia_elementu.count() == 1) + warunek += warunek_kopia + " || "; + else + warunek += warunek_kopia; + } + else { + tworzenie_warunkow(out, element->wyjscia_elementu[i], warunek_kopia, liczniki, timery); + } + } +} + +QString PLCino::poszukiwanie_portu_bootloadera(QList *przed_resetem, QList *po_resecie) +{ + for (int i = 0; i < po_resecie->count(); i++) { + bool znaleziono = false; + for (int j = 0; j < przed_resetem->count(); j++) { + if (po_resecie->at(i).portName() == przed_resetem->at(j).portName()) { + znaleziono = true; + break; + } + } + if (!znaleziono) + return po_resecie->at(i).portName(); + } + return ""; +} + +void PLCino::on_actionKompiluj_do_C_triggered() +{ + if (wybranie_sciezki_zapisu(KOMPILACJA) < 0) + return; + kompilator(); + statusBar()->showMessage("Kompilacja zakończona", 5000); + QMessageBox msgBox; + msgBox.setText("Kompilacja zakończona"); + msgBox.setIcon(QMessageBox::Information); + msgBox.exec(); +} + +void PLCino::on_actionKompiluj_i_wgraj_do_Arduino_triggered() +{ + QMessageBox msgBox; + if (konfiguracja.wybrana_plytka == brak || konfiguracja.nazwa_wybranego_portu.isEmpty()) { + msgBox.setText("Nie skonfigurowano ustawień układu Arduino!"); + msgBox.setIcon(QMessageBox::Critical); + msgBox.exec(); + return; + } + if (wybranie_sciezki_zapisu(KOMPILACJA) < 0) + return; + statusBar()->showMessage("Kompilacja do języka Arduino..."); + kompilator(); + QDir dir = QDir::root(); + dir.rmpath("temp/"); + dir.mkpath("temp/"); + dir.cd("temp/"); + + QFile log(dir.path() + "/log.txt"); + if (!log.open(QIODevice::WriteOnly)){ + QMessageBox msgBox; + msgBox.setText("Nie udało utworzyć pliku log!"); + msgBox.setIcon(QMessageBox::Critical); + msgBox.exec(); + return; + } + QTextStream out_log(&log); + QProcess proces_arduino_builder; + QProcess proces_avrdude; + QSerialPort odblokowanie_mikrokontrolera; + QList porty_przed_resetem; + QList porty_po_resecie; + QString COM_bootloadera; + statusBar()->showMessage("Kompilacja do formatu Intel HEX..."); + switch (konfiguracja.wybrana_plytka) { + case nano: + proces_arduino_builder.setProcessChannelMode(QProcess::MergedChannels); + proces_arduino_builder.start(("arduino-builder.exe -hardware hardware -tools har" + "dware\\tools -tools tools-builder -fqbn arduino:avr:nano:cpu=atmega328 -build-pat" + "h " + dir.absolutePath() + " -compile " + konfiguracja.sciezka_zapisu_kompilacja).toStdString().c_str()); + proces_arduino_builder.waitForFinished(-1); + out_log<showMessage("Wgrywanie programu do Arduino..."); + proces_avrdude.start(("avrdude.exe -v -C\"avrdude.conf\" -pm328p -carduino -P " + konfiguracja.nazwa_wybranego_portu + + " -b57600 -D -Uflash:w:" + dir.absolutePath() + "/" + konfiguracja.sciezka_zapisu_kompilacja.section('/', -1) + ".hex:i").toStdString().c_str()); + proces_avrdude.waitForFinished(10000); + out_log<showMessage("Uruchamianie bootloadera..."); + odblokowanie_mikrokontrolera.open(QIODevice::ReadWrite); + QThread::msleep(2000); + porty_po_resecie = QSerialPortInfo::availablePorts(); + COM_bootloadera = poszukiwanie_portu_bootloadera(&porty_przed_resetem, &porty_po_resecie); + odblokowanie_mikrokontrolera.close(); + statusBar()->showMessage("Wgrywanie programu do Arduino..."); + proces_avrdude.start(("avrdude.exe -v -C\"avrdude.conf\" -p atmega32u4 -c avr109 -P " + COM_bootloadera + + " -b 57600 -D -Uflash:w:" + dir.absolutePath() + "/" + konfiguracja.sciezka_zapisu_kompilacja.section('/', -1) + ".hex:i").toStdString().c_str()); + proces_avrdude.waitForFinished(10000); + out_log<showMessage("Wgrywanie programu do Arduino..."); + proces_avrdude.start(("avrdude.exe -v -C\"avrdude.conf\" -pm2560 -c wiring -P " + konfiguracja.nazwa_wybranego_portu + + " -b 115200 -D -Uflash:w:" + dir.absolutePath() + "/" + konfiguracja.sciezka_zapisu_kompilacja.section('/', -1) + ".hex:i").toStdString().c_str()); + proces_avrdude.waitForFinished(10000); + out_log<showMessage("Kompilacja zakończona", 5000); + msgBox.setText("Kompilacja i wgrywanie zakończone.\nSzczegóły w pliku " + dir.path() + "/log.txt"); + msgBox.setIcon(QMessageBox::Information); + msgBox.exec(); +} + +void PLCino::on_actionZapisz_triggered() +{ + if (wybranie_sciezki_zapisu(PROJEKT) >= 0) { + QFile plik_z_projektem(konfiguracja.sciezka_zapisu_projektu); + if (!plik_z_projektem.open(QIODevice::WriteOnly)){ + QMessageBox msgBox; + msgBox.setText("Nie udało się zapisać pliku!"); + msgBox.setIcon(QMessageBox::Critical); + msgBox.exec(); + return; + } + QDataStream zapis(&plik_z_projektem); + zapis<<(quint32)lista_modeli.count(); //liczba modeli + for (int i = 0; i < lista_modeli.count(); ++i) { + zapis<<(quint32)lista_modeli[i]->kolumny_temp; + if (lista_modeli[i]->model_dane.count() != 0) { + zapis<<(quint32)lista_modeli[i]->model_dane.count(); //liczba wierszy + if (lista_modeli[i]->model_dane.count() != 0) + zapis<<(quint32)lista_modeli[i]->model_dane.at(0)->count(); //liczba kolumn + } + for (int j = 0; j < lista_modeli[i]->model_dane.count(); ++j) { + for (int k = 0; k < lista_modeli[i]->model_dane.at(j)->count(); ++k) { + zapis<<(quint32)lista_modeli[i]->model_dane.at(j)->at(k)->rodzaj<<(quint32)lista_modeli[i]->model_dane.at(j)->at(k)->rodzaj2<model_dane.at(j)->at(k)->nazwa<model_dane.at(j)->at(k)->zmienna<model_dane.at(j)->at(k)->parametry; + } + } + } + zapis<<(quint32)lista_uzywanych_zmiennych.count(); + for (QMap::iterator i = lista_uzywanych_zmiennych.begin(); i != lista_uzywanych_zmiennych.end(); ++i) { + zapis<>liczba_zapisanych_modeli; + for (quint32 i = 0; i < liczba_zapisanych_modeli; ++i) { + quint32 kolumny_temp, liczba_wierszy_w_modelu; + odczyt>>kolumny_temp; + odczyt>>liczba_wierszy_w_modelu; + quint32 liczba_kolumn_w_modelu; + if (liczba_wierszy_w_modelu != 0) { + odczyt>>liczba_kolumn_w_modelu; + } + else { + liczba_kolumn_w_modelu = 0; + } + lista_modeli.insert(i, new model_drabinka(this, liczba_kolumn_w_modelu, liczba_wierszy_w_modelu)); + lista_modeli[i]->kolumny_temp=kolumny_temp; + for (quint32 j = 0; j < liczba_wierszy_w_modelu; ++j) { + for (quint32 k = 0; k < liczba_kolumn_w_modelu; ++k) { + elementy rodzaj_temp; + quint32 rodzaj2_temp; + QString nazwa_temp, zmienna_temp; + odczyt>>(quint32&)rodzaj_temp>>(quint32&)rodzaj2_temp>>nazwa_temp>>zmienna_temp>>lista_modeli[i]->model_dane.at(j)->at(k)->parametry; + lista_modeli[i]->model_dane.at(j)->at(k)->rodzaj = rodzaj_temp; + lista_modeli[i]->model_dane.at(j)->at(k)->rodzaj2 = rodzaj2_temp; + lista_modeli[i]->model_dane.at(j)->at(k)->nazwa = nazwa_temp; + lista_modeli[i]->model_dane.at(j)->at(k)->zmienna = zmienna_temp; + } + } + } + quint32 liczba_zapisanych_uzywanych_zmiennych; + odczyt>>liczba_zapisanych_uzywanych_zmiennych; + for (quint32 i = 0; i < liczba_zapisanych_uzywanych_zmiennych; ++i) { + QString klucz_temp, numer_pinu_temp; + quint32 typ_zmiennej_temp, rodzaj_pinu_temp; + odczyt>>klucz_temp>>numer_pinu_temp>>typ_zmiennej_temp>>rodzaj_pinu_temp; + lista_uzywanych_zmiennych.insert(klucz_temp, {numer_pinu_temp, rodzaj_pinu_temp, typ_zmiennej_temp}); + } + odczyt>>konfiguracja.nazwa_wybranego_portu>>konfiguracja.sciezka_zapisu_projektu>>(quint32&)konfiguracja.wybrana_plytka; + switch (konfiguracja.wybrana_plytka) { + case nano: + ui->actionNano->setChecked(true); + ui->actionMega->setChecked(false); + ui->actionLeonadro->setChecked(false); + break; + case leonardo: + ui->actionNano->setChecked(false); + ui->actionMega->setChecked(false); + ui->actionLeonadro->setChecked(true); + break; + case mega: + ui->actionNano->setChecked(false); + ui->actionMega->setChecked(true); + ui->actionLeonadro->setChecked(false); + break; + default: + break; + } + for (int i = 0; i < lista_modeli.count(); ++i) { + lista_obwodow.insert(i, new QTableView(this)); + lista_obwodow[i]->setModel(lista_modeli[i]); + lista_obwodow[i]->setAcceptDrops(true); + lista_obwodow[i]->setDropIndicatorShown(true); + lista_obwodow[i]->setDragDropOverwriteMode(true); + lista_obwodow[i]->setSelectionMode(QAbstractItemView::SingleSelection); //możliwość zaznaczenia tylko jednej komórki + lista_obwodow[i]->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Fixed); + lista_obwodow[i]->setMinimumHeight(400); + lista_obwodow[i]->verticalHeader()->setSectionResizeMode(QHeaderView::Fixed); + lista_obwodow[i]->verticalHeader()->setDefaultSectionSize(100); + lista_obwodow[i]->horizontalHeader()->setSectionResizeMode(QHeaderView::Fixed); + lista_obwodow[i]->horizontalHeader()->setDefaultSectionSize(100); + lista_obwodow[i]->adjustSize(); + ui->verticalLayout->addWidget(lista_obwodow[i],0); + connect(lista_obwodow[i], SIGNAL(doubleClicked(const QModelIndex &)), this, SLOT(edycja_wlasciwosci(const QModelIndex &))); //podłączenie sygnału podwójnego kliknięcia do metody edycja_wlasciwosci + } + plik_z_projektem.flush(); + plik_z_projektem.close(); +} + +void PLCino::on_actionEdycja_wlasciwosci_triggered() +{ + for (int i = 0; i < lista_obwodow.size(); i++) { + if(lista_obwodow[i]->hasFocus()) { + QModelIndexList zaznaczony_element = lista_obwodow[i]->selectionModel()->selectedIndexes(); //zawsze będzie tylko jeden element, bo wyłączone jest zaznaczanie wielu elementów w QTableView + if(zaznaczony_element.length() != 0) { + edycja_wlasciwosci(zaznaczony_element[0]); + break; + } + } + } +} + +void PLCino::on_actionUsun_element_triggered() +{ + for (int i = 0; i < lista_obwodow.size(); i++) { + if(lista_obwodow[i]->hasFocus()) { + QModelIndexList zaznaczony_element = lista_obwodow[i]->selectionModel()->selectedIndexes(); //zawsze będzie tylko jeden element, bo wyłączone jest zaznaczanie wielu elementów w QTableView + if(zaznaczony_element.length() != 0) { + lista_modeli[i]->model_dane.at(zaznaczony_element[0].row())->replace(zaznaczony_element[0].column(), new elementy_drabinki()); + break; + } + } + } +} + +void PLCino::on_actionWgraj_plik_C_do_Arduino_triggered() +{ + QMessageBox msgBox; + if (konfiguracja.wybrana_plytka == brak || konfiguracja.nazwa_wybranego_portu.isEmpty()) { + msgBox.setText("Nie skonfigurowano ustawień układu Arduino!"); + msgBox.setIcon(QMessageBox::Critical); + msgBox.exec(); + return; + } + QString sciezka_pliku = QFileDialog::getOpenFileName(this, tr("Otwórz"), + QDir::currentPath(), + tr("Kod źródłowy Arduino (*.ino)")); + if (sciezka_pliku.isEmpty()) + return; + QDir dir = QDir::root(); + dir.rmpath("temp/"); + dir.mkpath("temp/"); + dir.cd("temp/"); + + QFile log(dir.path() + "/log.txt"); + if (!log.open(QIODevice::WriteOnly)){ + QMessageBox msgBox; + msgBox.setText("Nie udało utworzyć pliku log!"); + msgBox.setIcon(QMessageBox::Critical); + msgBox.exec(); + return; + } + QTextStream out_log(&log); + QProcess proces_arduino_builder; + QProcess proces_avrdude; + QSerialPort odblokowanie_mikrokontrolera; + QList porty_przed_resetem; + QList porty_po_resecie; + QString COM_bootloadera; + statusBar()->showMessage("Kompilacja do formatu Intel HEX..."); + switch (konfiguracja.wybrana_plytka) { + case nano: + proces_arduino_builder.setProcessChannelMode(QProcess::MergedChannels); + proces_arduino_builder.start(("arduino-builder.exe -hardware hardware -tools har" + "dware\\tools -tools tools-builder -fqbn arduino:avr:nano:cpu=atmega328 -build-pat" + "h " + dir.absolutePath() + " -compile " + sciezka_pliku).toStdString().c_str()); + proces_arduino_builder.waitForFinished(-1); + out_log<showMessage("Wgrywanie programu do Arduino..."); + proces_avrdude.start(("avrdude.exe -v -C\"avrdude.conf\" -pm328p -carduino -P " + konfiguracja.nazwa_wybranego_portu + + " -b57600 -D -Uflash:w:" + dir.absolutePath() + "/" + sciezka_pliku.section('/', -1) + ".hex:i").toStdString().c_str()); + proces_avrdude.waitForFinished(10000); + out_log<showMessage("Uruchamianie bootloadera..."); + odblokowanie_mikrokontrolera.open(QIODevice::ReadWrite); + QThread::msleep(2000); + porty_po_resecie = QSerialPortInfo::availablePorts(); + COM_bootloadera = poszukiwanie_portu_bootloadera(&porty_przed_resetem, &porty_po_resecie); + odblokowanie_mikrokontrolera.close(); + statusBar()->showMessage("Wgrywanie programu do Arduino..."); + proces_avrdude.start(("avrdude.exe -v -C\"avrdude.conf\" -p atmega32u4 -c avr109 -P " + COM_bootloadera + + " -b 57600 -D -Uflash:w:" + dir.absolutePath() + "/" + sciezka_pliku.section('/', -1) + ".hex:i").toStdString().c_str()); + proces_avrdude.waitForFinished(10000); + out_log<showMessage("Wgrywanie programu do Arduino..."); + proces_avrdude.start(("avrdude.exe -v -C\"avrdude.conf\" -pm2560 -c wiring -P " + konfiguracja.nazwa_wybranego_portu + + " -b 115200 -D -Uflash:w:" + dir.absolutePath() + "/" + sciezka_pliku.section('/', -1) + ".hex:i").toStdString().c_str()); + proces_avrdude.waitForFinished(10000); + out_log<showMessage("Wgrywanie zakończone", 5000); + msgBox.setText("Wgrywanie zakończone.\nSzczegóły w pliku " + dir.path() + "/log.txt"); + msgBox.setIcon(QMessageBox::Information); + msgBox.exec(); + +} diff --git a/plcino.h b/plcino.h new file mode 100644 index 0000000..6a828dc --- /dev/null +++ b/plcino.h @@ -0,0 +1,130 @@ +#ifndef PLCINO_H +#define PLCINO_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "elementy_schematu.h" + +enum rodzaje_obslugiwanych_plytek { + leonardo, + nano, + mega, + brak +}; + +namespace Ui { +class PLCino; +} + +class PLCino : public QMainWindow //główna klasa programu +{ + Q_OBJECT + +public: + explicit PLCino(QWidget *parent = 0); + ~PLCino(); + +private slots: + void on_actionNowy_obwod_triggered(); + + void on_actionUsun_obwod_triggered(); + + void on_actionDodaj_kolumne_triggered(); + + void on_actionUsun_kolumne_triggered(); + + void on_actionDodaj_wiersz_triggered(); + + void on_actionUsun_wiersz_triggered(); + + void on_actionUzywane_zmienne_triggered(); + + void on_actionPort_triggered(); + + void edycja_wlasciwosci(const QModelIndex ModelIndex); + + void on_actionLeonadro_triggered(); + + void on_actionMega_triggered(); + + void on_actionNano_triggered(); + + void on_actionNowy_triggered(); + + void on_actionZamknij_triggered(); + + void on_actionKompiluj_do_C_triggered(); + + void on_actionKompiluj_i_wgraj_do_Arduino_triggered(); + + void on_actionZapisz_triggered(); + + void on_actionOtworz_triggered(); + + void on_actionEdycja_wlasciwosci_triggered(); + + void on_actionUsun_element_triggered(); + + void on_actionWgraj_plik_C_do_Arduino_triggered(); + +public: + Ui::PLCino *ui; + QList lista_obwodow; //lista graficznych obwodów(tabel) + QList lista_modeli; //lista modeli danych dla każdego graficznego obwodu + QMap lista_uzywanych_zmiennych; //lista używanych zmiennych z nazwami w środowisku graficznym oraz odpowiadającymi im nazwami w programie Arduino + uzywane_zmienne* okno_edycji_zmiennych; //okno służące do edycji listy używanych zmiennych + QDialog* okno_wyboru_portu; //okno używane do wyboru portu COM, do którego podłączona jest płytka Arduino + dodawanie_zmiennej *okno_dodawanie_zmiennej; //okno pojawiające się, gdy użytkownik chce ustawić zmienną do elementu, która jeszcze nie istnieje + edycja_specjalna *okno_edycji_specjalnej; + + struct { + QString nazwa_wybranego_portu; + rodzaje_obslugiwanych_plytek wybrana_plytka; + QString sciezka_zapisu_projektu; + QString sciezka_zapisu_kompilacja; + } konfiguracja; //struktura z konfiguracją programu + +private: + int kompilator(); + int wybranie_sciezki_zapisu(int); + + //ELEMENTY WYKORZYSTYWANE NA POTRZEBY KOMPILACJI + QString warunek; + bool sprawdz_czy_jest_na_liscie(elementy_drabinki* a, QList* b); + bool sprawdz_czy_jest_na_liscie(elementy_schematu* a, QList b); + bool sprawdz_czy_jest_na_liscie(QString a, QList liczniki, QList timery); + bool sprawdz_czy_jest_na_wejsciu_lub_wyjsciu(elementy_drabinki* a, elementy_schematu* b); + elementy_schematu* znajdz_element_drabinki(QList lista, elementy_drabinki* a); + bool czy_styk_nalezy_do_bloku_funkcyjnego(QString nazwa_zmiennej, QList liczniki, QList timery); + void tworzenie_warunkow(QTextStream &out, elementy_schematu* element, QString string, QList liczniki, QList timery); + QString poszukiwanie_portu_bootloadera(QList *przed_resetem, QList *po_resecie); +}; + +#endif // PLCINO_H diff --git a/plcino.ui b/plcino.ui new file mode 100644 index 0000000..6d2d26f --- /dev/null +++ b/plcino.ui @@ -0,0 +1,519 @@ + + + PLCino + + + Qt::WindowModal + + + + 0 + 0 + 1188 + 631 + + + + PLCino + + + + + + + 6 + + + + + QFrame::NoFrame + + + Qt::ScrollBarAsNeeded + + + Qt::ScrollBarAlwaysOff + + + QAbstractScrollArea::AdjustToContents + + + true + + + Qt::AlignHCenter|Qt::AlignTop + + + + + 0 + 0 + 906 + 536 + + + + + QLayout::SetMaximumSize + + + + + QLayout::SetDefaultConstraint + + + + + + + + + + + true + + + true + + + + Elementy drabinki + + + + + Cewka + + + ItemIsSelectable|ItemIsUserCheckable|ItemIsEnabled + + + + Zwykła -( )- + + + + + Zanegowana -(/)- + + + + + + Styk + + + ItemIsSelectable|ItemIsUserCheckable|ItemIsEnabled + + + + Zwykły -| |- + + + + + Zanegowany -|/|- + + + + + + Blok funkcyjny + + + ItemIsSelectable|ItemIsUserCheckable|ItemIsEnabled + + + + Licznik CTU + + + + + Timer TON + + + + + + Operator porównania + + + ItemIsSelectable|ItemIsUserCheckable|ItemIsEnabled + + + + Większe > + + + + + Większe bądź równe >= + + + + + Mniejsze < + + + + + Mniejsze bądź równe <= + + + + + Równe == + + + + + Różne != + + + + + + Łączniki + + + ItemIsSelectable|ItemIsUserCheckable|ItemIsEnabled + + + + ─ + + + + + │ + + + + + ┌ + + + + + ┐ + + + + + └ + + + + + ┘ + + + + + ├ + + + + + ┤ + + + + + ┬ + + + + + ┴ + + + + + ┼ + + + + + + + + + + + + + 0 + 0 + 1188 + 21 + + + + + Plik + + + + + + + + + Kompilacja + + + + + + + + Ustawienia + + + + Rodzaj płytki + + + + + + + + + + + + Edycja + + + + + + + + + + + + false + + + TopToolBarArea + + + false + + + + + + + + + + + + + + + false + + + + + Otwórz + + + Ctrl+O + + + + + Zamknij + + + + + Kompiluj do C++ + + + F5 + + + + + Kompiluj i wgraj do Arduino + + + F9 + + + + + Port + + + + + Zapisz + + + Ctrl+S + + + + + Używane zmienne + + + + + + :/ikony/C:/Users/Łukasz/Box Sync/Inżynierka/Ikony/nowa_linia.png:/ikony/C:/Users/Łukasz/Box Sync/Inżynierka/Ikony/nowa_linia.png + + + Nowy obwód + + + Utwórz nowy obwód z drabinką + + + Ctrl+T + + + + + + :/ikony/C:/Users/Łukasz/Box Sync/Inżynierka/Ikony/usun_linie.png:/ikony/C:/Users/Łukasz/Box Sync/Inżynierka/Ikony/usun_linie.png + + + Usuń obwód + + + Usuwa aktualnie wybrany obwód z drabinką + + + Ctrl+W + + + + + + :/ikony/C:/Users/Łukasz/Box Sync/Inżynierka/Ikony/dodaj_kolumne.png:/ikony/C:/Users/Łukasz/Box Sync/Inżynierka/Ikony/dodaj_kolumne.png + + + Dodaj kolumnę + + + Dodaje kolumnę do aktualnie wybranej linii + + + + + + :/ikony/C:/Users/Łukasz/Box Sync/Inżynierka/Ikony/usun_kolumne.png:/ikony/C:/Users/Łukasz/Box Sync/Inżynierka/Ikony/usun_kolumne.png + + + Usuń kolumnę + + + Usuwa kolumnę z aktualnie wybranej linii + + + + + + :/ikony/C:/Users/Łukasz/Box Sync/Inżynierka/Ikony/rsz_dodaj_wiersz.png:/ikony/C:/Users/Łukasz/Box Sync/Inżynierka/Ikony/rsz_dodaj_wiersz.png + + + Dodaj wiersz + + + + + + :/ikony/C:/Users/Łukasz/Box Sync/Inżynierka/Ikony/usun_wiersz.png:/ikony/C:/Users/Łukasz/Box Sync/Inżynierka/Ikony/usun_wiersz.png + + + Usuń wiersz + + + + + true + + + Leonadro + + + + + true + + + Mega + + + + + true + + + false + + + Nano + + + + + Zapisz jako + + + + + Nowy + + + Ctrl+N + + + + + Edycja właściwości + + + Edycja właściwości wybranego elementu + + + Return + + + + + Usuń element + + + Usuwa zaznaczony element + + + Del + + + + + Wgraj plik C++ do Arduino + + + F7 + + + + + + + + + diff --git a/typy_wyliczeniowe.h b/typy_wyliczeniowe.h new file mode 100644 index 0000000..8195538 --- /dev/null +++ b/typy_wyliczeniowe.h @@ -0,0 +1,62 @@ +#ifndef TYPY_WYLICZENIOWE_H +#define TYPY_WYLICZENIOWE_H + +enum elementy { + cewka, + styk, + operator_porownania, + blok_funkcyjny, + lacznik, + pusty +}; + +//RODZAJE CEWEK: +#define ZWYKLA 1 +#define ZANEGOWANA 2 +//RODZAJE STYKÓW: +#define ZWYKLY 1 +#define ZANEGOWANY 2 +//RODZAJE BLOKÓW FUNKCYJNYCH: +#define TIMER 1 +#define LICZNIK 2 +//RODZAJE OPERATORÓW PORÓWNANIA: +#define WIEKSZY_BADZ_ROWNY 1 +#define WIEKSZY 2 +#define MNIEJSZY_BADZ_ROWNY 3 +#define MNIEJSZY 4 +#define ROWNY 5 +#define ROZNY 6 +//RODZAJE ŁĄCZNIKÓW: +#define LEWO_PRAWO 1 +#define GORA_DOL 2 +#define DOL_PRAWO 3 +#define DOL_LEWO 4 +#define GORA_PRAWO 5 +#define GORA_LEWO 6 +//RODZAJE ROZDZIELACZY: +#define GORA_PRAWO_DOL 7 +#define GORA_LEWO_DOL 8 +#define LEWO_DOL_PRAWO 9 +#define LEWO_GORA_PRAWO 10 +#define GORA_DOL_LEWO_PRAWO 11 + +//PARAMETRY +#define WEJSCIA 1 +#define WYJSCIA 2 +#define PV 3 +#define ZMIENNA_RESETUJACA 4 +#define ELEMENT1 5 +#define ELEMENT2 6 +#define ELEMENT_DO_PRZENIESIENIA 7 +#define ZMIENNA_DOCELOWA 8 + +//TYP ZMIENNEJ +#define NIE_DOTYCZY 1 +#define DYSKRETNA 2 +//#define ANALOGOWA 3 +//RODZAJ PINU +//#define NIE_DOTYCZY 1 +#define WEJSCIE 2 +#define WYJSCIE 3 + +#endif // TYPY_WYLICZENIOWE_H diff --git a/uzywane_zmienne.cpp b/uzywane_zmienne.cpp new file mode 100644 index 0000000..eea292a --- /dev/null +++ b/uzywane_zmienne.cpp @@ -0,0 +1,66 @@ +#include "uzywane_zmienne.h" +#include "ui_uzywane_zmienne.h" +#include "plcino.h" + +uzywane_zmienne::uzywane_zmienne(QMap *lista, QWidget *parent) : + QDialog(parent), + ui(new Ui::uzywane_zmienne) +{ + ui->setupUi(this); + dialog = NULL; + lista_uzywanych_zmiennych = lista; + okno_edycji_zmiennej = NULL; + + model.setHeaderData(1, Qt::Horizontal, tr("Nazwa zmiennej")); + model.setHeaderData(2, Qt::Horizontal, tr("Numer pinu")); + model.setMap(lista_uzywanych_zmiennych); + ui->tableView->setModel(&model); + ui->tableView->setSelectionMode(QAbstractItemView::SingleSelection); //możliwość zaznaczenia tylko jednej komórki + connect(ui->tableView, SIGNAL(doubleClicked(const QModelIndex &)), this, SLOT(edycja_zmiennej(const QModelIndex &))); //podłączenie sygnału podwójnego kliknięcia do metody edycja_zmiennej +} + +uzywane_zmienne::~uzywane_zmienne() +{ + delete ui; +} + +void uzywane_zmienne::on_nowa_clicked() +{ + if (dialog == NULL) { + dialog = new dodawanie_zmiennej(lista_uzywanych_zmiennych, &model, "", NULL); + dialog->exec(); + } + else { + delete dialog; + dialog = new dodawanie_zmiennej(lista_uzywanych_zmiennych, &model, "", NULL); + dialog->exec(); + } +} + +void uzywane_zmienne::on_usun_clicked() +{ +// if(ui->tableView->hasFocus()) { + QModelIndexList zaznaczenie = ui->tableView->selectionModel()->selectedIndexes(); + if(zaznaczenie.length() != 0) { + model.usun_zmienna(model.data(model.index(zaznaczenie[0].row(), 0)).toString()); + } + // } +} + +void uzywane_zmienne::edycja_zmiennej(const QModelIndex ModelIndex) +{ + if(ModelIndex.isValid()) { + if(ui->tableView->hasFocus()) { + QModelIndex indeks = model.index(ModelIndex.row(), 0, QModelIndex()); + zmienna_w_arduino temp = lista_uzywanych_zmiennych->value(ui->tableView->model()->data(indeks).toString()); + if (okno_edycji_zmiennej == NULL) { + okno_edycji_zmiennej = new dodawanie_zmiennej(lista_uzywanych_zmiennych, &model, ui->tableView->model()->data(indeks).toString(), NULL, temp.numer_pinu, temp.typ_zmiennej - 1, temp.rodzaj_pinu - 1); + } + else { + delete okno_edycji_zmiennej; + okno_edycji_zmiennej = new dodawanie_zmiennej(lista_uzywanych_zmiennych, &model, ui->tableView->model()->data(indeks).toString(), NULL, temp.numer_pinu, temp.typ_zmiennej - 1, temp.rodzaj_pinu - 1); + } + okno_edycji_zmiennej->exec(); + } + } +} diff --git a/uzywane_zmienne.h b/uzywane_zmienne.h new file mode 100644 index 0000000..06f6713 --- /dev/null +++ b/uzywane_zmienne.h @@ -0,0 +1,37 @@ +#ifndef UZYWANE_ZMIENNE_H +#define UZYWANE_ZMIENNE_H + +#include +#include "dodawanie_zmiennej.h" +#include "model_uzywane_zmienne.h" +#include "zmienna_w_arduino.h" + +namespace Ui { +class uzywane_zmienne; +} + +class uzywane_zmienne : public QDialog +{ + Q_OBJECT + +public: + explicit uzywane_zmienne(QMap *lista, QWidget *parent = 0); + ~uzywane_zmienne(); + +private slots: + + void on_nowa_clicked(); + + void on_usun_clicked(); + + void edycja_zmiennej(const QModelIndex ModelIndex); + +private: + Ui::uzywane_zmienne *ui; + dodawanie_zmiennej* dialog; //okno odpowiedzialne za dodawanie nowych zmiennych + QMap *lista_uzywanych_zmiennych; //adres do listy używanych zmiennych + model_uzywane_zmienne model; //model danych używany przez listę używanych zmiennych(zrobiony tylko po to, żeby móc ustawić nagłówki kolumn) + dodawanie_zmiennej* okno_edycji_zmiennej; +}; + +#endif // UZYWANE_ZMIENNE_H diff --git a/uzywane_zmienne.ui b/uzywane_zmienne.ui new file mode 100644 index 0000000..52fe54b --- /dev/null +++ b/uzywane_zmienne.ui @@ -0,0 +1,49 @@ + + + uzywane_zmienne + + + Qt::WindowModal + + + + 0 + 0 + 622 + 300 + + + + Używane zmienne + + + + + + + + + + Nowa + + + + + + + Usuń + + + + + + + + + + + + + + + diff --git a/wybor_portu.cpp b/wybor_portu.cpp new file mode 100644 index 0000000..01268d1 --- /dev/null +++ b/wybor_portu.cpp @@ -0,0 +1,54 @@ +#include "wybor_portu.h" +#include "ui_wybor_portu.h" +#include +#include + +Wybor_portu::Wybor_portu(QWidget *parent, QString* adres_do_konfiguracji) : + QDialog(parent), + ui(new Ui::Wybor_portu) +{ + ui->setupUi(this); + setWindowTitle("Wybór portu"); + wybrany_port = adres_do_konfiguracji; + + QList dostepne_porty; + dostepne_porty = QSerialPortInfo::availablePorts(); + for(int i = 0; i < dostepne_porty.count(); ++i) { + ui->listWidget->addItem(dostepne_porty.at(i).portName() + " (" + dostepne_porty.at(i).description() + ")"); + } +} + +Wybor_portu::~Wybor_portu() +{ + delete ui; +} + +void Wybor_portu::on_buttonBox_clicked(QAbstractButton *button) +{ + if((QPushButton *)button == ui->buttonBox->button(QDialogButtonBox::Reset)){ + QList dostepne_porty; + dostepne_porty = QSerialPortInfo::availablePorts(); + ui->listWidget->clear(); + for(int i = 0; i < dostepne_porty.count(); ++i) { + ui->listWidget->addItem(dostepne_porty.at(i).portName() + " (" + dostepne_porty.at(i).description() + ")"); + } + } + else if((QPushButton *)button == ui->buttonBox->button(QDialogButtonBox::Ok)) { + if(ui->listWidget->selectedItems().count() != 0) { + QString nazwa_portu_temp = ui->listWidget->selectedItems().at(0)->text(); + int temp = nazwa_portu_temp.indexOf(" ("); //te dwie linijki kodu są odpowiedzialne za wycięcie z zaznaczonej opcji tylko nazwy portu COM + nazwa_portu_temp.truncate(temp); + *wybrany_port = nazwa_portu_temp; + this->hide(); + } + else { + QMessageBox msgBox; + msgBox.setText("Należy wybrać port!"); + msgBox.setIcon(QMessageBox::Critical); + msgBox.exec(); + } + } + else if((QPushButton *)button == ui->buttonBox->button(QDialogButtonBox::Cancel)) { + this->hide(); + } +} diff --git a/wybor_portu.h b/wybor_portu.h new file mode 100644 index 0000000..36520ac --- /dev/null +++ b/wybor_portu.h @@ -0,0 +1,30 @@ +#ifndef WYBOR_PORTU_H +#define WYBOR_PORTU_H + +#include +#include +#include + +namespace Ui { +class Wybor_portu; +} + +class Wybor_portu : public QDialog +{ + Q_OBJECT + +public: + explicit Wybor_portu(QWidget *parent = 0, QString *adres_do_konfiguracji = NULL); + ~Wybor_portu(); + +private slots: + + void on_buttonBox_clicked(QAbstractButton *button); + +private: + Ui::Wybor_portu *ui; + QWidget* rodzic; + QString* wybrany_port; +}; + +#endif // WYBOR_PORTU_H diff --git a/wybor_portu.ui b/wybor_portu.ui new file mode 100644 index 0000000..f518f00 --- /dev/null +++ b/wybor_portu.ui @@ -0,0 +1,48 @@ + + + Wybor_portu + + + Qt::WindowModal + + + + 0 + 0 + 402 + 275 + + + + Dialog + + + + + + + + QListView::ListMode + + + true + + + + + + + Qt::Vertical + + + QDialogButtonBox::Cancel|QDialogButtonBox::Ok|QDialogButtonBox::Reset + + + + + + + + + + diff --git a/zasoby.qrc b/zasoby.qrc new file mode 100644 index 0000000..f846f2a --- /dev/null +++ b/zasoby.qrc @@ -0,0 +1,11 @@ + + + C:/Users/Łukasz/Box Sync/Inżynierka/Ikony/dodaj_kolumne.png + C:/Users/Łukasz/Box Sync/Inżynierka/Ikony/dodaj_wiersz.png + C:/Users/Łukasz/Box Sync/Inżynierka/Ikony/nowa_linia.png + C:/Users/Łukasz/Box Sync/Inżynierka/Ikony/rsz_dodaj_wiersz.png + C:/Users/Łukasz/Box Sync/Inżynierka/Ikony/usun_kolumne.png + C:/Users/Łukasz/Box Sync/Inżynierka/Ikony/usun_linie.png + C:/Users/Łukasz/Box Sync/Inżynierka/Ikony/usun_wiersz.png + + diff --git a/zmienna_w_arduino.h b/zmienna_w_arduino.h new file mode 100644 index 0000000..e3cb2c8 --- /dev/null +++ b/zmienna_w_arduino.h @@ -0,0 +1,10 @@ +#ifndef ZMIENNA_W_ARDUINO_H +#define ZMIENNA_W_ARDUINO_H + +struct zmienna_w_arduino { + QString numer_pinu; + quint32 typ_zmiennej; // analogowa/dyskretna + quint32 rodzaj_pinu; // wejscie/wyjscie +}; + +#endif // ZMIENNA_W_ARDUINO_H