Added KDE3 version of ktechlab

git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/ktechlab@1095338 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 247 insertions, 0 deletions

diff --git a/src/simulator.h b/src/simulator.h
new file mode 100644
index 0000000..a6ade3a
--- /dev/null
+++ b/src/simulator.h
@@ -0,0 +1,247 @@
+/***************************************************************************
+ *   Copyright (C) 2005 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 SIMULATOR_H
+#define SIMULATOR_H
+
+#include "circuit.h"
+#include "logic.h"
+
+/**
+This should be a multiple of 1000. It is the number of times a second that
+linear elements are updated.
+*/
+const int LINEAR_UPDATE_RATE = int(1e4);
+
+/**
+This should be a multiple of 1000. It is the number of times a second that
+logic elements are updated.
+*/
+const int LOGIC_UPDATE_RATE = int(1e6);
+
+
+class Circuit;
+class CircuitDocument;
+class Component;
+class ComponentCallback;
+class ECNode;
+class GpsimProcessor;
+class LogicIn;
+class LogicOut;
+class Switch;
+class Wire;
+
+typedef QValueList<ECNode*> ECNodeList;
+typedef QValueList<LogicIn*> LogicInList;
+
+typedef void(Component::*VoidCallbackPtr)();
+
+template <typename T>
+class LinkedList
+{
+	public:
+		LinkedList( T * data ) { m_pData = data; m_pNext = 0l; }
+		T * data() const { return m_pData; }
+		
+		LinkedList<T> * m_pNext;
+		
+	protected:
+		T * m_pData;
+};
+
+
+class ComponentCallback
+{
+	public:
+		ComponentCallback( Component * component, VoidCallbackPtr function )
+		{
+			m_pComponent = component;
+			m_pFunction = function;
+		}
+		
+		void callback() { (m_pComponent->*m_pFunction)(); }
+		Component * component() const { return m_pComponent; }
+		
+	protected:
+		Component * m_pComponent;
+		VoidCallbackPtr m_pFunction;
+};
+
+
+/**
+This singleton class oversees all simulation (keeping in sync linear, nonlinear,
+logic, external simulators (such as gpsim), mechanical simulation, etc).
+@author David Saxton
+*/
+class Simulator : public QObject
+{
+	Q_OBJECT
+	public:
+		static Simulator * self();
+		~Simulator();
+		
+		/**
+		 * Number of (1/LOGIC_UPDATE_RATE) intervals that the simulator has been
+		 * stepping for.
+		 */
+		long long time() const { return m_stepNumber*(long long)(LOGIC_UPDATE_RATE/LINEAR_UPDATE_RATE) + m_llNumber; }
+		/**
+		 * Initializes a new logic chain.
+		 */
+		void createLogicChain( LogicOut * logicOut, const LogicInList & logicInList, const PinList & pinList );
+		/**
+		 * Adds the given LogicOut to the list of changed LogicOuts
+		 */
+		void addChangedLogic( LogicOut * changed )
+		{
+			m_pChangedLogicLast->setNextChanged( changed, m_currentChain );
+			m_pChangedLogicLast = changed;
+		}
+		/**
+		 * Remove pointers to the given LogicOut, called when it is deleted for
+		 * safety reasons.
+		 */
+		void removeLogicOutReferences( LogicOut * logic );
+		/**
+		 * Remove pointers to the given LogicIn, called when it is deleted for
+		 * safety reasons. Simulator does not have any references to LogicIns
+		 * itself - instead, they are removed from logic chains which are
+		 * currently marked as changed.
+		 */
+		void removeLogicInReferences( LogicIn * logic );
+		/**
+		 * Adds the given Circuit to the list of changed Circuits
+		 */
+		void addChangedCircuit( Circuit * changed )
+		{
+			m_pChangedCircuitLast->setNextChanged( changed, m_currentChain );
+			m_pChangedCircuitLast = changed;
+		}
+		inline void addStepCallback( int at, LinkedList<ComponentCallback> * ccb );
+		/**
+		 * Add the given processor to the simulator. GpsimProcessor::step will
+		 * be called while present in the simulator (it is at GpsimProcessor's
+		 * disgression whether to actually step, depending on its running
+		 * status).
+		 * @see detachGpsimProcessor( GpsimProcessor * cpu );
+		 */
+		void attachGpsimProcessor( GpsimProcessor * cpu );
+		/**
+		 * Remove the given processor from the simulation loop
+		 */
+		void detachGpsimProcessor( GpsimProcessor * cpu );
+		/**
+		 * Attach the component callback to the simulator. This will be called
+		 * during the logic update loop, at LOGIC_UPDATE_RATE times per second (so
+		 * make sure the function passed is an efficient one!).
+		 */
+		void attachComponentCallback( Component * component, VoidCallbackPtr function );
+		/**
+		 * Removes the callbacks for the given component from the simulator.
+		 */
+		void detachComponentCallbacks( Component * component );
+		/**
+		 * Attach the component to the simulator.
+		 */
+		void attachComponent( Component * component );
+		/**
+		 * Detaches the component from the simulator.
+		 */
+		void detachComponent( Component * component );
+		/**
+		 * Attach a circuit to the simulator
+		 */
+		void attachCircuit( Circuit * circuit );
+		/**
+		 * Detach a circuit from the simulator.
+		 */
+		void detachCircuit( Circuit * circuit );
+		/**
+		 * Attaches the switch to the simulator (only needed when the switch has
+		 * started bouncing.
+		 */
+		void attachSwitch( Switch * sw );
+		/**
+		 * Detaches the switch from the simulator (called when the switch has
+		 * stopped bouncing).
+		 */
+		void detachSwitch( Switch * sw );
+		/**
+		 * @return whether or not we are currently simulating stuff
+		 * @see slotSetSimulating
+		 */
+		bool isSimulating() const { return m_bIsSimulating; }
+		
+	public slots:
+		/**
+		 * Set whether or not to simulate at the moment.
+		 * @see isSimulating
+		 */
+		void slotSetSimulating( bool simulate );
+		
+	signals:
+		/**
+		 * Emitted when the simulating state changes.
+		 * @see slotSetSimulating
+		 */
+		void simulatingStateChanged( bool isSimulating );
+		
+	private slots:
+		void step();
+
+	protected:
+		template <typename T>
+		void attach( LinkedList<T> ** start, T * data );
+		template <typename T>
+		void detach( LinkedList<T> ** start, T * data );
+		template <typename T>
+		void detachAll( LinkedList<T> * list );
+		
+		bool m_bIsSimulating;
+		static Simulator * m_pSelf;
+		
+		///List of LogicOuts that are at the start of a LogicChain
+		QValueList<LogicOut*> m_logicChainStarts;
+		
+		LogicOut * m_pChangedLogicStart;
+		LogicOut * m_pChangedLogicLast;
+		
+		Circuit * m_pChangedCircuitStart;
+		Circuit * m_pChangedCircuitLast;
+		
+		LinkedList<GpsimProcessor> * m_gpsimProcessors;
+		LinkedList<Component> * m_components;
+		LinkedList<ComponentCallback> * m_componentCallbacks;
+		LinkedList<Circuit> * m_ordinaryCircuits;
+		LinkedList<Switch> * m_switches;
+		
+		LinkedList<ComponentCallback> * m_pStartStepCallback[LOGIC_UPDATE_RATE/LINEAR_UPDATE_RATE];
+		LinkedList<ComponentCallback> * m_pNextStepCallback[LOGIC_UPDATE_RATE/LINEAR_UPDATE_RATE];
+		
+	private:
+		Simulator();
+		long m_llNumber;
+		long long m_stepNumber;
+		unsigned char m_currentChain;
+};
+
+
+inline void Simulator::addStepCallback( int at, LinkedList<ComponentCallback> * ccb )
+{
+	if ( !m_pStartStepCallback[at] )
+		m_pStartStepCallback[at] = ccb;
+	
+	else
+		m_pNextStepCallback[at]->m_pNext = ccb;
+	
+	m_pNextStepCallback[at] = ccb;
+}
+
+#endif