#ifndef MYSOCKET_H
#define MYSOCKET_H
 
#include <QTcpSocket>
#include <QThread>
 
class MySocket : public QTcpSocket
{
    Q_OBJECT
public:
    explicit MySocket(int descriptor);
    void connectThread(QThread &thread);
signals:
    void sendData(QByteArray);
public slots:
    void setupSocket();
    void readSocket();
    void writeSocket(QByteArray);
    void disconnected();
    void connecte_d();
private:
    int socketDescriptor;
};
 
#endif // MYSOCKET_H

#include "mysocket.h"
 
MySocket::MySocket(int descriptor) :socketDescriptor(descriptor)
{
    this->setSocketDescriptor(descriptor);
}
void MySocket::connectThread(QThread &thread)
{
    connect(&thread, SIGNAL(started()), this, SLOT(setupSocket()));
}
void MySocket::setupSocket()
{
    connect(this, SIGNAL(readyRead()), this, SLOT(readSocket()));
    connect(this, SIGNAL(connected()), this, SLOT(connecte_d()));
    connect(this, SIGNAL(disconnected()), this, SLOT(disconnected()));
}
void MySocket::readSocket()
{
    QByteArray buffer;
    buffer.clear();
    buffer.append(this->readAll());
    qDebug() << buffer;
    emit sendData(buffer);
}
void MySocket::writeSocket(QByteArray data)
{
    this->write(data);
}
void MySocket::connecte_d()
{
    qDebug() << socketDescriptor << " connected";
}
void MySocket::disconnected()
{
    qDebug() << socketDescriptor << " Disconnected";
}

#ifndef MSEVER_H
#define MSEVER_H
 
#include <QTcpServer>
#include <QDebug>
#include <QThreadPool>
#include <QList>
#include <QString>
#include <QThread>
#include <QTcpSocket>
#include <QHash>
#include "mysocket.h"
 
class MServer : public QTcpServer
{
    Q_OBJECT
public:
    explicit MServer(QObject *parent = 0);
    ~MServer();
 
signals:
    void sendD(QByteArray);
public slots:
        void dataRec(QByteArray);
protected:
    void incomingConnection(int handle);
private:
    MySocket* mSocket;
    QList<QThread*>* myThreads;
    QThreadPool* threadPool;
    static int counter;
};
 
#endif // MSEVER_H

#include "msever.h"
int MServer::counter = 0;
MServer::MServer(QObject *parent) :
    QTcpServer(parent)
{
    if(this->listen(QHostAddress::Any, 1234))
        qDebug() << "Listening...";
    else
        qDebug() << "Server failed to start";
    myThreads = new QList<QThread*>();
    for(int i = 0; i <= 5; i++)
    {
        QThread* thread = new QThread();
        myThreads->append(thread);
    }
}
MServer::~MServer()
{
    for(int i = 0; i <= 5; i++)
        myThreads->at(i)->deleteLater();
}
void MServer::incomingConnection(int handle)
{
    qDebug() << handle << " Connected";
    mSocket = new MySocket(handle);
    mSocket->writeSocket("Welcome to Ayanda's Server");
 
    connect(mSocket, SIGNAL(sendData(QByteArray)), this, SLOT(dataRec(QByteArray)));
    connect(this, SIGNAL(sendD(QByteArray)), mSocket, SLOT(writeSocket(QByteArray)));
 
    mSocket->connectThread(*(myThreads->at(counter)));
    mSocket->moveToThread(myThreads->at(counter));
    myThreads->at(counter)->start();
    counter++;
 }
void MServer::dataRec(QByteArray data)
{
    emit sendD(data);
}

#include <QtCore/QCoreApplication>
#include "msever.h"
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    MServer Server;
    return a.exec();
}

#ifndef ASIXOXE_UI_H
#define ASIXOXE_UI_H
 
#include <QMainWindow>
#include <QUdpSocket>
#include <QTcpSocket>
#include <QThread>
#include <QInputDialog>
#include <QString>
 
namespace Ui {
    class AsiXoxe_ui;
}
 
class AsiXoxe_ui : public QMainWindow
{
    Q_OBJECT
 
public:
    explicit AsiXoxe_ui(QWidget *parent = 0);
    ~AsiXoxe_ui();
signals:
    void sendMsg(QString);
public slots:
    void displayMsg(QByteArray);
    void readMsg();
    void sendMsg();
    void connectedMsg(QString);
    void connectedMsg_2();
private:
    Ui::AsiXoxe_ui *ui;
    QTcpSocket* socket;
    QThread* thread;
    QString nickName;
 
private slots:
    void on_pushButton_2_clicked();
    void on_lineEdit_returnPressed();
    void on_pushButton_clicked();
};
 
#endif // ASIXOXE_UI_H

#include "asixoxe_ui.h"
#include "ui_asixoxe_ui.h"
 
AsiXoxe_ui::AsiXoxe_ui(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::AsiXoxe_ui)
{
    ui->setupUi(this);
    socket = new QTcpSocket(this);
    QHostAddress hAddr;
    hAddr.setAddress("192.168.43.78");
    socket->connectToHost(hAddr, 1234);
    socket->waitForConnected(30000);
 
    connect(socket, SIGNAL(readyRead()), this, SLOT(readMsg()));
    connect(socket, SIGNAL(connected(QString)),this, SLOT(connectedMsg(QString)));
}
 
AsiXoxe_ui::~AsiXoxe_ui()
{
    delete ui;
    thread->deleteLater();
}
 
void AsiXoxe_ui::displayMsg(QByteArray sentMsg)
{
    QString msg = QString(sentMsg.data());
    ui->textBrowser->append(msg);
}
 
void AsiXoxe_ui::on_pushButton_clicked()
{
    sendMsg();
 
}
 
void AsiXoxe_ui::sendMsg()
{
    QByteArray buffer;
    buffer.append(nickName);
    buffer.append(": ");
    buffer.append(ui->lineEdit->text());
    socket->write(buffer);
    ui->lineEdit->clear();
}
 
void AsiXoxe_ui::readMsg()
{
    thread = new QThread();
    ui->textBrowser->append(socket->readAll());
    socket->flush();
    socket->waitForBytesWritten(3000);
 
    socket->moveToThread(thread);
    thread->start();
}
 
void AsiXoxe_ui::on_lineEdit_returnPressed()
{
    sendMsg();
}
 
void AsiXoxe_ui::connectedMsg(QString c)
{
}
 
void AsiXoxe_ui::connectedMsg_2()
{
}
 
void AsiXoxe_ui::on_pushButton_2_clicked()
{
    nickName = QInputDialog::getText(this, "Name input," "Name or Nickname", 0);
}

#include <QtGui/QApplication>
#include "asixoxe_ui.h"
 
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    AsiXoxe_ui w;
 
    w.show();
 
    return a.exec();
}

// Slot, which is invoked on click of button.
void CDialog::loadString()
{
    if(sharedMemory.isAttached())
    {
        if(!sharedMemory.detach())
        {
            lbl->setText("Unable to detach from Shared Memory");
            return;
        }
    }
 
    char sString[] = "my string";
 
    QBuffer buffer;
    buffer.open(QBuffer::ReadWrite);
 
    QDataStream out(&buffer);
    out << sString;
 
    int size = buffer.size();
    qDebug() << size;
 
    if(!sharedMemory.create(size))
    {
        lbl->setText("Unable to create shared memory segment");
        qDebug() << lbl->text();
    }
    sharedMemory.lock();
    char *to = (char *) sharedMemory.data();
    const char *from = buffer.data();
    memcpy(to, from, qMin(sharedMemory.size(), size));
    sharedMemory.unlock();
 
    char * str;
    QDataStream in(&buffer);
    sharedMemory.lock();
    buffer.setData((char *)sharedMemory.constData(), sharedMemory.size());
    buffer.open(QBuffer::ReadOnly);
    in >> str;
    sharedMemory.unlock();
    qDebug() << str;
}

//NQShrdMem.cpp
int main()
{
  boost::interprocess::shared_memory_object shdmem(boost::interprocess::open_only, "ShrdMem", boost::interprocess::read_only);
 
  boost::interprocess::offset_t size; 
  if (shdmem.get_size(size)) 
    std::cout << "Shared Mem Size: " << size << std::endl; 
 
  boost::interprocess::mapped_region region2(shdmem, boost::interprocess::read_only); 
  char *i2 = static_cast<char *>(region2.get_address()); 
  std::cout << i2 << std::endl;
  return 0;
}

g++ -I /cygdrive/c/boost/boost_1_53_0/ NQShrdMem.cpp -o NQShrdMem /cygdrive/c/boost_lib/boost/bin.v2/libs/date_time/build/gcc-mingw-4.7.2/release/link-static/threading-multi/libboost_date_time-mgw47-mt-1_53.a

#include "FirstWindow.h"
int main(int argc, char *argv[])
{
	QApplication a(argc, argv);
	FirstWindow w;
 
	w.setAttribute( Qt :: WA_QuitOnClose );
	w.show();
	return a.exec();
}

#include "SecondWindow.h"
class FirstWindow : public QDialog
{
	Q_OBJECT
 
             private:
 
                    SecondWindow * window2;
 
	public:
                   void some_function( ){
 
                             this -> hide( );
                             window2 = new SecondWindow( );
                             window2 -> displayTheWindow( );
                   }
}

class SecondWindow : public QDialog
{
	Q_OBJECT
 
	private:
 
		QDialog * dialog;
 
            public slot:
 
                         void startFirstWindow( );
 
            public:
                  SecondWindow( ){
                      dialog = new QDialog( );
                      connect( this, SIGNAL( rejected( ) ), this, SLOT( startFirstWindow( ) ) );
                  }
}

//[... somewhere in the widget's header ...]
 
    QPen *_foreGround;
    QBrush *_backGround;
 
//[... somewhere in the widget's initialization process ...]
 
    _foreGround = new QPen();
    _foreGround->setCosmetic(true);
    _foreGround->setWidth(3);
    _backGround = new QBrush();
    _backGround->setColor(QColor(qRgba(0,0,0,0)));
 
//[...]
 
void QtProgressPie::paintEvent(QPaintEvent *e)
{
    // recalculate the value according to the conditions of QPainter::drawPie
    // step 1: subtract _minimum from _value (so the calculation base is always 0)
    // step 2: calculate the percentage of value (value/max * 100)
    // step 3: translate it to circular conditions (value/max * [100 * 3.6 * 16]) [...] = _FULLCIRCLE
    // step 4: take it times -1 (QPainter::drawPie works counter-clockwise with positive values)
 
    int _painterValue = ((_value - _minimum) / double(_maximum - _minimum) * _FULLCIRCLE) * -1;
 
    QPainter p;
    p.begin(this);  // Begin drawing on the widget
 
    // make sure that the widget appears always as a circle, not as an ellipse
    int _squaredSize = qMin(this->width(), this->height());
    p.setViewport((this->width() - _squaredSize) / 2,(this->height() - _squaredSize) / 2,
                  _squaredSize, _squaredSize);
    // subtract the width of the pen ("the border width") from the widget's rect() to get the drawable area
    int _borderWidth = _foreGround->width();
    QRect drawableArea(0 + _borderWidth, 0 + _borderWidth,
                       this->width() - _borderWidth * 2, this->height() - _borderWidth * 2);
 
 
    p.setRenderHint(QPainter::HighQualityAntialiasing, true);
    p.setPen(*_foreGround);
    //p.setBrush(*_backGround); <--- DOESN'T WORK
 
    // draw surrounding circle
    // _backGround->setStyle(Qt::NoBrush); <--- DOESN'T WORK
    p.setBrush(QBrush(QColor(qRgba(0,0,0,0)),Qt::NoBrush)); // <--- WORKS!
    p.drawEllipse(drawableArea);
 
 
    // draw pie if value < 0
    if (_painterValue < 0)
    {
        //_backGround->setStyle(Qt::SolidPattern); <--- DOESN'T WORK
        p.setBrush(QBrush(QColor(qRgba(0,0,0,0)),Qt::SolidPattern)); // <--- WORKS!
        p.drawPie(drawableArea, _OFFSET, _painterValue);
        // _OFFSET = 1/4 of _FULLCIRCLE (transition from 3 o'clock (drawPie's base) to 12 o'clock)
    }
 
    p.end();    // Drawing finished

int sceneWidth = 800;
int sceneHeight = 600;
 
    ui->graphicsView->setFixedWidth(sceneWidth);
    ui->graphicsView->setFixedHeight(sceneHeight);
 
// mScene is a subclass of QGraphicsScene
    mScene->clear();
 
    if (!imageQt.isNull()) { // imageQt is QImage
 
        QPixmap originalImage = QPixmap::fromImage(imageQt);
        QPixmap scaledImage = QPixmap(originalImage.scaledToHeight( (int) mScene->height(), Qt::SmoothTransformation) );
 
        ui->graphicsView->setFixedWidth( scaledImage.width() );
        ui->graphicsView->setFixedHeight( scaledImage.height() );
 
        mScene->addPixmap(scaledImage);
        ui->graphicsView->setScene(mScene);
        ui->graphicsView->setSceneRect(scaledImage.rect());
        ui->graphicsView->fitInView(mScene->itemsBoundingRect() , Qt::KeepAspectRatio);
 
        ui->graphicsView->show();

#include <QtPrintSupport/QPrintDialog>
#include <QtPrintSupport/QPrinter>

void MainWindow::on_printButton_clicked()
{
    QPrinter printer;
    QPrintDialog printDialog(&printer, this);
    if (printDialog.exec() == QDialog::Accepted) {
       ui->textBox->print(&printer);
    }
}

void MainWindow::create_actions()
{
    readAction = new QAction(tr("Read new deck"), this);
    QObject::connect(readAction, SIGNAL(triggered()), this, SLOT(read_deck(const QString &fileName))); *** point of error
 
    refreshAction = new QAction(tr("Reload current deck"), this);
    QObject::connect(refreshAction, SIGNAL(triggered()), this, SLOT(refresh_deck()));
 
    //saveAction = new QAction(tr("Save results to file"), this);
   // QObject::connect(saveAction, SIGNAL(triggered()), this, SLOT(save_analysis()));
 
    analyzeAction = new QAction(tr("Perform deck analysis"), this);
    QObject::connect(analyzeAction, SIGNAL(triggered()), this, SLOT(analyze_deck()));
 
    QObject::connect(exitAction,SIGNAL(triggered()), qApp, SLOT(quit()));
 
    QObject::connect(btns_a[0], SIGNAL(QPushButton::clicked()), this, SLOT(m_b()));
    QObject::connect(btns_a[1], SIGNAL(QPushButton::clicked()), this, SLOT(m_g()));
 
    QObject::connect(btns_a[2], SIGNAL(QPushButton::clicked()), this, SLOT(b_m()));
    QObject::connect(btns_a[3], SIGNAL(QPushButton::clicked()), this, SLOT(b_g()));
 
    QObject::connect(btns_a[4], SIGNAL(QPushButton::clicked()), this, SLOT(g_m()));
    QObject::connect(btns_a[5], SIGNAL(QPushButton::clicked()), this, SLOT(g_b()));
}

void MainWindow::read_deck(const QString &fileName)
{
    list_sizes[0] = 0;
    list_sizes[1] = 0;
    list_sizes[2] = 0;
    int monster_count = 0;
    int spell_count = 0;
    int trap_count = 0;
    current_file = fileName;
    std::string file = fileName.toStdString();
    std::string current_card;
    QString current_card_q;
    std::ifstream infile("file.txt");
    int passed_main = 0;
    std::string line;
    while(std::getline(infile, line))
    {
        if(line == "#main")
        {
            passed_main++;
        }
        else if(line == "#extra")
        {
            passed_main++;
        }
        else if(passed_main == 1)
        {
            current_card = read_name(line);
            current_card_q = QString::fromUtf8(current_card.c_str());
            QListWidgetItem *new_item = new QListWidgetItem;
            new_item->setText((current_card_q));
            mn_lst->QListWidget::addItem(new_item);
            list_sizes[0]++;
            read_type(current_card);
        }
    }
}

class MainWindow : public QMainWindow
{
    Q_OBJECT
 
public:
    MainWindow();
 
    std::string read_name(const std::string idnum);
    int read_number(const std::string idnum);
    int read_type(const std::string idnum);
    QListWidgetItem *items_a[10];
   // void save_analysis(const std::string &fileName);
public slots:
    void analyze_deck();
    void read_deck(const QString &fileName);
    void refresh_deck();
 
    void m_b();
    void m_g();
 
    void b_m();
    void b_g();
 
    void g_m();
    void g_b();
.
.
.

QString text("σ²");

QString text("σ" + Qsup(x));