Element.h

Go to the documentation of this file.

/*
 *  Copyright (C) 2017  Thales Lima Oliveira <thales@ufu.br>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#ifndef ELEMENT_H
#define ELEMENT_H
 
#include <wx/msgdlg.h>
#include <wx/geometry.h>
#include <wx/cursor.h>
#include <wx/menu.h>
#include <wx/stdpaths.h>
#include <wx/filename.h>
//#include <GL/glew.h>
#ifdef _MSC_VER
 //#include <windows.h>
#endif 
//#include <GL/gl.h>
#include <wx/graphics.h>
#include <wx/dc.h>
 
#include <complex>
 
#include "../utils/XMLParser.h"
//#include "../utils/PropertiesData.h"
#include "../utils/CommomTypes.h"
 
//#include <wx/log.h>
 
enum ElementType {
    TYPE_NONE = 0,
    TYPE_BUS,
    TYPE_CAPACITOR,
    TYPE_IND_MOTOR,
    TYPE_INDUCTOR,
    TYPE_LINE,
    TYPE_LOAD,
    TYPE_SYNC_GENERATOR,
    TYPE_SYNC_MOTOR,
    TYPE_TRANSFORMER,
    TYPE_HARMCURRENT,
    TYPE_TEXT
};
 
enum PickboxID {
    ID_PB_NONE = 0,     
    ID_PB_RIGHT,        
    ID_PB_LEFT,         
    ID_PB_RIGHT_BOTTOM, 
    ID_PB_RIGHT_TOP,    
    ID_PB_LEFT_BOTTOM,  
    ID_PB_LEFT_TOP      
};
 
enum ContextMenuID {
    ID_EDIT_ELEMENT = 0,    
    ID_LINE_ADD_NODE,       
    ID_LINE_REMOVE_NODE,    
    ID_ROTATE_CLOCK,        
    ID_ROTATE_COUNTERCLOCK, 
    ID_DELETE              
};
 
enum TextID {
    ID_TXT_NAME = 1000,
    ID_TXT_VOLTAGE,
    ID_TXT_ANGLE,
    ID_TXT_FAULTCURRENT,
    ID_TXT_FAULTVOLTAGE,
    ID_TXT_SCC,
    ID_TXT_THD,
    ID_TXT_ACTIVE_POWER,
    ID_TXT_REACTIVE_POWER,
    ID_TXT_BRANCH_ACTIVE_POWER_1_2,
    ID_TXT_BRANCH_ACTIVE_POWER_2_1,
    ID_TXT_BRANCH_REACTIVE_POWER_1_2,
    ID_TXT_BRANCH_REACTIVE_POWER_2_1,
    ID_TXT_BRANCH_LOSSES,
    ID_TXT_BRANCH_CURRENT_1_2,
    ID_TXT_BRANCH_CURRENT_2_1,
    ID_TXT_BRANCH_FAULT_CURRENT_1_2,
    ID_TXT_BRANCH_FAULT_CURRENT_2_1
};
class Element
{
public:
    Element();
 
    virtual ~Element() {}
 
    void SetDragging(bool dragging = true) { m_dragging = dragging; }
    void SetHeight(double height) { m_height = height; }
    void SetPosition(const wxPoint2DDouble position);
 
    void SetSelected(bool selected = true) { m_selected = selected; }
    void SetWidth(double width) { m_width = width; }
    void SetAngle(double angle) { m_angle = angle; }
    void ShowPickbox(bool showPickbox = true) { m_showPickbox = showPickbox; }
    void SetBorderSize(double borderSize) { m_borderSize = borderSize; }
    bool SetOnline(bool online = true);
 
    virtual void SetPointList(std::vector<wxPoint2DDouble> pointList) { m_pointList = pointList; }
    ElementType GetElementType() { return m_elementType; }
    wxRect2DDouble GetRect() const { return m_rect; }
    wxPoint2DDouble GetPosition() const { return m_position; }
    bool IsDragging() const { return m_dragging; }
    double GetHeight() const { return m_height; }
    bool IsSelected() const { return m_selected; }
    double GetWidth() const { return m_width; }
    double GetAngle() const { return m_angle; }
    double GetRotationAngle() const { return m_rotationAngle; }
    bool IsPickboxShown() const { return m_showPickbox; }
    bool IsOnline() const { return m_online; }
    virtual std::vector<wxPoint2DDouble> GetPointList() const { return m_pointList; }
    virtual bool AddParent(Element* parent, wxPoint2DDouble position) { return false; }
    virtual void AddParent(Element* parent) { m_parentList.push_back(parent); }
    virtual bool Contains(wxPoint2DDouble position) const = 0;
 
    virtual bool Intersects(wxRect2DDouble rect) const = 0;
 
    virtual Element* GetCopy() { return nullptr; }
    virtual void SetID(int id) { m_elementID = id; }
    virtual int GetID() const { return m_elementID; }
    virtual void AddChild(Element* child);
 
    virtual void RemoveChild(Element* child);
 
    virtual void ReplaceChild(Element* oldChild, Element* newChild);
 
    virtual wxString GetTipText() const { return wxEmptyString; }
 
    virtual void DrawDC(GUIColour* guiColour, wxPoint2DDouble translation, double scale, wxGraphicsContext* gc) const {}
    virtual void DrawDC(GUIColour* guiColour, wxPoint2DDouble translation, double scale, wxDC& dc) const {}
    virtual void Rotate(bool clockwise = true) {}
    virtual bool GetContextMenu(wxMenu& menu) { return false; }
    virtual void AddPoint(wxPoint2DDouble point) {}
    virtual void StartMove(wxPoint2DDouble position);
 
    virtual void Move(wxPoint2DDouble position);
 
    virtual void MoveNode(Element* parent, wxPoint2DDouble position) {}
    virtual bool NodeContains(wxPoint2DDouble position) { return false; }
    virtual void UpdateNodes() {}
 
    void SetParent(Element* parent, int num) { m_parentList[num] = parent; }
    void SetChild(Element* child, int num) { m_childList[num] = child; }
    virtual bool SetNodeParent(Element* parent) { return false; }
    virtual void RemoveParent(Element* parent) {}
    virtual void ReplaceParent(Element* oldParent, Element* newParent);
 
    virtual void RotateNode(Element* parent, bool clockwise = true) {}
    virtual bool PickboxContains(wxPoint2DDouble position) { return false; }
    virtual void MovePickbox(wxPoint2DDouble position) {}
    virtual wxCursor GetBestPickboxCursor() const { return wxCURSOR_ARROW; }
    virtual void ResetPickboxes() { m_activePickboxID = ID_PB_NONE; }
    virtual void ResetNodes() { m_activeNodeID = 0; }
    virtual wxPoint2DDouble WorldToScreen(wxPoint2DDouble translation,
        double scale,
        double offsetX = 0.0,
        double offsetY = 0.0) const;
 
    virtual wxPoint2DDouble WorldToScreen(wxPoint2DDouble position,
        wxPoint2DDouble translation,
        double scale,
        double offsetX = 0.0,
        double offsetY = 0.0) const;
 
    virtual bool RotatedRectanglesIntersects(wxRect2DDouble rect1,
        wxRect2DDouble rect2,
        double angle1,
        double angle2) const;
 
    //virtual void DrawCircle(wxPoint2DDouble position, double radius, int numSegments, GLenum mode = GL_LINE_LOOP) const;
 
    virtual void DrawDCRectangle(wxPoint2DDouble position, double width, double height, double angle, wxDC& dc) const;
 
    virtual void DrawDCRoundedRectRotated(wxDC& dc, const wxPoint2DDouble& center, double width, double height, double radius, double angleDeg, int arcSegments = 8) const;
 
    virtual void DrawDCCircle(wxPoint2DDouble position, double radius, int numSegments, wxGraphicsContext* gc) const;
 
    virtual void DrawDCCircle(wxPoint2DDouble position, double radius, wxDC& dc) const;
 
    //virtual void DrawArc(wxPoint2DDouble position,
    //  double radius,
    //  double initAngle,
    //  double finalAngle,
    //  int numSegments,
    //  GLenum mode = GL_LINE_LOOP) const;
 
    virtual void DrawDCArc(wxPoint2DDouble position, double radius, double initAngle, double finalAngle, int numSegments, wxGraphicsContext* gc) const;
 
    virtual void DrawDCArc(wxPoint2DDouble position, double radius, double initAngle, double finalAngle, wxDC& dc) const;
 
    //virtual void DrawRectangle(wxPoint2DDouble position, double width, double height, GLenum mode = GL_QUADS) const;
    //virtual void DrawRectangle(wxPoint2DDouble position, double width, double height) const;
 
    //virtual void DrawRectangle(wxPoint2DDouble* points, GLenum mode = GL_QUADS) const;
 
    //virtual void DrawTriangle(std::vector<wxPoint2DDouble> points, GLenum mode = GL_TRIANGLES) const;
 
    virtual void DrawDCTriangle(std::vector<wxPoint2DDouble> points, wxGraphicsContext* gc) const;
 
    virtual void DrawDCTriangle(std::vector<wxPoint> points, wxDC& dc) const;
 
    //virtual void DrawPoint(wxPoint2DDouble position, double size) const;
 
    //virtual void DrawLine(std::vector<wxPoint2DDouble> points, GLenum mode = GL_LINE_STRIP) const;
 
    //virtual void DrawPickbox(wxPoint2DDouble position) const;
 
    virtual void DrawDCPickbox(wxPoint2DDouble position, wxGraphicsContext* gc) const;
 
    virtual wxPoint2DDouble RotateAtPosition(wxPoint2DDouble pointToRotate, double angle, bool degrees = true) const;
 
    virtual wxPoint2DDouble RotateLocal(wxPoint2DDouble local, double angleDeg) const;
 
    virtual wxPoint RotateAround(const wxPoint2DDouble& p, const wxPoint2DDouble& center, double angleDeg) const;
 
    virtual std::vector<Element*> GetParentList() const { return m_parentList; }
    virtual std::vector<Element*> GetChildList() const { return m_childList; }
    // virtual wxPoint2DDouble GetMoveStartPosition() const { return m_moveStartPt; }
    // virtual wxPoint2DDouble GetMovePosition() const { return m_movePos; }
 
    virtual void CalculateBoundaries(wxPoint2DDouble& leftUp, wxPoint2DDouble& rightBottom) const;
 
    virtual void GeneralMenuItens(wxMenu& menu);
 
    virtual bool ShowForm(wxWindow* parent, Element* element, wxWindow* workspace = nullptr) { return false; }
    static bool DoubleFromString(wxWindow* parent, wxString strValue, double& value, wxString errorMsg);
 
    static bool IntFromString(wxWindow* parent, wxString strValue, int& value, wxString errorMsg);
 
    static wxString StringFromDouble(double value, int minDecimal = 1, int maxDecimals = 13);
 
    virtual double PointToLineDistance(wxPoint2DDouble point, int* segmentNumber = nullptr) const;
 
    bool IsInserted() const { return m_inserted; }
 
    void SetInserted(bool inserted = true) { m_inserted = inserted; }
 
    virtual rapidxml::xml_node<>* SaveElement(rapidxml::xml_document<>& doc, rapidxml::xml_node<>* elementListNode) { return nullptr; }
    virtual bool OpenElement(rapidxml::xml_node<>* elementNode) { return true; }
    void SaveCADProperties(rapidxml::xml_document<>& doc, rapidxml::xml_node<>* elementNode);
    bool OpenCADProperties(rapidxml::xml_node<>* elementNode);
 
protected:
    ElementType m_elementType = ElementType::TYPE_NONE;
    int m_elementID = 0;
    std::vector<Element*> m_parentList;
    std::vector<Element*> m_childList;
 
    wxRect2DDouble m_rect;
    wxPoint2DDouble m_position;
    double m_width = 0.0;
    double m_height = 0.0;
    double m_angle = 0.0;
    double m_borderSize = 2.0;
    double m_rotationAngle = 45.0;
    double m_switchSize = 10.0;
 
    std::vector<wxRect2DDouble> m_switchRect;
 
    bool m_selected = false;
    bool m_dragging = false;
    bool m_showPickbox = false;
    bool m_inserted = false;
 
    int m_activePickboxID = ID_PB_NONE;
    int m_activeNodeID = 0;
 
    std::vector<wxPoint2DDouble> m_pointList;
    std::vector<wxPoint2DDouble> m_movePts;
 
    wxPoint2DDouble m_moveStartPt;
    wxPoint2DDouble m_movePos;
 
    bool m_online = true;
 
    //OpenGLColour m_selectionColour;
    //wxColour m_selectionColour;
};
 
#endif  // ELEMENT_H