component.h

/***************************************************************************
 *   Copyright (C) 2003 by David Saxton                                    *
 *   david@bluehaze.org                                                    *
 *                                                                         *
 *   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     *
 *   (at your option) any later version.                                   *
 ***************************************************************************/

#ifndef COMPONENT_H
#define COMPONENT_H

#include "cnitem.h"

#include <qvaluelist.h>

class ICNDocument;
class CircuitDocument;
class ECNode;
class ECSubcircuit;
class Element;
class Node;
class Pin;

class BJT;
class Capacitance;
class CCCS;
class CCVS;
class CurrentSignal;
class CurrentSource;
class Diode;
class Inductance;
class LogicIn;
class LogicOut;
class OpAmp;
class Resistance;
class Switch;
class Transformer;
class VCCS;
class VCVS;
class VoltagePoint;
class VoltageSignal;
class VoltageSource;

typedef QValueList<ECNode*> ECNodeList;
typedef QValueList<Element*> ElementList;
typedef QValueList<Switch*> SwitchList;

typedef QValueList< QValueList<Pin*> > PinListList;

// FIXME: should be in it's own header/source file regardless of how tiny it is.
// OR it should be moved to the same file as the other element classes. 
class ElementMap
{
        public:
                ElementMap();
                
                Element *e; // The element
                Pin *n[4]; // The Pins associated with the CNodes in the element
        
                PinListList interCircuitDependent;
        
                PinListList interGroundDependent;
};

typedef QValueList<ElementMap> ElementMapList;

class Component : public CNItem
{
        Q_OBJECT
public:
        Component( ICNDocument *icnDocument, bool newItem, const QString &id );
        virtual ~Component();
        
        ECNode* createPin( double _x, double _y, int orientation, const QString &name );

// Positioning
        virtual bool canRotate() const { return true; }
        int angleDegrees() const { return m_angleDegrees; }

        void setAngleDegrees( int degrees );

        bool flipped() const { return b_flipped; }

        void setFlipped( bool flipped );

        void setNodalCurrents();

        CircuitDocument *circuitDocument() const { return m_pCircuitDocument; }

        void initElements( const uint stage );
        virtual void finishedCreation();

// FIXME: probably should be renamed to "TimeDependant" and "UpdateFortime".
        virtual bool doesStepNonLogic() const { return false; }
        virtual void stepNonLogic() {};

        static QWMatrix transMatrix(int angleDegrees, bool flipped, int x, int y, bool inverse = false );

        virtual ItemData itemData() const;

        virtual void restoreFromItemData(const ItemData &itemData );

// FIXME: I think a common design principal states that a parent class must not know
// anything about it's children. =( 
        BJT *createBJT(Pin *c, Pin *b, Pin *e, bool isNPN = true );
        BJT *createBJT(ECNode *c, ECNode *b, ECNode *e, bool isNPN = true );

        Capacitance *createCapacitance(Pin *n0, Pin *n1, double capacitance );
        Capacitance *createCapacitance(ECNode *n0, ECNode *n1, double capacitance );

        CCCS *createCCCS(Pin *n0, Pin *n1, Pin *n2, Pin *n3, double gain );
        CCCS *createCCCS(ECNode *n0, ECNode *n1, ECNode *n2, ECNode *n3, double gain );

        CCVS *createCCVS(Pin *n0, Pin *n1, Pin *n2, Pin *n3, double gain );
        CCVS *createCCVS(ECNode *n0, ECNode *n1, ECNode *n2, ECNode *n3, double gain );

        CurrentSignal *createCurrentSignal(Pin *n0, Pin *n1, double current );
        CurrentSignal *createCurrentSignal(ECNode *n0, ECNode *n1, double current );

        CurrentSource *createCurrentSource(Pin *n0, Pin *n1, double current );
        CurrentSource *createCurrentSource(ECNode *n0, ECNode *n1, double current );

        Diode *createDiode(Pin *n0, Pin *n1 );
        Diode *createDiode(ECNode *n0, ECNode *n1 );

        Inductance *createInductance(Pin *n0, Pin *n1, double inductance );
        Inductance *createInductance(ECNode *n0, ECNode *n1, double inductance );

        LogicIn *createLogicIn(Pin *node );
        LogicIn *createLogicIn(ECNode *node );

        LogicOut *createLogicOut(Pin *node, bool isHigh );
        LogicOut *createLogicOut(ECNode *node, bool isHigh );

        OpAmp *createOpAmp(Pin * nonInverting, Pin * out, Pin * inverting );
        OpAmp *createOpAmp(ECNode * nonInverting, ECNode * out, ECNode * inverting );

        Resistance *createResistance(Pin *n0, Pin *n1, double resistance );
        Resistance *createResistance(ECNode *n0, ECNode *n1, double resistance );

        Switch *createSwitch(Pin *n0, Pin *n1, bool open );
        Switch *createSwitch(ECNode *n0, ECNode *n1, bool open );

        VCCS *createVCCS(Pin *n0, Pin *n1, Pin *n2, Pin *n3, double gain );
        VCCS *createVCCS(ECNode *n0, ECNode *n1, ECNode *n2, ECNode *n3, double gain);

        VCVS *createVCVS(Pin *n0, Pin *n1, Pin *n2, Pin *n3, double gain );
        VCVS *createVCVS(ECNode *n0, ECNode *n1, ECNode *n2, ECNode *n3, double gain );

        VoltagePoint *createVoltagePoint(Pin *n0, double voltage );
        VoltagePoint *createVoltagePoint(ECNode *n0, double voltage );

        VoltageSignal *createVoltageSignal(Pin *n0, Pin *n1, double voltage );
        VoltageSignal *createVoltageSignal(ECNode *n0, ECNode *n1, double voltage );

        VoltageSource *createVoltageSource(Pin *n0, Pin *n1, double voltage );
        VoltageSource *createVoltageSource(ECNode *n0, ECNode *n1, double voltage );

        ECNode* ecNodeWithID(const QString &ecNodeId);

        void removeElement(Element *element, bool setPinsInterIndependent);

        void removeSwitch(Switch *sw);

        void removeElements( bool setPinsInterIndependent = false );

        SwitchList switchList() const { return m_switchList; }

// Random idiot: what's this "Signals:" thing? is it a C++ feature I'm too stupid to
// understand? 
signals:
        void elementCreated(Element *element);

        void elementDestroyed(Element *element);

        void switchCreated(Switch *sw);

        void switchDestroyed(Switch *sw);

// What's a public "slots"? Another crazy C++ Feature? 
public slots:
        virtual void slotUpdateConfiguration();
        virtual void removeItem();

protected:
        void drawPortShape(QPainter & p );
        virtual void itemPointsChanged();
        virtual void updateAttachedPositioning();
        virtual void initPainter(QPainter &p );

        virtual void deinitPainter(QPainter &p );

// FIXME:  Implies special knowledge of subclass (or what should be subclass.) 
        void initDIP(const QStringList & pins );

// FIXME: SHOULD BE SUBCLASS
        void initDIPSymbol(const QStringList & pins, int width );

        void init1PinLeft(int h1 = -1 );

        void init2PinLeft(int h1 = -1, int h2 = -1 );

        void init3PinLeft(int h1 = -1, int h2 = -1, int h3 = -1 );

        void init4PinLeft(int h1 = -1, int h2 = -1, int h3 = -1, int h4 = -1 );

        void init1PinRight(int h1 = -1 );

        void init2PinRight(int h1 = -1, int h2 = -1 );

        void init3PinRight(int h1 = -1, int h2 = -1, int h3 = -1 );

        void init4PinRight(int h1 = -1, int h2 = -1, int h3 = -1, int h4 = -1 );

        void rebuildPinInterDepedence();

        // Pointers to commonly used nodes
// design issue: In a very complex class, performance tweeks of this type tend to
// promote bugs. Perhaps a "fast component" subclass could add caching and other
// performance enhancements while building on a stable, reliable API. 
        ECNode *m_pPNode[4];
        ECNode *m_pNNode[4];

        QGuardedPtr<CircuitDocument> m_pCircuitDocument;
        int m_angleDegrees;
        bool b_flipped;

private:
        void setInterDependent(ElementMapList::iterator it, const QValueList<Pin*> & pins);

        void setAllPinsInterIndependent();

        void setInterCircuitDependent( ElementMapList::iterator it, const QValueList<Pin*> & pins );

        void setInterGroundDependent( ElementMapList::iterator it, const QValueList<Pin*> & pins );

        ElementMapList m_elementMapList;

// FIXME: again with the switches! bleh! 
        SwitchList m_switchList;

        ElementMapList::iterator handleElement(Element *e, const QValueList<Pin*> &pins );
};

#endif

---