part.h

/* ########################################################################
 
   PICSimLab - Programmable IC Simulator Laboratory
 
   ########################################################################
 
   Copyright (c) : 2010-2024  Luis Claudio Gambôa Lopes <lcgamboa@yahoo.com>
 
   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, or (at your option)
   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, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
   For e-mail suggestions :  lcgamboa@yahoo.com
   ######################################################################## */
 
#ifndef PART_H
#define PART_H
 
#include "board.h"
 
enum { PCW_END, PCW_COMBO, PCW_LABEL, PCW_SPIND, PCW_EDIT, PCW_SPIN, PCW_TEXT, PCW_DCOMBO };
 
typedef struct {
    int pcw_type;
    char label[20];
} PCWProp;
 
class part {
public:
    std::string GetName(void);
 
    virtual std::string GetHelpURL(void);
 
    virtual std::string GetAboutInfo(void) = 0;
 
    void Draw(void);
 
    virtual void DrawOutput(const unsigned int index) = 0;
 
    virtual void PreProcess(void) {};
 
    virtual void Process(void) {};
 
    virtual void PostProcess(void) {};
 
    virtual std::string GetPictureFileName(void);
 
    virtual std::string GetMapFile(void);
 
    virtual std::string GetPropertiesWindowFile(void);
 
    int GetInputCount(void);
 
    input_t* GetInput(int n);
 
    int GetOutputCount(void);
 
    output_t* GetOutput(int n);
 
    virtual void Reset(void) {};
 
    virtual void Stop(void) {};
 
    void EvMouseButtonPress(unsigned int button, unsigned int x, unsigned int y, unsigned int state);
 
    virtual void OnMouseButtonPress(unsigned int inputId, unsigned int button, unsigned int x, unsigned int y,
                                    unsigned int state) {};
 
    void EvMouseButtonRelease(unsigned int button, unsigned int x, unsigned int y, unsigned int state);
 
    virtual void OnMouseButtonRelease(unsigned int inputId, unsigned int button, unsigned int x, unsigned int y,
                                      unsigned int state) {};
 
    void EvMouseMove(unsigned int button, unsigned int x, unsigned int y, unsigned int state);
 
    virtual void OnMouseMove(unsigned int inputId, unsigned int button, unsigned int x, unsigned int y,
                             unsigned int state) {};
 
    virtual void EvKeyPress(unsigned int key, unsigned int mask) {};
 
    virtual void EvKeyRelease(unsigned int key, unsigned int mask) {};
 
    virtual std::string WritePreferences(void) = 0;
 
    virtual void ReadPreferences(std::string value) = 0;
 
    virtual unsigned short GetInputId(char* name) = 0;
 
    virtual unsigned short GetOutputId(char* name) = 0;
 
    virtual void ConfigurePropertiesWindow(void) = 0;
 
    virtual void ReadPropertiesWindow(void) = 0;
 
    virtual void ComboChange(const char* controlname, std::string value) {};
 
    virtual void SpinChange(const char* controlname, int value) {};
 
    virtual void ButtonEvent(const char* controlname, unsigned int button, unsigned int x, unsigned int y,
                             unsigned int state) {};
 
    virtual void KeyEvent(const char* controlname, unsigned int keysym, unsigned int ukeysym, unsigned int state) {};
 
    virtual void Event(const char* controlname) {};
 
    virtual void filedialog_EvOnClose(int retId) {};
 
    part(const unsigned x, const unsigned y, const char* name, const char* type, board* pboard_, const int id_,
         const int fsize = 8);
 
    void Init(void);
 
    virtual void PostInit(void) {};
 
    virtual ~part(void) {};
 
    int GetBitmap(void) { return BitmapId; };
 
    int GetX(void) { return X; };
 
    int GetY(void) { return Y; };
 
    void SetX(int x) { X = x; };
 
    void SetY(int y) { Y = y; };
 
    unsigned int GetWidth(void) { return Width; };
 
    unsigned int GetHeight(void) { return Height; };
 
    int PointInside(int x, int y);
 
    void RotateCoords(unsigned int* x, unsigned int* y);
 
    virtual void LoadPartImage(void);
 
    int GetOrientation(void);
 
    virtual void SetOrientation(int orientation);
 
    float GetScale(void);
 
    virtual void SetScale(double scale);
 
    int GetId(void) { return id; };
 
    void SetId(int id_) { id = id_; };
 
    unsigned char GetUpdate(void);
 
    void SetUpdate(unsigned char upd);
 
    int GetAlwaysUpdate(void);
 
    void SetAlwaysUpdate(int sau);
 
    const int GetPCWCount(void);
    const PCWProp* GetPCWProperties(void);
 
    const int GetPinCount(void) { return PinCount; };
    unsigned char* GetPins(void) { return Pins; };
    const int GetPinCtrlCount(void) { return PinCtrlCount; };
    const unsigned char* GetPinsCtrl(void) { return PinsCtrl; };
 
protected:
    virtual void RegisterRemoteControl(void) {};
 
    int id;                         
    input_t input[MAX_IDS];         
    input_t* input_ids[MAX_IDS];    
    output_t output[MAX_IDS];       
    output_t* output_ids[MAX_IDS];  
    int inputc;                     
    int outputc;                    
    unsigned int Height;            
    unsigned int Width;             
    int X;                          
    int Y;                          
    int BitmapId;                   
    unsigned int refresh;           
    int Orientation;                
    float Scale;                    
    unsigned int Update;            
    int always_update;              
    std::string Type;
    int PinCount;
    int PinCtrlCount;
    unsigned char* Pins;
    unsigned char* PinsCtrl;
    board* pboard;
    int Fsize;
 
    void ReadMaps(void);
 
    int PointInside(int x, int y, input_t input);
 
    void SetPCWProperties(const PCWProp* pcwprop);
    void SetPCWComboWithPinNames(const char* combo_name, const unsigned char pin);
    unsigned char GetPWCComboSelectedPin(const char* combo_name);
 
private:
    const PCWProp* PCWProperties;
    int PCWCount;
    std::string Name;
 
    void ReadInputMap(std::string fname);
 
    void ReadOutputMap(std::string fname);
};
 
#endif /* PART_H */
 
#ifndef PARTS_DEFS_H
#define PARTS_DEFS_H
 
#define MAX_PARTS 100
 
extern int NUM_PARTS;
 
#define part_init(name, function, menu)                                                                         \
    static part* function##_create(const unsigned int x, const unsigned int y, board* pboard_, const int id_) { \
        part* p = new function(x, y, name, menu, pboard_, id_);                                                 \
        p->Init();                                                                                              \
        return p;                                                                                               \
    };                                                                                                          \
    static void __attribute__((constructor)) function##_init(void);                                             \
    static void function##_init(void) {                                                                         \
        part_register(name, function##_create, menu);                                                           \
    }
 
typedef part* (*part_create_func)(const unsigned int x, const unsigned int y, board* pboard_, const int id_);
 
void part_register(const char* name, part_create_func pcreate, const char* menu);
 
part* create_part(std::string name, const unsigned int x, const unsigned int y, board* pboard_, const int id_);
 
typedef struct {
    char name[30];
    part_create_func pcreate;
    char menu[30];
} part_desc;
 
extern part_desc parts_list[MAX_PARTS];
 
#endif /* PARTS_DEFS_H */