/************************************************************************

        Copyright (c) 2005-2012 by Juphoon System Software Co., Ltd.
                       All rights reserved.

     This software is confidential and proprietary to Juphoon System Software Co.,
     Ltd.. No part of this software may be reproduced, stored, transmitted,
     disclosed or used in any form or by any means other than as expressly
     provided by the written license agreement between JusTel and its
     licensee.

     THIS SOFTWARE IS PROVIDED BY JusTel "AS IS" AND ANY EXPRESS OR 
     IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     ARE DISCLAIMED. IN NO EVENT SHALL JusTel BE LIABLE FOR ANY DIRECT, 
     INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
     (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 
     OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
     STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 
     IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
     POSSIBILITY OF SUCH DAMAGE. 

                    Juphoon System Software Co., Ltd.

************************************************************************/
/*************************************************
  File name     : rbuttons.cpp
  Module        : UI Widget
  Author       	: vic.ren
  Created on    : 2012-10-09
  Description   :
    Custom buttons

  Modify History:
  1. Date:        Author:         Modification:
*************************************************/
/* include header files */
#include "JusCallPch.h"
#include <QApplication>

RMetroBtn::RMetroBtn(QWidget *parent) 
    : QPushButton(parent)
    , m_bIsHover(false)
    , m_nBoder(2)
    , m_colorForeground(RStyle::mainColor())
    , m_colorHover(RStyle::hoverBgColor())
    , m_colorPressed(RStyle::pressedBgColor())
{
    setFlat(true);
    setAutoFillBackground(true);
    setFocusPolicy(Qt::NoFocus);
    setCursor(Qt::PointingHandCursor);

    QFont font = this->font();
    font.setBold(true);
    setFont(font);
    resize(94, 30);

    updateStyle();
}

void RMetroBtn::paintEvent(QPaintEvent * event)
{
    if (!event) return;

    if (m_bIsHover)
    {
        QPainter painter(this);
        painter.fillRect(rect(), m_colorHover);
    }
    
    QPushButton::paintEvent(event);
}

void RMetroBtn::enterEvent(QEvent * event)
{
    if (!event) return;
    m_bIsHover = true;
    QPushButton::enterEvent(event);
}

void RMetroBtn::leaveEvent(QEvent * event)
{
    if (!event) return;
    m_bIsHover = false;
    QPushButton::leaveEvent(event);
}

void RMetroBtn::mouseMoveEvent(QMouseEvent *)
{
}

void RMetroBtn::setButtonNegtive()
{
    m_colorForeground = RStyle::secondaryColor();
    m_colorHover = RStyle::hoverBgColor();
    m_colorPressed = RStyle::pressedBgColor();
    
    updateStyle();
}

void RMetroBtn::setBoderWidth(int nBoder)
{
    m_nBoder = nBoder;
    updateStyle();
}

void RMetroBtn::updateStyle()
{
    QString qsStyleSheet;
    qsStyleSheet = "RMetroBtn {background: transparent;}"
        "RMetroBtn:enabled {border: " + QString::number(m_nBoder) + "px solid " 
        + m_colorForeground.name() + "; color: " 
        + m_colorForeground.name() + ";}"
    	"RMetroBtn:disabled {border: " + QString::number(m_nBoder) + "px solid" 
    	+ RStyle::disabledColor().name() + "; color:"
    	+ RStyle::disabledColor().name() + ";}"
    	"RMetroBtn:hover {color:"
    	+ m_colorForeground.name() + "; background: transparent;}"
    	"RMetroBtn:pressed {color: white; background: "
    	+ m_colorPressed.name() +"; border: 0px}"
    	"RMetroBtn::menu-indicator {border:none; background:transparent;}";
    setStyleSheet(qsStyleSheet);
}

RUnderLineBtn::RUnderLineBtn(QWidget *parent) : QPushButton(parent),
    m_colorFont(RStyle::missedColor())
{
    setFlat(true);
    setAutoFillBackground(true);
    setFocusPolicy(Qt::NoFocus);
    setCursor(Qt::PointingHandCursor);

    QFont font = this->font();
    font.setPixelSize(12);
    font.setUnderline(true);
    setFont(font);
    setFixedHeight(25);
    updateStyle();
}

void RUnderLineBtn::setText(const QString &qsText)
{
    QPushButton::setText(qsText);
    
    QFontMetrics fm(font());
    setFixedWidth(fm.width(qsText) + 20);
}

void RUnderLineBtn::updateStyle()
{
    QString qsStyleSheet;
    qsStyleSheet = "RUnderLineBtn {background: transparent;}"
        "RUnderLineBtn:enabled {border: 0px; color: " 
        + m_colorFont.name() + ";}"
    	"RUnderLineBtn::menu-indicator {border:none; background:transparent;}";
    setStyleSheet(qsStyleSheet);
}

void RUnderLineBtn::setFontColor(QColor color)
{
    m_colorFont = color;
    updateStyle();
}

RRightTopBtn::RRightTopBtn(QWidget *parent, const QString &qsImage) 
    : QPushButton(parent), m_bIsHover(false), m_qsImage(qsImage), 
    m_colorBgHover(RStyle::hoverBgColor()), 
    m_colorBgPressed(RStyle::pressedBgColor()), 
    m_colorNormal(RStyle::fourthColor()), m_colorBgNormal(Qt::transparent), 
    m_colorPressed(Qt::white)
{
    setFlat(true);
    setAutoFillBackground(true);
    setFocusPolicy(Qt::NoFocus);
    setCursor(Qt::PointingHandCursor);
    setStyleSheet("RRightTopBtn {background: transparent;}"
        "RRightTopBtn:hover {background: transparent;}"
        "RRightTopBtn:pressed {background: transparent;}"
        "RRightTopBtn::menu-indicator {border:none; background:transparent;}");
}

void RRightTopBtn::enterEvent(QEvent * event)
{
    if (!event) return;
    m_bIsHover = true;
    QPushButton::enterEvent(event);
}

void RRightTopBtn::leaveEvent(QEvent * event)
{
    if (!event) return;
    m_bIsHover = false;
    QPushButton::leaveEvent(event);
}

void RRightTopBtn::mouseMoveEvent(QMouseEvent *)
{
}

void RRightTopBtn::paintEvent(QPaintEvent * event)
{
    if (!event) return;
    QPushButton::paintEvent(event);
    
	if (m_qsImage.isEmpty())
		return;
    QColor color;
    if (isDown())
        color = m_colorPressed;
    else
        color = m_colorNormal;
    QImage image(m_qsImage);

    QPainter painter;
    QImage sourceImage(size(), QImage::Format_ARGB32_Premultiplied);
    painter.begin(&sourceImage);
    painter.setCompositionMode(QPainter::CompositionMode_Source);
    painter.fillRect(sourceImage.rect(), Qt::transparent);
    painter.setCompositionMode(QPainter::CompositionMode_SourceOver);
    painter.drawImage(0, 0, image);
    painter.end();
    
    QImage destinationImage(size(), QImage::Format_ARGB32_Premultiplied);
    painter.begin(&destinationImage);
    painter.setCompositionMode(QPainter::CompositionMode_Source);
    painter.fillRect(destinationImage.rect(), Qt::transparent);
    painter.setCompositionMode(QPainter::CompositionMode_SourceOver);
    painter.fillRect(destinationImage.rect(), color);
    painter.end();

    QImage resultImage(size(), QImage::Format_ARGB32_Premultiplied);    
    painter.begin(&resultImage);
    painter.setCompositionMode(QPainter::CompositionMode_Source);
    painter.fillRect(resultImage.rect(), Qt::transparent);
    painter.setCompositionMode(QPainter::CompositionMode_SourceOver);
    painter.drawImage(0, 0, destinationImage);
    painter.setCompositionMode(QPainter::CompositionMode_DestinationIn);
    painter.drawImage(0, 0, sourceImage);
    painter.end();
    
    painter.begin(this);
    if (m_bIsHover)
    {
        if (isDown())
            painter.fillRect(rect(), m_colorBgPressed);
        else
            painter.fillRect(rect(), m_colorBgHover);
    }
    painter.drawImage(0, 0, resultImage);
}

void RRightTopBtn::setBtnWhite(bool bWhite)
{
    if (bWhite)
    {
        m_colorPressed = Qt::white;
        m_colorNormal = Qt::white;
        m_colorBgPressed = RStyle::pressedBgColor();
        m_colorBgHover = RStyle::hoverBgColor();
    }
    else
    {
        m_colorPressed = Qt::white;
        m_colorNormal = RStyle::fourthColor();
        m_colorBgPressed = RStyle::pressedBgColor();
        m_colorBgHover = RStyle::hoverBgColor();
    }
}

RImageBtn::RImageBtn(QWidget *parent, const QString &qsBoder, 
    const QString &qsBg) : QPushButton(parent), m_bIsHover(false), 
    m_colorBgHover(RStyle::hoverBgColor()), m_qsBoder(qsBoder), m_qsBg(qsBg),
    m_colorBgPressed(RStyle::pressedBgColor()), m_colorNormal(RStyle::mainColor()), 
    m_colorBgNormal(Qt::transparent), m_colorPressed(Qt::white)
{
    setFlat(true);
    setAutoFillBackground(true);
    setFocusPolicy(Qt::NoFocus);
    setCursor(Qt::PointingHandCursor);
    setStyleSheet("RImageBtn {background: transparent;}"
        "RImageBtn::menu-indicator {border:none; background:transparent;}");
}

void RImageBtn::enterEvent(QEvent * event)
{
    if (!event) return;
    m_bIsHover = true;
    QPushButton::enterEvent(event);
}

void RImageBtn::leaveEvent(QEvent * event)
{
    if (!event) return;
    m_bIsHover = false;
    QPushButton::leaveEvent(event);
}

void RImageBtn::mouseMoveEvent(QMouseEvent *)
{
}

void RImageBtn::paintEvent(QPaintEvent *event)
{
    if (!event) return;
    QPushButton::paintEvent(event);
    
	if (m_qsImage.isEmpty())
		return;
    QImage image(m_qsImage);
    image = image.scaled(size(), Qt::KeepAspectRatio, 
        Qt::SmoothTransformation);
    
    QColor color;
    if (isDown() || isChecked())
        color = m_colorPressed;
    else if (!isEnabled())
        color = RStyle::disabledColor();
    else
        color = m_colorNormal;

    QPainter painter;
    QImage sourceImage(size(), QImage::Format_ARGB32_Premultiplied);
    painter.begin(&sourceImage);
    painter.setCompositionMode(QPainter::CompositionMode_Source);
    painter.fillRect(sourceImage.rect(), Qt::transparent);
    painter.setCompositionMode(QPainter::CompositionMode_SourceOver);
    painter.drawImage(0, 0, image);
    if (!isDown() && !isChecked())
    {
        QImage imageCircle(m_qsBoder);
        imageCircle = imageCircle.scaled(size(), Qt::KeepAspectRatio, 
            Qt::SmoothTransformation);
        painter.drawImage(0, 0, imageCircle);
    }
    painter.end();
    
    QImage destinationImage(size(), QImage::Format_ARGB32_Premultiplied);
    painter.begin(&destinationImage);
    painter.setCompositionMode(QPainter::CompositionMode_Source);
    painter.fillRect(destinationImage.rect(), Qt::transparent);
    painter.setCompositionMode(QPainter::CompositionMode_SourceOver);
    painter.fillRect(destinationImage.rect(), color);
    painter.end();

    QImage resultImage(size(), QImage::Format_ARGB32_Premultiplied);    
    painter.begin(&resultImage);
    painter.setCompositionMode(QPainter::CompositionMode_Source);
    painter.fillRect(resultImage.rect(), Qt::transparent);
    painter.setCompositionMode(QPainter::CompositionMode_SourceOver);
    painter.drawImage(0, 0, destinationImage);
    painter.setCompositionMode(QPainter::CompositionMode_DestinationIn);
    painter.drawImage(0, 0, sourceImage);
    painter.end();

    painter.begin(this);
    if (m_bIsHover || isChecked())
    {
        QPainter painterB;
        QImage backgroundImage(size(), QImage::Format_ARGB32_Premultiplied);
        painterB.begin(&backgroundImage);
        painterB.setCompositionMode(QPainter::CompositionMode_Source);
        painterB.fillRect(backgroundImage.rect(), Qt::transparent);
        painterB.setCompositionMode(QPainter::CompositionMode_SourceOver);
        QImage imageBg(m_qsBg);
        imageBg = imageBg.scaled(size(), Qt::KeepAspectRatio, 
            Qt::SmoothTransformation);
        painterB.drawImage(0, 0, imageBg);
        painterB.end();

        QColor colorBg;
        if (isDown() || isChecked())
            colorBg = m_colorBgPressed;
        else
            colorBg = m_colorBgHover;
        
        QImage destinationImageB(size(), QImage::Format_ARGB32_Premultiplied);
        painterB.begin(&destinationImageB);
        painterB.setCompositionMode(QPainter::CompositionMode_Source);
        painterB.fillRect(destinationImageB.rect(), Qt::transparent);
        painterB.setCompositionMode(QPainter::CompositionMode_SourceOver);
        painterB.fillRect(destinationImageB.rect(), colorBg);
        painterB.end();

        QImage resultImageB(size(), QImage::Format_ARGB32_Premultiplied);    
        painterB.begin(&resultImageB);
        painterB.setCompositionMode(QPainter::CompositionMode_Source);
        painterB.fillRect(resultImageB.rect(), Qt::transparent);
        painterB.setCompositionMode(QPainter::CompositionMode_SourceOver);
        painterB.drawImage(0, 0, destinationImageB);
        painterB.setCompositionMode(QPainter::CompositionMode_DestinationIn);
        painterB.drawImage(0, 0, backgroundImage);
        painterB.end();
        
        painter.drawImage(0, 0, resultImageB);
            
    }
    painter.drawImage(0, 0, resultImage);
}

void RImageBtn::setColor(QColor colorNormal, 
    QColor colorPressed)
{
    m_colorNormal = colorNormal;
    m_colorPressed = colorPressed;
}

void RImageBtn::setBackgroundColor(QColor colorBgNormal, 
    QColor colorBgHover, QColor colorBgPressed)
{
    m_colorBgNormal = colorBgNormal;
    m_colorBgHover = colorBgHover;
    m_colorBgPressed = colorBgPressed;
}

void RImageBtn::setBackgroud(const QString & qsImage)
{
	m_qsImage = qsImage;
}

QString RImageBtn::background()
{
    return m_qsImage;
}

RImageCheckBox::RImageCheckBox(QWidget *parent, 
    const QString &qsCheckImage, const QString &qsUnCheckedImage, bool bIsWhite) 
    : QPushButton(parent), m_qsCheckedImage(qsCheckImage), 
    m_qsUnCheckedImage(qsUnCheckedImage), m_bIsWhite(bIsWhite)
{
    setFocusPolicy(Qt::NoFocus);
    setCheckable(true);
    setCursor(Qt::PointingHandCursor);
    setStyleSheet("QCheckBox::indicator:unchecked{ border:none; width: 20px;"
        "height: 20px; background:transparent;}"
        "QCheckBox::indicator:checked{border:none; width: 20px; height: 20px;"
        "background:transparent;}");
}

void RImageCheckBox::enterEvent(QEvent * event)
{
    if (!event) return;
    QPushButton::enterEvent(event);
    emit signalHovered();
}

void RImageCheckBox::leaveEvent(QEvent * event)
{
    if (!event) return;
    QPushButton::leaveEvent(event);
}

void RImageCheckBox::mouseMoveEvent(QMouseEvent *)
{
}

void RImageCheckBox::paintEvent(QPaintEvent * event)
{
    if (!event) return;
    
	if (m_qsCheckedImage.isEmpty() || m_qsUnCheckedImage.isEmpty())
		return;
    QColor color;
    if (!isEnabled())
        color = RStyle::disabledColor();
    else if (isChecked())
        color = RStyle::mainColor();
    else
    {
        if (m_bIsWhite)
            color = Qt::white;
        else
            color = RStyle::fontColor();
    }
    
    QImage image;
    if (isChecked())
        image = QImage(m_qsCheckedImage);
    else
        image = QImage(m_qsUnCheckedImage);
    image = image.scaled(size(), Qt::KeepAspectRatio, 
        Qt::SmoothTransformation);
    
    QPainter painter;
    QImage sourceImage(size(), QImage::Format_ARGB32_Premultiplied);
    painter.begin(&sourceImage);
    painter.setCompositionMode(QPainter::CompositionMode_Source);
    painter.fillRect(sourceImage.rect(), Qt::transparent);
    painter.setCompositionMode(QPainter::CompositionMode_SourceOver);
    painter.drawImage(0, 0, image);
    painter.end();
    
    QImage destinationImage(size(), QImage::Format_ARGB32_Premultiplied);
    painter.begin(&destinationImage);
    painter.setCompositionMode(QPainter::CompositionMode_Source);
    painter.fillRect(destinationImage.rect(), Qt::transparent);
    painter.setCompositionMode(QPainter::CompositionMode_SourceOver);
    painter.fillRect(destinationImage.rect(), color);
    painter.end();

    QImage resultImage(size(), QImage::Format_ARGB32_Premultiplied);    
    painter.begin(&resultImage);
    painter.setCompositionMode(QPainter::CompositionMode_Source);
    painter.fillRect(resultImage.rect(), Qt::transparent);
    painter.setCompositionMode(QPainter::CompositionMode_SourceOver);
    painter.drawImage(0, 0, destinationImage);
    painter.setCompositionMode(QPainter::CompositionMode_DestinationIn);
    painter.drawImage(0, 0, sourceImage);
    painter.end();
    
    painter.begin(this);
    painter.drawImage(0, 0, resultImage);
}

RTabBtn::RTabBtn(QWidget *parent) : QRadioButton(parent), 
    m_colorUnChecked(RStyle::fontColor())
{
    setFocusPolicy(Qt::NoFocus);
    setCursor(Qt::PointingHandCursor);
    QFont font = QApplication::font();
    font.setFamily("Verdana");
    font.setPixelSize(24);
    font.setBold(false);
    setFont(font);
    resize(TABWIDTH - 1, TABHEIGHT + 30);
    updateStyle();
}

void RTabBtn::paintEvent(QPaintEvent * event)
{
    if (!event) return;
    QRadioButton::paintEvent(event);
    if (!isChecked())
        return;

    QPainter painter;
    QImage image(":/images/ic_btn_tab.png");
    QImage sourceImage(size(), QImage::Format_ARGB32_Premultiplied);
    painter.begin(&sourceImage);
    painter.setCompositionMode(QPainter::CompositionMode_Source);
    painter.fillRect(sourceImage.rect(), Qt::transparent);
    painter.setCompositionMode(QPainter::CompositionMode_SourceOver);
    painter.drawImage(0, 0, image);
    painter.end();
    
    QImage destinationImage(size(), QImage::Format_ARGB32_Premultiplied);
    painter.begin(&destinationImage);
    painter.setCompositionMode(QPainter::CompositionMode_Source);
    painter.fillRect(destinationImage.rect(), Qt::transparent);
    painter.setCompositionMode(QPainter::CompositionMode_SourceOver);
    painter.fillRect(destinationImage.rect(), RStyle::backgroundColor());
    painter.end();

    QImage resultImage(size(), QImage::Format_ARGB32_Premultiplied);    
    painter.begin(&resultImage);
    painter.setCompositionMode(QPainter::CompositionMode_Source);
    painter.fillRect(resultImage.rect(), Qt::transparent);
    painter.setCompositionMode(QPainter::CompositionMode_SourceOver);
    painter.drawImage(0, 0, destinationImage);
    painter.setCompositionMode(QPainter::CompositionMode_DestinationIn);
    painter.drawImage(0, 0, sourceImage);
    painter.end();
    
    painter.begin(this);
    
    painter.drawImage(0, 0, resultImage);
}

void RTabBtn::setNewCnt(bool bHasNew)
{
    if (bHasNew)
        m_colorUnChecked = Qt::white;
    else
        m_colorUnChecked = Qt::white;
    updateStyle();
}

void RTabBtn::updateStyle()
{
    QString qsStyleSheet;
    qsStyleSheet = "RTabBtn:unchecked {padding-left:30px; color: white; background: transparent;}"
        "RTabBtn:checked {padding-left:30px; color: white; background: " 
        + RStyle::pressedBgColor().name() + ";}"
        "RTabBtn::indicator {height: 0px; width: 0px}";
    setStyleSheet(qsStyleSheet);
}

RTagBtn::RTagBtn(QWidget *parent) : QRadioButton(parent)
{
    setFocusPolicy(Qt::NoFocus);
    setCursor(Qt::PointingHandCursor);
    QFont font = this->font();
    font.setPixelSize(14);
    setFont(font);
    updateStyle();
}

void RTagBtn::mousePressEvent(QMouseEvent * event)
{
    if (!event) return;
    if (isChecked()) return;
    QRadioButton::mousePressEvent(event);
}

void RTagBtn::updateStyle()
{
    QString qsStyleSheet;
    qsStyleSheet = "RTagBtn:unchecked { color: " 
        + RStyle::fontColor().name() + "}"
        "RTagBtn:checked { color: " + RStyle::mainColor().name() + "}"
        "RTagBtn::indicator {height: 0px; width: 0px}";
    setStyleSheet(qsStyleSheet);
}

RKeyBtn::RKeyBtn(QWidget *parent) : QPushButton(parent), m_bIsHover(false),
    m_colorForeground(Qt::white)
{
    setFlat(true);
    setAutoFillBackground(true);
    setFocusPolicy(Qt::NoFocus);
    setCursor(Qt::PointingHandCursor);
    m_pTimer = new QTimer(this);
	m_pTimer->setSingleShot(true);
	connect(m_pTimer, SIGNAL(timeout()), SLOT(slotLongClickTimeout()));
    connect(this, SIGNAL(pressed()), SLOT(slotBtnPressed()));
    connect(this, SIGNAL(released()), SLOT(slotBtnReleased()));
    setStyleSheet("RKeyBtn {background: transparent;}");
}

void RKeyBtn::enterEvent(QEvent * event)
{
    if (!event) return;
    QPushButton::enterEvent(event);
    m_bIsHover = true;
}

void RKeyBtn::leaveEvent(QEvent * event)
{
    if (!event) return;
    QPushButton::leaveEvent(event);
    m_bIsHover = false;
}

void RKeyBtn::paintEvent(QPaintEvent * event)
{
    if (!event) return;
    QPushButton::paintEvent(event);
    if (m_qsImage.isEmpty()) return;
    
    QColor colorBackground;
    QColor colorForeground;
    if (isDown())
    {
        colorForeground = m_colorForeground;
        colorBackground = RStyle::pressedBgColor();
    }
    else if (m_bIsHover)
    {
        colorForeground = m_colorForeground;
        colorBackground = RStyle::hoverBgColor();
    }
    else
    {
        colorForeground = m_colorForeground;
        colorBackground = RStyle::mainColor();
    }
    QImage image(m_qsImage);
    //image = image.scaled(size(), Qt::KeepAspectRatio, 
        //Qt::SmoothTransformation);
    
    QPainter painter;
    QImage sourceImage(size(), QImage::Format_ARGB32_Premultiplied);
    painter.begin(&sourceImage);
    painter.setCompositionMode(QPainter::CompositionMode_Source);
    painter.fillRect(sourceImage.rect(), Qt::transparent);
    painter.setCompositionMode(QPainter::CompositionMode_SourceOver);
    painter.drawImage((width() - image.width())/2, (height() - image.height())/2, image);
    painter.end();
    
    QImage destinationImage(size(), QImage::Format_ARGB32_Premultiplied);
    painter.begin(&destinationImage);
    painter.setCompositionMode(QPainter::CompositionMode_Source);
    painter.fillRect(destinationImage.rect(), Qt::transparent);
    painter.setCompositionMode(QPainter::CompositionMode_SourceOver);
    painter.fillRect(destinationImage.rect(), colorForeground);
    painter.end();

    QImage resultImage(size(), QImage::Format_ARGB32_Premultiplied);    
    painter.begin(&resultImage);
    painter.setCompositionMode(QPainter::CompositionMode_Source);
    painter.fillRect(resultImage.rect(), Qt::transparent);
    painter.setCompositionMode(QPainter::CompositionMode_SourceOver);
    painter.drawImage(0, 0, destinationImage);
    painter.setCompositionMode(QPainter::CompositionMode_DestinationIn);
    painter.drawImage(0, 0, sourceImage);
    painter.end();

    painter.begin(this);
    painter.fillRect(rect(), colorBackground);
    painter.drawImage(0, 0, resultImage);
}

void RKeyBtn::setForeground(QColor color)
{
    m_colorForeground = color;
}

void RKeyBtn::setBackgroud(const QString & qsImage)
{
	m_qsImage = qsImage;
	updateStyle();
}

void RKeyBtn::updateStyle()
{
    update();
}

void RKeyBtn::slotLongClickTimeout()
{
	emit signalLongClicked();
}

void RKeyBtn::slotBtnPressed()
{
    if (!m_pTimer->isActive())
        m_pTimer->start(1000);
}

void RKeyBtn::slotBtnReleased()
{
    if (m_pTimer->isActive())
        m_pTimer->stop();
}

RColorBtn::RColorBtn(QWidget *parent) : QPushButton(parent), 
    m_bIsHover(false)
{
    setFlat(true);
    setAutoFillBackground(true);
    setFocusPolicy(Qt::NoFocus);
    setCursor(Qt::PointingHandCursor);
    QFont font = this->font();
    font.setBold(true);
    setFont(font);
    resize(110, 30);
    updateStyle();
}

void RColorBtn::paintEvent(QPaintEvent * event)
{
    if (!event) return;

    if (!isEnabled())
    {
        QPainter painter(this);
        painter.fillRect(rect(), RStyle::mainColor());
        painter.setPen(QColor(255, 255, 255, 127));
        painter.drawText(rect(), Qt::AlignCenter, text());
        return;
    }

    QPushButton::paintEvent(event);
}

void RColorBtn::enterEvent(QEvent * event)
{
    if (!event) return;
    m_bIsHover = true;
    QPushButton::enterEvent(event);
}

void RColorBtn::leaveEvent(QEvent * event)
{
    if (!event) return;
    m_bIsHover = false;
    QPushButton::leaveEvent(event);
}

void RColorBtn::setColor(QColor colorNormal, QColor colorHover, 
    QColor colorPressed)
{
    m_colorNormal = colorNormal;
    m_colorHover = colorHover;
    m_colorPressed = colorPressed;
    updateStyle();
}

void RColorBtn::setBackgroundColor(QColor colorBgNormal, 
    QColor colorBgHover, QColor colorBgPressed)
{
    m_colorBgNormal = colorBgNormal;
    m_colorBgHover = colorBgHover;
    m_colorBgPressed = colorBgPressed;
    updateStyle();
}

void RColorBtn::updateStyle()
{
    QString qsStyleSheet;
    qsStyleSheet = "RColorBtn {border:none; background: " 
        + m_colorBgNormal.name() + "; color : " + m_colorNormal.name() + "}"
    	"RColorBtn:disabled {background: rgb(180, 180, 180); color: white;}"
    	"RColorBtn:hover {background: " + m_colorBgHover.name() + "; color : " + m_colorHover.name() + "}"
    	"RColorBtn:pressed {background: " + m_colorBgPressed.name() 
    	+ "; color:" + m_colorPressed.name() + ";}"
    	"RColorBtn::menu-indicator {border:none; background:transparent;}";
    setStyleSheet(qsStyleSheet);
}

RLabelBtn::RLabelBtn(QWidget *parent) : QPushButton(parent)
{
    setFlat(true);
    setPalette(QPalette(Qt::black));
    setAutoFillBackground(true);
    setFocusPolicy(Qt::NoFocus);
    setCursor(Qt::PointingHandCursor);
    setStyleSheet("RLabelBtn:disabled {color: transparent}");
}

void RLabelBtn::resize(int nWidth, int nHeight)
{
    QPushButton::resize(nWidth, nHeight);
    setIconSize(QSize(nWidth, nHeight));
}

void RLabelBtn::resize(QSize size)
{
    QPushButton::resize(size);
    setIconSize(size);
}
#if 0
RUnknownThumb::RUnknownThumb(QWidget *parent) : QPushButton(parent)
{
    setFlat(true);
    setPalette(QPalette(Qt::black));
    setAutoFillBackground(true);
    setFocusPolicy(Qt::NoFocus);
    setCursor(Qt::PointingHandCursor);
    setStyleSheet("RUnknownThumb:disabled {color: transparent}");
}

RUnknownThumb::~RUnknownThumb()
{
}

void RUnknownThumb::enterEvent(QEvent * event)
{
    if (!event) return;
    QPushButton::enterEvent(event);
    QPixmap pmp = QPixmap(RClient::absoluteThumbPath(UNKNOWN_THUMB));
    pmp = pmp.scaled(size(), Qt::KeepAspectRatio, Qt::SmoothTransformation);
    setIcon(QIcon(pmp));
}

void RUnknownThumb::leaveEvent(QEvent * event)
{
    if (!event) return;
    QPushButton::leaveEvent(event);
    QPixmap pmp = QPixmap(RClient::absoluteThumbPath(DEFAULT_THUMB));
    pmp = pmp.scaled(size(), Qt::KeepAspectRatio, Qt::SmoothTransformation);
    setIcon(QIcon(pmp));
}

void RUnknownThumb::resize(int nWidth, int nHeight)
{
    QPushButton::resize(nWidth, nHeight);
    setIconSize(QSize(nWidth, nHeight));
}

void RUnknownThumb::resize(QSize size)
{
    QPushButton::resize(size);
    setIconSize(size);
}
#endif
RAnimateBtn::RAnimateBtn(QWidget *parent) : QLabel(parent), 
    m_nCurrentIndex(0)
{
    InitAnimate();
}

void RAnimateBtn::paintEvent(QPaintEvent *event)
{
    if (!event) return;
	QLabel::paintEvent(event);
    QPainter painter(this);
    painter.setRenderHint(QPainter::HighQualityAntialiasing);
    painter.fillRect(rect(), RStyle::mainColor());
    painter.drawPixmap((width() - m_pmpDraw.width())/2, 
        (height() - m_pmpDraw.height())/2, m_pmpDraw.width(), m_pmpDraw.height(), 
        m_pmpDraw);
	painter.end();
}

void RAnimateBtn::showEvent(QShowEvent *event)
{
    if (!event) return;

    QLabel::showEvent(event);
    StartAnimate();
}

void RAnimateBtn::hideEvent(QHideEvent *event)
{
    if (!event) return;

    QLabel::hideEvent(event);
    StopAnimate();
}

void RAnimateBtn::InitAnimate()
{
  	QPixmap pmp = QPixmap(":/images/img_logining_1.png");
    m_VectPmp.append(pmp);
	
	pmp = QPixmap(":/images/img_logining_2.png");
    m_VectPmp.append(pmp);
	
	pmp = QPixmap(":/images/img_logining_3.png");
    m_VectPmp.append(pmp);
	
    connect(&m_timerUpdatePmp, SIGNAL(timeout()), SLOT(slotUpdateFrame()));

}

void RAnimateBtn::StartAnimate()
{
    m_timerUpdatePmp.start(200);
    slotUpdateFrame();
}

void RAnimateBtn::StopAnimate()
{
    m_timerUpdatePmp.stop();
    m_nCurrentIndex = 0;
}

void RAnimateBtn::slotUpdateFrame()
{
    if (m_nCurrentIndex == m_VectPmp.size())
    {
        m_nCurrentIndex = 0;
    }
    m_pmpDraw = m_VectPmp[m_nCurrentIndex];
    m_nCurrentIndex ++;
    update();
}