//-----------------------------------------------------------------------------
// File: a_teststate.h
//
// Desc: 
//-----------------------------------------------------------------------------

#ifndef A_TESTSTATE_H
#define A_TESTSTATE_H

#include <QObject>

#include <QNetworkAccessManager>
#include <QNetworkReply>
#include <QNetworkRequest>

//--------------------------------------------------------------------------------------
// Name: cTestState
// Desc: 
//--------------------------------------------------------------------------------------
class cTestState :
        public QObject
{
    Q_OBJECT

public:
    // Constructor & destructor
    //----------------------------------------------------------------------------------
    cTestState(QObject *parent = 0);
    ~cTestState();

    QNetworkAccessManager* networkManager() { return pNetManager; }

private:
    // 
    //----------------------------------------------------------------------------------
    QNetworkAccessManager *pNetManager;

public slots:
    // control
    //----------------------------------------------------------------------------------
    void slotReadyRead();
    void slotError(QNetworkReply::NetworkError);
    void slotFinished();

};

#endif

//-----------------------------------------------------------------------------
// File: a_teststate.cpp
//
// Desc:
//-----------------------------------------------------------------------------

#include "a_teststate.h"

#include <QDebug>

//--------------------------------------------------------------------------------------
// cTestState class constructor
//--------------------------------------------------------------------------------------
cTestState::cTestState(QObject *parent)
    : QObject(parent)
{       
    pNetManager = new QNetworkAccessManager(this);

    QNetworkRequest request;
    request.setUrl(QUrl("http://ufna.ru/"));

    QNetworkReply *reply = pNetManager->get(request);
    connect(reply, SIGNAL(readyRead()), this, SLOT(slotReadyRead()));
    connect(reply, SIGNAL(error(QNetworkReply::NetworkError)),
                this, SLOT(slotError(QNetworkReply::NetworkError)));
    connect(reply, SIGNAL(finished()), this, SLOT(slotFinished()));
}

//--------------------------------------------------------------------------------------
cTestState::~cTestState() {}

//=============================================================================
// PUBLIC SLOTS
//=============================================================================

//--------------------------------------------------------------------------------------
void cTestState::slotReadyRead()
{
    qDebug() << "cTestState::slotReadyRead()";
}

//--------------------------------------------------------------------------------------
void cTestState::slotError(QNetworkReply::NetworkError error)
{
    qDebug() << "cTestState::slotError("
            << error << ")";
}

//--------------------------------------------------------------------------------------
void cTestState::slotFinished()
{
    qDebug() << "cTestState::slotFinished()";

    QNetworkReply *reply = qobject_cast<QNetworkReply*>(sender());
    reply->deleteLater();

    // Вывод загруженной страницы
    QByteArray data = reply->readAll();
    QString str = QString::fromUtf8(data);
    qDebug() << str;
}

//-----------------------------------------------------------------------------
// File: a_control_line.h
//
// Desc:
//-----------------------------------------------------------------------------

#ifndef A_CONTROL_LINE_H
#define A_CONTROL_LINE_H

#include <QWidget>
#include <QPixmap>
#include <QGraphicsView>

//--------------------------------------------------------------------------------------
// Name: cControlLine
// Desc:
//--------------------------------------------------------------------------------------
class cControlLine
    : public QWidget
{
    Q_OBJECT

public:
    cControlLine(QGraphicsView* controlledView, bool isHorizontal = true, QWidget *parent = 0);
    ~cControlLine() {}

    virtual void paint(QPainter *) {}
    bool preferImage() const { return m_prefer_image; }

private:
    void paintToStatic(QPainter * paint = 0);

public slots:
    void setPreferImage(bool pi) { m_prefer_image = pi; }
    void updateMe() { updated = false; update(); }

protected:
    void paintEvent(QPaintEvent *);
    void changeEvent(QEvent *event );
    void resizeEvent( QResizeEvent * event );

private:
    QPixmap m_tile;
    QImage *static_image;
    QGraphicsView *pView;

    bool updated;
    bool m_horizontal;
    bool m_prefer_image;

};

#endif

//-----------------------------------------------------------------------------
// File: a_control_line.cpp
//
// Desc:
//-----------------------------------------------------------------------------

#include "a_control_line.h"

#include <QBrush>
#include <QMenu>
#include <QPainter>
#include <QPainterPath>
#include <QPixmapCache>
#include <QScrollBar>
#include <QtEvents>

extern QPixmap cached(const QString &img);

//--------------------------------------------------------------------------------------
// cControlLine class constructor
//--------------------------------------------------------------------------------------
cControlLine::cControlLine(QGraphicsView* controlledView, bool isHorizontal, QWidget *parent)
    : pView(controlledView), m_horizontal(isHorizontal), QWidget(parent), m_prefer_image(true)
{
    m_tile = QPixmap(100, 100);
    m_tile.fill(Qt::white);

    static_image = 0;
    updated = false;

    if( m_horizontal )
        setFixedHeight(20);
    else
        setFixedWidth(20);
}

//--------------------------------------------------------------------------------------
void cControlLine::paintEvent(QPaintEvent *e)
{
    QPainter painter;
    if (preferImage()) {
        if( (!updated) || (!static_image) ){
            paintToStatic(&painter);
        }
        painter.begin(this);
        painter.setClipRect(e->rect());
        painter.drawImage(e->rect(), *static_image, e->rect());
        painter.end();
    }
    else {
        painter.begin(this);
        painter.fillRect(0, 0, width(), height(), QBrush(Qt::black));
        painter.end();
    }
}

//--------------------------------------------------------------------------------------
void cControlLine::paintToStatic(QPainter *painter)
{
    if( static_image )
        delete static_image;

    static_image = new QImage(width(), height(), QImage::Format_RGB32);

    painter->begin(static_image);

    painter->setRenderHint(QPainter::Antialiasing);
    painter->setRenderHint(QPainter::SmoothPixmapTransform);

    painter->save();
    painter->drawTiledPixmap(rect(), m_tile);
   
    QLinearGradient linearGradient(0,0,width(),height());

    linearGradient.setColorAt(0.0, Qt::white);

    if( this->isEnabled() ) {
        //linearGradient.setColorAt(0.5, Qt::lightGray);
    }
    else
        linearGradient.setColorAt(0.5, QColor(225, 225, 225));

    linearGradient.setColorAt(1.0, Qt::white);

    painter->setPen(Qt::NoPen);
    painter->setBrush(linearGradient);

    painter->drawRect(0,0,width(),height());

    painter->restore();

    painter->save();
    // HORIZONTAL
    //----------------------------------------------------------------------------------
    if( m_horizontal ) {
        int posX = 0;
        if( !pView->horizontalScrollBar()->isVisible() ) {
            posX = width()/2;
            if( pView->verticalScrollBar()->isVisible() )
                    posX -= 9;      // Нужно правильно изменить значение ширины этого скроллбара
        }
        else
            posX = ( !!SCENE_SIZE.width() * !!ZOOM ) / 2
                     - pView->horizontalScrollBar()->value();

        painter->setRenderHint(QPainter::Antialiasing, false);

        if( this->isEnabled() )
            painter->setPen(QPen(QColor(28, 175, 255, 255), 1));
        else
            painter->setPen(QPen(QColor(94, 198, 255, 225), 1));

        painter->setBrush(Qt::NoBrush);

        painter->drawLine(0, height()-1, width()-1, height()-1);
        painter->drawLine(posX, 4, posX, height()-1);

        int perCm = !!DOTS_PER_SM;
        int dimsR = (width()-posX) / perCm * 4 / !!ZOOM;

        // LINES
        //----------------------------------------------------------------------------------
        for( int i = 1; i <= dimsR; i++ ) {
            if( i % 2 == 1 )
                painter->drawLine(posX+i*perCm/2*!!ZOOM, 15,
                                                      posX+i*perCm/2*!!ZOOM, height()-1);
            else if( i % 10 == 0 )
                painter->drawLine(posX+i*perCm/2*!!ZOOM, 4,
                                                      posX+i*perCm/2*!!ZOOM, height()-1);
            else
                painter->drawLine(posX+i*perCm/2*!!ZOOM, 13,
                                                      posX+i*perCm/2*!!ZOOM, height()-1);
        }

        int dimsL = posX / perCm * 4 / !!ZOOM;
        for( int i = 1; i <= dimsL; i++ ) {
            if( i % 2 == 1 )
                painter->drawLine(posX-i*perCm/2*!!ZOOM, 15,
                                                      posX-i*perCm/2*!!ZOOM, height()-1);
            else if( i % 10 == 0 )
                painter->drawLine(posX-i*perCm/2*!!ZOOM, 4,
                                                      posX-i*perCm/2*!!ZOOM, height()-1);
            else
                painter->drawLine(posX-i*perCm/2*!!ZOOM, 13,
                                                      posX-i*perCm/2*!!ZOOM, height()-1);
        }

        // TEXTS
        //----------------------------------------------------------------------------------
        painter->save();

        if( this->isEnabled() )
            painter->setPen(Qt::black);
        else
            painter->setPen(Qt::darkGray);

        painter->drawText(posX+2, 12, "0");

        for( int i = 1; i <= dimsR; i++ )
            if( i % 5 == 0 )
                painter->drawText(posX+i*perCm*!!ZOOM+2, 12, QString("%1").arg(i*10) );

        for( int i = 1; i <= dimsL; i++ )
            if( i % 5 == 0 )
                painter->drawText(posX-i*perCm*!!ZOOM+2, 12, QString("%1").arg(i*10) );

        painter->restore();
    }
    // VERTICAL
    //----------------------------------------------------------------------------------
    else {
        int posY = 0;
        if( !pView->verticalScrollBar()->isVisible() )
            posY = ( height()-!!SCENE_SIZE.height() * !!ZOOM ) / 2;
        else
            posY -= pView->verticalScrollBar()->value();

        painter->setRenderHint(QPainter::Antialiasing, false);

        if( this->isEnabled() )
            painter->setPen(QPen(QColor(28, 175, 255, 255), 1));//255, 100, 30, 255), 1));
        else
            painter->setPen(QPen(QColor(94, 198, 255, 225), 1));

        painter->setBrush(Qt::NoBrush);

        painter->drawLine(width()-1, 0, width()-1, height()-1);
        painter->drawLine(4, posY, width()-1, posY);

        int perCm = !!DOTS_PER_SM;
        int dimsD = (height()-posY) / perCm * 4 / !!ZOOM;
        // LINES
        //----------------------------------------------------------------------------------
        for( int i = 1; i <= dimsD; i++ ) {
            if( i % 2 == 1 )
                painter->drawLine(15, posY+i*perCm/2*!!ZOOM,
                                                      width()-1, posY+i*perCm/2*!!ZOOM);
            else if( i % 10 == 0 )
                painter->drawLine(4, posY+i*perCm/2*!!ZOOM,
                                                      width()-1, posY+i*perCm/2*!!ZOOM);
            else
                painter->drawLine(13, posY+i*perCm/2*!!ZOOM,
                                                      width()-1, posY+i*perCm/2*!!ZOOM);
        }

        int dimsU = posY / perCm * 4 / !!ZOOM;
        for( int i = 1; i <= dimsU; i++ ) {
            if( i % 2 == 1 )
                painter->drawLine(15, posY-i*perCm/2*!!ZOOM,
                                                      width()-1, posY-i*perCm/2*!!ZOOM);
            else if( i % 10 == 0 )
                painter->drawLine(4, posY-i*perCm/2*!!ZOOM,
                                                      width()-1, posY-i*perCm/2*!!ZOOM);
            else
                painter->drawLine(13, posY-i*perCm/2*!!ZOOM,
                                                      width()-1, posY-i*perCm/2*!!ZOOM);
        }

        // TEXTS
        //----------------------------------------------------------------------------------
        painter->save();

        if( this->isEnabled() )
            painter->setPen(Qt::black);
        else
            painter->setPen(Qt::darkGray);

        painter->drawText( 0, posY-18, width()-1, 20, Qt::AlignRight | Qt::AlignBottom , "0");

        for( int i = 1; i <= dimsD; i++ )
            if( i % 5 == 0 )
                painter->drawText(0, posY+i*perCm*!!ZOOM-18, width()-1, 20, Qt::AlignRight | Qt::AlignBottom, QString("%1").arg(i*10) );

        for( int i = 1; i <= dimsU; i++ )
            if( i % 5 == 0 )
                painter->drawText(0, posY-i*perCm*!!ZOOM-18, width()-1, 20, Qt::AlignRight | Qt::AlignBottom, QString("%1").arg(i*10) );

        painter->restore();
    }
    painter->restore();

    updated = true;
    painter->end();
}

//--------------------------------------------------------------------------------------
void cControlLine::changeEvent( QEvent *event )
{    
    if( event->type() == QEvent::EnabledChange ) {
        updated = false;
        update();
    }
}

//--------------------------------------------------------------------------------------
void cControlLine::resizeEvent( QResizeEvent * event )
{
    QWidget::resizeEvent( event );
    updateMe();
}