Example #1
0
QApplicationStatus::QApplicationStatus(QObject *parent) :
    AbstractServiceImplementation(parent),
    m_statusUri(""),
    m_statusSocketState(Down),
    m_connected(false),
    m_connectionState(Disconnected),
    m_error(NoError),
    m_errorString(""),
    m_running(false),
    m_synced(false),
    m_channels(MotionChannel | ConfigChannel | IoChannel | TaskChannel | InterpChannel),
    m_context(NULL),
    m_statusSocket(NULL),
    m_statusHeartbeatTimer(new QTimer(this))
{
    connect(m_statusHeartbeatTimer, SIGNAL(timeout()),
            this, SLOT(statusHeartbeatTimerTick()));

    connect(this, SIGNAL(taskChanged(QJsonObject)),
            this, SLOT(updateRunning(QJsonObject)));
    connect(this, SIGNAL(interpChanged(QJsonObject)),
            this, SLOT(updateRunning(QJsonObject)));


    initializeObject(MotionChannel);
    initializeObject(ConfigChannel);
    initializeObject(IoChannel);
    initializeObject(TaskChannel);
    initializeObject(InterpChannel);
}
Example #2
0
void TaskHistogram::setTask(TaskBase *task)
{
    if( m_task == task )
        return;

    qDebug() << "TaskHistogram::setTask()" << task;

    if( m_task )
    {
        disconnect(m_cycleConn);
        disconnect(m_redConn);
        disconnect(m_greenConn);
        disconnect(m_blueConn);
        disconnect(m_lumConn);
    }

    m_task = task;

    if( m_task )
    {
        m_cycleConn = connect( m_task->worker(), &WorkerBase::cycleChanged,
                               m_task->worker(), &WorkerBase::requestHistogram );
        m_redConn   = connect( m_task->worker()->histogram(), &HistogramMaker::redChanged,
                               this, &TaskHistogram::setRed );
        m_greenConn = connect( m_task->worker()->histogram(), &HistogramMaker::greenChanged,
                               this, &TaskHistogram::setGreen );
        m_blueConn  = connect( m_task->worker()->histogram(), &HistogramMaker::blueChanged,
                               this, &TaskHistogram::setBlue );
        m_lumConn   = connect( m_task->worker()->histogram(), &HistogramMaker::lumChanged,
                               this, &TaskHistogram::setLum );
    }

    emit taskChanged(m_task);
}
Example #3
0
void Task::setTask(AbstractGroupableItem *abstractItem)
{
    if (m_abstractItem)
    {
        disconnect(m_abstractItem, SIGNAL(destroyed()), this, SLOT(validate()));
    }

    m_abstractItem = abstractItem;
    m_command = QString();
    m_launcherUrl = KUrl();

    if (m_abstractItem)
    {
        if (m_validateTimer > 0)
        {
            killTimer(m_validateTimer);

            m_validateTimer = 0;
        }

        connect(m_abstractItem, SIGNAL(destroyed()), this, SLOT(validate()));
    }

    if (m_abstractItem->itemType() == TaskManager::GroupItemType)
    {
        m_group = qobject_cast<TaskGroup*>(abstractItem);
        m_taskType = GroupType;

        if (m_applet->groupManager()->groupingStrategy() != TaskManager::GroupManager::ManualGrouping && m_group->members().count())
        {
            TaskItem *task = qobject_cast<TaskItem*>(m_group->members().first());

            if (task && task->task())
            {
                if (m_group->name().isEmpty())
                {
                    m_group->setName(task->task()->visibleName());
                }

                if (m_applet->groupManager()->groupingStrategy() == TaskManager::GroupManager::ProgramGrouping)
                {
                    m_command = command(task->task()->pid());
                }
            }
        }

        QList<WId> windowList = windows();

        for (int i = 0; i < windowList.count(); ++i)
        {
            emit windowAdded(windowList.at(i));
        }

        connect(m_group, SIGNAL(changed(::TaskManager::TaskChanges)), this, SLOT(taskChanged(::TaskManager::TaskChanges)));
        connect(m_group, SIGNAL(groupEditRequest()), this, SLOT(showPropertiesDialog()));
        connect(m_group, SIGNAL(itemAdded(AbstractGroupableItem*)), this, SLOT(addItem(AbstractGroupableItem*)));
        connect(m_group, SIGNAL(itemRemoved(AbstractGroupableItem*)), this, SLOT(removeItem(AbstractGroupableItem*)));
    }
Example #4
0
void QApplicationStatus::updateTask(const pb::EmcStatusTask &task)
{
    Service::recurseMessage(task, &m_task);
    emit taskChanged(m_task);
}
Example #5
0
TodoNote::TodoNote(const QFileInfo& fileinfo, Note::Type type_new)
	: Note(fileinfo, type_new)
{
	text_edit = new TextEdit();
	text_edit->setAcceptRichText(false);
	text_edit->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
//	text_edit->setMinimumHeight(100);
//	text_edit->setMaximumHeight(200);

	model = new TodoModel();
	proxy_model = new TodoProxyModel();
	proxy_model->setSourceModel(model);

	tree_view = new QTreeView();
	tree_view->setModel(proxy_model);
	tree_view->setEditTriggers(QAbstractItemView::DoubleClicked | QAbstractItemView::SelectedClicked);
	tree_view->setSelectionBehavior(QAbstractItemView::SelectRows);
    tree_view->header()->setSectionResizeMode(QHeaderView::ResizeToContents);
	tree_view->header()->hide();
	tree_view->setDragEnabled(true);
	tree_view->setAcceptDrops(true);
	tree_view->setDropIndicatorShown(true);
	tree_view->setDragDropMode(QAbstractItemView::InternalMove);
	tree_view->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::MinimumExpanding);

	connect(proxy_model, SIGNAL(dataChanged(const QModelIndex&, const QModelIndex&)), this, SLOT(taskChanged(QModelIndex)));
	connect(tree_view->selectionModel(), SIGNAL(currentChanged(QModelIndex,QModelIndex)), this, SLOT(taskChanged(QModelIndex)));

	tree_view->setContextMenuPolicy(Qt::CustomContextMenu);
	tree_view->setAnimated(true);

	connect(tree_view, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(contextMenuRequested(QPoint)));

	menu_context = new QMenu();
	menu_context->addAction(tr("Insert new task"), this, SLOT(insertTask()));
	menu_context->addAction(tr("Insert new task"), this, SLOT(insertSubTask()));
	menu_context->addAction(tr("Remove this task"), this, SLOT(removeTask()));
	//menu_context->addAction(tr("Hide completed tasks"), this, SLOT(hideCompletedTasks()));
	//menu_context->actions()[TODO_ACTION_HIDE_COMPLETED]->setCheckable(true);

	for(int i=2; i<model->columnCount(); ++i)
		tree_view->setColumnHidden(i, true);

	lb_date_start = new QLabel;
	lb_date_0 = new QLabel(tr("Created: "), lb_date_start);
	lb_date_stop = new QLabel;
	lb_date_1 = new QLabel(tr("Completed: "), lb_date_stop);
	dt_date_limit = new QDateTimeEdit;
	dt_date_limit->setCalendarPopup(true);
	cb_date_limit = new QCheckBox(tr("Limited: "), dt_date_limit);
	cb_date_limit->setCheckable(true);

	grid_layout = new QGridLayout();
	QGridLayout* l = qobject_cast<QGridLayout*>(grid_layout);
	l->addWidget(lb_date_0, 0, 0);
	l->addWidget(lb_date_start, 0, 1);
	l->addWidget(lb_date_1, 1, 0);
	l->addWidget(lb_date_stop, 1, 1);
	l->addWidget(cb_date_limit, 2, 0);
	l->addWidget(dt_date_limit, 2, 1);

	extra_layout = new QVBoxLayout;
	extra_layout->addItem(grid_layout);
	extra_layout->addWidget(text_edit);

	extra_widget = new QWidget;
	extra_widget->setLayout(extra_layout);
	extra_widget->hide();

	main_layout = new QVBoxLayout();
	main_layout->addWidget(tree_view);
	main_layout->addWidget(extra_widget);

	area = new QScrollArea();
	area->setLayout(main_layout);

	load(); //loading note's content

	mapper = new QDataWidgetMapper();
	mapper->setModel(proxy_model);
	mapper->addMapping(text_edit, 6, "plainText");
	mapper->addMapping(lb_date_start, 2, "text");
	mapper->addMapping(lb_date_stop, 3, "text");
	lb_date_start->setLocale(settings.getLocale());
	dt_date_limit->setLocale(settings.getLocale());
	dt_date_limit->calendarWidget()->setLocale(settings.getLocale());

	tree_view->setCurrentIndex(QModelIndex());
}