/*
* Copyright (C) 2019 Tianjin KYLIN Information Technology Co., Ltd.
*
* 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 3, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, see <http://www.gnu.org/licenses/&gt;.
*
*/
#include "clock.h"
#include "ui_clock.h"
#include <QMessageBox>
#include "fieldvalidutil.h"
#include <QThread>
#include "mediaplayerpool.h"
#include <QLibraryInfo>
#include "coreplayer/playcontroller.h"

using std::string;
using clockInterface::ReturnMsg;
using clockInterface::STATUS_CODE;


extern void qt_blurImage(QImage &blurImage, qreal radius, bool quality, int transposed);
const double PI=3.141592;


#define SWITCH_BTN_HIGHLIGHT_BACK_COLOR 61,107,229,255

const static int DIALOG_MOVE_WIDTH = 16;
const static int DIALOG_WIDTH = 340;

Clock::Clock(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::Clock)
{
    //异步初始化
//    MediaPlayerPool::getInstance();
    music = new QMediaPlayer();
    //右键菜单，选择”create new translation file“；项目中会添加一个以”.ts“为后缀的文件，例如”testtranslator_zh.ts“;
    //使用Qt Linguist打开该文件，就可以为指定的字符串设置译文；
    //在相应的“.ts”文件的右键菜单中点击“lupdate”项，才会更新。
    //翻译完成后，点击”文件“菜单下的”发布“项，就会生成.qm文件；
    QTranslator *translator = new QTranslator;
    // Get system locale
    //切换英文
    QLocale en_us = QLocale("en_US");
    QLocale current = QLocale();
    if (translator->load(current, QLatin1String("ukui-clock"), QLatin1String("_"), QLatin1String("/usr/share/ukui-clock/ukui31"))){
        QApplication::installTranslator(translator);
    }
    else{
        qDebug() << "cannot load translator ukui-clock_" << QLocale::system().name() << ".qm!";
    }
    //加载Qt翻译

    QTranslator * qtTranslator = new QTranslator;
    QString translationsPath = QLibraryInfo::location(QLibraryInfo::TranslationsPath);
    if(qtTranslator->load(QLocale(), QStringLiteral("qt"), QLatin1String("_"), translationsPath)){
        QApplication::installTranslator(qtTranslator);
    }else{
        qDebug()<<"dbq- cannot load qt"<< QLocale::system().name() << ".qm!";
    }

    //ui 构造代码
    ui->setupUi(this);
    currentTheme = new theme();
    //创建或打开数据库
    clock_sql::createConnection();
     //in order to use the same world in English
    this->setWindowTitle(tr(CLOCK_TITLE_NAME));
    ui->clockTitleLabel->setText(tr(CLOCK_TITLE_NAME));

    //创建用户手册dbus客户端
    createUserGuideDebusClient();
    mousePressed = 0;
    //设置数据库
    model_setup = clock_sql::getSetupTable(this);
    model_setup->select();
    //创建数据库
    m_bellQueryModel = clock_sql::getBellTable(this);
    bellIni();
    //闹钟按钮图片初始化
    buttonImageInit();
    //倒计时 运行光圈页初始化
    CountdownInit();
    //秒表初始化
    stopwatchInit();
    //闹钟页初始化
    clockInit();
    setupInit();
    this->setFixedSize(390,580);
    /*实现鼠标左键滑动效果
    *Realize the sliding effect of left mouse button*/
    ui->alarmListWidget -> setFrameShape(QListWidget::NoFrame);
    ui->timeListWidget -> setFrameShape(QListWidget::NoFrame);
    QScroller::grabGesture(ui->alarmListWidget,QScroller::LeftMouseButtonGesture); /*设置鼠标左键拖动  Set left mouse drag*/
    QScroller::grabGesture(ui->timeListWidget,QScroller::LeftMouseButtonGesture); /*设置鼠标左键拖动  Set left mouse drag*/
    ui->alarmListWidget -> setVerticalScrollMode(QAbstractItemView::ScrollPerPixel);  /*设置像素级滑动    Set pixel level slide*/
    ui->timeListWidget -> setVerticalScrollMode(QAbstractItemView::ScrollPerPixel); /*设置像素级滑动  Set pixel level slide*/
    ui->alarmListWidget->setProperty("contextMenuPolicy", Qt::CustomContextMenu);    /*重要：设置QListWidget的contextMenuPolicy属性，不然不能显示右键菜单*/
    ui->alarmListWidget ->setGridSize(QSize(340, 108+15));
    ui->timeListWidget ->setGridSize(QSize(340, 58+10));
    //主屏信息
    primaryManager = new PrimaryManager();
    //闹钟居中
    //move((m_pSreenInfo->m_screenWidth - this->width() + m_pSreenInfo->m_nScreen_x )/2, (m_pSreenInfo->m_screenHeight - this->height())/2);
    utils = new Utils();
    utils->centerToScreen(this);
    ui->switchClock->setFixedSize(40,40);
    navigationBtnStyle(ui->switchClock);
    ui->switchClock->setToolTip(tr(CLOCK_TITLE_NAME));
    ui->switchCountdown->setFixedSize(40,40);
    navigationBtnStyle(ui->switchCountdown);
    ui->switchCountdown->setToolTip(tr("Count down"));

    ui->switchStopwatch->setFixedSize(40,40);
    navigationBtnStyle(ui->switchStopwatch);
    ui->switchStopwatch->setToolTip(tr("Watch"));

    connect(ui->switchCountdown, SIGNAL(clicked()), this, SLOT( CountdownPageSwitch ()));
    connect(ui->switchClock, SIGNAL(clicked()), this, SLOT( AlarmPageSwitch ()));
    connect(ui->switchStopwatch, SIGNAL(clicked()), this, SLOT( StopwatchPageSwitch ()));

     AlarmPageSwitch ();/*初始显示闹钟界面
                               Initial display alarm interface*/

    close_or_hide_page = new close_or_hide(this);

    shadow->installEventFilter(this);
    ui->alarmListWidget->installEventFilter(this);
    //蓝色
    QPalette palette = ui->suspendCountdownBtn->palette();
    QColor ColorPlaceholderText(248,163,76,255);
    QBrush brush3;
    brush3.setColor(ColorPlaceholderText);
    //主题框架1.0.6-5kylin2
    palette.setColor(QPalette::Highlight,QColor(248,163,76,255));
    palette.setColor(QPalette::Button,QColor(248,163,76,255));
    palette.setBrush(QPalette::ButtonText, QBrush(Qt::white));
    ui->suspendCountdownBtn->setPalette(palette);
    startCountSingle->setEnabled(false);
    ui->countdownStackedW->setCurrentIndex(0);
    drawNoAlarmPrompt();//绘制无闹钟提示图标
    onMin_5btnClicked();//倒计时初始时间默认五分钟
    //字体设置
    QString selfFont = Utils::loadFontFamilyFromTTF();
    QFont f(selfFont);
    f.setPixelSize(38);
    ui->timeShowBig->setFont(f);
    //监听主题
    settingsStyle();
    //主题框架1.0.6-5kylin2
    //配置重要按钮

    //添加
    ui->addAlarmBtn->setProperty("isImportant", true);
    //新建闹钟保存
    ui->saveBtnOnEditAlarm->setProperty("isImportant", true);
    //倒计时 滚轮页设置页，开始
    startCountSingle->setProperty("isImportant", true);
    //倒计时，运行页，开始结束
//    ui->count_stat->setProperty("isImportant", true);
    //秒表 开始结束
    ui->startStopwatch->setProperty("isImportant", true);
//    倒计时 暂停继续
    ui->suspendCountdownBtn->setProperty("isImportant", true);
    //倒计时 开始结束
    ui->startCountdownBtn->setProperty("useButtonPalette", true);
    //闹钟编辑 取消
    ui->cancelbtnOnEditAlarm->setProperty("useButtonPalette", true);
    //秒表 计次
    ui->ringBtn->setProperty("useButtonPalette", true);
    //迷你窗口
    updateTinyBtn();
    //倒计时上的小闹钟
//    ui->countdownAlarmIcon->setProperty("useButtonPalette", true);




}

Clock::~Clock()
{
    delete timer;
    delete timer_2;
    delete countdown_timer;
    delete model;
    delete model_setup;
    delete dialog_repeat;
    delete dialog_music;
    delete count_music_sellect;
    delete ui->countdownRunPage;
    delete ui;
    delete utils;
    delete primaryManager;
    delete alarmNoticeDialog;
    delete countdownNoticeDialog;
    delete tinycountdownDia;
    delete currentTheme;
}
//重写关闭事件
void Clock::closeEvent(QCloseEvent *event)
{
        closeHandel();

        if(close_or_hide_page->close_flag==1){
            event->ignore();
            setWindowState(Qt::WindowMinimized);
            close_or_hide_page->close_flag = 0;
        }else if(close_or_hide_page->close_flag==2){
            event->accept();
            exit(0);
        }else{
            event->ignore();
        }
}
void Clock::closeHandel()
{
    QPointF position = this->pos();
    XAtomHelper::setStandardWindowHint(close_or_hide_page->winId());
    close_or_hide_page->move(position.x()+20,position.y()+200);
    close_or_hide_page->exec();
}

void Clock::enableTrayIcon()
{
    if (m_trayIcon) {
        return;
    }
    QAction *quitAction = new QAction(tr("&Quit"), this);
    connect(quitAction, &QAction::triggered, qApp,
            &QCoreApplication::quit);
    QMenu *trayIconMenu = new QMenu();
    trayIconMenu->addAction(quitAction);
    m_trayIcon = new QSystemTrayIcon();
    m_trayIcon->setToolTip(tr("Alarm"));
    m_trayIcon->setContextMenu(trayIconMenu);
    QIcon trayicon = QIcon::fromTheme("kylin-alarm-clock");
    m_trayIcon->setIcon(trayicon);
    connect(m_trayIcon, &QSystemTrayIcon::activated, this, [=](QSystemTrayIcon::ActivationReason r){
        if (r == QSystemTrayIcon::Trigger) {
            this->show();
        }
    });
    m_trayIcon->show();
}
void Clock::disableTrayIcon()
{
#if defined(Q_OS_LINUX) || defined(Q_OS_UNIX)
    if (m_trayIcon) {
        m_trayIcon->deleteLater();
    }
#endif
}
/*
*监听主题
*/
void Clock::settingsStyle()
{

    GsettingSubject * subject = GsettingSubject::getInstance();
    connect(subject,&GsettingSubject::blackStyle, this,[=](){
        this->blackStyle();
    });
    connect(subject,&GsettingSubject::whiteStyle, this,[=](){
        this->whiteStyle();
    });
    connect(subject,&GsettingSubject::iconChnaged, this,[=](){
        ui->titleIcon->setPixmap(QIcon::fromTheme("kylin-alarm-clock").pixmap(24,24));
    });


    connect(subject,&GsettingSubject::timeZoneChanged, this,[=](QString timeZone){
        this->m_timeZone =timeZone;
    });

    connect(subject,&GsettingSubject::fontChanged, this,[=](int size){
        this->CURRENT_FONT_SIZE=size;
        this->updateFront(size);
    });

    subject->iniWidgetStyle();
    subject->iniFontSize();
    subject->iniTimeZone();

}


/**
 * @brief 闹钟按钮图片初始化 Alarm button picture initialization
 */
void Clock::buttonImageInit()
{
    pixmap4 = QPixmap(":/image/icon-4-16x16.png");
    //“重复”下拉框对号勾选
    repeat_on_Pixmap = QPixmap(":/image/object-select-symbolic.png");
    repeat_off_Pixmap = QPixmap("");
    //启用主题框架不需要代码
//    this->setWindowIcon(QIcon::fromTheme("kylin-alarm-clock",QIcon(":/image/kylin-alarm-clock.svg")));
    //左上角闹钟图标
    ui->titleIcon->setPixmap(QIcon::fromTheme("kylin-alarm-clock").pixmap(24,24));
    //倒计时上的小闹钟图标
    ui->countdownAlarmIcon->setPixmap(pixmap4);
    ui->countdownAlarmIcon->setVisible(true);
    ui->countdownAlarmIcon->setFocusPolicy(Qt::NoFocus);

    muteBtnStyle();
    minBtnStyle();
    menuBtnStyle();
    closeBtnStyle();




    //提醒铃声 倒计时设置页
    musicSelectOnCountdownSet = new Btn_new(0, tr("  bell"),Btn_new::SELECT_BTN, ui->countdownSetPage);
    //提醒铃声 倒计时页面运行页
    musicSelectOnCountdownRun = new Btn_new( 0,tr("  bell"),Btn_new::SELECT_BTN, ui->countdownRunPage);
    int moveHeight = 310;
    int moveWidth = DIALOG_MOVE_WIDTH;
    updateCountdownSelectBtnStyle(musicSelectOnCountdownSet,moveWidth,moveHeight);
    updateCountdownSelectBtnStyle(musicSelectOnCountdownRun,moveWidth,moveHeight);
    //闹钟名称 新建闹钟
    clockEditOnClockNew = new Btn_new( 0,tr("  name"),Btn_new::LINE_EDIT, ui->editAlarmPage);
    updateCountdownSelectBtnStyle(clockEditOnClockNew,moveWidth,180);
    //重复 新建闹钟
    int selectHeight = 240;
    int selectGap = 60;
    repeatSelectOnClockNew = new Btn_new( 0,tr("  repeat"),Btn_new::SELECT_BTN, ui->addAlarmPage);
    updateClockSelectBtnStyle(repeatSelectOnClockNew,selectHeight);
    selectHeight+=selectGap;
    //提醒铃声 新建闹钟
    musicSelectOnClockNew = new Btn_new( 0,tr("  bell"),Btn_new::SELECT_BTN, ui->addAlarmPage);
    updateClockSelectBtnStyle(musicSelectOnClockNew,selectHeight);
    selectHeight+=selectGap;
    //稍后提醒 新建闹钟
    remindSelectOnClockNew = new Btn_new( 0,tr("  remind"),Btn_new::SELECT_BTN, ui->addAlarmPage);
    updateClockSelectBtnStyle(remindSelectOnClockNew,selectHeight);

}
/*
*倒计时页初始化
*Countdown page initialization
*/
void Clock::CountdownInit()
{
    /*初始化定时器
     Initialize timer*/
    countdown_timer = new QTimer();
    /*信号和槽
     Signals and slots*/
    //倒计时开始-结束
    connect(ui->startCountdownBtn, SIGNAL(clicked()), this, SLOT(startbtnCountdown()) );
//    connect(tinycountdownDia, SIGNAL(finishClick()), this, SLOT(tinyCountdownFinish()) );
    //倒计时执行
    connect(countdown_timer, SIGNAL(timeout()), this, SLOT(statCountdownMsec()));
    /*设置定时器每个多少毫秒发送一个timeout()信号
     Set the timer to send a timeout () signal every milliseconds*/
    countdown_timer->setInterval(10);
    countdown_hour = 0;
    countdown_minute = 0;
    countdown_second = 9;
    countdown_pushflag = 0;

    countdown_isStarted = 0;
    countdown_isStarted_2 = 0;
    ui->countdownRunPage->countdownRunRoundBar->setRange(0,COUNTDOWN_TIME);
    /*初始化倒计时进度圈
     Initialize countdown progress circle*/
    ui->countdownRunPage->countdownRunRoundBar->setValue(COUNTDOWN_TIME);
    //父的顶部
    ui->startCountdownBtn->raise();
    //初始化倒计时弹窗
    countdownNoticeDialog = new Natice_alarm(60,-1);
    countdownNoticeDialog->timer->stop();
    countdownNoticeDialog->timer_xumhuan->stop();
    countdownNoticeDialog->m_musicPlayer->stop();
    //小型窗体
    if(tinycountdownDia==nullptr){
        tinycountdownDia = new tinyCountdown();
    }
    //绑定主窗体操作
    connect(tinycountdownDia,SIGNAL(mainWindowClick()),this,SLOT(activeWindow()));
    //结束
    connect(tinycountdownDia, &tinyCountdown::finishClick, this, [=](){
        tinyCountdownFinish();
    } );
    //暂停
    connect(tinycountdownDia, &tinyCountdown::suspendClick, this, [=](int onRun){
        countdown_isStarted_2 = onRun;
        onCountPushClicked();
    } );
}

/*
*秒表页初始化
*Stopwatch page initialization
*/
void Clock::stopwatchInit()
{
    /*初始化定时器
     Initialize timer*/
    timer = new QTimer();
    /*信号和槽
     Signals and slots*/
    connect(timer, SIGNAL(timeout()), this, SLOT(CountDown()));
    /*设置定时器每个多少毫秒发送一个timeout()信号
     Set the timer to send a timeout () signal every milliseconds*/
    timer->setInterval(10);
    //显示时间大
    ui->timeShowBig->setText("00:00.00");
    //显示时间小
    ui->timeShowSmall->setText("00:00.00");
    isStarted = 0;
    hour=0;
    minute=0;
    second=0;
    pushflag=0 ;
    /*时间间隔定时器
     Time interval timer*/
    timer_2 = new QTimer();
    //秒表的 每次计次后清零重新计算的时间
    connect(timer_2, SIGNAL(timeout()), this, SLOT(stopwatchJg()));
    timer_2->setInterval(10);
    stopwatch_hour = 0;
    stopwatch_minute = 0;
    stopwatch_second = 0;
    stopwatch_isStarted = 0;

    ui->timeShowBig->move(90,125);
    ui->timeShowSmall->move(90,190);
    ui->timeListWidget->move(25,230);
    ui->startStopwatch->raise();
    ui->ringBtn->raise();
    //计次间隔时间最长，最短
    timeSepOrderIndex = new QMap<long,int>();
    hisLongShortIndex = new QList<int>();
}

/*
*闹钟页初始化
*Alarm page initialization
*/
void Clock::clockInit()
{
//    alarmNoticeDialog = new Natice_alarm(60,-1);
    QTimer *timer_clock = new QTimer(this);
    //动态监控闹钟与本地时间
    connect(timer_clock, SIGNAL(timeout()), this, SLOT(timerUpdate()) );/*动态获取时间
                                                                         Dynamic acquisition time*/
    timer_clock->start(1000);
    connect( ui->addAlarmBtn, SIGNAL(clicked()), this, SLOT(setAlarmClock()) );/*添加闹钟
                                                                                  Add alarm*/
    ui->timeShowBig->setAlignment(Qt::AlignHCenter);
    ui->timeShowSmall->setAlignment(Qt::AlignHCenter);
    ui->remainTime->setAlignment(Qt::AlignHCenter);
    //单个表读取和写入数据库记录的高级接口
    model = new QSqlTableModel(this);
    model->setTable("clock");
    model->setEditStrategy(QSqlTableModel::OnManualSubmit);
    model->select(); /*选取整个表的所有行
                      Select all rows of the entire table*/
    /*初始化一个包含两个Action(Delete和ClearAll)的菜单*/
    popMenu_In_ListWidget_ = new QMenu(this);
    action_Delete_In_ListWidget_ = new QAction(tr("Delete"), this);
    action_Clear_In_ListWidget_ = new QAction(tr("ClearAll"), this);
    action_edit_In_ListWidget_ = new QAction(tr("edit"), this);
    popMenu_In_ListWidget_->addAction(action_edit_In_ListWidget_);
    popMenu_In_ListWidget_->addAction(action_Delete_In_ListWidget_);

    connect(this->action_Delete_In_ListWidget_, SIGNAL(triggered()), this, SLOT(deleteAlarm()));
    //编辑
    connect(this->action_edit_In_ListWidget_, SIGNAL(triggered()), this, SLOT(listdoubleClickslot()));
    connect(ui->alarmListWidget,SIGNAL(itemDoubleClicked(QListWidgetItem*)),this,SLOT(listdoubleClickslot()));
    connect(ui->saveBtnOnEditAlarm, SIGNAL(clicked()), this, SLOT(setAlarmSave()) );
    connect(ui->startStopwatch, SIGNAL(clicked()), this, SLOT(onPushbuttonStartClicked()));
    connect(ui->ringBtn, SIGNAL(clicked()), this, SLOT(onPushbuttonRingClicked()));
    connect(ui->cancelbtnOnEditAlarm, SIGNAL(clicked()), this, SLOT(alarmCancelSave()) );
    //与下拉框绑定
    connect(repeatSelectOnClockNew, SIGNAL(clicked()), this, SLOT(alarmRepeat()) );
    connect(musicSelectOnClockNew, SIGNAL(clicked()), this, SLOT(selectAlarmMusic()) );
    connect(remindSelectOnClockNew, SIGNAL(clicked()), this, SLOT(selectRemindLate()) );
    connect(musicSelectOnCountdownSet, SIGNAL(clicked()), this, SLOT(countdownMusicSellect()));
    connect(musicSelectOnCountdownRun, SIGNAL(clicked()), this, SLOT(countdownMusicSellect()));


    //暂停继续按钮
    connect(ui->suspendCountdownBtn, SIGNAL(clicked()), this, SLOT(onCountPushClicked()));


    connect(ui->tinyWindowBtn, SIGNAL(clicked()), this, SLOT(onTinyClicked()));
    /*绑定右键显示菜单：在单击右键之后会执行槽函数， 槽函数中负责弹出右键菜单*/
    connect(ui->alarmListWidget, SIGNAL(customContextMenuRequested(const QPoint &)),
        this, SLOT(onCustomContextMenuRequested(const QPoint &)));

    //初始化SystemTimeFlag，不然初始值可能不为0或者1
    iniSystemTimeFlag();
    //绘制闹钟列表
    updateAlarmClock();

}

void Clock::keyPressEvent(QKeyEvent *event)
{
    if(16777264==event->key()){
        callUserGuide();
    }

}

void Clock::callUserGuide()
{
    if(userGuideInterface!=nullptr){
        userGuideInterface->call(QString("showGuide"), "ukui-clock");
    }
}



/*
* 事件处理函数
*/
void Clock::onCustomContextMenuRequested(const QPoint &pos)
{
    /*弹出右键菜单*/
    if(ui->alarmListWidget->itemAt(pos)!=NULL){
        //右键弹窗与闹钟绑定
        popMenu_In_ListWidget_->exec(QCursor::pos());
    }
}

/*
* 默认初始设置
* Default initial settings
*/
void Clock::setupInit()
{
    countdownSetStartTime();/*倒计时初始化数字转盘
                               Countdown initialization digital turntable*/

    alarmSetStartTime();/*闹钟初始化数字转盘
                            Alarm initialization digital turntable*/
    modelSetupSet(); /*设置数据库初始化
                        Set database initialization*/
    textTimerupdate();
    clockEditOnClockNew->clockNameLineEdit->setMaxLength(16);/*限制闹钟名字长度为9个字符*/

    /*设置输入框无视空格,过滤特殊字符*/
    QRegExp rx = QRegExp("^[\u4E00-\u9FA5A-Za-z0-9_]+$");
    QRegExpValidator* validator = new QRegExpValidator(rx);
    clockEditOnClockNew->clockNameLineEdit->setValidator(validator);

    //倒计时的铃声
    QString bellId = model_setup->index(0, 1).data().toString();
    QString bellName = m_selectBtnUtil->getBellNameById(bellId);
    musicSelectOnCountdownSet->textLabel->setText(bellName);
    musicSelectOnCountdownRun->textLabel->setText(bellName);

    //重复下拉框
    int moreWidth = 20;
    dialog_repeat = new  set_alarm_repeat_Dialog(DIALOG_WIDTH+moreWidth,290,9,ui->editAlarmPage);dialog_repeat->hide();
    //铃声下拉框
    int bellSize = m_selectBtnUtil->getBellListSize();
    dialog_music = new  set_alarm_repeat_Dialog(DIALOG_WIDTH+moreWidth,172,bellSize,ui->editAlarmPage);dialog_music->hide();
    //稍后提醒下拉框
    dialog_remind_late = new  set_alarm_repeat_Dialog(DIALOG_WIDTH+moreWidth,258,6,ui->editAlarmPage);dialog_remind_late->hide();
    //倒计时铃声选择
    count_music_sellect = new  set_alarm_repeat_Dialog(DIALOG_WIDTH+moreWidth,172,bellSize,ui->countdownPage);count_music_sellect->hide();

    setMusicSelectDialogListById(bellId,count_music_sellect->listWidget);
  //存储重复选择的星期，默认清零
    for (int i = 0; i < 9; i++) {
        repeat_day[i] = 0;
    }


    connect(dialog_repeat->listWidget,SIGNAL(itemClicked(QListWidgetItem*)),this,SLOT(repeatListclickslot()));
    connect(dialog_music->listWidget,SIGNAL(itemClicked(QListWidgetItem*)),this,SLOT(musicListclickslot()));
    connect(dialog_remind_late->listWidget,SIGNAL(itemClicked(QListWidgetItem*)),this,SLOT(remindLateListClickSlot()));
    connect(count_music_sellect->listWidget,SIGNAL(itemClicked(QListWidgetItem*)),this,SLOT(countMusicListclickslot()));
    connect(dialog_repeat,&set_alarm_repeat_Dialog::dialogClose,this,[=](){
        repeatSelectOnClockNew->updateIconLabel(0);
    });
    connect(dialog_music,&set_alarm_repeat_Dialog::dialogClose,this,[=](){
        musicSelectOnClockNew->updateIconLabel(0);
    });
    connect(dialog_remind_late,&set_alarm_repeat_Dialog::dialogClose,this,[=](){
        remindSelectOnClockNew->updateIconLabel(0);
    });
    connect(count_music_sellect,&set_alarm_repeat_Dialog::dialogClose,this,[=](){
        musicSelectOnCountdownSet->updateIconLabel(0);
        musicSelectOnCountdownRun->updateIconLabel(0);
    });
    indexWeekdayMap = new QHash<int,QString>();
    indexWeekdayMap->insert(0,":monday");
    indexWeekdayMap->insert(1,":tuesday");
    indexWeekdayMap->insert(2,":wednesday");
    indexWeekdayMap->insert(3,":thusday");
    indexWeekdayMap->insert(4,":friday");
    indexWeekdayMap->insert(5,":saturday");
    indexWeekdayMap->insert(6,":sunday");
}

void Clock::bellIni()
{
    m_selectBtnUtil = new SelectBtnUtil();
    int rowNum = m_bellQueryModel->rowCount();
    if (rowNum < 1) {
        QList<QString> * defaultBell = SelectBtnUtil::getDefaultBellList();
        QList<QString> * defaultBellTr = SelectBtnUtil::getDefaultBellTrList();
        for (int i=0;i<defaultBell->size();i++) {
            m_bellQueryModel->insertRow(i);
            QString temp = defaultBell->at(i);
            QString tempTr = defaultBellTr->at(i);
            m_bellQueryModel->setData(m_bellQueryModel->index(i, 0), Utils::getRandomId());
            m_bellQueryModel->setData(m_bellQueryModel->index(i, 1), tempTr);
            m_bellQueryModel->setData(m_bellQueryModel->index(i, 2), temp);
            QString path = DEFAULT_BELL_SAVE_PATH;
            path = path.append(temp).append(".wav");
            m_bellQueryModel->setData(m_bellQueryModel->index(i, 3), path);
            QDateTime time = QDateTime::currentDateTime();   //获取当前时间
            qint64 timeT = time.toMSecsSinceEpoch();
            m_bellQueryModel->setData(m_bellQueryModel->index(i, 4), timeT);
            m_bellQueryModel->setData(m_bellQueryModel->index(i, 5), 0);
            //排序，暂停1ms
            QThread::msleep(1);
        }
        delete defaultBell;
        m_bellQueryModel->submitAll();
        m_selectBtnUtil->refreshBellData();
    }
}

/*
 * 时间间隔执行
 * Interval calculation execution callback
 */
void Clock::stopwatchJg()
{
    if (stopwatch_hour < 10) {
        QString hours_str = QString::number(stopwatch_hour);
        stopwatch_jg_h = "0"+hours_str;
    } else {
        stopwatch_jg_h = QString::number(stopwatch_hour);
    }

    if (stopwatch_minute < 10) {
        QString minute_str = QString::number(stopwatch_minute);
        stopwatch_jg_m = "0"+minute_str;
    }else {
        stopwatch_jg_m = QString::number(stopwatch_minute);
    }

    if (stopwatch_second < 10) {
        QString second_str = QString::number(stopwatch_second);
        stopwatch_jg_s = "0"+second_str;
    } else {
        stopwatch_jg_s = QString::number(stopwatch_second);
    }

    ui->timeShowSmall->setText(stopwatch_jg_h+TIME_SEPARATOR+stopwatch_jg_m+"."+stopwatch_jg_s);

    stopwatch_second++;
    if (stopwatch_second==100) {
        stopwatch_minute++; stopwatch_second=0;}
    if (stopwatch_minute==60) {
        stopwatch_hour++; stopwatch_minute=0;}
}

/*
 * 秒表执行
 * Stopwatch execution
 */
void Clock::CountDown()
{
    if (hour < 10) {
        QString hours_str = QString::number(hour);
        stopwatch_h = "0"+hours_str;
    } else {
        stopwatch_h = QString::number(hour);
    }

    if (minute < 10) {
        QString minute_str = QString::number(minute);
        stopwatch_m = "0"+minute_str;
    } else {
        stopwatch_m = QString::number(minute);
    }

    if (second < 10) {
        QString second_str = QString::number(second);
        stopwatch_s = "0"+second_str;
    } else {
        stopwatch_s = QString::number(second);
    }
    ui->timeShowBig->setText(stopwatch_h+TIME_SEPARATOR+stopwatch_m+"."+stopwatch_s);
    QString selfFont = Utils::loadFontFamilyFromTTF();
    QFont f(selfFont);
    f.setPixelSize(38);
    ui->timeShowBig->setFont(f);
    //命名很不友好
    //second单位是10ms
    second++;
    //minute单位是秒
    if (second==100){
        minute++; second=0;
    }
    //hour单位是分钟
    if (minute==60){
        hour++; minute=0;
    }

}
/*
 * 秒表开始暂停继续
 * Stopwatch start pause continue
 */
void Clock::onPushbuttonStartClicked()
{
    if (!isStarted) {
        ui->startStopwatch->setText(tr("suspend"));
        QPalette palette = ui->startStopwatch->palette();
        QColor ColorPlaceholderText(248,163,76,255);
        QBrush brush2;
        brush2.setColor(ColorPlaceholderText);
        //主题框架1.0.6-5kylin2
        palette.setColor(QPalette::Highlight,QColor(248,163,76,255));
        palette.setColor(QPalette::Button,QColor(248,163,76,255));
        palette.setBrush(QPalette::ButtonText, QBrush(Qt::white));
        ui->startStopwatch->setPalette(palette);

        if (stopwatch_isStarted == 0) {
            timer_2->start();
            stopwatch_isStarted = 1;
        }
        timer->start();
        isStarted=1;
        if (!stopwatch_Animation) {
            stopwatchStartAnimation();
            stopwatch_Animation = 1;
        }
        ui->ringBtn->setText(tr("count"));
    } else {
        timer->stop();
        /*查询间隔计时器是否启动
         Query whether the interval timer starts*/
        if (stopwatch_isStarted == 1) {
            timer_2->stop();
            stopwatch_isStarted = 0;
        }
        isStarted=0;
        ui->startStopwatch->setText(tr("continue"));

        QPalette palette = ui->startStopwatch->palette();
        QColor ColorPlaceholderText(248,163,76,255);
        QBrush brush2;
        brush2.setColor(ColorPlaceholderText);
        //主题框架1.0.6-5kylin2
        palette.setColor(QPalette::Highlight,QColor(69, 173, 110,255));
        palette.setColor(QPalette::Button,QColor(69, 173, 110,255));
        palette.setBrush(QPalette::ButtonText, QBrush(Qt::white));
        ui->startStopwatch->setPalette(palette);
        ui->ringBtn->setText(tr("reset"));
    }
    return;
}

/*
 *倒计时标签动画移动
 *Countdown start animation move
 */
void Clock::stopwatchStartAnimation()
{
    animation1 = new QPropertyAnimation(ui->timeShowBig, "geometry");
    animation1->setDuration(1000);
    animation1->setKeyValueAt(0, QRect(90, 125, 210, 70));
    animation1->setEndValue(QRect(90, 4, 210, 70));
    animation1->start();

    animation2 = new QPropertyAnimation(ui->timeShowSmall, "geometry");
    animation2->setDuration(1000);
    animation2->setKeyValueAt(0, QRect(90, 173, 210, 41));
    animation2->setEndValue(QRect(90, 60, 210, 41));
    animation2->start();

    animation3 = new QPropertyAnimation(ui->timeListWidget, "geometry");
    animation3->setDuration(1000);
    animation3->setKeyValueAt(0, QRect(25 ,230, 340, 270));
    animation3->setEndValue(QRect(25, 109, 340, 270));
    animation3->start();
}
/*
 * 倒计时开始动画移动
 * Countdown start animation move
 */
void Clock::stopwatchStopAnimation()
{
    animation1 = new QPropertyAnimation(ui->timeShowBig, "geometry");
    animation1->setDuration(1000);
    animation1->setKeyValueAt(0, QRect(90, 4, 210, 70));
    animation1->setEndValue(QRect(90, 125, 210, 70));
    animation1->start();

    animation2 = new QPropertyAnimation(ui->timeShowSmall, "geometry");
    animation2->setDuration(1000);
    animation2->setKeyValueAt(0, QRect(90, 55, 210, 41));
    animation2->setEndValue(QRect(90, 183, 210, 41));
    animation2->start();

    animation3 = new QPropertyAnimation(ui->timeListWidget, "geometry");
    animation3->setDuration(1000);
    animation3->setKeyValueAt(0, QRect(25 ,109, 340, 270));
    animation3->setEndValue(QRect(25, 230, 340, 270));
    animation3->start();
}

/*
 * 计次
 * times count
 */
void Clock::onPushbuttonRingClicked()
{
    if (!isStarted) {
        //复位
        //清空数据
        timeSepOrderIndex->clear();
        hisLongShortIndex->clear();
        if (nullptr != timer) {
            timer->stop();
            timer_2->stop();
            ui->timeShowBig->setText("00:00.00");
            ui->timeShowSmall->setText("00:00.00");
            isStarted = 0;
            stopwatch_isStarted = 0;
            hour = 0; minute = 0;second = 0;
            stopwatch_hour = 0;
            stopwatch_minute = 0;
            stopwatch_second = 0;
            ui->startStopwatch->setText(tr("start"));
            ui->startStopwatch->setPalette(ui->addAlarmBtn->palette());
            for (int i=0; i < stopwatch_item_flag; i++) {
                delete stopwatch_w[i];
                delete stopwatch_aItem[i];
            }
            stopwatch_item_flag = 0;
            if (stopwatch_Animation) {
                stopwatchStopAnimation();
                stopwatch_Animation = 0;
            }
        }
    }else{
        //计次
        if (stopwatch_isStarted == 0) {
            timer_2->start();
            stopwatch_isStarted = 1;
        }
        if (stopwatch_item_flag < 100) {
            stopwatch_aItem[stopwatch_item_flag] =new QListWidgetItem;
            stopwatch_aItem[stopwatch_item_flag]->setSizeHint(QSize(340,58));
            stopwatch_aItem[stopwatch_item_flag]->setTextColor(QColor(255, 0, 0, 255));
            ui->timeListWidget->insertItem(0,stopwatch_aItem[stopwatch_item_flag]);

            ui->timeListWidget->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
            ui->timeListWidget->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
            stopwatch_w[stopwatch_item_flag] = new stopwatch_item(ui->timeListWidget);

            stopwatch_w[stopwatch_item_flag]->stopwatch1->setText(tr("count")+QString::number(stopwatch_item_flag+1));
            stopwatch_w[stopwatch_item_flag]->stopwatch2->setText(tr("interval ")+stopwatch_jg_h+TIME_SEPARATOR+stopwatch_jg_m+"."+stopwatch_jg_s);
            //间隔时间存入列表
            long sepTime = stopwatch_hour*3600+stopwatch_minute*60+stopwatch_second;
            timeSepOrderIndex->insert(sepTime,stopwatch_item_flag);
            //添加标签
            updateLongestShortLabel();

            stopwatch_w[stopwatch_item_flag]->stopwatch3->setText(stopwatch_h+TIME_SEPARATOR+stopwatch_m+"."+stopwatch_s);
            QString selfFont = Utils::loadFontFamilyFromTTF();
            QFont f(selfFont);
            f.setPixelSize(24);
            stopwatch_w[stopwatch_item_flag]->stopwatch3->setFont(f);

            ui->timeListWidget->setItemWidget(stopwatch_aItem[stopwatch_item_flag],stopwatch_w[stopwatch_item_flag]);

            stopwatch_hour = 0;
            stopwatch_minute = 0;
            stopwatch_second = 0;

            stopwatch_item_flag++;

        } else if(stopwatch_item_flag >= 100) {
            QToolTip::showText(mapToGlobal(ui->timeListWidget->pos()+QPoint(90,340)),tr("up to 100 times"),this);
        }
    }


    //秒表页面子项字体更新
    updateStopwatchItemFront(CURRENT_FONT_SIZE);
}

void Clock::updateLongestShortLabel()
{
    QListIterator<int> iterator(*hisLongShortIndex);
    while (iterator.hasNext()) {
        int index = iterator.next();
        stopwatch_w[index]->updateTipCommonStyle();
    }
    long shortIndex = timeSepOrderIndex->first();
    stopwatch_w[shortIndex]->updateTipShortestStyle();
    int longIndex = timeSepOrderIndex->last();
    stopwatch_w[longIndex]->updateTipLongestStyle();
    //存储到历史
    hisLongShortIndex->clear();
    hisLongShortIndex->append(shortIndex);
    hisLongShortIndex->append(longIndex);


}

/*
 *复位
 *reset
 */
void Clock::onPushbuttonTimeselectClicked()
{
    if (nullptr != timer) {
        if (isStarted)
            return;
        timer->stop();
        timer_2->stop();
        ui->timeShowBig->setText("00:00.00");
        ui->timeShowSmall->setText("00:00.00");
        isStarted = 0;
        stopwatch_isStarted = 0;
        hour = 0; minute = 0;second = 0;
        stopwatch_hour = 0;
        stopwatch_minute = 0;
        stopwatch_second = 0;
        ui->startStopwatch->setText(tr("start"));
        ui->startStopwatch->setPalette(ui->addAlarmBtn->palette());

        for (int i=0; i < stopwatch_item_flag; i++) {
            delete stopwatch_w[i];
            delete stopwatch_aItem[i];
        }
        stopwatch_item_flag = 0;
        if (stopwatch_Animation) {
            stopwatchStopAnimation();
            stopwatch_Animation = 0;
        }
    }
}

/*
 * 窗口关闭
 * window closing
 */
void Clock::windowClosingClicked()
{
    closeHandel();

    if(close_or_hide_page->close_flag==1){
//        setWindowState(Qt::WindowMinimized);
        this->hide();
        //加入托盘
        enableTrayIcon();
        close_or_hide_page->close_flag = 0;
    }else if(close_or_hide_page->close_flag==2){
        exit(0);
    }
}

/*
 *窗口最小化
 *window minimizing
 */
void Clock::windowMinimizingClicked()
{
    this->showNormal();
    this->showMinimized();
}

void Clock::muteAllBell()
{
    //静音反转
    m_muteOn = !m_muteOn;
    QPixmap pixmap = QPixmap(":/image/miniIcon/mute-off.png");
    if(m_muteOn){
        pixmap = QPixmap(":/image/miniIcon/mute-on.png");
    }
    ui->muteBtn->setIcon(pixmap);
    if(m_muteOn){
        QPoint position = frameGeometry().center();
        int x = position.x()-m_commonToolTip->geometry().width()/2;
        int y = position.y()-m_commonToolTip->geometry().height()/2;
        m_commonToolTip->move(x,y);
        m_commonToolTip->show();
        m_commonToolTipRemainTime = 2;
        m_commonToolTipCloseTimer->start();
        //存储静音到数据库
        model_setup->setData(model_setup->index(0, 0), 1);//静音    Mute
    }else{
        model_setup->setData(model_setup->index(0, 0), 0);//静音    Mute
    }
    model_setup->submitAll();
}

/*
 * 倒计时切换
 * Countdown switch
 */
void Clock:: CountdownPageSwitch ()
{
    setSwitchHighlightColor(ui->switchCountdown);
    setSwitchDefaultColor(ui->switchClock);
    setSwitchDefaultColor(ui->switchStopwatch);
    ui->mainWidget->setCurrentIndex(0);
}
void Clock::setBtnIcon(QPushButton *btn, QString imgUrl, QString localUrl)
{
    QIcon icon=Utils::getQIcon(imgUrl,localUrl);
    btn->setIcon(QIcon::fromTheme(imgUrl));
    btn->setIconSize(QSize(18, 18));
    QPainter p(btn);
//    表示引擎应尽可能对图元的边缘进行抗锯齿。
    p.setRenderHint(QPainter::Antialiasing);
}
void Clock::setDefaultIcon(QPushButton *btn)
{
    if(btn==ui->switchClock){
        setBtnIcon(ui->switchClock,"ukui-alarm-symbolic",":/image/alarm.png");
    }else if(btn==ui->switchCountdown){
        setBtnIcon(ui->switchCountdown,"ukui-countselect-symbolic",":/image/count.png");
    }else if(btn==ui->switchStopwatch){
        setBtnIcon(ui->switchStopwatch,"ukui-stopwatch-symbolic",":/image/stopwatch.png");
    }
    if(theme::themetype==1){
        changeIconHeight(btn);
    }
}
QColor Clock::getHighlightActive()
{
    return palette().color(QPalette::Active,QPalette::Highlight);
}

QColor Clock::getButtonActive()
{
    return palette().color(QPalette::Active,QPalette::Button);
}
void Clock::setSwitchDefaultColor(QPushButton * btn)
{
    auto pa = btn->palette();
    QColor btnAcCol = getButtonActive();
    pa.setColor(QPalette::Active,QPalette::Button,btnAcCol);
    btn->setPalette(pa);
    setDefaultIcon(btn);
}
void Clock::setSwitchHighlightColor(QPushButton * btn)
{

    auto pa = btn->palette();
    QColor highAcCol = getHighlightActive();
    pa.setColor(QPalette::Active,QPalette::Button,highAcCol);
    btn->setPalette(pa);
    //修改图标颜色
    changeIconHeight(btn);

}
/*
 * 闹钟窗口切换
 * Alarm window switchin
 */
void Clock:: AlarmPageSwitch ()
{
    setSwitchDefaultColor(ui->switchCountdown);
    setSwitchHighlightColor(ui->switchClock);
    setSwitchDefaultColor(ui->switchStopwatch);
    ui->mainWidget->setCurrentIndex(1);
}
void Clock::changeIconHeight(QPushButton *btn)
{
    QPixmap pix = btn->icon().pixmap(btn->iconSize());
    QPixmap tarPix=theme::changeIconColor(pix,palette().highlightedText().color());
    btn->setIcon(QIcon(tarPix));
}
/*
 * 秒表窗口切换
 * Stopwatch window switch
 */
void Clock:: StopwatchPageSwitch ()
{
    setSwitchDefaultColor(ui->switchCountdown);
    setSwitchDefaultColor(ui->switchClock);
    setSwitchHighlightColor(ui->switchStopwatch);
    ui->mainWidget->setCurrentIndex(2);
}


/**
 * @brief 闹钟列表项
 */
void Clock::textTimerupdate()
{
    //闹钟表条数
    int rowNum = model->rowCount();
    model_setup->select();
    QTime time = QTime::currentTime();
    int time_H = time.hour();
    int time_M = time.minute();
    int time_S = time.second();
    //Timeformat
    //系统24时
    if (checkSystem24()) {
        set24ClockItem(time_H,time_M,time_S,rowNum);
    } else {
        //系统12时制
        set12ClockItem(time_H,time_M,time_S,rowNum);
    }
}

/**
 * @brief 设置24时制闹钟
 */
void Clock::set24ClockItem(int time_H,int time_M,int time_S,int rowNum)
{
    if(system_time_flag == 0){
        system_time_flag = 1;
        clearClockItem( rowNum);
    } else {
        system_time_flag = 1;
    }
}
/**
 * @brief 设置12时制闹钟
 */
void Clock::set12ClockItem(int time_H,int time_M,int time_S,int rowNum)
{
    //原来是24时，则重新构建
    if (system_time_flag == 1) {
        system_time_flag = 0;
        clearClockItem(rowNum);
    } else {
        system_time_flag = 0;
    }
}
/**
 * @brief 清理重新构建闹钟列表
 */
void Clock::clearClockItem(int rowNum)
{
    for(int i=0; i<rowNum; i++) {
        delete aItem[i];
        delete w1[i];
    }
    updateAlarmClock();
}
/**
 * @brief 初始化系统时间标识
 */
void Clock::iniSystemTimeFlag()
{
    //跟随系统
    if(checkSystem24()){
        system_time_flag = 1;
    }else{
        system_time_flag = 0;
    }

}
/**
 * @brief 判断系统是否是24时制
 */
bool Clock::checkSystem24()
{
    //Qt提供了一个QProcess类用于启动外部程序并与之通信
    QProcess process;
    process.start("gsettings get org.ukui.control-center.panel.plugins hoursystem");
    //阻塞，直到外部程序结束
    process.waitForFinished();
    QByteArray output = process.readAllStandardOutput();
    QString str_output = output;
    return str_output.compare("'24'\n") == 0;
}

void Clock::muteBtnStyle()
{
    int mute = model_setup->index(0, 0).data().toInt();
    m_muteOn = mute==1?true:false;
    QPixmap pixmap = QPixmap(":/image/miniIcon/mute-off.png");
    if(m_muteOn){
        pixmap = QPixmap(":/image/miniIcon/mute-on.png");
    }
    ui->muteBtn->setIcon(pixmap);
    ui->muteBtn->setIconSize(QSize(32, 32));
    QPainter p(ui->muteBtn);
    //表示引擎应尽可能对图元的边缘进行抗锯齿。
    p.setRenderHint(QPainter::Antialiasing);
    ui->muteBtn->setFlat(true);
    ui->muteBtn->setVisible(true);
    ui->muteBtn->setFocusPolicy(Qt::NoFocus);
    ui->muteBtn->setToolTip(tr("mute"));
    //弹窗初始化
    m_commonToolTip = new CommonToolTip(this);
    m_commonToolTip->hide();
    m_commonToolTip->setMsgText(tr("All bells are off"));
    //弹窗定时
    m_commonToolTipCloseTimer = new QTimer(this);
    m_commonToolTipCloseTimer->setInterval(1000);
    connect(m_commonToolTipCloseTimer, &QTimer::timeout, this, [=](){
        m_commonToolTipRemainTime--;
        if(m_commonToolTipRemainTime<=0){
            m_commonToolTipCloseTimer->stop();
            m_commonToolTip->hide();
        }
    });
    connect(ui->muteBtn, SIGNAL(clicked()), this, SLOT(muteAllBell()));
}
/**
 * @brief 最小化按钮样式
 */
void Clock::minBtnStyle()
{
    //窗口最小化
    ui->minmizeBtn->setIcon(QIcon::fromTheme("window-minimize-symbolic"));
    ui->minmizeBtn->setFlat(true);
    ui->minmizeBtn->setVisible(true);
    ui->minmizeBtn->setFocusPolicy(Qt::NoFocus);
    ui->minmizeBtn->setProperty("useIconHighlightEffect", 0x2);
    ui->minmizeBtn->setProperty("isWindowButton", 0x01);
    ui->minmizeBtn->setToolTip(tr("Minimize"));
    connect(ui->minmizeBtn, SIGNAL(clicked()), this, SLOT(windowMinimizingClicked()));
}
/**
 * @brief 关闭按钮样式
 */
void Clock::closeBtnStyle()
{

    //窗口关闭
    ui->closeTitleBtn->setIcon(QIcon::fromTheme("window-close-symbolic"));
    ui->closeTitleBtn->setFlat(true);
    ui->closeTitleBtn->setVisible(true);
    ui->closeTitleBtn->setFocusPolicy(Qt::NoFocus);
    //主题框架1.0.6-5kylin2
    ui->closeTitleBtn->setProperty("isWindowButton", 0x2);
    ui->closeTitleBtn->setProperty("useIconHighlightEffect", 0x8);
    ui->closeTitleBtn->setToolTip(tr("Quit"));
    connect(ui->closeTitleBtn, SIGNAL(clicked()), this, SLOT(windowClosingClicked()));
}
/**
 * @brief 菜单按钮样式
 */
void Clock::menuBtnStyle()
{
    //菜单项
    ui->menuBtn->setIcon(QIcon::fromTheme("open-menu-symbolic"));
    ui->menuBtn->setVisible(true);
    ui->menuBtn->setFocusPolicy(Qt::NoFocus);
    ui->menuBtn->setToolTip(tr("Menu"));
    ui->menuBtn->setProperty("useIconHighlightEffect", 0x2);
    ui->menuBtn->setProperty("useButtonPalette", true);
    /*设置关于页*/
    ui->menuBtn->setPopupMode(QToolButton::InstantPopup);
    m_menu = new QMenu(ui->menuBtn);
    m_menu->setProperty("fillIconSymbolicColor", true);
//    ui->pushButton_12->setProperty("useButtonPalette", true);
    //菜单项的操作
    //帮助
    QAction *m_helpAction = new QAction(m_menu);
    //关于
    QAction *m_aboutAction = new QAction(m_menu);
    //关闭
    QAction *m_closeAction = new QAction(m_menu);
    m_helpAction->setText(tr("Help"));
    m_aboutAction->setText(tr("About"));
    m_closeAction->setText(tr("Close"));
    m_menu->addAction(m_helpAction);
    m_menu->addAction(m_aboutAction);
    m_menu->addAction(m_closeAction);
    ui->menuBtn->setMenu(m_menu);
    connect(m_helpAction, &QAction::triggered, this, [=](){
        qDebug() << "help clicked";
        callUserGuide();
    });
    connect(m_aboutAction, &QAction::triggered, this, [=](){
        About *dialog = new About();
        QPointF position = this->pos();
        XAtomHelper::setStandardWindowHint(dialog->winId());
        dialog->move(position.x()-15,position.y()+130);
        dialog->exec();
    });
    connect(m_closeAction, SIGNAL(triggered()), this, SLOT(windowClosingClicked()));

    //手动改成透明色
    QPalette pale =ui->menuBtn->palette();
    pale.setColor(QPalette::Active,QPalette::Button,Qt::transparent);
    ui->menuBtn->setPalette(pale);
}
/*
 * @brief 检查小窗体是否初始化
 */
bool Clock::checkTinyCountdownDia()
{
    return tinycountdownDia!=nullptr?true:false;
}

void Clock::navigationBtnStyle(QPushButton * btn)
{
    setDefaultIcon(btn);;
    //不使用主题高亮
    btn->setProperty("useIconHighlightEffect", false);
    //使用灰按钮
    btn->setProperty("useButtonPalette", true);
}

void Clock::updateClockSelectBtnStyle(SelectBtn *temp, int moveHeight)
{
    temp->move(25,moveHeight);
}

void Clock::updateCountdownSelectBtnStyle(SelectBtn *temp, int moveWidth, int moveHeight)
{
    temp->move(moveWidth,moveHeight);
}

void Clock::updateClockSelectBtnStyle(Btn_new *temp, int moveHeight)
{
    temp->move(DIALOG_MOVE_WIDTH,moveHeight);
}

void Clock::updateCountdownSelectBtnStyle(Btn_new *temp, int moveWidth, int moveHeight)
{
    temp->move(moveWidth,moveHeight);
}

void Clock::updateClockSelectBtnLabel(QLabel *temp, int moveHeight, QString text)
{
    temp->setText(text);
    temp->setAlignment(Qt::AlignLeft|Qt::AlignVCenter);
    temp->setStyleSheet("font-size:14px;");
    int labelLeftSpace = 20;
    temp->move(labelLeftSpace, moveHeight);
}

void Clock::widgetListWhiteStyle(QListWidget *listWidget)
{
    QString listBackColor = getDefaultGreyColor();
    QString selectItemRadius = QString::number(SELECT_ITEM_RADIUS);
    listWidget->setStyleSheet("QListWidget{background-color: rgba(0, 0, 0, 0);}\
                                  QListWidget::Item{background-color:"+listBackColor+";border-radius:"+selectItemRadius+"px;}\
                                  QListWidget::item::selected{background-color:rgba(233, 233, 233,255);border-radius:"+selectItemRadius+"px;border:1px solid rgba(131, 131, 131,0);}\
                                  QListWidget::item:hover{background-color:rgba(233, 233, 233,255);border-radius:"+selectItemRadius+"px;}\
                                  QScrollBar:vertical{width:4px;background:rgba(0, 0, 0, 0);}QScrollBar::handle:vertical{width:4px;background:rgba(186, 193, 201, 1);}\
                                  QScrollBar::up-arrow:vertical, QScrollBar::down-arrow:vertical{background: white;border: 2px solid transparent;}\
                                  ");
}

void Clock::widgetListBlackStyle(QListWidget *listWidget)
{
    QString selectItemRadius = QString::number(SELECT_ITEM_RADIUS);
    listWidget->setStyleSheet("QListWidget{background-color: rgba(0, 0, 0, 0);}\
                                  QListWidget::Item{background-color:rgba(41, 41, 41, 255);border-radius:"+selectItemRadius+"px;}\
                                  QListWidget::item::selected{background-color:rgba(55, 55, 59, 255);border-radius:"+selectItemRadius+"px;border:1px solid rgba(131, 131, 131,0);}\
                                  QListWidget::item:hover{background-color:rgba(55, 55, 59, 255);border-radius:"+selectItemRadius+"px;}\
                                  QScrollBar:vertical{width:4px;background:rgba(0, 0, 0, 0);}QScrollBar::handle:vertical{width:4px;background:rgba(186, 193, 201, 1);}\
                                  QScrollBar::up-arrow:vertical, QScrollBar::down-arrow:vertical{background: white;border: 2px solid transparent;}\
                                  ");
}

/*
 * 动态监控闹钟与本地时间
 * Dynamic monitoring alarm clock and local time
 */
void Clock::timerUpdate()
{
    QTime time = QTime::currentTime();
    int timeH = time.hour();
    int timeM = time.minute();
    int timeS = time.second();

    model_setup->select();
    //更新闹钟列表项
    textTimerupdate();

    int rowNum = model->rowCount();
    //遍历闹钟
    for (int i = 0; i < rowNum; i++) {
        /*判断星期
         Judgment week*/
        QDateTime current_date_time = QDateTime::currentDateTime();
        //今天没提醒闹钟，则continue
        //缩写的本地化日期名称
        if (current_date_time.toString("ddd").compare("周一")==0 &&  model->index(i, 6).data().toInt() == 0)
             continue;
         if (current_date_time.toString("ddd").compare("周二")==0 &&  model->index(i, 7).data().toInt() == 0)
             continue;
         if (current_date_time.toString("ddd").compare("周三")==0 &&  model->index(i, 8).data().toInt() == 0)
             continue;
         if (current_date_time.toString("ddd").compare("周四")==0 &&  model->index(i, 9).data().toInt() == 0)
             continue;
         if (current_date_time.toString("ddd").compare("周五")==0 &&  model->index(i, 10).data().toInt() == 0)
             continue;
         if (current_date_time.toString("ddd").compare("周六")==0 &&  model->index(i, 11).data().toInt() == 0)
             continue;
         if (current_date_time.toString("ddd").compare("周日")==0 &&  model->index(i, 12).data().toInt() == 0)
             continue;

        /*判断开关
         Judgment switch*/
         //闹钟关闭 则 continue
        if ( model->index(i, 3).data().toInt() == 1)
            continue;
        //闹钟时间到
        if (timeH == model->index(i, 0).data().toInt()
                && timeM == model->index(i, 1).data().toInt()
                && timeS == 0) {
            double music_time = 30;
            if (model->index(i, 13).data().toString().compare(tr("2min"))==0) {
                music_time = 2*60;
            } else if (model->index(i, 13).data().toString().compare(tr("3min"))==0) {
                music_time = 3*60;
            } else if (model->index(i, 13).data().toString().compare(tr("4min"))==0) {
                music_time = 4*60;
            } else if (model->index(i, 13).data().toString().compare(tr("6min"))==0) {
                music_time = 6*60;
            } else {
                music_time = 60;
            }
            QString id = model->index(i, 14).data().toString();
            noticeDialogShow(music_time, i ,id);
            if(model->index(i, 5).data().toString().compare(tr("No repetition"))==0)
                offAlarm(i);
        }
    }
    //触发一次paintEvent
    update();
    //更新闹钟页面子项字体
    updateAlarmItemFront(CURRENT_FONT_SIZE);
    //刷新倒计时上 时间格式
    getCountdownOverTime();
}

/*
 * 通知弹窗
 * Notification Popup
 */
void Clock::noticeDialogShow(int close_time, int alarm_num, QString id)
{
    model_setup->select();
    QScreen *screen=QGuiApplication::primaryScreen ();
    //闹钟弹窗
    alarmNoticeDialog = new Natice_alarm(close_time,alarm_num,nullptr,id);
    if(countdownNoticeDialog != nullptr) {
        if (countdownNoticeDialog->isVisible() == 0)
            moveUnderMultiScreen(UP_RIGHT,alarmNoticeDialog,1);
        else
            moveUnderMultiScreen(UP_RIGHT,alarmNoticeDialog,0);
    }
    else
        moveUnderMultiScreen(UP_RIGHT,alarmNoticeDialog,1);
    alarmNoticeDialog->playMusic();
}


/**
 * @brief 重绘窗口，更新闹钟 Redraw window, update alarm clock
 */
void Clock::updateAlarmClock()
{
    int rowNum = model->rowCount();
    int hour_now;
    int min_now;
    if(rowNum){
        ui->noAlarm->hide();
        ui->noAlarmIcon->hide();
    }else{
        ui->noAlarm->show();
        ui->noAlarmIcon->show();
    }
    auto sqlQuery = clock_sql::getQSqlQuery();
    sqlQuery.exec("select * from clock order by Hour ASC,Minute ASC");
    int alarmNum = 0;
    //实现id补偿，原表设计没有主键，为实现旧数据兼容
//    QList<int> * needIdNumList = new QList<int>();
//    QHash<int,int> * numToIndex =new QHash<int,int>();
    while (sqlQuery.next()) {
        //窗体
        aItem[alarmNum] =new QListWidgetItem;
        aItem[alarmNum]->setSizeHint(QSize(340,108));
        aItem[alarmNum]->setTextColor(QColor(255, 0, 0, 255));
        ui->alarmListWidget->addItem(aItem[alarmNum]);
        ui->alarmListWidget->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
        ui->alarmListWidget->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
        //闹钟信息
        w1[alarmNum] = new item_new(ui->alarmListWidget);
        //信息与展示窗体绑定
        ui->alarmListWidget->setItemWidget(aItem[alarmNum],w1[alarmNum]);
        //绑定Id到闹钟子项
        auto hisId =  sqlQuery.value(14).toString();
        w1[alarmNum]->setId(hisId);
        hour_now =sqlQuery.value( 0).toInt();
        min_now =sqlQuery.value( 1).toInt();
        int onOff = sqlQuery.value(3).toInt();
        if(onOff==1){
            w1[alarmNum]->closeStyle(CURRENT_FONT_SIZE);
        }else{
            w1[alarmNum]->openStyle(CURRENT_FONT_SIZE);
        }
        if (system_time_flag) {
            //24时制
            changeTimeNum(hour_now,min_now);//转换int为QString
            // Convert int to qstring
            w1[alarmNum]->alarmLabel0->setText(alarmHour_str+TIME_SEPARATOR+alarmMinute_str);
            QString selfFont = Utils::loadFontFamilyFromTTF();
            QFont f(selfFont);
            f.setPixelSize(38);
            w1[alarmNum]->alarmLabel0->setFont(f);

            w1[alarmNum]->alarmLabel1->hide();
        } else {
            //12时制
            if (hour_now >= 12) {
                w1[alarmNum]->alarmLabel1->setText(tr("PM"));
                if (hour_now == 12) {
                    w1[alarmNum]->alarmLabel0->setText(changeNumToStr(hour_now)+" : "+changeNumToStr(min_now));
                } else {
                    w1[alarmNum]->alarmLabel0->setText(changeNumToStr(hour_now-12)+" : "+changeNumToStr(min_now));
                }
            } else {
                w1[alarmNum]->alarmLabel1->setText(tr("AM"));
                if (hour_now == 0) {
                    w1[alarmNum]->alarmLabel0->setText(changeNumToStr(12)+" : "+changeNumToStr(min_now));
                } else {
                    w1[alarmNum]->alarmLabel0->setText(changeNumToStr(hour_now)+" : "+changeNumToStr(min_now));
                }
            }
        }
        /*闹钟开关
         Alarm switch*/
        //onoroff
        if (sqlQuery.value( 3).toInt() == 1) {
            w1[alarmNum]->alarm_on_off0->initClose();
        } else {
            w1[alarmNum]->alarm_on_off0->initOpen();
        }
        //Name 闹钟名
        QString clockName = sqlQuery.value( 13).toString();
        int sizeLimit = 8;
        if(clockName.length()>sizeLimit){
            w1[alarmNum]->alarmLabel_w0->setToolTip(clockName);
            //名字超长
            clockName = clockName.left(sizeLimit);
            clockName = clockName+"..";
        }
        w1[alarmNum]->alarmLabel_w0->setText(clockName);
        //repeat 重复
        QString werk_str = sqlQuery.value( 5).toString();
        QString werk_day ;
        int werk = 0;
        for (int i=0; i<7; i++) {
            //从周一到周日开始判断 为1
            if (sqlQuery.value( 6+i).toInt()) {
                //拼接werk_day
                if(i == 0){
                    werk_day = werk_day + tr("Mon")+"  ";
                }else if(i == 1){
                    werk_day = werk_day + tr("Tue")+"  ";
                }else if(i == 2){
                    werk_day = werk_day + tr("Wed")+"  ";
                }else if(i == 3){
                    werk_day = werk_day + tr("Thu")+"  ";
                }else if(i == 4){
                    werk_day = werk_day + tr("Fri")+"  ";
                }else if(i == 5){
                    werk_day = werk_day + tr("Sat")+"  ";
                }else if(i == 6){
                    werk_day = werk_day + tr("Sun")+"  ";
                }
            }else{
                //不是全为1
                werk = 1;
            }
        }
        if(werk){
            w1[alarmNum]->alarmLabel_s0->setText(werk_day);
        }else {
            if(werk_str == tr("Every day") || werk_str == "每天"){
                w1[alarmNum]->alarmLabel_s0->setText(tr("Every day"));
            }else if(werk_str == "Workingday" || werk_str == "工作日"){
                w1[alarmNum]->alarmLabel_s0->setText(tr("Workingday"));
            }else if(werk_str == "No repetition" || werk_str == "不重复"){
                w1[alarmNum]->alarmLabel_s0->setText(tr("No repetition"));
            }
        }
        //闹钟开关绑定
        connect( w1[alarmNum]->alarm_on_off0, SIGNAL(clicked()), this, SLOT(OnOffAlarm()) );
        alarmNum++;
    }
//    updateClockIdByNum(needIdNumList,numToIndex);

}

/*
 * 绘制无闹钟提示
 * Draw no alarm prompt
 */
void Clock::drawNoAlarmPrompt()
{
    ui->noAlarmIcon->setPixmap(QPixmap(":/image/noClockWhite.png"));//.pixmap(164,194)
    ui->noAlarm->setAlignment(Qt::AlignHCenter);
}

/*
 * 修改时间单数 为两位数
 * Modify time singular to two digits
 */
void Clock::changeTimeNum(int alarmHour, int alarmMinute)
{
    if (alarmHour < 10) {
        QString hours_str = QString::number(alarmHour);
        alarmHour_str = "0"+hours_str;
    } else {
        alarmHour_str = QString::number(alarmHour);
    }
    if (alarmMinute < 10) {
        QString minute_str = QString::number(alarmMinute);
        alarmMinute_str = "0"+minute_str;
    } else {
        alarmMinute_str = QString::number(alarmMinute);
    }
}




/*
 * 新建闹钟按钮回调
 * New alarm button callback
 */
void Clock::setAlarmClock()
{
    onEditPage = false;
    //新建闹钟页
    ui->mainWidget->setCurrentIndex(3);
    //取消
    ui->cancelbtnOnEditAlarm->show();
    repeat_new_or_edit_flag = 0;

    model_setup->select();/*调用默认设置
                           Call default settings*/
    repeat_str_model = tr("Workingday");
    //工作日默认
    repeatSelectOnClockNew->textLabel->setText(repeat_str_model+tr("(default)"));
    //工作日设置的逻辑
    for (int i=0; i<5; i++) {
        repeat_day[i] = 1;
    }
    remind_late_str_model= tr("none");
    //设置新建闹钟默认铃声
    QString defaultBellId = m_selectBtnUtil->getDefaultBellId();
    QString bellName = m_selectBtnUtil->getBellNameById(defaultBellId);
    musicSelectOnClockNew->textLabel->setText(bellName);
    setMusicSelectDialogListById(defaultBellId,dialog_music->listWidget);
    //设置默认稍后提醒
    remindSelectOnClockNew->textLabel->setText(remind_late_str_model);
    setRemindLateSelectDialogListByName(remind_late_str_model,dialog_remind_late->listWidget);
    clock_name = tr(CLOCK_TITLE_NAME);
    clockEditOnClockNew->clockNameLineEdit->setText(clock_name);
}
/**
 * @brief 设置新建闹钟的铃声的默认值
 * @param name
 */
void Clock::setMusicSelectDialogListById(QString bellId, QListWidget *temp)
{
    int status = m_selectBtnUtil->getBellIndexById(bellId);
    temp->setCurrentRow(status);
}

void Clock::setRemindLateSelectDialogListByName(QString name, QListWidget *temp)
{

    int status = getRemindStatusByName(name);
    temp->setCurrentRow(status);
}

int Clock::getRemindStatusByName(QString name)
{
    int status = 0;
    if(name.compare("none") == 0 || name.compare("不需要") == 0){
        status = 0;
    }else if(name.compare("five mins late") == 0 || name.compare("5分钟后") == 0){
        status = 1;
    }else if(name.compare("ten mins late") == 0 || name.compare("10分钟后") == 0){
        status = 2;
    }else if(name.compare("twenty mins late") == 0 || name.compare("20分钟后") == 0){
        status = 3;
    }else if(name.compare("thirsty mins late") == 0 || name.compare("30分钟后") == 0){
        status = 4;
    }else if(name.compare("one hour late") == 0 || name.compare("1小时后") == 0){
        status = 5;
    }
    return status;
}

/*
 * 闹钟新建界面保存回调
 * Alarm new interface save callback
 */
void Clock::setAlarmSave()
{
    if(onEditPage){
        //编辑页面保存
        QString clockName = clockEditOnClockNew->clockNameLineEdit->text();
        if(clockName.isEmpty()){
            delete_msg *deletemsg = new delete_msg();
            deletemsg->ui->msgInfo->setText(tr("Please set alarm name!"));
            QPointF position = this->pos();
            deletemsg->move(position.x()+67,position.y()+250);
            deletemsg->exec();
            return ;
        }
        auto curentId = getClockPkByCurrentNum();
        auto sqlQuery = clock_sql::getQSqlQuery();
        sqlQuery.prepare("update clock set hour=:hour,minute=:minute,bell_id=:music,repeat=:repeat,"
                         "name=:name,monday=:monday,tuesday=:tuesday,wednesday=:wednesday,thursday=:thusday,"
                         "friday=:friday,saturday=:saturday,sunday=:sunday,remind_status=:remind_status where id=:id");
        sqlQuery.bindValue(":id",curentId);
        sqlQuery.bindValue(":hour",timer_alarm_start24->m_currentValue);
        sqlQuery.bindValue(":minute",timer_alarm_start60->m_currentValue);
        QString bellId = getSelectBellId(dialog_music);
        sqlQuery.bindValue(":music",bellId);
        sqlQuery.bindValue(":repeat",repeat_str_model);
        sqlQuery.bindValue(":remind_status",remind_late_str_model);
        sqlQuery.bindValue(":name",clockName);
        for (int i=0; i<7; i++) {
            QString day = indexWeekdayMap->value(i);
            if (repeat_day[i]) {
                sqlQuery.bindValue(day,1);
            } else {
                sqlQuery.bindValue(day,0);
            }
        }
        sqlQuery.exec();
        model->submitAll();
        int m = model->rowCount();
        /*每次updateAlarmClock()之前，删除全部闹钟相关控件
          Delete all alarm related controls before updatealrmclock()*/
        for (int i = 0; i < m; i++) {
            delete aItem[i];
            delete w1[i];
        }
        updateAlarmClock();
        updateAlarmItemFront(CURRENT_FONT_SIZE);
        ui->mainWidget->setCurrentIndex(1);
        ui->mainWidget->raise();/*将页面放置最前方
                                    Put the page at the front*/
        ui->minmizeBtn->raise();
        ui->closeTitleBtn->raise();
        ui->menuBtn->raise();

        if (dialog_repeat)
            dialog_repeat->close();

        if (dialog_music)
            dialog_music->close();
        if(dialog_remind_late)
            dialog_remind_late->close();
    }else{
        //新建页面保存
        clockEditOnClockNew->clockNameLineEdit->setText(clockEditOnClockNew->clockNameLineEdit->text().remove(QRegExp("\\s")));//去除所以空格
        if(clockEditOnClockNew->clockNameLineEdit->text().isEmpty()){
            delete_msg *deletemsg = new delete_msg();
            deletemsg->ui->msgInfo->setText(tr("Please set alarm name!"));
            QPointF position = this->pos();
            deletemsg->move(position.x()+67,position.y()+250);
            deletemsg->exec();
            return ;
        }
        int rowNum;
        rowNum = model->rowCount();

        qDebug() << rowNum << "闹钟数";
        if (rowNum < 20) {
            saveClockToDatabase(rowNum);
        } else {
            QMessageBox::warning(this, tr("warning"), tr("the number of alarms reaches limit!！"), tr("yes"));
        }

        ui->mainWidget->setCurrentIndex(1);
        ui->mainWidget->raise();//将页面放置最前方
                                   // Put the page at the front
        ui->minmizeBtn->raise();
        ui->closeTitleBtn->raise();
        ui->menuBtn->raise();

        if (dialog_repeat)
            dialog_repeat->close();
        if (dialog_music)
            dialog_music->close();
    }
    updateAlarmItemFront(CURRENT_FONT_SIZE);
}

void Clock::saveClockToDatabase(int rowNum)
{
    QString clockName = clockEditOnClockNew->clockNameLineEdit->text();
    model->insertRow(rowNum);

    model->setData(model->index(rowNum, 0), timer_alarm_start24->m_currentValue);
    model->setData(model->index(rowNum, 1), timer_alarm_start60->m_currentValue);
    QString bellId = getSelectBellId(dialog_music);
    model->setData(model->index(rowNum, 2), bellId);
    model->setData(model->index(rowNum, 15), remind_late_str_model);
    model->setData(model->index(rowNum, 3), int(0));
    model->setData(model->index(rowNum, 4), int(model->index(rowNum-1, 4).data().toInt()+1));
    model->setData(model->index(rowNum, 5), repeat_str_model);
    model->setData(model->index(rowNum, 13), clockName);
    //主键
    auto id = Utils::getRandomId();
    model->setData(model->index(rowNum, 14), id);
    for (int i=0; i<7; i++) {
        model->setData(model->index(rowNum, i+6), repeat_day[i]);
    }
    model->submitAll();

    for (int i=0; i<rowNum; i++) {
        delete aItem[i];
        delete w1[i];
    }
    qDebug() << model->index(rowNum, 0).data().toString()
             << model->index(rowNum, 1).data().toString()
             << QFileInfo( model->index(rowNum, 2).data().toString() ).fileName();
    updateAlarmClock();
}

QString Clock::getSelectBellId(set_alarm_repeat_Dialog *tempDialog)
{
    int num=tempDialog->listWidget->currentRow();
    QString id = m_selectBtnUtil->getBellIdByIndex(num);
    return id;
}

QString Clock::addAlarm(clockInterface::RequestParams param)
{
    return addAlarm(param.clockName,param.hour,param.minute);
}

QString Clock::addAlarmJosn(QString param)
{
    neb::CJsonObject oJson(param.toStdString());
    QString clockName = QString::fromStdString(oJson["clockName"].ToString());
    QString hour = QString::fromStdString(oJson["hour"].ToString());
    QString minute = QString::fromStdString(oJson["minute"].ToString());
    if(FieldValidUtil::isNull(hour)){
        return formatReturnMsg(clockInterface::FAIL,"小时为空");
    }
    if(FieldValidUtil::isNull(minute)){
        return formatReturnMsg(clockInterface::FAIL,"分钟为空");
    }
    return addAlarm(clockName,  hour.toInt(),  minute.toInt());
}

QString Clock::updateClockByIdJosn(QString param)
{
    neb::CJsonObject oJson(param.toStdString());
    QString id = QString::fromStdString(oJson["id"].ToString());
    if(FieldValidUtil::isNull(id)){
        return formatReturnMsg(clockInterface::FAIL,"主键id为空");
    }
    id = FieldValidUtil::QStringFilter(id);
    QString clockName = QString::fromStdString(oJson["clockName"].ToString());
    QString hour = QString::fromStdString(oJson["hour"].ToString());
    QString minute = QString::fromStdString(oJson["minute"].ToString());
    if(FieldValidUtil::isNull(clockName)&&FieldValidUtil::isNull(hour)&&FieldValidUtil::isNull(minute)){
        return formatReturnMsg(clockInterface::FAIL,"没有需要修改的数据");
    }
    updateClockDatabase(id,clockName,hour,minute,0);
    return formatReturnMsg(clockInterface::SUCCESS,"闹钟修改成功");
}

QString Clock::selectClockByIdJosn(QString param)
{
    neb::CJsonObject oJson(param.toStdString());
    QString id = QString::fromStdString(oJson["id"].ToString());
    if(FieldValidUtil::isNull(id)){
        return formatReturnMsg(clockInterface::FAIL,"主键id为空");
    }
    id = FieldValidUtil::QStringFilter(id);
    auto sqlQuery = getClockByPK(id);
    QString queryId = sqlQuery.value(14).toString();
    if(FieldValidUtil::isNull(queryId)){
        return formatReturnMsg(clockInterface::FAIL,"查询结果为空");
    }
    oJson.Add("name",sqlQuery.value(13).toString().toStdString());
    oJson.Add("hour",sqlQuery.value( 0).toInt());
    oJson.Add("minute",sqlQuery.value( 1).toInt());
    return formatReturnMsg(oJson,clockInterface::SUCCESS,"闹钟查询成功");
}

QString Clock::deleteClockByIdJosn(QString param)
{
    neb::CJsonObject oJson(param.toStdString());
    QString id = QString::fromStdString(oJson["id"].ToString());
    if(FieldValidUtil::isNull(id)){
        return formatReturnMsg(clockInterface::FAIL,"主键id为空");
    }
    id = FieldValidUtil::QStringFilter(id);
    deleteAlarmDatabase(id);
    return formatReturnMsg(clockInterface::SUCCESS,"闹钟删除成功");
}

QString Clock::addAlarm(QString clockName, int hour, int minute)
{
    //表单验证
    if(FieldValidUtil::isNull(clockName)){
        return formatReturnMsg(clockInterface::FAIL,"闹钟名为空");
    }
    QString clockNameQstr = FieldValidUtil::QStringFilter(clockName);
    if(clockNameQstr.length()>16){
        return formatReturnMsg(clockInterface::FAIL,"闹钟名超过16个字");
    }
    if(!FieldValidUtil::isValueBetweenRange(hour,0,23)){
        return formatReturnMsg(clockInterface::FAIL,"小时位不是0-23之间的整数");
    }
    if(!FieldValidUtil::isValueBetweenRange(minute,0,59)){
        return formatReturnMsg(clockInterface::FAIL,"分钟位不是0-59之间的整数");
    }
    int rowNum;
    rowNum = model->rowCount();
    if(rowNum>=20){
        return formatReturnMsg(clockInterface::FAIL,"闹钟数已达上限");
    }

    //存储到数据库
    model->insertRow(rowNum);
    model->setData(model->index(rowNum, 0), hour);
    model->setData(model->index(rowNum, 1), minute);
    model->setData(model->index(rowNum, 2), tr("glass"));
    model->setData(model->index(rowNum, 3), int(0));
    model->setData(model->index(rowNum, 4), int(model->index(rowNum-1, 4).data().toInt()+1));
    model->setData(model->index(rowNum, 5), tr("No repetition"));
    model->setData(model->index(rowNum, 13), clockNameQstr);
    //主键
    auto id = Utils::getRandomId();
    model->setData(model->index(rowNum, 14), id);
    for (int i=0; i<7; i++) {
        model->setData(model->index(rowNum, i+6), 1);
    }
    model->submitAll();
    for (int i=0; i<rowNum; i++) {
        delete aItem[i];
        delete w1[i];
    }
    updateAlarmClock();
    updateAlarmItemFront(CURRENT_FONT_SIZE);
    neb::CJsonObject oJson;
    oJson.Add("id",id.toStdString());
    return formatReturnMsg(oJson,clockInterface::SUCCESS,"闹钟添加成功");
}

QString Clock::formatReturnMsg(neb::CJsonObject oJson, clockInterface::STATUS_CODE status, std::string msg)
{
    oJson.Add("status",status);
    oJson.Add("msg",msg);
    return QString::fromStdString(oJson.ToString());
}
/**
 * @brief 构造返回值
 * @param status 状态
 * @param msg 返回信息
 * @return
 */
QString Clock::formatReturnMsg(STATUS_CODE status, string msg)
{

    neb::CJsonObject oJson;
    oJson.Add("status",status);
    oJson.Add("msg",msg);
    return QString::fromStdString(oJson.ToString());
}





/*
 *闹钟新建界面取消回调
 * Cancel callback in alarm new interface
 */
void Clock::alarmCancelSave()
{
    ui->mainWidget->setCurrentIndex(1);
    ui->mainWidget->raise();
    ui->minmizeBtn->raise();
    ui->closeTitleBtn->raise();
    ui->menuBtn->raise();
}

/*
 * 双击闹钟打开重编辑页面
 * Double click the alarm clock to open the re edit page
 */
void Clock::listdoubleClickslot()
{
    onEditPage = true;
    ui->mainWidget->setCurrentIndex(3);
    //以链表序号找寻数据
    auto curentId = getClockPkByCurrentNum();
    //根据id查询数据
    auto sqlQuery = getClockByPK(curentId);
    timer_alarm_start24->m_currentValue=sqlQuery.value( 0).toInt();
    timer_alarm_start60->m_currentValue=sqlQuery.value( 1).toInt();
    repeat_new_or_edit_flag = 1;
    QString werk_day ;
    int werk = 0;
    for (int i=0; i<7; i++) {
        if (sqlQuery.value( 6+i).toInt()) {
            if(i == 0){
                werk_day = werk_day + tr("Mon")+"  ";
            }else if(i == 1){
                werk_day = werk_day + tr("Tue")+"  ";
            }else if(i == 2){
                werk_day = werk_day + tr("Wed")+"  ";
            }else if(i == 3){
                werk_day = werk_day + tr("Thu")+"  ";
            }else if(i == 4){
                werk_day = werk_day + tr("Fri")+"  ";
            }else if(i == 5){
                werk_day = werk_day + tr("Sat")+"  ";
            }else if(i == 6){
                werk_day = werk_day + tr("Sun")+"  ";
            }
        }else{
            werk = 1;
        }
    }
    if(werk){
        repeatSelectOnClockNew->textLabel->setText(werk_day);
    }else {
        repeatSelectOnClockNew->textLabel->setText(tr("Every day"));
    }
    if(sqlQuery.value( 5).toString() == tr("  work") || sqlQuery.value( 5).toString() == tr("  工作日")){
        repeatSelectOnClockNew->textLabel->setText(tr("  work"));
    }
    if(sqlQuery.value( 5).toString() == tr("No repetition") || sqlQuery.value( 5).toString() == tr("不重复")){
        repeatSelectOnClockNew->textLabel->setText(tr("No repetition"));
    }
    repeat_str_model = sqlQuery.value( 5).toString();

    updateRepeatStr(repeatSelectOnClockNew->textLabel);

    QString bellId =  sqlQuery.value( 2).toString();
    auto name = m_selectBtnUtil->getBellNameById(bellId);
    musicSelectOnClockNew->textLabel->setText(name);
    setMusicSelectDialogListById(bellId,dialog_music->listWidget);

    //重复
    remind_late_str_model =  sqlQuery.value( 15).toString();
    qDebug()<<"从数据库查稍后"<<remind_late_str_model;
    int status = getRemindStatusByName(remind_late_str_model);
    remind_late_str_model = getRemindLateStrFromNum(status);
    remindSelectOnClockNew->textLabel->setText(remind_late_str_model);
    setRemindLateSelectDialogListByName(remind_late_str_model,dialog_remind_late->listWidget);

    clock_name = sqlQuery.value( 13).toString();
    clockEditOnClockNew->clockNameLineEdit->setText(clock_name);
    for (int i=0; i<7; i++) {
        if (sqlQuery.value( 6+i).toInt()) {
            repeat_day[i] = 1;
        } else {
            repeat_day[i] = 0;
        }
    }
}

QString Clock::getClockPkByCurrentNum()
{
    int num = ui->alarmListWidget->currentRow();
    auto widgetItem = static_cast<item_new *>(ui->alarmListWidget->itemWidget(aItem[num]));
    auto curentId = widgetItem->id();
    return curentId;
}

QSqlQuery Clock::getClockByPK(QString id)
{
    auto sqlQuery = clock_sql::getQSqlQuery();
    sqlQuery.prepare("select * from clock where id=:id");
    sqlQuery.bindValue(":id",id);
    sqlQuery.exec();
    sqlQuery.next();
    return sqlQuery;
}



/*
 * 闹钟重编辑页面删除闹钟回调
 * Alarm re edit page delete alarm callback
 */
void Clock::deleteAlarm()
{
    int rowNum = model->rowCount();


/*
    delete_msg *deletemsg = new delete_msg();
    QPointF position = this->pos();
    deletemsg->move(position.x()+35,position.y()+200);
    deletemsg->exec();
*/

/*
 * 重新适配QMessageBox控件
 * Refit the qmessagebox control
 */
    int ret;
    QMessageBox msg(this);

    msg.setIcon(QMessageBox::Question);
    msg.setWindowTitle(QObject::tr("Hint"));
    msg.setText(QObject::tr("Are you sure to delete？"));
    msg.addButton(QObject::tr("sure"), QMessageBox::AcceptRole);
    msg.addButton(QObject::tr("cancel"), QMessageBox::RejectRole);

    ret = msg.exec();

    if (ret == QMessageBox::RejectRole) {
        qDebug()<<"dbq-不删除";
    } else {
        //删除数据
        auto curentId = getClockPkByCurrentNum();
        deleteAlarmDatabase(curentId);
        rowNum = model->rowCount();
        qDebug() << rowNum;

    }
    //闹钟页面子项
    updateAlarmItemFront(CURRENT_FONT_SIZE);
}

void Clock::deleteAlarmDatabase(QString id)
{
    int rowNum = model->rowCount();
    auto sqlQuery = clock_sql::getQSqlQuery();
    sqlQuery.prepare("delete from clock where id=:id");
    sqlQuery.bindValue(":id",id);
    sqlQuery.exec();
    for (int i=0; i<rowNum; i++) {
                delete w1[i];
                delete aItem[i];
    }
    model->submitAll();
    updateAlarmClock();
    updateAlarmItemFront(CURRENT_FONT_SIZE);
}

void Clock::updateClockDatabase(QString id, QString name, QString hour, QString minute, int onOff)
{
    QString sql = "update clock set ";
    if(FieldValidUtil::isNotNull(name)){
        sql = sql.append(" Name=:clockName , ");
    }
    if(FieldValidUtil::isNotNull(hour)){
        sql = sql.append(" Hour=:hour , ");
    }
    if(FieldValidUtil::isNotNull(minute)){
        sql = sql.append(" Minute=:minute , ");
    }
    sql = sql.append(" on_or_off=:onOff , ");
    sql = sql.remove(sql.length()-2,2);
    sql = sql.append(" where Id=:id");
    int rowNum = model->rowCount();
    auto sqlQuery = clock_sql::getQSqlQuery();
    sqlQuery.prepare(sql);
    sqlQuery.bindValue(":id",id);
    //绑定数据
    if(FieldValidUtil::isNotNull(name)){
        name = FieldValidUtil::QStringFilter(name);
        sqlQuery.bindValue(":clockName",name);
    }
    if(FieldValidUtil::isNotNull(hour)){
        sqlQuery.bindValue(":hour",hour.toInt());
    }
    if(FieldValidUtil::isNotNull(minute)){
        sqlQuery.bindValue(":minute",minute.toInt());
    }
    sqlQuery.bindValue(":onOff",onOff);
    sqlQuery.exec();
    model->submitAll();
    if(FieldValidUtil::isNotNull(name)||FieldValidUtil::isNotNull(hour)||FieldValidUtil::isNotNull(minute)){
        for (int i=0; i<rowNum; i++) {
                    delete w1[i];
                    delete aItem[i];
        }
        updateAlarmClock();
        updateAlarmItemFront(CURRENT_FONT_SIZE);
    }
}



/*
 * 闹钟开关
 * Alarm switch
 */
void Clock::OnOffAlarm()
{
    int i=0 ;
    CustomButton *btn = qobject_cast<CustomButton*>(QObject::sender());
    while (btn != w1[i]->alarm_on_off0) {
        i++;
    }
    QString id = w1[i]->id();
    if (model->index(i, 3).data().toInt() == 0) {
        btn->closeSlot();
        w1[i]->closeStyle(CURRENT_FONT_SIZE);
        updateClockDatabase(id,nullptr,nullptr,nullptr,1);
    } else {
        btn->openSlot();
        w1[i]->openStyle(CURRENT_FONT_SIZE);
        updateClockDatabase(id,nullptr,nullptr,nullptr,0);
    }
}
/*
 * 不重复时单独关闭闹钟
 * Turn off the alarm separately if it is not repeated
 */
void Clock::offAlarm(int i)
{
    w1[i]->alarm_on_off0->closeSlot();
    model->setData(model->index(i, 3), int(1));
    model->submitAll();

    int rowNum = model->rowCount();
    for (int i = 0; i < rowNum; i++) {
        delete aItem[i];
        delete w1[i];
    }
    updateAlarmClock();
}

/*
 * 倒计时音乐选择
 * Countdown music selection
 */
void Clock::countdownMusicSellect()
{
    musicSelectOnCountdownSet->updateIconLabel(1);
    musicSelectOnCountdownRun->updateIconLabel(1);
    QPointF position = this->pos();
    count_music_sellect->move(position.x()+DIALOG_MOVE_WIDTH,position.y()+482);
    count_music_sellect->setWindowFlags(Qt::Popup);
    refreshMusicSelectList(count_music_sellect);
    count_music_sellect->show();
//    connect(count_music_sellect->listWidget,SIGNAL(itemClicked(QListWidgetItem*)),this,SLOT(countMusicListclickslot()));
}
/*
 * 倒计时音乐选择单机回调
 * Countdown music selection single callback
 */
void Clock::countMusicListclickslot()
{
    int num=count_music_sellect->listWidget->currentRow();
    int size = count_music_sellect->rowNum_all;
    //最后一个自定义铃声
    if(num==(size-1)){
        addDivBell(count_music_sellect,Clock::count_down);
    }else{
        QString id = m_selectBtnUtil->getBellIdByIndex(num);
        QString path = m_selectBtnUtil->getBellPathById(id);
        QString name = m_selectBtnUtil->getBellNameById(id);
        musicSelectOnClockNew->textLabel->setText(name);
        //排除无
        if(num==0){
            path="";
        }
        playMusicFromPath(path);
        model_setup->setData(model_setup->index(0, 1), id);
        musicSelectOnCountdownSet->textLabel->setText(name);
        musicSelectOnCountdownRun->textLabel->setText(name);
        model_setup->submitAll();
    }
    count_music_sellect->close();
}

void Clock::playMusicFromPath(QString path)
{
//    delete musicSelectPlay;
//    musicSelectPlay = new QMediaPlayer(this);
    //停止上次播放
//    stopHisPlay();

//    delete music;
//    music = new QMediaPlayer();
//    music->setMedia(QUrl::fromLocalFile(path));
//    music->play();

    playController::getInstance().playSingleSong(path,0);

}

void Clock::stopHisPlay()
{
    if(hisPlayer!=nullptr){
        hisPlayer->stop();
    }
}
//TODO 加按钮
void Clock::addDivBell(set_alarm_repeat_Dialog *tempDialog, btnType type)
{
    QString filePath = m_selectBtnUtil->openAudioFileDialog(tempDialog);
    if(FieldValidUtil::isNotNull(filePath)){
        qWarning()<<"dbq-开始复制"<<filePath;
        //复制文件
        QString toPatn = m_selectBtnUtil->copyAudioFile(filePath);
        //存储到数据库
        QString bellId = m_selectBtnUtil->saveToBellTable(toPatn);
        QString name = m_selectBtnUtil->getBellNameById(bellId);

        if(type==Clock::count_down){
            musicSelectOnCountdownSet->textLabel->setText(name);
            musicSelectOnCountdownRun->textLabel->setText(name);
        }else{
            musicSelectOnClockNew->textLabel->setText(name);
        }

        playMusicFromPath(toPatn);
        //刷新窗体
//        rebuildCountdownMusicDialog();
        //选中新建的铃声
//        setMusicSelectDialogListById(bellId,count_music_sellect->listWidget);
    }
}

//倒计时执行
// Countdown execution
void Clock::statCountdown(){
    //减1算法
    if(countdown_second>0){
        countdown_second--;
    }else if(countdown_second==0&&countdown_minute>=1){
        countdown_minute--;
        countdown_second=59;
    }else if(countdown_second==0&&countdown_minute==0&&countdown_hour>=1){
        countdown_hour--;
        countdown_minute=59;
        countdown_second=59;
    }

    QString h; QString m; QString s;
    if (countdown_hour < 10){
        QString hours_str = QString::number(countdown_hour);
        h = "0"+hours_str;
    } else {
        h = QString::number(countdown_hour);
    }
    if (countdown_minute < 10) {
        QString minute_str = QString::number(countdown_minute);
        m = "0"+minute_str;
    } else {
        m = QString::number(countdown_minute);
    }

    if (countdown_second < 10) {
        QString second_str = QString::number(countdown_second);
        s = "0"+second_str;
    }else {
        s = QString::number(countdown_second);
    }
    ui->remainTime->setText(h+TIME_SEPARATOR+m+TIME_SEPARATOR+s);
    QString selfFont = Utils::loadFontFamilyFromTTF();
    QFont f(selfFont);
    f.setPixelSize(40);
    ui->remainTime->setFont(f);

    //小型倒计时 显示倒计时时间
    if(this->m_selectTinyCountdown){
        if(checkTinyCountdownDia()){
            tinycountdownDia->updateTimeInfo(h+TIME_SEPARATOR+m+TIME_SEPARATOR+s);
        }
    }
    //时间归零
    if (countdown_hour==0 && countdown_minute==0 && (countdown_second)==0) {
        startbtnCountdown();
        countdown_timer->stop();
        //倒计时通知弹窗
        countdownNoticeDialogShow();
    }
}

void Clock::statCountdownMsec()
{
    countdown_msec-=10;
    if(countdown_msec<=0){
        //减1算法
        if(countdown_second>0){
            countdown_second--;
        }else if(countdown_second==0&&countdown_minute>=1){
            countdown_minute--;
            countdown_second=59;
        }else if(countdown_second==0&&countdown_minute==0&&countdown_hour>=1){
            countdown_hour--;
            countdown_minute=59;
            countdown_second=59;
        }
        countdown_msec=1000;
    }
    //设置当前时间
    int ringmax = countdown_hour*3600 + countdown_minute*60 + countdown_second;
    ui->countdownRunPage->countdownRunRoundBar->setValue(ringmax);

    QString h; QString m; QString s;
    if (countdown_hour < 10){
        QString hours_str = QString::number(countdown_hour);
        h = "0"+hours_str;
    } else {
        h = QString::number(countdown_hour);
    }
    if (countdown_minute < 10) {
        QString minute_str = QString::number(countdown_minute);
        m = "0"+minute_str;
    } else {
        m = QString::number(countdown_minute);
    }

    if (countdown_second < 10) {
        QString second_str = QString::number(countdown_second);
        s = "0"+second_str;
    }else {
        s = QString::number(countdown_second);
    }
    ui->remainTime->setText(h+TIME_SEPARATOR+m+TIME_SEPARATOR+s);
    QString selfFont = Utils::loadFontFamilyFromTTF();
    QFont f(selfFont);
    f.setPixelSize(40);
    ui->remainTime->setFont(f);

    //小型倒计时 显示倒计时时间
    if(this->m_selectTinyCountdown){
        if(checkTinyCountdownDia()){
            tinycountdownDia->updateTimeInfo(h+TIME_SEPARATOR+m+TIME_SEPARATOR+s);
        }
    }
    //时间归零
    if (countdown_hour==0 && countdown_minute==0 && (countdown_second)==0) {
        startbtnCountdown();
        countdown_timer->stop();
        //倒计时通知弹窗
        countdownNoticeDialogShow();
    }
}

/*
 * 倒计时通知弹窗
 * Countdown notification pop-up
 */
void Clock::countdownNoticeDialogShow()
{
    //关闭tiny倒计时
    if(checkTinyCountdownDia()){
        tinycountdownDia->set_dialog_close();
    }

    model_setup->select();
    QScreen *screen=QGuiApplication::primaryScreen ();
    QRect mm=screen->availableGeometry() ;
    int screen_width = mm.width();
    int screen_height = mm.height();
    model_setup->select();
//    countdownNoticeDialog->timer_value = 59;
    //多少秒后自动关闭
    countdownNoticeDialog->ui->autoCloseTime->setText(tr("60 Seconds to close"));
    //左上图标
//    countdownNoticeDialog->ui->titleLabel->setText(tr("Alarm"));
    //时间到
    if (alarmNoticeDialog != nullptr) {
        if (alarmNoticeDialog->isVisible() == 0)
            moveUnderMultiScreen(UP_RIGHT,countdownNoticeDialog,1);
        else
            moveUnderMultiScreen(UP_RIGHT,countdownNoticeDialog,0);
    } else
      moveUnderMultiScreen(UP_RIGHT,countdownNoticeDialog,1);
    countdownNoticeDialog->playMusic();
}

/*
 * 倒计时开始-结束
 * Countdown start end callback
 */
void Clock::startbtnCountdown(){
    if (!countdown_isStarted) {

        //点击了开始
        if (hourTimerRing->m_currentValue==0 && minuteTimeRing->m_currentValue==0 && secondTimeRing->m_currentValue==0) {
            return;
        }
        //当前剩余时间，单位秒
        int ringmax = hourTimerRing->m_currentValue*3600 + minuteTimeRing->m_currentValue*60 + secondTimeRing->m_currentValue;
        //进度圈
        ui->countdownRunPage->countdownRunRoundBar->setRange(0,ringmax);
        //切换进度条颜色
        ui->countdownRunPage->countdownRunRoundBar->switchRunRingColor();
        ui->startCountdownBtn->setStyleSheet("");
        countdown_isStarted=1;
        //结束
        ui->startCountdownBtn->setText(tr("End"));
        //点击开始，刷新数值
        refreshCountdownLabel11Flag = true;
        //设置倒计时初始时间label9 中间数字
        setcoutdownNumber(hourTimerRing->m_currentValue, minuteTimeRing->m_currentValue, secondTimeRing->m_currentValue);//获取转轮当前值
        //倒计时页面
        ui->countdownStackedW->setCurrentIndex(1);
        countdown_timer->start();
        //光圈的进度值修改定时启动

    } else {
        //点击了结束，或者时间耗尽
        ui->countdownRunPage->countdownRunRoundBar->setRange(0,COUNTDOWN_TIME);
        ui->countdownRunPage->countdownRunRoundBar->setValue(COUNTDOWN_TIME);/*初始化倒计时进度圈
                                               Initialize countdown progress circle*/
        countdown_timer->stop();
        countdown_isStarted=0;
        countdown_isStarted_2=0;
        hourTimerRing->m_currentValue = 0;
        minuteTimeRing->m_currentValue = 0;
        secondTimeRing->m_currentValue = 0;
        ui->startCountdownBtn->setText(tr("start"));
        ui->remainTime->setText("00:00:00");
        //切换到倒计时滚轮页
        ui->countdownStackedW->setCurrentIndex(0);
        //暂停
        ui->suspendCountdownBtn->setText(tr("suspend"));

        QPalette palette = ui->suspendCountdownBtn->palette();
        QColor ColorPlaceholderText(248,163,76,255);
        QBrush brush2;
        brush2.setColor(ColorPlaceholderText);
        //主题框架1.0.6-5kylin2
        palette.setColor(QPalette::Highlight,QColor(248,163,76,255));
        palette.setColor(QPalette::Button,QColor(248,163,76,255));
        palette.setBrush(QPalette::ButtonText, QBrush(Qt::white));
        ui->suspendCountdownBtn->setPalette(palette);
        //小窗体清零，隐藏
        if(checkTinyCountdownDia()){
            tinycountdownDia->clearData();
        }
    }
    return;
}

void Clock::tinyCountdownFinish()
{
    tinycountdownDia->hide();
    activeWindow();
    startbtnCountdown();
}

/*
 * 设置倒计时初始时间
 * Set the initial countdown time
 */
void Clock::setcoutdownNumber(int h1, int m1, int s1){
    countdown_hour=h1; countdown_minute=m1 ; countdown_second=s1;

    QString h; QString m; QString s;

    if (countdown_hour < 10){
        QString hours_str = QString::number(countdown_hour);
        h = "0"+hours_str;
    } else {
        h = QString::number(countdown_hour);
    }

    if (countdown_minute < 10) {
        QString minute_str = QString::number(countdown_minute);
        m = "0"+minute_str;
    } else {
        m = QString::number(countdown_minute);
    }

    if (countdown_second < 10) {
        QString second_str = QString::number(countdown_second);
        s = "0"+second_str;
    } else {
        s = QString::number(countdown_second);
    }

    ui->remainTime->setText(h+TIME_SEPARATOR+m+TIME_SEPARATOR+s);
    QString selfFont = Utils::loadFontFamilyFromTTF();
    QFont f(selfFont);
    f.setPixelSize(40);
    ui->remainTime->setFont(f);
    //获取倒计时结束时间
    getCountdownOverTime();
}

/*
 * 倒计时5分钟
 * Countdown 5 minutes set callback
 */
void Clock::onMin_5btnClicked()
{
    hourTimerRing->m_currentValue = 0;
    minuteTimeRing->m_currentValue = 5;
    secondTimeRing->m_currentValue = 0;
    setcoutdownNumber(0, 5, 0);
}

/*
 * 获取倒计时结束时间
 * Get countdown end time
 */
void Clock::getCountdownOverTime()
{
    QTime time = QTime::currentTime();
    int timeH = time.hour();
    int timeM = time.minute();
    int timeS = time.second();
    if(refreshCountdownLabel11Flag){
        x_h = countdown_hour + timeH;
        x_m = countdown_minute + timeM;
        //分钟位进1
        if(countdown_second+timeS>=60){
            x_m+=1;
        }
        refreshCountdownLabel11Flag = false;
        if (x_m >= 60) {
            x_m = x_m - 60;
            x_h ++;
        }
    }
    if (x_h >= 48) {
         x_h = x_h - 48;
         ui->countdownAlarmTime->setText(tr("after tomorrow")+formatX_h(x_h)+TIME_SEPARATOR+changeNumToStr(x_m));
     } else if (x_h >= 24) {
         x_h = x_h - 24;
         ui->countdownAlarmTime->setText(tr("Tomorrow")+formatX_h(x_h)+TIME_SEPARATOR+changeNumToStr(x_m));
    } else{
        ui->countdownAlarmTime->setText(formatX_h(x_h)+TIME_SEPARATOR+changeNumToStr(x_m));
    }
}
//上下午格式
QString Clock::get12hourStr(int x_h)
{
    QString str;
    //12时
   if (x_h >= 12) {
       x_h = x_h - 12;
       str=tr("PM")+" "+changeNumToStr(x_h);
   } else {
       str=tr("AM")+" "+changeNumToStr(x_h);
   }
   return str;
}
/**
 * @brief 创建用户手册dbus客户端
 */
void Clock::createUserGuideDebusClient()
{
    // 用户手册
    QString serviceName = "com.kylinUserGuide.hotel"
                          + QString("%1%2").arg("_").arg(QString::number(getuid()));
    //创建dbus-client
    userGuideInterface = new QDBusInterface(serviceName,
                                            "/",
                                            "com.guide.hotel",
                                            QDBusConnection::sessionBus());
    qDebug() << "connect to kylinUserGuide" << userGuideInterface->isValid();
    if (!userGuideInterface->isValid()) {
        qDebug() << "fail to connect to kylinUserGuide";
        qDebug() << qPrintable(QDBusConnection::sessionBus().lastError().message());
        return;
    }
}

void Clock::onTinyClicked()
{
    this->m_selectTinyCountdown=true;
    //主窗体最小化
    setWindowState(Qt::WindowMinimized);
    moveUnderMultiScreen(UP_RIGHT,tinycountdownDia,0);
    tinycountdownDia->showTop();
}

void Clock::activeWindow()
{
    setWindowState(Qt::WindowActive);
}
//刷新时间格式
QString Clock::formatX_h(int x_h)
{
    QString str;
    //跟随系统时间
   if(m_timeZone == "24"){
       str=changeNumToStr(x_h);
   }else{
       //12时
      str =get12hourStr(x_h);
   }
    return str;
}
/*
 * 单位变双位
 * Integer to character
 */
QString Clock::changeNumToStr(int alarmHour)
{
    QString str;
    if (alarmHour < 10) {
        QString hours_str = QString::number(alarmHour);
        str = "0"+hours_str;
    } else {
        str = QString::number(alarmHour);
    }
    return str;
}

/*
 * 倒计时-暂停继续
 * Countdown - pause resume callback
 */
void Clock::onCountPushClicked()
{
    tinycountdownDia->updateOnRunState(countdown_isStarted_2);
    if (countdown_isStarted_2){
        //点击了继续
        ui->suspendCountdownBtn->setText(tr("suspend"));
        //切换进度条颜色
        ui->countdownRunPage->countdownRunRoundBar->switchRunRingColor();

        QPalette palette = ui->suspendCountdownBtn->palette();
        QColor ColorPlaceholderText(248,163,76,255);
        QBrush brush2;
        brush2.setColor(ColorPlaceholderText);
        //主题框架1.0.6-5kylin2
        palette.setColor(QPalette::Highlight,QColor(248,163,76,255));
        palette.setColor(QPalette::Button,QColor(248,163,76,255));
        palette.setBrush(QPalette::ButtonText, QBrush(Qt::white));
        ui->suspendCountdownBtn->setPalette(palette);

        countdown_timer->start();
        countdown_isStarted_2=0;
        refreshCountdownLabel11Flag = true;
        getCountdownOverTime();
    } else {
        //点击了暂停
        ui->suspendCountdownBtn->setText(tr("continue"));
        //切换进度条颜色
        ui->countdownRunPage->countdownRunRoundBar->switchStopRingColor();

        QPalette palette = ui->suspendCountdownBtn->palette();
        QColor ColorPlaceholderText(SWITCH_BTN_HIGHLIGHT_BACK_COLOR);
        QBrush brush2;
        brush2.setColor(ColorPlaceholderText);
        //主题框架1.0.6-5kylin2
        palette.setColor(QPalette::Highlight,QColor(69, 173, 110,255));
        palette.setColor(QPalette::Button,QColor(69, 173, 110,255));
        palette.setBrush(QPalette::ButtonText, QBrush(Qt::white));
        ui->suspendCountdownBtn->setPalette(palette);

        countdown_timer->stop();
        countdown_isStarted_2=1;
    }

    return;
}

/*
 * 倒计时初始数字转盘
 * Countdown initial digital dial
 */
void Clock::countdownSetStartTime()
{

    //倒计时小时滚轮
    hourTimerRing = new VerticalScroll_99(ui->countdownSetPage);
    QLabel * h_in_m = new QLabel (ui->countdownSetPage);
    //倒计时分钟
    minuteTimeRing = new VerticalScroll_60(ui->countdownSetPage);
    QLabel * m_in_s = new QLabel (ui->countdownSetPage);
    //倒计时秒
    secondTimeRing = new VerticalScroll_60(ui->countdownSetPage);
    QLabel * after_s = new QLabel (ui->countdownSetPage);


    h_in_m->resize(50,30);
    h_in_m->setText(tr("hour"));
//    h_in_m->setStyleSheet("font: 30pt 'Sans Serif';");
    m_in_s->resize(50,30);
    m_in_s->setText(tr("min"));
//    m_in_s->setStyleSheet("font: 30pt 'Sans Serif';");
    after_s->resize(50,30);
    after_s->setText(tr("sec"));
//    after_s->setStyleSheet("font: 30pt 'Sans Serif';");
    int ringMoveWidth = 73;
    int ringMoveHeight = 45;
    int timeSep = 100;
    int labelSep = 55;
    int timeLabelMoveHeight = 130;
    hourTimerRing->move(ringMoveWidth, ringMoveHeight);
    h_in_m->move(ringMoveWidth+labelSep,timeLabelMoveHeight);
    //hour 要比min长
    if(Utils::checkLocalUs()){
        ringMoveWidth+=timeSep+4;
    }else{
        ringMoveWidth+=timeSep;
    }
    minuteTimeRing->move(ringMoveWidth, ringMoveHeight);
    m_in_s->move(ringMoveWidth+labelSep,timeLabelMoveHeight);
    ringMoveWidth+=timeSep;
    secondTimeRing->move(ringMoveWidth, ringMoveHeight);
    after_s->move(ringMoveWidth+labelSep,timeLabelMoveHeight);
    //配置倒计时页的开始按钮
    startCountSingle = new QPushButton(ui->countdownSetPage);
    startCountSingle->resize(120,34);
    startCountSingle->move(135,401);
    startCountSingle->setText(tr("start"));
    connect(startCountSingle, SIGNAL(clicked()), this, SLOT(startbtnCountdown()) );

    QPalette palette2 = startCountSingle->palette();
    QColor ColorPlaceholderText2(233,233,233,255);
    QBrush brush2;
    brush2.setColor(ColorPlaceholderText2);
    palette2.setColor(QPalette::Button,QColor(233,233,233,255));
    //palette2.setBrush(QPalette::ButtonText, QBrush(Qt::white));
    startCountSingle->setPalette(palette2);

    QTimer *timer_count_start;
    timer_count_start = new QTimer();
    connect(timer_count_start, SIGNAL(timeout()), this, SLOT(countStatBtnGray()));
    timer_count_start->setInterval(100);
    timer_count_start->start();
}

/*
 * 倒计时页开始键致灰
 *  Start button of countdown page grays out
 */
void Clock::countStatBtnGray()
{
    if(hourTimerRing->m_currentValue==0 && minuteTimeRing->m_currentValue==0 && secondTimeRing->m_currentValue==0) {
        startCountSingle->setEnabled(false);
        QStyleOption opt;
        opt.init(this);

        if(theme::themetype==0){
            QPalette palette2 = startCountSingle->palette();
            QColor ColorPlaceholderText2(233,233,233,255);
            QBrush brush2;
            brush2.setColor(ColorPlaceholderText2);
            palette2.setColor(QPalette::Button,QColor(233,233,233,255));
            palette2.setBrush(QPalette::ButtonText, QBrush(QColor(158,158,158,255)));
            startCountSingle->setPalette(palette2);
        }else{
            QPalette palette2 = startCountSingle->palette();
            QColor ColorPlaceholderText2(45,45,48,255);
            QBrush brush2;
            brush2.setColor(ColorPlaceholderText2);
            palette2.setColor(QPalette::Button,QColor(45,45,48,255));
            palette2.setBrush(QPalette::ButtonText, QBrush(QColor(58,58,58,255)));
            startCountSingle->setPalette(palette2);
        }
    }else{
        startCountSingle->setEnabled(true);
        QPalette palette2 = startCountSingle->palette();
        QColor ColorPlaceholderText2(SWITCH_BTN_HIGHLIGHT_BACK_COLOR);
        QBrush brush2;
        brush2.setColor(ColorPlaceholderText2);
        palette2.setColor(QPalette::Button,QColor(SWITCH_BTN_HIGHLIGHT_BACK_COLOR));
        palette2.setBrush(QPalette::ButtonText, QBrush(Qt::white));
        startCountSingle->setPalette(palette2);
    }
}


void Clock::updateLabelFront(QLabel *label, int size)
{
    QString styleSheet = "font-size:";
    styleSheet.append(QString::number(size)).append("px;");
    label->setStyleSheet(styleSheet);
}

void Clock::updateQLineEditFront(QLineEdit *lineEdit, int size)
{
    QFont font ;
    font.setPixelSize(size);
    lineEdit->setFont(font);
}
/**
 * @brief 放大闹钟子项字体
 */
void Clock::updateAlarmItemFront(int size)
{
    QListWidget * alarmList = ui->alarmListWidget;
    for (int i=0;i<alarmList->count() ;i++ ) {
        QListWidgetItem * varItem =  alarmList->item(i);
        item_new * varWidget = static_cast<item_new*>(alarmList->itemWidget(varItem)) ;
        varWidget->commonStyle(size);
    }
}

void Clock::updateStopwatchItemFront(int size)
{
    QListWidget * stopwatchList = ui->timeListWidget;
    for (int i=0;i<stopwatchList->count() ;i++ ) {
        QListWidgetItem * varItem =  stopwatchList->item(i);
        stopwatch_item * varWidget = static_cast<stopwatch_item*>(stopwatchList->itemWidget(varItem)) ;
        updateLabelFront(varWidget->stopwatch1,round(1.1*size));
        updateLabelFront(varWidget->stopwatch2,round(1.1*size));
        updateLabelFront(varWidget->stopwatch3,round(2.2*size));
    }
}
void Clock::updateFront(const int size)
{

    //闹钟页面子项
    updateAlarmItemFront(size);
    //秒表页面 两个时间
    updateLabelFront(ui->timeShowBig,round(3.2*size));
    updateLabelFront(ui->timeShowSmall,round(1.73*size));
    //秒表页面子项
    updateStopwatchItemFront(size);
    double font = 1.15;
    //闹钟编辑页面
    //重复
    updateLabelFront(repeatSelectOnClockNew->nameLabel,round(font*size));
    updateLabelFront(repeatSelectOnClockNew->textLabel,round(font*size));
    //提醒铃声
    updateLabelFront(musicSelectOnClockNew->nameLabel,round(font*size));
    updateLabelFront(musicSelectOnClockNew->textLabel,round(font*size));
    //稍后提醒
    updateLabelFront(remindSelectOnClockNew->nameLabel,round(font*size));
    updateLabelFront(remindSelectOnClockNew->textLabel,round(font*size));
    //倒计时 set 铃声
    updateLabelFront(musicSelectOnCountdownSet->nameLabel,round(font*size));
    updateLabelFront(musicSelectOnCountdownSet->textLabel,round(font*size));
    //倒计时 run 铃声
    updateLabelFront(musicSelectOnCountdownRun->nameLabel,round(font*size));
    updateLabelFront(musicSelectOnCountdownRun->textLabel,round(font*size));
    //闹钟名
    updateLabelFront(clockEditOnClockNew->nameLabel,round(font*size));
    //闹钟编辑
    updateQLineEditFront(clockEditOnClockNew->clockNameLineEdit,round(font*size));
}
void Clock::updateRepeatStr(QLabel *label){
    if(Utils::checkLocalChina()){
        updateLabelTextByLength(label,16);
    }
    if(Utils::checkLocalUs()){
        updateLabelTextByLength(label,25);
    }
}
void Clock::updateLabelTextByLength(QLabel *label, int limitSize)
{
    QString str = label->text();
    if(str.length()>limitSize){
        label->setToolTip(str);
        str = Utils::getOmitStr(str,limitSize);
    }
    label->setText(str);
}


/*
 * 闹钟初始化数字转盘
 * Alarm clock initialization digital turntable drawing
 */
void Clock::alarmSetStartTime()
{
    shadow = new QWidget(ui->editAlarmPage);
    shadow->move(115,58);
    shadow->resize(160,58);
    //闹钟小时滚轮
    timer_alarm_start24 = new VerticalScroll_24(ui->editAlarmPage, this);
    QLabel * h_in_m = new QLabel (ui->editAlarmPage);
    //闹钟分钟滚轮
    timer_alarm_start60 = new VerticalScroll_60(ui->editAlarmPage);

    timer_alarm_start24->resize(63,220);
    timer_alarm_start60->resize(63,220);

    QLabel * hour_ring = new QLabel (ui->editAlarmPage);
    QLabel * min_ring = new QLabel (ui->editAlarmPage);

    hour_ring->hide();
    min_ring->hide();

    hour_ring->setAlignment(Qt::AlignHCenter);
    min_ring->setAlignment(Qt::AlignHCenter);

    h_in_m->resize(10,40);
    h_in_m->setText(TIME_SEPARATOR);
    h_in_m->setStyleSheet("font: 25pt;");

    hour_ring->resize(50,30);
    hour_ring->setText(tr("hour"));
    hour_ring->setStyleSheet("font: 13pt ;color: rgb(148, 148, 148);");
    min_ring->resize(50,30);
    min_ring->setText(tr("min"));
    min_ring->setStyleSheet("font: 13pt ;color: rgb(148, 148, 148);");
    int ringMoveHeight = -30;
    timer_alarm_start24->move(124, ringMoveHeight);
    hour_ring->move(140,7);
    h_in_m->move(187,60);
    timer_alarm_start60->move(196, ringMoveHeight);
    min_ring->move(212,7);
}

/*
 * 闹钟初始化工作日选择界面绘制回调
 * Alarm clock initialization workday selection interface drawing callback
 */
void Clock::alarmRepeat()
{
    repeatSelectOnClockNew->updateIconLabel(1);
    int num;
    //repeat_new_or_edit_flag 编辑是1
    if(repeat_new_or_edit_flag)
        num = ui->alarmListWidget->currentRow();
    else {
        num= model->rowCount();
    }
        QPointF position = this->pos();//446
        dialog_repeat->move(position.x()+DIALOG_MOVE_WIDTH,position.y()+420);
        dialog_repeat->setWindowFlags(Qt::Popup);
        dialog_repeat->widget[0]->alarmLabel0->setText(tr("No repetition"));
        dialog_repeat->widget[1]->alarmLabel0->setText(tr("Workingday"));
        dialog_repeat->widget[2]->alarmLabel0->setText(tr("Mon"));
        dialog_repeat->widget[3]->alarmLabel0->setText(tr("Tue"));
        dialog_repeat->widget[4]->alarmLabel0->setText(tr("Wed"));
        dialog_repeat->widget[5]->alarmLabel0->setText(tr("Thu"));
        dialog_repeat->widget[6]->alarmLabel0->setText(tr("Fri"));
        dialog_repeat->widget[7]->alarmLabel0->setText(tr("Sat"));
        dialog_repeat->widget[8]->alarmLabel0->setText(tr("Sun"));
        for (int i=0; i<7; i++) {
            if (repeat_day[i]) {
                //前两个是不重复和工作日
                dialog_repeat->widget[i+2]->alarmLabel1->setPixmap(repeat_on_Pixmap);
            } else {
                dialog_repeat->widget[i+2]->alarmLabel1->setPixmap(repeat_off_Pixmap);
            }
        }
        dialog_repeat->show();
}
/*
 * 重复选项单击回调
 * Repeat option click callback
 */
void Clock::repeatListclickslot()
{
    int num=dialog_repeat->listWidget->currentRow();
    QString day[7] ;
    day[0]= tr("Mon")+"  ";
    day[1] = tr("Tue")+"  ";
    day[2] = tr("Wed")+"  ";
    day[3] = tr("Thu")+"  ";
    day[4] = tr("Fri")+"  ";
    day[5] = tr("Sat")+"  ";
    day[6] = tr("Sun")+"  ";
    //存储"重复"数据
    switch (num)
    {
    case 0:
        repeatSelectOnClockNew->textLabel->setText(tr("No repetition"));
        repeat_str_model = tr("No repetition");
        //不重复
        for (int i=0; i<7; i++) {
            // 周一到周日 全存1
            repeat_day[i] = 1;
            qDebug() << repeat_day[i];
            //周一到周日 设为不选中 但后续会被覆盖？
            dialog_repeat->widget[i+2]->alarmLabel1->setPixmap(repeat_off_Pixmap);
        }

        dialog_repeat->close();
        return;
        break;
    case 1:
        repeatSelectOnClockNew->textLabel->setText(tr("Workingday"));
        repeat_str_model = tr("Workingday");
        for (int i=0; i<7; i++) {
            if(i<5) {
                repeat_day[i] = 1;
                dialog_repeat->widget[i+2]->alarmLabel1->setPixmap(repeat_on_Pixmap);
            } else {
                repeat_day[i] = 0;
                dialog_repeat->widget[i+2]->alarmLabel1->setPixmap(repeat_off_Pixmap);
            }
        }
        dialog_repeat->widget[7]->alarmLabel1->setPixmap(repeat_on_Pixmap);
        dialog_repeat->widget[8]->alarmLabel1->setPixmap(repeat_on_Pixmap);
        dialog_repeat->close();
        return;
        break;
    case 2:
        if (repeat_day[0] == 0 ) {
            repeat_day[0] = 1;
            dialog_repeat->widget[2]->alarmLabel1->setPixmap(repeat_on_Pixmap);
        } else {
            if(repeat_day[1]== 0 && repeat_day[2]== 0 && repeat_day[3]== 0 && repeat_day[4]== 0 && repeat_day[5]== 0 && repeat_day[6]== 0){
                 //防止全部勾选被取消
            }else{
            repeat_day[0] = 0;
            dialog_repeat->widget[2]->alarmLabel1->setPixmap(repeat_off_Pixmap);
            }
        }
        break;
    case 3:
        if(repeat_day[1] == 0 ) {
            repeat_day[1] = 1;
            dialog_repeat->widget[3]->alarmLabel1->setPixmap(repeat_on_Pixmap);
        } else {
            if(repeat_day[0]== 0 && repeat_day[2]== 0 && repeat_day[3]== 0 && repeat_day[4]== 0 && repeat_day[5]== 0 && repeat_day[6]== 0){

            }else{
            repeat_day[1] = 0;
            dialog_repeat->widget[3]->alarmLabel1->setPixmap(repeat_off_Pixmap);
            }
        }
        break;
    case 4:
        if (repeat_day[2] == 0 ) {
            repeat_day[2] = 1;
            dialog_repeat->widget[4]->alarmLabel1->setPixmap(repeat_on_Pixmap);
        } else {
            if(repeat_day[1]== 0 && repeat_day[0]== 0 && repeat_day[3]== 0 && repeat_day[4]== 0 && repeat_day[5]== 0 && repeat_day[6]== 0){

            }else{
            repeat_day[2] = 0;
            dialog_repeat->widget[4]->alarmLabel1->setPixmap(repeat_off_Pixmap);
            }
        }
        break;
    case 5:
        if (repeat_day[3] == 0 ) {
            repeat_day[3] = 1;
            dialog_repeat->widget[5]->alarmLabel1->setPixmap(repeat_on_Pixmap);
        } else {
            if(repeat_day[1]== 0 && repeat_day[2]== 0 && repeat_day[0]== 0 && repeat_day[4]== 0 && repeat_day[5]== 0 && repeat_day[6]== 0){

            }else{
            repeat_day[3] = 0;
            dialog_repeat->widget[5]->alarmLabel1->setPixmap(repeat_off_Pixmap);
            }
        }
        break;
    case 6:
        if (repeat_day[4] == 0 ) {
            repeat_day[4] = 1;
            dialog_repeat->widget[6]->alarmLabel1->setPixmap(repeat_on_Pixmap);
        } else {
            if(repeat_day[1]== 0 && repeat_day[2]== 0 && repeat_day[3]== 0 && repeat_day[0]== 0 && repeat_day[5]== 0 && repeat_day[6]== 0){

            }else{
            repeat_day[4] = 0;
            dialog_repeat->widget[6]->alarmLabel1->setPixmap(repeat_off_Pixmap);
            }
        }
        break;
    case 7:
        if (repeat_day[5] == 0 ) {
            repeat_day[5] = 1;
            dialog_repeat->widget[7]->alarmLabel1->setPixmap(repeat_on_Pixmap);
        } else {
            if(repeat_day[1]== 0 && repeat_day[2]== 0 && repeat_day[3]== 0 && repeat_day[4]== 0 && repeat_day[0]== 0 && repeat_day[6]== 0){

            }else{
            repeat_day[5] = 0;
            dialog_repeat->widget[7]->alarmLabel1->setPixmap(repeat_off_Pixmap);
            }
        }
        break;
    case 8:
        if (repeat_day[6] == 0 ) {
            repeat_day[6] = 1;
            dialog_repeat->widget[8]->alarmLabel1->setPixmap(repeat_on_Pixmap);
        } else {
            if(repeat_day[1]== 0 && repeat_day[2]== 0 && repeat_day[3]== 0 && repeat_day[4]== 0 && repeat_day[5]== 0 && repeat_day[0]== 0){

            }else{
            repeat_day[6] = 0;
            dialog_repeat->widget[8]->alarmLabel1->setPixmap(repeat_off_Pixmap);
            }
        }
        break;
    default:
        break;
    }
    //构造重复repeat_str
    for (int i=0; i<7; i++) {
        if (repeat_day[i]) {
            repeat_str=repeat_str+day[i];
        }
    }
    if(repeat_day[0]&&repeat_day[1]&&repeat_day[2]&&repeat_day[3]&&repeat_day[4]&&repeat_day[5]&&repeat_day[6])
        repeat_str = tr("Every day");
    repeatSelectOnClockNew->textLabel->setText(repeat_str);
    repeat_str_model = repeat_str;
    repeat_str="";
    updateRepeatStr(repeatSelectOnClockNew->textLabel);
}

/*
 * 闹钟初始化音乐选择界面回调
 * Alarm clock initialization music selection interface callback
 */
void Clock::selectAlarmMusic()
{
    musicSelectOnClockNew->updateIconLabel(1);
    QPointF position = this->pos();
    dialog_music->move(position.x()+DIALOG_MOVE_WIDTH,position.y()+482);
    dialog_music->setWindowFlags(Qt::Popup);
    refreshMusicSelectList(dialog_music);
    dialog_music->show();
}

void Clock::refreshMusicSelectList(set_alarm_repeat_Dialog *tempDialog)
{
//    tempDialog = new
    QList<QString> * bellList = m_selectBtnUtil->getAllBellItem();
    int newSize = bellList->size();
    int currentSize = tempDialog->rowNum_all;
    if(currentSize<newSize){
        for (int i=currentSize;i<newSize;i++) {
            tempDialog->set_aItem(i);
        }
        tempDialog->rowNum_all=newSize;
    }
    for (int i=0;i<bellList->size();i++) {
        tempDialog->widget[i]->alarmLabel0->setText(bellList->at(i));
    }
}





void Clock::selectRemindLate()
{
    remindSelectOnClockNew->updateIconLabel(1);
    QPointF position = this->pos();
    dialog_remind_late->move(position.x()+DIALOG_MOVE_WIDTH,position.y()+510);
    dialog_remind_late->setWindowFlags(Qt::Popup);
    dialog_remind_late->widget[0]->alarmLabel0->setText(tr("none"));
    dialog_remind_late->widget[1]->alarmLabel0->setText(tr("five mins late"));
    dialog_remind_late->widget[2]->alarmLabel0->setText(tr("ten mins late"));
    dialog_remind_late->widget[3]->alarmLabel0->setText(tr("twenty mins late"));
    dialog_remind_late->widget[4]->alarmLabel0->setText(tr("thirsty mins late"));
    dialog_remind_late->widget[5]->alarmLabel0->setText(tr("one hour late"));
    dialog_remind_late->show();

}

/*
 * 闹钟初始化单击选择音乐
 * Alarm initialization Click to select music
 */
void Clock::musicListclickslot()
{
    int num=dialog_music->listWidget->currentRow();
    int size = dialog_music->rowNum_all;
    //最后一个自定义铃声
    if(num==(size-1)){
        addDivBell(dialog_music,Clock::add_clock);
    }else{
        QString id = m_selectBtnUtil->getBellIdByIndex(num);
        QString path = m_selectBtnUtil->getBellPathById(id);
        QString name = m_selectBtnUtil->getBellNameById(id);
        musicSelectOnClockNew->textLabel->setText(name);
        //排除无
        if(num==0){
            path="";
        }
        playMusicFromPath(path);
    }
    dialog_music->close();
}

void Clock::remindLateListClickSlot()
{
    int num=dialog_remind_late->listWidget->currentRow();
    remind_late_str_model =getRemindLateStrFromNum(num);
    remindSelectOnClockNew->textLabel->setText(remind_late_str_model);
    dialog_remind_late->close();
}

QString Clock::getRemindLateStrFromNum(int num)
{
    QString temp=tr("none");
    switch (num)
    {
    case 0:
        temp=tr("none");
        break;
    case 1:
        temp=tr("five mins late");
        break;
    case 2:
        temp=tr("ten mins late");
        break;
    case 3:
        temp=tr("twenty mins late");
        break;
    case 4:
        temp=tr("thirsty mins late");
        break;
    case 5:
        temp=tr("one hour late");
        break;
    default:
        temp=tr("none");
        break;
    }
    return temp;
}



/*
 * Default setting database data initialization
 * 默认设置数据库数据初始化
 */
void Clock::modelSetupSet()
{
    int setup_rowNum;
    setup_rowNum = model_setup->rowCount();
    if (setup_rowNum < 1) {
        model_setup->insertRow(setup_rowNum);
        model_setup->setData(model_setup->index(setup_rowNum, 0), int(0));//静音    Mute
        QString id = m_selectBtnUtil->getDefaultBellId();
        model_setup->setData(model_setup->index(setup_rowNum, 1), id);
    }
    model_setup->submitAll();
}



void Clock::paintEvent(QPaintEvent *event)
{
    Q_UNUSED(event);
    QPainter p(this);
    p.setRenderHint(QPainter::Antialiasing);  // 反锯齿;
    QPainterPath rectPath;
    rectPath.addRoundedRect(this->rect(), 0, 0); // 左上右下

    QPainter painter(this);
    QStyleOption opt;
    opt.init(this);
    painter.setBrush(opt.palette.color(QPalette::Base));

    QColor mainColor;
    mainColor = palette().color(QPalette::Base);
    p.fillPath(rectPath,QBrush(mainColor));
}



bool Clock::eventFilter(QObject *watched, QEvent *event)
{
    if(watched == ui->editAlarmPage && event->type() == QEvent::Paint)
    {
        showPaint(); //响应函数
    }

    if(watched == shadow && event->type() == QEvent::Paint)
    {
//        showPaint7();
    }
    return QWidget::eventFilter(watched,event);
}

/*
 * 实现响应函数设置页
*/
void Clock::showPaint()
{
    QPainter painter(ui->editAlarmPage);
    painter.setPen(Qt::gray);
    painter.setBrush(Qt::green);
    QStyleOption opt;
    opt.init(this);
    painter.setBrush(opt.palette.color(QPalette::Base));
    painter.setPen(Qt::transparent);
    QRect rect = ui->editAlarmPage->rect();
    rect.setWidth(rect.width() - 0);
    rect.setHeight(rect.height() - 0);
    painter.drawRoundedRect(rect, 7, 7);
    {
        QPainterPath painterPath;
        painterPath.addRoundedRect(rect, 0, 0);
        painter.drawPath(painterPath);
    }
}



/*
 * 实现响应函数设置页
*/
void Clock::showPaint7()
{
    QPainter painter(shadow);
    painter.setPen(Qt::gray);
    painter.setBrush(Qt::green);
    QStyleOption opt;
    opt.init(this);
    painter.setBrush(opt.palette.color(QPalette::Base));


    painter.setBrush(QColor(theme::timeScrollBackColor));

    painter.setPen(Qt::transparent);
    QRect rect = shadow->rect();
    rect.setWidth(rect.width() - 0);
    rect.setHeight(rect.height() - 0);
    painter.drawRoundedRect(rect, 7, 7);
    {
        QPainterPath painterPath;
        painterPath.addRoundedRect(rect, 8, 8);
        painter.drawPath(painterPath);
    }
}
/**
 * @brief 多屏幕下，Natice_alarm移动
 * @param spostion SP_LEFT 左下角 SP_RIGHT 右下角 SP_CENTER 居中
 * @param
 *
 * @return 返回说明
 */
void Clock::moveUnderMultiScreen(Clock::ScreenPosition spostion,QWidget * tempDialog,int hiddenFlag)
{
    QScreen *screen=QGuiApplication::primaryScreen ();
    int screen_width = screen->geometry().width();
    int screen_height = screen->geometry().height();
    int x = primaryManager->getNScreen_x();
    int y = primaryManager->getNScreen_y();
    int heightRadio = 20;
    int widthRadio = 14;

    switch (spostion) {
    case SP_LEFT:
    {
        int moveWidth = x+round(tempDialog->width()+round(1.0/heightRadio*screen_width));
        int moveHeight = y+round(screen_height-tempDialog->height()-round(1.0/widthRadio*screen_height));
        tempDialog->move(moveWidth,moveHeight);
    }break;
    case SP_RIGHT:
    {
        int moveWidth = x+round(screen_width-tempDialog->width());
        int moveHeight = y+round(screen_height-tempDialog->height()-50);
        tempDialog->move(moveWidth,moveHeight);
        if (hiddenFlag == 1)
        tempDialog->move(moveWidth,moveHeight);
        else
        tempDialog->move(moveWidth,moveHeight-tempDialog->height());
    }break;
    case SP_CENTER:
    {
        int moveWidth = x+round((screen_width-tempDialog->width())*1.0/2);
        int moveHeight = y+round((screen_height-tempDialog->height())*1.0/2);
        tempDialog->move(moveWidth,moveHeight);
    }break;
    case UP_LEFT:
    {
        int moveWidth = x+round(tempDialog->width()+round(1.0/heightRadio*screen_width));
        int moveHeight = y+round(tempDialog->height()+round(1.0/widthRadio*screen_height));
        tempDialog->move(moveWidth,moveHeight);
    }break;
    case UP_RIGHT:
    {
        int moveWidth = x+round(screen_width-tempDialog->width()-round(1.0/heightRadio*screen_width));
        int moveHeight = y+round(1.0/20*screen_height);
        tempDialog->move(moveWidth,moveHeight);
    }break;
    case UP_CENTER:
    {
        int moveWidth = x+round((screen_width-tempDialog->width())*1.0/2);
        int moveHeight = y+round((screen_height-tempDialog->height())*1.0/2);
        tempDialog->move(moveWidth,moveHeight);
    }break;
    default:
    {}
    }
}


void Clock::updateTinyBtn()
{
    QPixmap pixmap = QPixmap(":image/switchIconB.png");
    ui->tinyWindowBtn->setProperty("useButtonPalette", true);
    ui->tinyWindowBtn->setIcon(pixmap);
    ui->tinyWindowBtn->setIconSize(QSize(24,24));
    ui->tinyWindowBtn->setToolTip(tr("mini window"));
//    ui->tinyWindowBtn->setFlat(true);
}
void Clock::updateSwitchBtnStyle()
{
    int index=ui->mainWidget->currentIndex();
    if(index==1){
        AlarmPageSwitch();
    }else if(index==0){
        CountdownPageSwitch ();
    }else if(index==2){
        StopwatchPageSwitch ();
    }
}
//黑色主题
void  Clock::blackStyle()
{
    ui->timeShowBig->setStyleSheet("color: rgba(255, 255, 255, 0.9);font-size:38px;");
    QString selfFont = Utils::loadFontFamilyFromTTF();
    QFont f(selfFont);
    f.setPixelSize(38);
    ui->timeShowBig->setFont(f);
    ui->remainTime->setStyleSheet("color: rgba(255, 255, 255, 0.9)");
    ui->noAlarmIcon->setPixmap(QPixmap(":/image/noClockBlack.png"));
    ui->noAlarm->setStyleSheet("color: rgba(255, 255, 255, 0.6);font-size:16px;");

    widgetListBlackStyle(ui->alarmListWidget);
    widgetListBlackStyle(ui->timeListWidget);
    QString itemRadius = QString::number(ITEM_RADIUS);
    clockEditOnClockNew->clockNameLineEdit->setStyleSheet("QLineEdit{background-color:rgb(55, 55, 59);border-radius:"+itemRadius+"px;color: rgb(148, 148, 148);}");
    ui->tinyWindowBtn->setIcon(QIcon(":image/switchIconW.png"));
    updateSwitchBtnStyle();
}
//白色主题
void  Clock::whiteStyle()
{
    ui->timeShowBig->setStyleSheet("color: rgba(49, 66, 89, 1);font-size:38px;");
    QString selfFont = Utils::loadFontFamilyFromTTF();
    QFont f(selfFont);
    f.setPixelSize(38);
    ui->timeShowBig->setFont(f);
    ui->remainTime->setStyleSheet("color: rgba(49, 66, 89, 1)");
    ui->noAlarmIcon->setPixmap(QPixmap(":/image/noClockWhite.png"));
    ui->noAlarm->setStyleSheet("color: rgba(49, 66, 89, 0.6);font-size:16px;");
    widgetListWhiteStyle(ui->alarmListWidget);
    widgetListWhiteStyle(ui->timeListWidget);
    QString itemRadius = QString::number(ITEM_RADIUS);
    clockEditOnClockNew->clockNameLineEdit->setStyleSheet("QLineEdit{background-color:rgb(240, 240, 240);border-radius:"+itemRadius+"px;color: rgb(148, 148, 148);}");
    ui->tinyWindowBtn->setIcon(QIcon(":image/switchIconB.png"));
    updateSwitchBtnStyle();
}

QString Clock::getDefaultGreyColor()
{
    QColor color = QColor(COUNTDOWN_RING_BACKCOLOR_WHITE_STYLE);
    QString str = theme::getColorStr(color);
    return str;
}





