Logo Search packages:      
Sourcecode: ktechlab version File versions

discretelogic.cpp

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

#include "canvasitemparts.h"
#include "discretelogic.h"
#include "ecnode.h"
#include "logic.h"
#include "libraryitem.h"
#include "simulator.h"

#include <klocale.h>
#include <qpainter.h>


//BEGIN class Inverter
Item* Inverter::construct( ItemDocument *itemDocument, bool newItem, const char *id )
{
      return new Inverter( (ICNDocument*)itemDocument, newItem, id );
}

LibraryItem* Inverter::libraryItem()
{
      QStringList ids;
      ids << "ec/inverter" << "ec/not";
      return new LibraryItem(
            ids,
            i18n("Inverter"),
            i18n("Logic"),
            "not.png",
            LibraryItem::lit_component,
            Inverter::construct );
}

Inverter::Inverter( ICNDocument *icnDocument, bool newItem, const char *id )
      : Component( icnDocument, newItem, id ? id : "not" )
{
      m_name = i18n("Inverter");
      m_desc = i18n("The output is the logical inverse of the logic-input state.");
      setSize( -8, -8, 16, 16 );

      init1PinLeft();
      init1PinRight();
      
      m_pIn = createLogicIn(m_pNNode[0]);
      m_pOut = createLogicOut( m_pPNode[0], true );
      
      m_pIn->setCallback( this, (CallbackPtr)(&Inverter::inStateChanged) );
      inStateChanged(false);
}


Inverter::~Inverter()
{
}


void Inverter::inStateChanged( bool newState )
{
      (static_cast<LogicOut*>(m_pOut))->setHigh( !newState );
}


void Inverter::drawShape( QPainter &p )
{
      initPainter(p);
      int _x = (int)x()-8;
      int _y = (int)y()-8;
      QPointArray pa(3);
      pa[0] = QPoint( _x, _y );
      pa[1] = QPoint( _x+width()-6, _y+(height()/2) );
      pa[2] = QPoint( _x, _y+height() );
      p.drawPolygon(pa);
      p.drawPolyline(pa);
      p.drawEllipse( _x+width()-6, _y+(height()/2)-3, 7, 7 );
      deinitPainter(p);
}
//END class Inverter


//BEGIN class Buffer
Item* Buffer::construct( ItemDocument *itemDocument, bool newItem, const char *id )
{
      return new Buffer( (ICNDocument*)itemDocument, newItem, id );
}

LibraryItem* Buffer::libraryItem()
{
      return new LibraryItem(
            QString::QString("ec/buffer"),
            i18n("Buffer"),
            i18n("Logic"),
            "buffer.png",
            LibraryItem::lit_component,
            Buffer::construct );
}

Buffer::Buffer( ICNDocument *icnDocument, bool newItem, const char *id )
      : Component( icnDocument, newItem, id ? id : "buffer" )
{
      m_name = i18n("Buffer");
      m_desc = i18n("Cleans the logic input, with the output high or low depending on input trigger levels.");
      setSize( -8, -8, 16, 16 );

      init1PinLeft();
      init1PinRight();
      
      m_pIn = createLogicIn(m_pNNode[0]);
      m_pOut = createLogicOut( m_pPNode[0], true );
      
      m_pIn->setCallback( this, (CallbackPtr)(&Buffer::inStateChanged) );
      inStateChanged(false);
}


Buffer::~Buffer()
{
}


void Buffer::inStateChanged( bool newState )
{
      m_pOut->setHigh(newState);
}


void Buffer::drawShape( QPainter &p )
{
      initPainter(p);
      int _x = (int)x()-8;
      int _y = (int)y()-8;
      QPointArray pa(3);
      pa[0] = QPoint( _x, _y );
      pa[1] = QPoint( _x+width(), _y+(height()/2) );
      pa[2] = QPoint( _x, _y+height() );
      p.drawPolygon(pa);
      p.drawPolyline(pa);
      deinitPainter(p);
}
//END class Buffer


//BEGIN class ECLogicInput
Item* ECLogicInput::construct( ItemDocument *itemDocument, bool newItem, const char *id )
{
      return new ECLogicInput( (ICNDocument*)itemDocument, newItem, id );
}

LibraryItem* ECLogicInput::libraryItem()
{
      return new LibraryItem(
            QString::QString("ec/logic_input"),
            i18n("Logic Input"),
            i18n("Logic"),
            "logic_input.png",
            LibraryItem::lit_component,
            ECLogicInput::construct );
}

ECLogicInput::ECLogicInput( ICNDocument *icnDocument, bool newItem, const char *id )
      : Component( icnDocument, newItem, (id) ? id : "logic_input" )
{
      m_name = i18n("Logic Input");
      m_desc = i18n("Provides a user-adjustable logic state.<br><br>"
                        "Click to pulse high, or drag the mouse off to keep the output high.");
      setSize( -8, -8, 16, 16 );
      
      b_state = false;
      addButton( "button", QRect( -24, -8, 16, 16 ), "", true );
      
      createProperty( "useToggle", Variant::Type::Bool );
      property("useToggle")->setCaption( i18n("Use Toggle") );
      property("useToggle")->setValue(true);

      init1PinRight();
      
      m_pOut = createLogicOut( m_pPNode[0], false );
}


ECLogicInput::~ECLogicInput()
{
}


void ECLogicInput::dataChanged()
{
      button("button")->setToggle( dataBool("useToggle") );
}


void ECLogicInput::drawShape( QPainter &p )
{
      initPainter(p);
      if (b_state)
            p.setBrush( QColor( 255, 166, 0 ) );
      else
            p.setBrush( Qt::white );
      p.drawEllipse( (int)x()-4, (int)y()-6, 12, 12 );
      deinitPainter(p);
}


void ECLogicInput::buttonStateChanged( const QString &, bool state )
{
      b_state = state;
      m_pOut->setHigh(b_state);
}
//END class ECLogicInput


//BEGIN class ECLogicOutput
Item* ECLogicOutput::construct( ItemDocument *itemDocument, bool newItem, const char *id )
{
      return new ECLogicOutput( (ICNDocument*)itemDocument, newItem, id );
}

LibraryItem* ECLogicOutput::libraryItem()
{
      return new LibraryItem(
            QString::QString("ec/logic_output"),
            i18n("Logic Output"),
            i18n("Logic"),
            "logic_output.png",
            LibraryItem::lit_component,
            ECLogicOutput::construct );
}

ECLogicOutput::ECLogicOutput( ICNDocument *icnDocument, bool newItem, const char *id )
      : Component( icnDocument, newItem, (id) ? id : "logic_output" )
{
      m_name = i18n("Logic Output");
      m_desc = i18n("Shows the logic-state of the input.");
      setSize( -8, -8, 16, 16 );
      
      init1PinLeft();
      m_pIn = createLogicIn(m_pNNode[0]);
      
      m_pSimulator = Simulator::self();
      
      m_lastDrawState = 0.0;
      m_lastSwitchTime = m_lastDrawTime = m_pSimulator->time();
      m_highTime = 0;
      m_bLastState = false;
      m_bDynamicContent = true;
      
      m_pIn->setCallback( this, (CallbackPtr)(&ECLogicOutput::inStateChanged) );
}

ECLogicOutput::~ECLogicOutput()
{
}

void ECLogicOutput::inStateChanged( bool newState )
{
      if ( m_bLastState == newState )
            return;
      
      unsigned long long newTime = m_pSimulator->time();
      unsigned long long dt = newTime - m_lastSwitchTime;
      
      m_lastSwitchTime = newTime;
      
      m_bLastState = newState;
      if (!newState)
      {
            // Gone from high to low
            m_highTime += dt;
      }
}


void ECLogicOutput::drawShape( QPainter &p )
{
      unsigned long long newTime = m_pSimulator->time();
      unsigned long long runTime = newTime - m_lastDrawTime;
      m_lastDrawTime = newTime;
      
      if (m_bLastState)
      {
            // Logic in is currently high
            m_highTime += newTime - m_lastSwitchTime;
      }
      
      double state;
      
      if ( runTime == 0 )
            state = m_lastDrawState;
      
      else
            state = m_lastDrawState = double(m_highTime)/double(runTime);
      
      initPainter(p);
      p.setBrush( QColor( 255, uint(255-state*(255-166)), uint((1-state)*255) ) );
      p.drawEllipse( int(x()-8), int(y()-8), width(), height() );
      deinitPainter(p);
      
      m_lastSwitchTime = newTime;
      m_highTime = 0;
}
//END class ECLogicOutput


Generated by  Doxygen 1.6.0   Back to index