Пример #1
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*)));
    }
Пример #2
0
void Task::addItem(AbstractGroupableItem *abstractItem)
{
    if (abstractItem->itemType() != TaskManager::GroupItemType)
    {
        TaskItem *task = qobject_cast<TaskItem*>(abstractItem);

        if (task->task())
        {
            emit windowAdded(task->task()->window());
        }
    }

    emit changed(WindowsChanged);
}
Пример #3
0
void Task::removeItem(AbstractGroupableItem *abstractItem)
{
    if (m_group && m_group->members().count() == 1)
    {
        m_taskType = TaskType;
        m_abstractItem = m_group->members().first();
        m_group = NULL;
        m_task = qobject_cast<TaskItem*>(m_abstractItem);
    }

    TaskItem *task = qobject_cast<TaskItem*>(abstractItem);

    if (task && task->task())
    {
        emit windowRemoved(task->task()->window());
    }

    emit changed(EveythingChanged);
}
Пример #4
0
void Task::publishIconGeometry(const QRect &geometry)
{
    if (m_task && m_task->task())
    {
        m_task->task()->publishIconGeometry(geometry);
    }
    else if (m_group)
    {
        QList<AbstractGroupableItem*> items = m_group->members();

        for (int i = 0; i < items.count(); ++i)
        {
            if (items.at(i)->itemType() == TaskManager::TaskItemType)
            {
                TaskItem *task = qobject_cast<TaskItem*>(items.at(i));
                task->task()->publishIconGeometry(geometry);
            }
        }
    }
}
Пример #5
0
void Task::kill()
{
    KSysGuard::Processes processes;
    processes.updateAllProcesses();

    if (m_taskType == TaskType && m_task)
    {
        processes.killProcess(m_task->task()->pid());
    }
    else if (m_taskType == GroupType && m_group)
    {
        QList<AbstractGroupableItem*> members = m_group->members();

        for (int i = 0; i < members.count(); ++i)
        {
            TaskItem *task = qobject_cast<TaskItem*>(members.at(i));

            if (task)
            {
                processes.killProcess(task->task()->pid());
            }
        }
    }
}