part.h

/* ########################################################################
 
   PICSimLab - Programmable IC Simulator Laboratory
 
   ########################################################################
 
   Copyright (c) : 2010-2026 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 int ReadPreferences(std::string value) = 0;

    virtual int PreferencesNumberFields(void) = 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; };

    virtual 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 */