Inheritance diagram for ControlEditor:

Collaboration diagram for ControlEditor:

[legend]

Public Types
enum class	ControlEditorMode : int { MODE_EDIT = 0 , MODE_MOVE_ELEMENT , MODE_MOVE_LINE , MODE_DRAG , MODE_DRAG_INSERT , MODE_INSERT , MODE_INSERT_LINE , MODE_SELECTION_RECT , MODE_PASTE , MODE_DRAG_PASTE }

Public Member Functions
	ControlEditor (wxWindow *parent)

	ControlEditor (wxWindow *parent, int ioflags=IOControl::IN_TERMINAL_VOLTAGE\|IOControl::IN_VELOCITY\|IOControl::OUT_FIELD_VOLTAGE\|IOControl::OUT_MEC_POWER)

virtual void	AddElement (ControlElementButtonID id)

virtual void	Redraw ()

virtual void	SetJustOpened (bool justOpened)

virtual void	RotateSelectedElements (bool clockwise)

virtual void	DeleteSelectedElements ()

virtual void	CheckConnections ()

virtual std::vector< std::shared_ptr< ConnectionLine > >	GetConnectionLineList () const

virtual std::vector< std::shared_ptr< ControlElement > >	GetControlElementList () const

virtual void	SetElementsList (const std::vector< std::shared_ptr< ControlElement > > &elementList)

virtual void	SetConnectionsList (const std::vector< std::shared_ptr< ConnectionLine > > &connectionList)

virtual void	SetControlContainer (ControlElementContainer *ctrlContainer)

virtual void	SetPlotLib (int plotLib)

virtual void	OnClose (wxCloseEvent &event)

virtual void	OnTestClick (wxCommandEvent &event)

virtual void	OnButtonOKClick (wxCommandEvent &event)

virtual void	OnImportClick (wxCommandEvent &event)

virtual void	OnExportClick (wxCommandEvent &event)

virtual void	OnKeyDown (wxKeyEvent &event)

virtual void	OnIdle (wxIdleEvent &event)

virtual void	OnScroll (wxMouseEvent &event)

virtual void	OnDoubleClick (wxMouseEvent &event)

virtual void	OnLeftClickDown (wxMouseEvent &event)

virtual void	OnLeftClickUp (wxMouseEvent &event)

virtual void	OnMiddleDown (wxMouseEvent &event)

virtual void	OnMiddleUp (wxMouseEvent &event)

virtual void	OnMouseMotion (wxMouseEvent &event)

virtual void	OnPaint (wxPaintEvent &event)

virtual void	LeftClickDown (wxMouseEvent &event)

virtual void	BuildColourList ()

virtual wxColour	GetNextColour ()

void	BuildControlElementPanel ()

Protected Member Functions
int	GetNextID ()

std::vector< std::shared_ptr< ConnectionLine > >::iterator	DeleteLineFromList (std::vector< std::shared_ptr< ConnectionLine > >::iterator &it)

Protected Attributes
Camera *	m_camera = nullptr

ControlEditorMode	m_mode = ControlEditorMode::MODE_EDIT

wxRect2DDouble	m_selectionRect

wxPoint2DDouble	m_startSelRect

std::vector< std::shared_ptr< ControlElement > >	m_elementList

std::vector< std::shared_ptr< ConnectionLine > >	m_connectionList

ControlElementContainer *	m_ctrlContainer = nullptr

bool	m_justOpened = false

int	m_ioFlags = 0

int	m_inputType = 0

double	m_startTime = 1.0

double	m_slope = 1.0

double	m_timeStep = 1e-4

double	m_simTime = 10.0

int	m_plotLib = 0

std::vector< wxColour >	m_colourList

std::vector< wxColour >::iterator	m_itColourList

Detailed Description

Definition at line 109 of file ControlEditor.h.

Member Enumeration Documentation

◆ ControlEditorMode

enum class ControlEditor::ControlEditorMode : int

strong

Definition at line 112 of file ControlEditor.h.

                                 : int {
        MODE_EDIT = 0,
        MODE_MOVE_ELEMENT,
        MODE_MOVE_LINE,
        MODE_DRAG,
        MODE_DRAG_INSERT,
        MODE_INSERT,
        MODE_INSERT_LINE,
        MODE_SELECTION_RECT,
        MODE_PASTE,
        MODE_DRAG_PASTE
    };

Constructor & Destructor Documentation

◆ ControlEditor() [1/2]

ControlEditor::ControlEditor ( wxWindow * parent )

inline

Definition at line 124 of file ControlEditor.h.

124: ControlEditorBase(parent) {}

◆ ControlEditor() [2/2]

ControlEditor::ControlEditor	(	wxWindow *	parent,
		int	ioflags = `IOControl::IN_TERMINAL_VOLTAGE \| IOControl::IN_VELOCITY \| IOControl::OUT_FIELD_VOLTAGE \| IOControl::OUT_MEC_POWER`
	)

Definition at line 137 of file ControlEditor.cpp.

                                                          : ControlEditorBase(parent)
{
    BuildControlElementPanel();
    //m_glContext = new wxGLContext(m_glCanvas, sharedGLContext);
    //m_glContext->SetCurrent(*m_glCanvas);
    m_camera = new Camera();
    m_selectionRect = wxRect2DDouble(0, 0, 0, 0);
    m_cePanel->SetBackgroundColour(wxColour(255, 255, 255));
    m_cePanel->SetBackgroundStyle(wxBG_STYLE_PAINT);  // To allow wxBufferedPaintDC works properly.
    // m_camera->SetScale(1.2);
    m_ioFlags = ioflags;
 
    BuildColourList();
}

◆ ~ControlEditor()

ControlEditor::~ControlEditor ( )

virtual

Definition at line 151 of file ControlEditor.cpp.

{
    // m_tfButton->Disconnect(wxEVT_LEFT_DOWN, wxMouseEventHandler(ControlEditor::LeftClickDown), m_tfButton, this);
}

Member Function Documentation

◆ AddElement()

void ControlEditor::AddElement ( ControlElementButtonID id )

virtual

Definition at line 274 of file ControlEditor.cpp.

{
    switch (id) {
    case ControlElementButtonID::ID_IO: {
        m_mode = ControlEditorMode::MODE_INSERT;
        auto io = std::make_shared<IOControl>(m_ioFlags, GetNextID());
        m_elementList.push_back(io);
    } break;
    case ControlElementButtonID::ID_TF: {
        m_mode = ControlEditorMode::MODE_INSERT;
        auto tf = std::make_shared<TransferFunction>(GetNextID());
        m_elementList.push_back(tf);
    } break;
    case ControlElementButtonID::ID_SUM: {
        m_mode = ControlEditorMode::MODE_INSERT;
        auto sum = std::make_shared<Sum>(GetNextID());
        m_elementList.push_back(sum);
    } break;
    case ControlElementButtonID::ID_CONST: {
        m_mode = ControlEditorMode::MODE_INSERT;
        auto constant = std::make_shared<Constant>(GetNextID());
        m_elementList.push_back(constant);
    } break;
    case ControlElementButtonID::ID_LIMITER: {
        m_mode = ControlEditorMode::MODE_INSERT;
        auto limiter = std::make_shared<Limiter>(GetNextID());
        m_elementList.push_back(limiter);
    } break;
    case ControlElementButtonID::ID_GAIN: {
        m_mode = ControlEditorMode::MODE_INSERT;
        auto gain = std::make_shared<Gain>(GetNextID());
        m_elementList.push_back(gain);
    } break;
    case ControlElementButtonID::ID_MULT: {
        m_mode = ControlEditorMode::MODE_INSERT;
        auto mult = std::make_shared<Multiplier>(GetNextID());
        m_elementList.push_back(mult);
    } break;
    case ControlElementButtonID::ID_EXP: {
        m_mode = ControlEditorMode::MODE_INSERT;
        auto exp = std::make_shared<Exponential>(GetNextID());
        m_elementList.push_back(exp);
    } break;
    case ControlElementButtonID::ID_RATELIM: {
        m_mode = ControlEditorMode::MODE_INSERT;
        auto rateLim = std::make_shared<RateLimiter>(GetNextID());
        m_elementList.push_back(rateLim);
    } break;
    case ControlElementButtonID::ID_MATH_DIV: {
        m_mode = ControlEditorMode::MODE_INSERT;
        auto divider = std::make_shared<Divider>(GetNextID());
        m_elementList.push_back(divider);
    } break;
    case ControlElementButtonID::ID_MATH_EXPR: {
        m_mode = ControlEditorMode::MODE_INSERT;
        auto mathExpr = std::make_shared<MathExpression>(GetNextID());
        m_elementList.push_back(mathExpr);
    } break;
    }
}

◆ BuildColourList()

void ControlEditor::BuildColourList ( )

virtual

Definition at line 1034 of file ControlEditor.cpp.

{
    m_colourList.push_back(wxColour(255, 30, 0));
    m_colourList.push_back(wxColour(0, 30, 255));
    m_colourList.push_back(wxColour(0, 128, 0));
    m_colourList.push_back(wxColour(100, 100, 100));
    m_colourList.push_back(wxColour(255, 128, 0));
    m_colourList.push_back(wxColour(128, 0, 255));
    m_colourList.push_back(wxColour(0, 255, 128));
    m_colourList.push_back(wxColour(255, 255, 0));
    m_colourList.push_back(wxColour(255, 0, 255));
    m_colourList.push_back(wxColour(0, 255, 255));
    m_colourList.push_back(wxColour(128, 255, 0));
    m_colourList.push_back(wxColour(255, 0, 128));
    m_colourList.push_back(wxColour(0, 128, 255));
    m_colourList.push_back(wxColour(128, 128, 128));
    m_colourList.push_back(*wxBLACK);
    m_itColourList = --m_colourList.end();
}

◆ BuildControlElementPanel()

void ControlEditor::BuildControlElementPanel ( )

Definition at line 156 of file ControlEditor.cpp.

{
    m_panelControlElements->SetDoubleBuffered(true);
    wxWrapSizer* wrapSizer = new wxWrapSizer();
    m_panelControlElements->SetSizer(wrapSizer);
 
    wxFileName exeFileName(wxStandardPaths::Get().GetExecutablePath());
    //wxString exePath = exeFileName.GetPath();
 
    ControlElementButton* ioButton = new ControlElementButton(
        m_panelControlElements, _("In/Out"),
        wxImage(Paths::GetDataPath() + "/images/control/io.png"),
        static_cast<int>(ControlElementButtonID::ID_IO));
    wrapSizer->Add(ioButton, 0, wxALL, 5);
    ioButton->Bind(wxEVT_LEFT_DOWN, &ControlEditor::LeftClickDown, this);
 
    ControlElementButton* tfButton = new ControlElementButton(
        m_panelControlElements, _("Transfer fcn"),
        wxImage(Paths::GetDataPath() + "/images/control/transferFunc.png"),
        static_cast<int>(ControlElementButtonID::ID_TF));
    wrapSizer->Add(tfButton, 0, wxALL, 5);
    tfButton->Bind(wxEVT_LEFT_DOWN, &ControlEditor::LeftClickDown, this);
 
    ControlElementButton* sumButton = new ControlElementButton(
        m_panelControlElements, _("Sum"),
        wxImage(Paths::GetDataPath() + "/images/control/sum.png"),
        static_cast<int>(ControlElementButtonID::ID_SUM));
    wrapSizer->Add(sumButton, 0, wxALL, 5);
    sumButton->Bind(wxEVT_LEFT_DOWN, &ControlEditor::LeftClickDown, this);
 
    ControlElementButton* constButton = new ControlElementButton(
        m_panelControlElements, _("Constant"),
        wxImage(Paths::GetDataPath() + "/images/control/value.png"),
        static_cast<int>(ControlElementButtonID::ID_CONST));
    wrapSizer->Add(constButton, 0, wxALL, 5);
    constButton->Bind(wxEVT_LEFT_DOWN, &ControlEditor::LeftClickDown, this);
 
    ControlElementButton* gainButton = new ControlElementButton(
        m_panelControlElements, _("Gain"),
        wxImage(Paths::GetDataPath() + "/images/control/gain.png"),
        static_cast<int>(ControlElementButtonID::ID_GAIN));
    wrapSizer->Add(gainButton, 0, wxALL, 5);
    gainButton->Bind(wxEVT_LEFT_DOWN, &ControlEditor::LeftClickDown, this);
 
    ControlElementButton* limButton = new ControlElementButton(
        m_panelControlElements, _("Limiter"),
        wxImage(Paths::GetDataPath() + "/images/control/limiter.png"),
        static_cast<int>(ControlElementButtonID::ID_LIMITER));
    wrapSizer->Add(limButton, 0, wxALL, 5);
    limButton->Bind(wxEVT_LEFT_DOWN, &ControlEditor::LeftClickDown, this);
 
    ControlElementButton* rateLimButton = new ControlElementButton(
        m_panelControlElements, _("Rate limiter"),
        wxImage(Paths::GetDataPath() + "/images/control/rateLimiter.png"),
        static_cast<int>(ControlElementButtonID::ID_RATELIM));
    wrapSizer->Add(rateLimButton, 0, wxALL, 5);
    rateLimButton->Bind(wxEVT_LEFT_DOWN, &ControlEditor::LeftClickDown, this);
 
    ControlElementButton* multButton = new ControlElementButton(
        m_panelControlElements, _("Multiplier"),
        wxImage(Paths::GetDataPath() + "/images/control/mult.png"),
        static_cast<int>(ControlElementButtonID::ID_MULT));
    wrapSizer->Add(multButton, 0, wxALL, 5);
    multButton->Bind(wxEVT_LEFT_DOWN, &ControlEditor::LeftClickDown, this);
 
    ControlElementButton* divButton = new ControlElementButton(
        m_panelControlElements, _("Divider"),
        wxImage(Paths::GetDataPath() + "/images/control/div.png"),
        static_cast<int>(ControlElementButtonID::ID_MATH_DIV));
    wrapSizer->Add(divButton, 0, wxALL, 5);
    divButton->Bind(wxEVT_LEFT_DOWN, &ControlEditor::LeftClickDown, this);
 
    ControlElementButton* mathExprButton = new ControlElementButton(
        m_panelControlElements, _("Math Expression"),
        wxImage(Paths::GetDataPath() + "/images/control/mathExpr.png"),
        static_cast<int>(ControlElementButtonID::ID_MATH_EXPR));
    wrapSizer->Add(mathExprButton, 0, wxALL, 5);
    mathExprButton->Bind(wxEVT_LEFT_DOWN, &ControlEditor::LeftClickDown, this);
 
    ControlElementButton* satButton = new ControlElementButton(
        m_panelControlElements, _("Exponential"),
        wxImage(Paths::GetDataPath() + "/images/control/sat.png"),
        static_cast<int>(ControlElementButtonID::ID_EXP));
    wrapSizer->Add(satButton, 0, wxALL, 5);
    satButton->Bind(wxEVT_LEFT_DOWN, &ControlEditor::LeftClickDown, this);
}

◆ CheckConnections()

void ControlEditor::CheckConnections ( )

virtual

Definition at line 816 of file ControlEditor.cpp.

{
    for (auto it = m_connectionList.begin(); it != m_connectionList.end(); ++it) {
        ConnectionLine* cLine = it->get();
        if (cLine->GetType() == ConnectionLine::ConnectionLineType::ELEMENT_ELEMENT) {
            if (cLine->GetParentList().size() < 2) { it = DeleteLineFromList(it); }
        }
        else if (cLine->GetParentList().size() < 1) {
            it = DeleteLineFromList(it);
        }
    }
}

◆ DeleteLineFromList()

std::vector< std::shared_ptr< ConnectionLine > >::iterator ControlEditor::DeleteLineFromList ( std::vector< std::shared_ptr< ConnectionLine > >::iterator & it )

protected

Definition at line 787 of file ControlEditor.cpp.

{
    ConnectionLine* cLine = it->get();
 
    // Delete children recursively
    auto childList = cLine->GetLineChildList();
    for (auto child : childList) {
        for (auto itL = m_connectionList.begin(); itL != m_connectionList.end(); ) {
            if (itL->get() == child)
                itL = DeleteLineFromList(itL);
            else
                ++itL;
        }
    }
    // Remove parents
    auto parentList = cLine->GetParentList();
    for (auto parent : parentList) {
        if (parent) parent->RemoveChild(cLine);
    }
    if (cLine->GetParentLine()) cLine->GetParentLine()->RemoveChild(cLine);
 
    // Free nodes
    auto nodeList = cLine->GetNodeList();
    for (auto node : nodeList)
        node->SetConnected(false);
 
    return m_connectionList.erase(it);
}

◆ DeleteSelectedElements()

void ControlEditor::DeleteSelectedElements ( )

virtual

Definition at line 748 of file ControlEditor.cpp.

{
    for (auto it = m_elementList.begin(); it != m_elementList.end();) {
        Element* element = it->get();
        if (element->IsSelected()) {
            // Remove child/parent.
            auto childList = element->GetChildList();
            for (auto child : childList) {
                // The child is always a connection line, but check it.
                //ConnectionLine* child = static_cast<ConnectionLine*>(*itC);
                if (auto childLine = dynamic_cast<ConnectionLine*>(child)) {
                    // Delete the connection line.
                    for (auto itCo = m_connectionList.begin(); itCo != m_connectionList.end(); ) {
                        if (itCo->get() == childLine)
                            itCo = DeleteLineFromList(itCo);
                        else
                            ++itCo;
                    }
                }
 
            }
            m_elementList.erase(it);
            //if (element) delete element;
        }
        else {
            ++it;
        }
    }
 
    for (auto it = m_connectionList.begin(); it != m_connectionList.end(); ) {
        ConnectionLine* line = it->get();
        if (line->IsSelected())
            it = DeleteLineFromList(it);
        else
            ++it;
    }
    Redraw();
}

◆ GetConnectionLineList()

virtual std::vector< std::shared_ptr< ConnectionLine > > ControlEditor::GetConnectionLineList ( ) const

inlinevirtual

Definition at line 137 of file ControlEditor.h.

137{ return m_connectionList; }

◆ GetControlElementList()

virtual std::vector< std::shared_ptr< ControlElement > > ControlEditor::GetControlElementList ( ) const

inlinevirtual

Definition at line 138 of file ControlEditor.h.

138{ return m_elementList; }

◆ GetNextColour()

wxColour ControlEditor::GetNextColour ( )

virtual

Definition at line 1054 of file ControlEditor.cpp.

{
    if (*m_itColourList == *wxBLACK)
        m_itColourList = m_colourList.begin();
    else
        ++m_itColourList;
 
    return *m_itColourList;
}

◆ GetNextID()

int ControlEditor::GetNextID ( )

protected

Definition at line 1021 of file ControlEditor.cpp.

{
    int id = 0;
    for (auto& element : m_elementList) {
        if (element->GetID() > id) id = element->GetID();
    }
    for (auto& line : m_connectionList) {
        if (line->GetID() > id) id = line->GetID();
    }
    id++;
    return id;
}

◆ LeftClickDown()

void ControlEditor::LeftClickDown ( wxMouseEvent & event )

virtual

Definition at line 243 of file ControlEditor.cpp.

{
    AddElement(static_cast<ControlElementButtonID>(event.GetId()));
    event.Skip();
}

◆ OnButtonOKClick()

virtual void ControlEditor::OnButtonOKClick ( wxCommandEvent & event )

inlinevirtual

Definition at line 146 of file ControlEditor.h.

146{ Close(); }

◆ OnClose()

void ControlEditor::OnClose ( wxCloseEvent & event )

virtual

Definition at line 1015 of file ControlEditor.cpp.

{
    if (m_ctrlContainer) { m_ctrlContainer->FillContainer(this); }
    event.Skip();
}

◆ OnDoubleClick()

void ControlEditor::OnDoubleClick ( wxMouseEvent & event )

virtual

Definition at line 404 of file ControlEditor.cpp.

{
    wxPoint2DDouble clickPoint = event.GetPosition();
    bool redraw = false;
 
    if (m_mode == ControlEditor::ControlEditorMode::MODE_EDIT) {
        for (auto& element : m_elementList) {
            if (element->Contains(m_camera->ScreenToWorld(clickPoint))) {
                element->ShowForm(this, element.get());
                CheckConnections();
                auto childList = element->GetChildList();
                for (auto itC = childList.begin(), itEndC = childList.end(); itC != itEndC; ++itC) {
                    ConnectionLine* line = static_cast<ConnectionLine*>(*itC);
                    line->UpdatePoints();
                }
                redraw = true;
            }
        }
    }
 
    if (redraw) Redraw();
}

◆ OnExportClick()

void ControlEditor::OnExportClick ( wxCommandEvent & event )

virtual

Definition at line 829 of file ControlEditor.cpp.

{
    FileHanding fileHandling(this);
 
    wxFileDialog saveFileDialog(this, _("Save CTL file"), "", "", "CTL files (*.ctl)|*.ctl",
        wxFD_SAVE | wxFD_OVERWRITE_PROMPT);
    if (saveFileDialog.ShowModal() == wxID_CANCEL) return;
 
    fileHandling.SaveControl(saveFileDialog.GetPath());
    wxFileName fileName(saveFileDialog.GetPath());
    event.Skip();
}

◆ OnIdle()

void ControlEditor::OnIdle ( wxIdleEvent & event )

virtual

Definition at line 699 of file ControlEditor.cpp.

{
    //if(m_justOpened) {
    //    this->Raise();
    //
    //    // Update all text elements
    //    m_justOpened = false;
    //    for(auto it = m_elementList.begin(), itEnd = m_elementList.end(); it != itEnd; ++it) {
    //        ControlElement* element = *it;
    //        if(!element->UpdateText()) m_justOpened = true;
    //    }
    //    Redraw();
    //}
}

◆ OnImportClick()

void ControlEditor::OnImportClick ( wxCommandEvent & event )

virtual

Definition at line 842 of file ControlEditor.cpp.

{
    wxFileDialog openFileDialog(this, _("Open CTL file"), "", "", "CTL files (*.ctl)|*.ctl",
        wxFD_OPEN | wxFD_FILE_MUST_EXIST);
    if (openFileDialog.ShowModal() == wxID_CANCEL) return;
 
    wxFileName fileName(openFileDialog.GetPath());
 
    FileHanding fileHandling(this);
    if (!fileHandling.OpenControl(fileName, m_elementList, m_connectionList)) {
        wxMessageDialog msgDialog(this, _("It was not possible to open the selected file."), _("Error"),
            wxOK | wxCENTRE | wxICON_ERROR);
        msgDialog.ShowModal();
    }
    Redraw();
    event.Skip();
}

◆ OnKeyDown()

void ControlEditor::OnKeyDown ( wxKeyEvent & event )

virtual

Definition at line 713 of file ControlEditor.cpp.

{
    char key = event.GetUnicodeKey();
    if (key != WXK_NONE) {
        switch (key) {
        case WXK_DELETE:  // Delete selected elements.
        {
            DeleteSelectedElements();
        } break;
        case 'R':  // Rotate the selected elements.
        {
            RotateSelectedElements(event.GetModifiers() != wxMOD_SHIFT);
        } break;
        case 'L': {
            // tests
        } break;
        }
    }
}

◆ OnLeftClickDown()

void ControlEditor::OnLeftClickDown ( wxMouseEvent & event )

virtual

Definition at line 427 of file ControlEditor.cpp.

{
    wxPoint2DDouble clickPoint = event.GetPosition();
    bool foundElement = false;
 
    if (m_mode == ControlEditorMode::MODE_INSERT) {
        m_mode = ControlEditor::ControlEditorMode::MODE_EDIT;
    }
    else {
        for (auto& element : m_elementList) {
            bool foundNode = false;
            auto nodeList = element->GetNodeList();
            for (auto itN = nodeList.begin(), itNEnd = nodeList.end(); itN != itNEnd; ++itN) {
                Node* node = *itN;
                if (node->Contains(m_camera->ScreenToWorld(clickPoint))) {
                    m_mode = ControlEditorMode::MODE_INSERT_LINE;
                    auto line = std::make_shared<ConnectionLine>(node, GetNextID());
                    m_connectionList.push_back(line);
                    element->AddChild(line.get());
                    line->AddParent(element.get());
                    foundElement = true;
                    foundNode = true;
                }
            }
 
            if (!foundNode) {
                // Set movement initial position (not necessarily will be moved).
                element->StartMove(m_camera->ScreenToWorld(clickPoint));
 
                // Click in an element.
                if (element->Contains(m_camera->ScreenToWorld(clickPoint))) {
                    if (!foundElement) {
                        element->SetSelected();
                        foundElement = true;
                    }
                    m_mode = ControlEditor::ControlEditorMode::MODE_MOVE_ELEMENT;
                }
            }
        }
        if (m_mode != ControlEditorMode::MODE_INSERT_LINE) {
            for (auto& line : m_connectionList) {
                line->StartMove(m_camera->ScreenToWorld(clickPoint));
                if (line->Contains(m_camera->ScreenToWorld(clickPoint))) {
                    line->SetSelected();
                    foundElement = true;
                    m_mode = ControlEditorMode::MODE_MOVE_LINE;
                }
            }
        }
    }
 
    if (!foundElement) {
        m_mode = ControlEditorMode::MODE_SELECTION_RECT;
        m_startSelRect = m_camera->ScreenToWorld(clickPoint);
    }
 
    Redraw();
    event.Skip();
}

◆ OnLeftClickUp()

void ControlEditor::OnLeftClickUp ( wxMouseEvent & event )

virtual

Definition at line 487 of file ControlEditor.cpp.

{
    bool foundNode = false;
    for (auto& element : m_elementList) {
        if (m_mode == ControlEditorMode::MODE_INSERT_LINE) {
            auto nodeList = element->GetNodeList();
            for (auto node : nodeList) {
                if (node->Contains(m_camera->ScreenToWorld(event.GetPosition()))) {
                    //ConnectionLine* line = *(m_connectionList.end() - 1);
                    auto line = m_connectionList.back();
                    if (line->AppendNode(node, element.get())) {
                        line->AddParent(element.get());
                        element->AddChild(line.get());
                        line->UpdatePoints();
                        m_mode = ControlEditor::ControlEditorMode::MODE_EDIT;
                        foundNode = true;
                    }
                }
            }
        }
        else if (m_mode == ControlEditorMode::MODE_SELECTION_RECT) {
            if (element->Intersects(m_selectionRect)) {
                element->SetSelected();
            }
            else if (!event.ControlDown()) {
                element->SetSelected(false);
            }
        }
        else if (!event.ControlDown()) {
            if (!element->Contains(m_camera->ScreenToWorld(event.GetPosition()))) { element->SetSelected(false); }
        }
    }
 
    auto& lastLine = m_connectionList.back();
    for (auto& cLine : m_connectionList) {
        if (m_mode == ControlEditorMode::MODE_INSERT_LINE && !foundNode && cLine.get() != lastLine.get()) {
            if (cLine->Contains(m_camera->ScreenToWorld(event.GetPosition()))) {
                //ConnectionLine* iLine = *(m_connectionList.end() - 1);
                auto iLine = m_connectionList.back();
                if (iLine->SetParentLine(cLine.get())) {
                    cLine->AddChild(iLine.get());
                    iLine->UpdatePoints();
                    m_mode = ControlEditor::ControlEditorMode::MODE_EDIT;
                    foundNode = true;
                }
            }
        }
        else if (m_mode == ControlEditorMode::MODE_SELECTION_RECT) {
            if (cLine->Intersects(m_selectionRect)) {
                cLine->SetSelected();
            }
            else if (!event.ControlDown()) {
                cLine->SetSelected(false);
            }
        }
        else if (!event.ControlDown()) {
            if (!cLine->Contains(m_camera->ScreenToWorld(event.GetPosition()))) { cLine->SetSelected(false); }
        }
    }
 
    m_selectionRect = wxRect2DDouble(0, 0, 0, 0);
 
    if (m_mode == ControlEditorMode::MODE_INSERT_LINE && !foundNode) {
        //ConnectionLine* cLine = *(m_connectionList.end() - 1);
        auto cLine = m_connectionList.back();
        // Free nodes
        auto nodeList = cLine->GetNodeList();
        for (auto itN = nodeList.begin(), itEndN = nodeList.end(); itN != itEndN; ++itN) {
            Node* node = *itN;
            node->SetConnected(false);
        }
        // Remove the associated child from parents.
        auto parentList = cLine->GetParentList();
        for (auto it = parentList.begin(), itEnd = parentList.end(); it != itEnd; ++it) {
            Element* element = *it;
            element->RemoveChild(cLine.get());
        }
        m_connectionList.pop_back();
        //if (cLine) delete cLine;
        m_mode = ControlEditor::ControlEditorMode::MODE_EDIT;
    }
    else if (m_mode != ControlEditorMode::MODE_INSERT) {
        m_mode = ControlEditor::ControlEditorMode::MODE_EDIT;
    }
 
    Redraw();
    event.Skip();
}

◆ OnMiddleDown()

void ControlEditor::OnMiddleDown ( wxMouseEvent & event )

virtual

Definition at line 576 of file ControlEditor.cpp.

{
    // Set to drag mode.
    switch (m_mode) {
    case ControlEditorMode::MODE_INSERT: {
        m_mode = ControlEditorMode::MODE_DRAG_INSERT;
    } break;
    case ControlEditorMode::MODE_PASTE: {
        m_mode = ControlEditorMode::MODE_DRAG_PASTE;
    } break;
    default: {
        m_mode = ControlEditorMode::MODE_DRAG;
    } break;
    }
    m_camera->StartTranslation(m_camera->ScreenToWorld(event.GetPosition()));
}

◆ OnMiddleUp()

void ControlEditor::OnMiddleUp ( wxMouseEvent & event )

virtual

Definition at line 593 of file ControlEditor.cpp.

{
    switch (m_mode) {
    case ControlEditorMode::MODE_DRAG_INSERT: {
        m_mode = ControlEditorMode::MODE_INSERT;
    } break;
    case ControlEditorMode::MODE_DRAG_PASTE: {
        m_mode = ControlEditorMode::MODE_PASTE;
    } break;
    case ControlEditorMode::MODE_INSERT:
    case ControlEditorMode::MODE_PASTE: {
        // Does nothing.
    } break;
    default: {
        m_mode = ControlEditor::ControlEditorMode::MODE_EDIT;
    } break;
    }
}

◆ OnMouseMotion()

void ControlEditor::OnMouseMotion ( wxMouseEvent & event )

virtual

Definition at line 612 of file ControlEditor.cpp.

{
    wxPoint2DDouble clickPoint = event.GetPosition();
    bool redraw = false;
 
    switch (m_mode) {
    case ControlEditorMode::MODE_INSERT: {
        //Element* newElement = *(m_elementList.end() - 1);  // Get the last element in the list.
        auto newElement = m_elementList.back();
        newElement->Move(m_camera->ScreenToWorld(clickPoint));
        redraw = true;
    } break;
    case ControlEditorMode::MODE_INSERT_LINE: {
        //ConnectionLine* line = *(m_connectionList.end() - 1);
        auto line = m_connectionList.back();
        line->SetTemporarySecondPoint(m_camera->ScreenToWorld(clickPoint));
        line->UpdatePoints();
        redraw = true;
    } break;
    case ControlEditorMode::MODE_DRAG:
    case ControlEditorMode::MODE_DRAG_INSERT:
    case ControlEditorMode::MODE_DRAG_PASTE: {
        m_camera->SetTranslation(clickPoint);
        redraw = true;
    } break;
    case ControlEditor::ControlEditorMode::MODE_MOVE_ELEMENT: {
        for (auto& element : m_elementList) {
            if (element->IsSelected()) {
                element->Move(m_camera->ScreenToWorld(clickPoint));
                auto childList = element->GetChildList();
                for (auto itC = childList.begin(), itEndC = childList.end(); itC != itEndC; itC++) {
                    ConnectionLine* line = static_cast<ConnectionLine*>(*itC);
                    line->UpdatePoints();
                }
                redraw = true;
            }
        }
    } break;
    case ControlEditorMode::MODE_MOVE_LINE: {
        for (auto& line : m_connectionList) {
            if (line->IsSelected()) {
                line->Move(m_camera->ScreenToWorld(clickPoint));
                redraw = true;
            }
        }
    } break;
    case ControlEditorMode::MODE_SELECTION_RECT: {
        wxPoint2DDouble currentPos = m_camera->ScreenToWorld(clickPoint);
        double x, y, w, h;
        if (currentPos.m_x < m_startSelRect.m_x) {
            x = currentPos.m_x;
            w = m_startSelRect.m_x - currentPos.m_x;
        }
        else {
            x = m_startSelRect.m_x;
            w = currentPos.m_x - m_startSelRect.m_x;
        }
        if (currentPos.m_y < m_startSelRect.m_y) {
            y = currentPos.m_y;
            h = m_startSelRect.m_y - currentPos.m_y;
        }
        else {
            y = m_startSelRect.m_y;
            h = currentPos.m_y - m_startSelRect.m_y;
        }
 
        m_selectionRect = wxRect2DDouble(x, y, w, h);
        redraw = true;
    } break;
    default:
        break;
    }
 
    if (redraw) Redraw();
    event.Skip();
}

◆ OnPaint()

void ControlEditor::OnPaint ( wxPaintEvent & event )

virtual

Definition at line 335 of file ControlEditor.cpp.

{
    //wxPaintDC dc(m_glCanvas);
    //SetViewport();
    //
    //glScaled(m_camera->GetScale(), m_camera->GetScale(), 0.0);                          // Scale
    //glTranslated(m_camera->GetTranslation().m_x, m_camera->GetTranslation().m_y, 0.0);  // Translation
    //
    //for(auto it = m_connectionList.begin(), itEnd = m_connectionList.end(); it != itEnd; ++it) {
    //    ConnectionLine* line = *it;
    //    line->Draw(m_camera->GetTranslation(), m_camera->GetScale());
    //}
    //
    //for(auto it = m_elementList.begin(), itEnd = m_elementList.end(); it != itEnd; ++it) {
    //    Element* element = *it;
    //    element->Draw(m_camera->GetTranslation(), m_camera->GetScale());
    //}
    //
    //glLineWidth(1.0);
    //glColor4d(0.0, 0.5, 1.0, 1.0);
    //glBegin(GL_LINE_LOOP);
    //glVertex2d(m_selectionRect.m_x, m_selectionRect.m_y);
    //glVertex2d(m_selectionRect.m_x, m_selectionRect.m_y + m_selectionRect.m_height);
    //glVertex2d(m_selectionRect.m_x + m_selectionRect.m_width, m_selectionRect.m_y + m_selectionRect.m_height);
    //glVertex2d(m_selectionRect.m_x + m_selectionRect.m_width, m_selectionRect.m_y);
    //glEnd();
    //glColor4d(0.0, 0.5, 1.0, 0.3);
    //glBegin(GL_QUADS);
    //glVertex2d(m_selectionRect.m_x, m_selectionRect.m_y);
    //glVertex2d(m_selectionRect.m_x, m_selectionRect.m_y + m_selectionRect.m_height);
    //glVertex2d(m_selectionRect.m_x + m_selectionRect.m_width, m_selectionRect.m_y + m_selectionRect.m_height);
    //glVertex2d(m_selectionRect.m_x + m_selectionRect.m_width, m_selectionRect.m_y);
    //glEnd();
    //
    //glFlush();  // Sends all pending information directly to the GPU.
    //m_glCanvas->SwapBuffers();
    //event.Skip();
    wxBufferedPaintDC dc(m_cePanel);
    dc.Clear();
    wxGraphicsContext* gc = wxGraphicsContext::Create(dc);
 
    // Draw
    if (gc) {
 
        gc->Scale(m_camera->GetScale(), m_camera->GetScale());
        gc->Translate(m_camera->GetTranslation().m_x, m_camera->GetTranslation().m_y);
 
        for (auto line : m_connectionList) {
            //ConnectionLine* line = *it;
            line->DrawDC(m_camera->GetTranslation(), m_camera->GetScale(), gc);
        }
 
        for (auto element : m_elementList) {
            element->DrawDC(m_camera->GetTranslation(), m_camera->GetScale(), gc);
        }
 
        // Selection rectangle
        gc->SetPen(wxPen(wxColour(0, 125, 255, 255)));
        gc->SetBrush(wxBrush(wxColour(0, 125, 255, 125)));
        gc->DrawRectangle(m_selectionRect.m_x, m_selectionRect.m_y, m_selectionRect.m_width, m_selectionRect.m_height);
 
        delete gc;
    }
    event.Skip();
}

◆ OnScroll()

void ControlEditor::OnScroll ( wxMouseEvent & event )

virtual

Definition at line 689 of file ControlEditor.cpp.

{
    if (event.GetWheelRotation() > 0)
        m_camera->SetScale(event.GetPosition(), +0.05);
    else
        m_camera->SetScale(event.GetPosition(), -0.05);
 
    Redraw();
}

◆ OnTestClick()

void ControlEditor::OnTestClick ( wxCommandEvent & event )

virtual

Definition at line 860 of file ControlEditor.cpp.

{
    // Reset colour list position for the test plot.
    m_itColourList = --m_colourList.end();
 
    std::vector<IOControl*> ioList;
 
    for (auto& element : m_elementList) {
        if (auto io = dynamic_cast<IOControl*>(element.get())) {
            ioList.push_back(io);
        }
    }
 
    ControlSystemTest csTest(this, ioList, &m_inputType, &m_startTime, &m_slope, &m_timeStep, &m_simTime);
    if (csTest.ShowModal() == wxID_OK) {
        double printStep = 1e-3;
        double pdbStep = 1e-1;
 
        struct InputData {
            wxString name;
            std::vector<double> values;
        };
 
        std::vector<InputData> inputList;
 
        // Store real flags for restoring after the test and set initial value.
        std::vector<IOControl::IOFlags> realFlagValue;
        for (auto* io : ioList) {
            realFlagValue.push_back(io->GetValue());
            if (io->GetType() == Node::NodeType::NODE_OUT) {
                SimTestData testData = io->GetSimTestData();
                io->SetValue(IOControl::IN_TEST);
                io->SetTestValue(testData.initialValue);
                inputList.push_back({ io->GetName(), {} });
            }
        }
 
        wxProgressDialog pbd(_("Test"), _("Initializing..."), 100, this,
            wxPD_APP_MODAL | wxPD_AUTO_HIDE | wxPD_CAN_ABORT | wxPD_SMOOTH);
        ControlElementSolver solver(this, m_timeStep, 1e-5);
        solver.InitializeValues(false);
        if (solver.IsOK()) {
            bool simStopped = false;
            double currentTime = 0.0;
            double printTime = 0.0;
            double pdbTime = 0.0;
            std::vector<double> time;
            std::vector<double> solution;
 
            while (currentTime <= m_simTime) {
                for (auto* io : ioList) {
                    SimTestData testData = io->GetSimTestData();
                    if (currentTime >= testData.startTime) {
                        switch (testData.type) {
                        case 0: {
                            io->SetTestValue(testData.slope);
                        } break;
                        case 1: {
                            io->SetTestValue(testData.slope * (currentTime - testData.startTime));
                        } break;
                        case 2: {
                            io->SetTestValue(testData.slope * std::pow(currentTime - testData.startTime, 2));
                        } break;
                        default: {
                            io->SetTestValue(0.0);
                            break;
                        }
                        }
                    }
                }
 
                solver.SetCurrentTime(currentTime);
                solver.SolveNextStep();
                if (!solver.IsOK()) {
                    wxString msg = wxString::Format(_("Failed to solve the control system.\n%s"), solver.GetErrorMessage());
                    wxMessageDialog msgDialog(this, msg, _("Error"), wxOK | wxCENTRE | wxICON_ERROR);
                    msgDialog.ShowModal();
                    simStopped = true;
                    currentTime = m_simTime;
                }
 
                if (printTime >= printStep) {
                    time.push_back(currentTime);
                    solution.push_back(solver.GetLastSolution());
                    //inputV.push_back(input);
                    int i = 0;
                    for (auto* io : ioList) {
                        if (io->GetType() == Node::NodeType::NODE_OUT) {
                            inputList[i].values.push_back(io->GetTestValue());
                            i++;
                        }
                    }
                    printTime = 0.0;
                }
 
                if (pdbTime > pdbStep) {
                    if (!pbd.Update((currentTime / m_simTime) * 100, wxString::Format("Time = %.2fs", currentTime))) {
                        pbd.Update(100);
                        simStopped = true;
                        currentTime = m_simTime;
                    }
                    pdbTime = 0.0;
                }
 
                printTime += m_timeStep;
                currentTime += m_timeStep;
                pdbTime += m_timeStep;
            }
 
            if (!simStopped) {
                std::vector<ElementPlotData> epdList;
                ElementPlotData curveData(_("I/O"), ElementPlotData::CurveType::CT_TEST);
                int i = 0;
                for (const auto& input : inputList) {
                    curveData.AddData(input.values, input.name);
                    curveData.SetPlot(i);
                    curveData.SetColour(i, GetNextColour());
                    i++;
                }
                //curveData.AddData(inputV, _("Input"));
                curveData.AddData(solution, _("Output"));
                curveData.SetPlot(i);
                curveData.SetColour(i, GetNextColour());
 
                //curveData.SetPlot(0);
                //curveData.SetColour(0, *wxRED);
                //curveData.SetPlot(1);
                //curveData.SetColour(1, *wxBLUE);
 
                epdList.push_back(curveData);
 
                ChartView* cView = new ChartView(this, epdList, time, static_cast<PlotLib>(m_plotLib));
                cView->Show();
                cView->UpdatePlot();
            }
        }
        else {
            wxMessageDialog msgDialog(
                this,
                wxString::Format(_("Failed to solve the control system.\n%s"), solver.GetErrorMessage()),
                _("Error"),
                wxOK | wxCENTRE | wxICON_ERROR
            );
 
            msgDialog.ShowModal();
        }
 
        // Restore real flags.
        for (size_t i = 0; i < ioList.size(); i++) {
            if (ioList[i]->GetType() == Node::NodeType::NODE_OUT)
                ioList[i]->SetValue(realFlagValue[i]);
        }
    }
}

◆ Redraw()

virtual void ControlEditor::Redraw ( )

inlinevirtual

Definition at line 132 of file ControlEditor.h.

132{ m_cePanel->Refresh(); }

◆ RotateSelectedElements()

void ControlEditor::RotateSelectedElements ( bool clockwise )

virtual

Definition at line 733 of file ControlEditor.cpp.

{
    for (auto& element : m_elementList) {
        if (element->IsSelected()) {
            element->Rotate(clockwise);
            auto childList = element->GetChildList();
            for (auto itC = childList.begin(), itEndC = childList.end(); itC != itEndC; itC++) {
                ConnectionLine* line = static_cast<ConnectionLine*>(*itC);
                line->UpdatePoints();
            }
        }
    }
    Redraw();
}

◆ SetConnectionsList()

virtual void ControlEditor::SetConnectionsList ( const std::vector< std::shared_ptr< ConnectionLine > > & connectionList )

inlinevirtual

Definition at line 140 of file ControlEditor.h.

140{ m_connectionList = connectionList; }

◆ SetControlContainer()

virtual void ControlEditor::SetControlContainer ( ControlElementContainer * ctrlContainer )

inlinevirtual

Definition at line 141 of file ControlEditor.h.

141{ m_ctrlContainer = ctrlContainer; }

◆ SetElementsList()

virtual void ControlEditor::SetElementsList ( const std::vector< std::shared_ptr< ControlElement > > & elementList )

inlinevirtual

Definition at line 139 of file ControlEditor.h.

139{ m_elementList = elementList; }

◆ SetJustOpened()

virtual void ControlEditor::SetJustOpened ( bool justOpened )

inlinevirtual

Definition at line 133 of file ControlEditor.h.

133{ m_justOpened = justOpened; }

◆ SetPlotLib()

virtual void ControlEditor::SetPlotLib ( int plotLib )

inlinevirtual

Definition at line 142 of file ControlEditor.h.

142{ m_plotLib = plotLib; }

Member Data Documentation

◆ m_camera

Camera* ControlEditor::m_camera = nullptr

protected

Definition at line 173 of file ControlEditor.h.

◆ m_colourList

std::vector<wxColour> ControlEditor::m_colourList

protected

Definition at line 197 of file ControlEditor.h.

◆ m_connectionList

std::vector< std::shared_ptr<ConnectionLine> > ControlEditor::m_connectionList

protected

Definition at line 183 of file ControlEditor.h.

◆ m_ctrlContainer

ControlElementContainer* ControlEditor::m_ctrlContainer = nullptr

protected

Definition at line 185 of file ControlEditor.h.

◆ m_elementList

std::vector< std::shared_ptr<ControlElement> > ControlEditor::m_elementList

protected

Definition at line 181 of file ControlEditor.h.

◆ m_inputType

int ControlEditor::m_inputType = 0

protected

Definition at line 190 of file ControlEditor.h.

◆ m_ioFlags

int ControlEditor::m_ioFlags = 0

protected

Definition at line 188 of file ControlEditor.h.

◆ m_itColourList

std::vector<wxColour>::iterator ControlEditor::m_itColourList

protected

Definition at line 198 of file ControlEditor.h.

◆ m_justOpened

bool ControlEditor::m_justOpened = false

protected

Definition at line 187 of file ControlEditor.h.

◆ m_mode

ControlEditorMode ControlEditor::m_mode = ControlEditorMode::MODE_EDIT

protected

Definition at line 175 of file ControlEditor.h.

◆ m_plotLib

int ControlEditor::m_plotLib = 0

protected

Definition at line 195 of file ControlEditor.h.

◆ m_selectionRect

wxRect2DDouble ControlEditor::m_selectionRect

protected

Definition at line 177 of file ControlEditor.h.

◆ m_simTime

double ControlEditor::m_simTime = 10.0

protected

Definition at line 194 of file ControlEditor.h.

◆ m_slope

double ControlEditor::m_slope = 1.0

protected

Definition at line 192 of file ControlEditor.h.

◆ m_startSelRect

wxPoint2DDouble ControlEditor::m_startSelRect

protected

Definition at line 178 of file ControlEditor.h.

◆ m_startTime

double ControlEditor::m_startTime = 1.0

protected

Definition at line 191 of file ControlEditor.h.

◆ m_timeStep

double ControlEditor::m_timeStep = 1e-4

protected

Definition at line 193 of file ControlEditor.h.

The documentation for this class was generated from the following files:

Project/editors/ControlEditor.h
Project/editors/ControlEditor.cpp

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Member Enumeration Documentation

◆ ControlEditorMode

Constructor & Destructor Documentation

◆ ControlEditor() [1/2]

◆ ControlEditor() [2/2]

◆ ~ControlEditor()

Member Function Documentation

◆ AddElement()

◆ BuildColourList()

◆ BuildControlElementPanel()

◆ CheckConnections()

◆ DeleteLineFromList()

◆ DeleteSelectedElements()

◆ GetConnectionLineList()

◆ GetControlElementList()

◆ GetNextColour()

◆ GetNextID()

◆ LeftClickDown()

◆ OnButtonOKClick()

◆ OnClose()

◆ OnDoubleClick()

◆ OnExportClick()

◆ OnIdle()

◆ OnImportClick()

◆ OnKeyDown()

◆ OnLeftClickDown()

◆ OnLeftClickUp()

◆ OnMiddleDown()

◆ OnMiddleUp()

◆ OnMouseMotion()

◆ OnPaint()

◆ OnScroll()

◆ OnTestClick()

◆ Redraw()

◆ RotateSelectedElements()

◆ SetConnectionsList()

◆ SetControlContainer()

◆ SetElementsList()

◆ SetJustOpened()

◆ SetPlotLib()

Member Data Documentation

◆ m_camera

◆ m_colourList

◆ m_connectionList

◆ m_ctrlContainer

◆ m_elementList

◆ m_inputType

◆ m_ioFlags

◆ m_itColourList

◆ m_justOpened

◆ m_mode

◆ m_plotLib

◆ m_selectionRect

◆ m_simTime

◆ m_slope

◆ m_startSelRect

◆ m_startTime

◆ m_timeStep