qavrgtestwindow.cpp

Go to the documentation of this file.

#include "qavrgtestwindow.h"

#include <QHBoxLayout>
#include <stdio.h>

QavrgTestProxy::QavrgTestProxy(int useProxy, int useTransaction, QavrgTestInteger *integer, QSpinBox *spinBox, QObject *parent)
  : QObject(parent),
    m_UseProxy(useProxy),
    m_UseTransaction(useTransaction),
    m_Value(integer->get_Integer()),
    m_Integer(integer),
    m_SpinBox(spinBox),
    m_TransactionId(0)
{
}

void QavrgTestProxy::valueChanged(int value, qint64 id)
{
  printf("QavrgTestProxy::valueChanged(%d,%ld)\n", value, (long int) id);

  if (value != m_Value) {
    m_Value = value;

    if (m_UseTransaction) {
      if (id > m_TransactionId) {
        m_TransactionId = id;

        printf("emit changeSpinBox(%d)\n", m_Value);

        emit changeSpinBox(value);
      } else {
        printf("emission skipped because %ld <= %ld\n", (long int) id, (long int) m_TransactionId);
      }
    } else {
      emit changeSpinBox(value);
    }
  }
}

void QavrgTestProxy::spinBoxChanged(int value)
{
  printf("QavrgTestProxy::spinBoxChanged(%d)\n", value);

  if (value != m_Value) {
    m_Value = value;

    printf("emit changeInteger(%d, %ld)\n", m_Value, (long int) m_TransactionId);

    emit changeInteger(m_Value, m_TransactionId++);
  }
}

QavrgTestInteger::QavrgTestInteger(int useProxy, int useTransaction, QObject *parent)
  : QObject(parent),
    m_Mutex(QMutex::Recursive),
    m_UseProxy(useProxy),
    m_UseTransaction(useTransaction),
    m_Value(0),
    m_TransactionId(0),
    m_NQueuedUpdates(0)
{
}

void QavrgTestInteger::linkTo(QSpinBox *spinBox)
{
  if (m_UseProxy) {
    QavrgTestProxy *proxy = new QavrgTestProxy(m_UseProxy, m_UseTransaction, this, spinBox, NULL);

    proxy -> moveToThread(spinBox -> thread());

    connect(this, SIGNAL(chg_Integer(int,qint64)), proxy, SLOT(valueChanged(int,qint64)), Qt::QueuedConnection);
    connect(proxy, SIGNAL(changeInteger(int,qint64)), this, SLOT(setValue(int,qint64)), Qt::QueuedConnection);

    connect(spinBox, SIGNAL(valueChanged(int)), proxy, SLOT(spinBoxChanged(int)), Qt::DirectConnection);
    connect(proxy, SIGNAL(changeSpinBox(int)), spinBox, SLOT(setValue(int)), Qt::DirectConnection);

    spinBox -> setValue(get_Integer());
  } else {
    connect(this, SIGNAL(chg_Integer(int,qint64)), spinBox, SLOT(setValue(int)), Qt::DirectConnection);
    connect(spinBox, SIGNAL(valueChanged(int)), this, SLOT(setValue(int)), Qt::DirectConnection);
  }
}

void QavrgTestInteger::setValue(int value, qint64 id)
{
  printf("QavrgTestInteger::setValue(%d,%ld,%d)\n", value, (long int) id, m_NQueuedUpdates);

  m_NQueuedUpdates--;

  set_Integer(value);
}

void QavrgTestInteger::set_Integer(int value)
{
  QMutexLocker lock(&m_Mutex);

  printf("%ld: QavrgTestInteger::set_Integer(%d)\n", (long int) m_TransactionId, value);

  if (value != m_Value) {
    m_Value = value;

    m_NQueuedUpdates++;

    emit chg_Integer(m_Value, m_TransactionId++);
  }
}

int QavrgTestInteger::get_Integer() const
{
  QMutexLocker lock(&m_Mutex);

  return m_Value;
}

QavrgTestThread::QavrgTestThread(int useProxy, int useTransaction, QavrgTestWindow *win, QObject *parent)
  : QThread(parent),
    m_Integer(NULL),
    m_UseProxy(useProxy),
    m_UseTransaction(useTransaction),
    m_Window(win)
{
}

void QavrgTestThread::run()
{
  m_Integer = new QavrgTestInteger(m_UseProxy, m_UseTransaction);

  m_Integer -> linkTo(m_Window -> m_SpinBox);

  exec();
}

QavrgTestWindow::QavrgTestWindow(int useProxy, int useTransaction, QWidget *parent)
  : QWidget(parent),
    m_SpinBox(NULL),
    m_Increment(NULL),
    m_DoubleIncrement(NULL),
    m_CountFive(NULL),
    m_UseProxy(useProxy),
    m_UseTransaction(useTransaction),
    m_Thread(NULL)
{
  m_Thread = new QavrgTestThread(m_UseProxy, m_UseTransaction, this, this);

  QHBoxLayout *layout = new QHBoxLayout();

  m_SpinBox = new QSpinBox();
  m_Increment = new QPushButton("I++");
  m_DoubleIncrement = new QPushButton("I++;I++");
  m_CountFive = new QPushButton("12345");
  m_CountThousand = new QPushButton("Thousand");

  m_SpinBox -> setMinimum(-1000);
  m_SpinBox -> setMaximum(99999);

  layout -> addWidget(m_SpinBox);
  layout -> addWidget(m_Increment);
  layout -> addWidget(m_DoubleIncrement);
  layout -> addWidget(m_CountFive);
  layout -> addWidget(m_CountThousand);

  setLayout(layout);

  connect(m_Increment, SIGNAL(clicked()), this, SLOT(increment()));
  connect(m_DoubleIncrement, SIGNAL(clicked()), this, SLOT(doubleIncrement()));
  connect(m_CountFive, SIGNAL(clicked()), this, SLOT(countFive()));
  connect(m_CountThousand, SIGNAL(clicked()), this, SLOT(countThousand()));

  m_Thread -> start();

  show();
}

void QavrgTestWindow::increment()
{
  int val = m_Thread -> m_Integer -> get_Integer();

  printf("QavrgTestWindow::increment -> %d\n", val);

  m_Thread -> m_Integer -> set_Integer(val+1);
//  emit set_Integer(val+1);
}

void QavrgTestWindow::doubleIncrement()
{
  printf("QavrgTestWindow::doubleIncrement\n");

  increment();
  increment();
}

void QavrgTestWindow::countFive()
{
  printf("QavrgTestWindow::countFive");

  m_Thread -> m_Integer -> set_Integer(1);
  m_Thread -> m_Integer -> set_Integer(2);
  m_Thread -> m_Integer -> set_Integer(3);
  m_Thread -> m_Integer -> set_Integer(4);
  m_Thread -> m_Integer -> set_Integer(5);
}

void QavrgTestWindow::countThousand()
{
  for (int i=1; i<=1000; i++) {
    m_Thread -> m_Integer -> set_Integer(i);
  }
}