Logo Search packages:      
Sourcecode: ktechlab version File versions  Download package

microsettings.cpp

/***************************************************************************
 *   Copyright (C) 2003-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 "itemdocumentdata.h"
#include "microinfo.h"
#include "micropackage.h"
#include "pinmapping.h"


//BEGIN class VariableInfo
VariableInfo::VariableInfo()
{
      type = MicroSettings::vt_unknown;
      value = QVariant(0);
      initAtStart = false;
      permanent = false;
}

void VariableInfo::setValue( const QVariant & _value )
{
      value = _value;
}

QString VariableInfo::valueAsString() const
{
      if ( value.canCast(QVariant::String) ) return value.toString();
      if ( value.canCast(QVariant::Int) ) return QString::number(value.toInt());
      return "0";
}
//END class VariableInfo


//BEGIN class PinSettings
PinSettings::PinSettings()
      : QObject()
{
      m_type = PinSettings::pt_input;
      m_state = PinSettings::ps_off;
      m_id = "pin";
}

PinSettings::PinSettings( PinSettings::pin_type _type, PinSettings::pin_state _state, const QString &id, const QString &port )
{
      m_type = _type;
      m_state = _state;
      m_id = id;
      m_port = port;
}


void PinSettings::setType( PinSettings::pin_type type )
{
      if ( m_type == type )
            return;
      m_type = type;
      emit settingsChanged();
}


void PinSettings::setState( PinSettings::pin_state state )
{
      if ( m_state == state)
            return;
      m_state = state;
      emit settingsChanged();
}
//END class PinSettings



//BEGIN class MicroSettings
MicroSettings::MicroSettings( MicroInfo * microInfo )
{
      _microInfo = microInfo;
      
      QStringList portNames = _microInfo->package()->portNames();
      const QStringList::iterator portNamesEnd = portNames.end();
      for ( QStringList::iterator it = portNames.begin(); it != portNamesEnd; ++it )
      {
            PinSettingsList portPins;
            QStringList pinIDs;
            pinIDs = _microInfo->package()->pinIDs( PicPin::type_bidir | PicPin::type_open, *it );
            pinIDs.sort();
            const int numPins = pinIDs.size();
            for ( int i=0; i<numPins; i++ )
            {
                  PinSettings *pinSettings = new PinSettings( PinSettings::pt_input, PinSettings::ps_off, pinIDs[i], *it ); 
                  m_pinSettingsList.append(pinSettings);
                  portPins.append(pinSettings);
            }
            m_ports[*it] = portPins;
      }
}

MicroSettings::~MicroSettings()
{
      const PinSettingsList::iterator pinListEnd = m_pinSettingsList.end();
      for ( PinSettingsList::iterator it = m_pinSettingsList.begin(); it != pinListEnd; ++it )
      {
            delete *it;
      }
//    delete m_variableList;
}

00112 void MicroSettings::setPinType( const QString &id, PinSettings::pin_type type )
{
      PinSettings *pin = pinWithID(id);
      if (pin) pin->setType(type);
}

00118 void MicroSettings::setPinState( const QString &id, PinSettings::pin_state state )
{
      PinSettings *pin = pinWithID(id);
      if (pin)
            pin->setState(state);
}


00126 PinSettings* MicroSettings::pinWithID( const QString &id )
{
      const PinSettingsList::iterator pinListEnd = m_pinSettingsList.end();
      for ( PinSettingsList::iterator it = m_pinSettingsList.begin(); it != pinListEnd; ++it )
      {
            if ( (*it)->id() == id ) return *it;
      }
      return 0L;
}

00136 int MicroSettings::portState( const QString &port )
{
      if ( microInfo()->package()->portNames().findIndex(port) == -1 ) return -1;
      
      int pinPower = 1;
      int num = 0;
      
      const PinSettingsList::iterator pinListEnd = m_pinSettingsList.end();
      for ( PinSettingsList::iterator it = m_pinSettingsList.begin(); it != pinListEnd; ++it )
      {
            if ( (*it)->port() == port )
            {
                  if ( (*it)->state() == PinSettings::ps_on ) num += pinPower;
//                cout << "(*it)->state()="<<(*it)->state()<<endl;
                  pinPower *= 2;
            }
      }
      
      return num;
}

00157 int MicroSettings::portType( const QString &port )
{
      if ( microInfo()->package()->portNames().findIndex(port) == -1 ) return -1;
      
      int pinPower = 1;
      int num = 0;
      
      const PinSettingsList::iterator pinListEnd = m_pinSettingsList.end();
      for ( PinSettingsList::iterator it = m_pinSettingsList.begin(); it != pinListEnd; ++it )
      {
            if ( (*it)->port() == port )
            {
                  if ( (*it)->type() == PinSettings::pt_input ) num += pinPower;
                  pinPower *= 2;
            }
      }
      
      return num;
}

00177 void MicroSettings::setPortState( const QString &port, int state )
{
      PortList::iterator plit = m_ports.find(port);
      if ( plit == m_ports.end() ) return;
      
      const PinSettingsList::iterator plitEnd = plit.data().end();
      for ( PinSettingsList::iterator it = plit.data().begin(); it != plitEnd; ++it )
      {
//          cout << "state="<<state<<endl;
            (*it)->setState( (state%2 == 1) ? PinSettings::ps_on : PinSettings::ps_off );
//          cout << "(*it)->state()="<<(*it)->state()<<endl;
            state /= 2;
      }
}

00192 void MicroSettings::setPortType( const QString &port, int type )
{
      PortList::iterator plit = m_ports.find(port);
      if ( plit == m_ports.end() ) return;
      
      const PinSettingsList::iterator plitEnd = plit.data().end();
      for ( PinSettingsList::iterator it = plit.data().begin(); it != plitEnd; ++it )
      {
            (*it)->setType( (type%2 == 1) ? PinSettings::pt_input : PinSettings::pt_output );
            type /= 2;
      }
}


00206 MicroData MicroSettings::microData() const
{
      MicroData data;
      data.id = microInfo()->id();
      data.pinMappings = pinMappings();
      
      const PinSettingsList::const_iterator pinListEnd = m_pinSettingsList.end();
      for ( PinSettingsList::const_iterator it = m_pinSettingsList.begin(); it != pinListEnd; ++it )
      {
            data.pinMap[(*it)->id()].type = (*it)->type();
            data.pinMap[(*it)->id()].state= (*it)->state();
      }
      
      const VariableMap::const_iterator variableMapEnd = m_variableMap.end();
      for ( VariableMap::const_iterator it = m_variableMap.begin(); it != variableMapEnd; ++it )
      {
            if ( it.data().permanent )
                  data.variableMap[it.key()] = it.data().valueAsString();
      } 
      
      return data;
}


void MicroSettings::restoreFromMicroData( const MicroData &microData )
{
      setPinMappings( microData.pinMappings );
      
      const PinDataMap::const_iterator pinMapEnd = microData.pinMap.end();
      for ( PinDataMap::const_iterator it = microData.pinMap.begin(); it != pinMapEnd; ++it )
      {
            PinSettings *pin = pinWithID(it.key());
            if (pin)
            {
                  pin->setState( it.data().state );
                  pin->setType( it.data().type );
            }
      }
      
      const QStringMap::const_iterator variableMapEnd = microData.variableMap.end();
      for ( QStringMap::const_iterator it = microData.variableMap.begin(); it != variableMapEnd; ++it )
      {
            setVariable( it.key(), it.data(), true );
      }
}


00253 void MicroSettings::setVariable( const QString &name, QVariant value, bool permanent )
{
      if ( name.isNull() ) return;
      VariableMap::iterator it = m_variableMap.find(name);
      if ( it != m_variableMap.end() )
      {
            it.data().setValue(value);
            it.data().permanent = permanent;
            it.data().initAtStart = permanent;
      }
      else
      {
            VariableInfo info;
            info.setValue(value);
            info.permanent = permanent;
            info.initAtStart = permanent;
            m_variableMap[name] = info;
      }
}


00274 QStringList MicroSettings::variableNames()
{
      QStringList list;
      const VariableMap::iterator variableMapEnd = m_variableMap.end();
      for ( VariableMap::iterator it = m_variableMap.begin(); it != variableMapEnd; ++it )
      {
            list += it.key();
      }
      return list;
}


00286 VariableInfo* MicroSettings::variableInfo( const QString &name )
{
      if ( name.isNull() ) return 0l;
      VariableMap::iterator it = m_variableMap.find(name);
      if ( it != m_variableMap.end() ) {
            return &(it.data());
      } else {
            return 0l;
      }
}


00298 bool MicroSettings::deleteVariable( const QString &name )
{
      if ( name.isNull() ) return false;
      VariableMap::iterator it = m_variableMap.find(name);
      if ( it != m_variableMap.end() )
      {
            m_variableMap.erase(it);
            return true;
      } else {
            return false;
      }
}


00312 void MicroSettings::removeAllVariables()
{
      m_variableMap.clear();
}


00318 PinMapping MicroSettings::pinMapping( const QString & id ) const
{
      return m_pinMappings[id];
}


00324 void MicroSettings::setPinMappings( const PinMappingMap & pinMappings )
{
      m_pinMappings = pinMappings;
      emit pinMappingsChanged();
}


00331 PinMappingMap MicroSettings::pinMappings() const
{
      return m_pinMappings;
}
//END class MicroSettings



Generated by  Doxygen 1.6.0   Back to index