Task for adjusting

//taskwidget.h
#ifndef TASKWIDGET_H
#define TASKWIDGET_H

#include
#include "ui_taskwidget.h"
#include
enum{TASK_START,TASK_PAUSE,TASK_TOP};
class TaskWidget : public QWidget
{
Q_OBJECT

public:
TaskWidget(QWidget *parent = 0);
~TaskWidget();

public:
void startProgressBar();
void pauseProgressBar();
void stopProgressBar();
int getTaskStatus();
private:
Ui::TaskWidgetClass ui;
QTimer *timer;
int int_progress;
int int_status;
private slots:
void timerStart();
};

#endif // TASKWIDGET_H
/
//taskwidget.cpp
#include "taskwidget.h"

#define TIMER_SPEED 100
TaskWidget::TaskWidget(QWidget *parent)
: QWidget(parent)
{
ui.setupUi(this);
timer = new QTimer(this);
int_progress = 0;
connect(timer, SIGNAL(timeout()), this, SLOT(timerStart()));
ui.progressBar->setMaximum(100);
}

TaskWidget::~TaskWidget()
{
}

void TaskWidget::startProgressBar()
{
ui.label->setText(tr("Starting..."));
timer->start(TIMER_SPEED);
int_status = TASK_START;
}
void TaskWidget::pauseProgressBar()
{
ui.label->setText(tr("Pauseing..."));
timer->stop();
int_status = TASK_PAUSE;
}
void TaskWidget::stopProgressBar()
{
ui.label->setText(tr("Stoping..."));
timer->stop();
int_progress = 0;
int_status = TASK_TOP;
}

int TaskWidget::getTaskStatus()
{
return int_status;
}

void TaskWidget::timerStart()
{
if(int_progress < 100)
{
int_progress ++;
}
else
{
int_progress = 0;
}
ui.progressBar->setValue(int_progress);
}

//qttaskcount.cpp
#include "qttaskcount.h"
#include
#include "taskwidget.h"

#define TASK_DEFALT_COUNT 5
QtTaskCount::QtTaskCount(QWidget *parent, Qt::WFlags flags)
: QMainWindow(parent, flags)
{
ui.setupUi(this);
ui.taskCountSpinBox->setValue(TASK_DEFALT_COUNT);
taskCount = ui.taskCountSpinBox->value();
connect(ui.taskCountSpinBox, SIGNAL(valueChanged(int)), this, SLOT(spinboxValueChanged(int)));
}

QtTaskCount::~QtTaskCount()
{

}

void QtTaskCount::on_addTaskBtn_clicked()
{
//void QTreeWidget::setItemWidget ( QTreeWidgetItem * item, int column, QWidget * widget )
addTask();
}

void QtTaskCount::addTask()
{
TaskWidget *taskWidget = new TaskWidget();
QListWidgetItem *item = new QListWidgetItem();
ui.listWidget->addItem(item);
item->setSizeHint(taskWidget->size());
ui.listWidget->setItemWidget(item,taskWidget);
if (initializeAddTask())
{
taskWidget->startProgressBar();
startTaskWidgetList.append(taskWidget);
}
else
{
taskWidget->pauseProgressBar();
pauseTaskWidgetList.append(taskWidget);
}
allTaskWidgetList.append(taskWidget);
refreshCountShow();
}

void QtTaskCount::startSelectedTask()
{
getSelectedTaskWidget()->startProgressBar();
}

void QtTaskCount::pauseSelectedTask()
{
getSelectedTaskWidget()->pauseProgressBar();
}

void QtTaskCount::stopSelectedTask()
{
getSelectedTaskWidget()->stopProgressBar();
}

TaskWidget* QtTaskCount::getSelectedTaskWidget()
{
QList list = ui.listWidget->QListWidget::selectedItems();
TaskWidget * taskwidget = (TaskWidget*)ui.listWidget->itemWidget(list[0]);
return taskwidget;
}

bool QtTaskCount::initializeAddTask()
{
if (getStartTaskCount() < taskCount)
{
return true;
}
else
{
return false;
}
}

int QtTaskCount::getAllTaskCount()
{
return allTaskWidgetList.count();
}

int QtTaskCount::getStartTaskCount()
{
return startTaskWidgetList.count();
}

int QtTaskCount::getPauseTaskCount()
{
return pauseTaskWidgetList.count();
}

int QtTaskCount::getStopTaskCount()
{
return stopTaskWidgetList.count();
}

void QtTaskCount::taskListRemoveAtTask()
{
int taskStatus = getSelectedTaskWidget()->getTaskStatus();
switch (taskStatus)
{
case TASK_START:
{
startTaskWidgetList.removeAt(startTaskWidgetList.indexOf(getSelectedTaskWidget()));
break;
}
case TASK_PAUSE:
{
pauseTaskWidgetList.removeAt(pauseTaskWidgetList.indexOf(getSelectedTaskWidget()));
break;
}
case TASK_TOP:
{
stopTaskWidgetList.removeAt(stopTaskWidgetList.indexOf(getSelectedTaskWidget()));
break;
}
}
}

void QtTaskCount::on_pauseTaskBtn_clicked()
{
taskListRemoveAtTask();
pauseSelectedTask();
pauseTaskWidgetList.append(getSelectedTaskWidget());
refreshCountShow();
}

void QtTaskCount::on_startTaskBtn_clicked()
{
if (initializeAddTask())
{
taskListRemoveAtTask();
startSelectedTask();
startTaskWidgetList.append(getSelectedTaskWidget());
}
refreshCountShow();
}

void QtTaskCount::on_stopTaskBtn_clicked()
{
taskListRemoveAtTask();
stopSelectedTask();
stopTaskWidgetList.append(getSelectedTaskWidget());
refreshCountShow();
}

void QtTaskCount::refreshCountShow()
{
ui.startTaskCountlb->setText(QString::number(getStartTaskCount()));
ui.pauseTaskCountlb->setText(QString::number(getPauseTaskCount()));
ui.stopTaskCountlb->setText(QString::number(getStopTaskCount()));
ui.allTaskCountlb->setText(QString::number(getAllTaskCount()));
}

void QtTaskCount::spinboxValueChanged(int int_value)
{
if (taskCount > int_value)
{
if (int_value < 0)
{
return;
}
int subTaskCount = taskCount - int_value;
int startTaskCount = startTaskWidgetList.count() - 1;
if (startTaskCount == -1)
{
ui.taskCountSpinBox->setValue(taskCount);
return;
}
for (int i = 0;ipauseProgressBar();
pauseTaskWidgetList.append(startTaskWidgetList[startTaskCount]);
startTaskWidgetList.removeAt(startTaskCount);
startTaskCount--;
}
}
else
{
int subTaskCount = int_value - taskCount;
int pauseTaskCount = pauseTaskWidgetList.count() - 1;
if (pauseTaskCount == -1)
{
ui.taskCountSpinBox->setValue(taskCount);
return;
}
for (int i = 0;istartProgressBar();
startTaskWidgetList.append(pauseTaskWidgetList[pauseTaskCount]);
pauseTaskWidgetList.removeAt(pauseTaskCount);
pauseTaskCount--;
}
}
taskCount = int_value;
refreshCountShow();
}
//
//qttaskcount.h
#ifndef QTTASKCOUNT_H
#define QTTASKCOUNT_H

#include
#include "ui_qttaskcount.h"
#include "taskwidget.h"
#include

class TaskWidget;
class QListWidgetItem;
class QtTaskCount : public QMainWindow
{
Q_OBJECT

public:
QtTaskCount(QWidget *parent = 0, Qt::WFlags flags = 0);
~QtTaskCount();

private:
Ui::QtTaskCountClass ui;
QList allTaskWidgetList;
QList startTaskWidgetList;
QList pauseTaskWidgetList;
QList stopTaskWidgetList;

int getAllTaskCount();
int getStartTaskCount();
int getPauseTaskCount();
int getStopTaskCount();

TaskWidget* getSelectedTaskWidget();
void addTask();
void startSelectedTask();
void pauseSelectedTask();
void stopSelectedTask();
bool initializeAddTask();
void taskListRemoveAtTask();
void refreshCountShow();

int taskCount;

private slots:
void on_stopTaskBtn_clicked();
void on_startTaskBtn_clicked();
void on_pauseTaskBtn_clicked();
void on_addTaskBtn_clicked();
void spinboxValueChanged(int int_value);
};

#endif // QTTASKCOUNT_H