taskswnd.c

ReactOS是一些高手根据Windows XP的内核编写出的类XP。内核实现机理和API函数调用几乎相同。甚至可以兼容XP的程序。喜欢研究系统内核的人可以看一看。

                                    IN PTASK_GROUP TaskGroup)
{
    ASSERT(TaskGroup->Index >= 0);

    /* FIXME: Implement */

    return TaskGroup->Index;
}

static VOID
TaskSwitchWnd_ExpandTaskGroup(IN OUT PTASK_SWITCH_WND This,
                              IN PTASK_GROUP TaskGroup)
{
    ASSERT(TaskGroup->dwTaskCount > 0);
    ASSERT(TaskGroup->IsCollapsed);
    ASSERT(TaskGroup->Index >= 0);

    /* FIXME: Implement */
}

static INT
TaskSwitchWnd_UpdateTaskItemButton(IN OUT PTASK_SWITCH_WND This,
                                   IN PTASK_ITEM TaskItem)
{
    TBBUTTONINFO tbbi;

    ASSERT(TaskItem->Index >= 0);

    tbbi.cbSize = sizeof(tbbi);
    tbbi.dwMask = TBIF_BYINDEX | TBIF_STATE | TBIF_TEXT;
    tbbi.fsState = TBSTATE_ENABLED;
    if (This->ActiveTaskItem == TaskItem)
        tbbi.fsState |= TBSTATE_CHECKED;

    /* Check if we're updating a button that is the last one in the
       line. If so, we need to set the TBSTATE_WRAP flag! */
    if (This->TbButtonsPerLine != 0 &&
        (TaskItem->Index + 1) % This->TbButtonsPerLine == 0)
    {
        tbbi.fsState |= TBSTATE_WRAP;
    }

    tbbi.pszText = TaskSwitchWnd_GetWndTextFromTaskItem(This,
                                                        TaskItem);

    if (!SendMessage(This->hWndToolbar,
                     TB_SETBUTTONINFO,
                     (WPARAM)TaskItem->Index,
                     (LPARAM)&tbbi))
    {
        TaskItem->Index = -1;
        return -1;
    }

    DbgPrint("Updated button %d for hwnd 0x%p\n", TaskItem->Index, TaskItem->hWnd);
    return TaskItem->Index;
}

static PTASK_ITEM
TaskSwitchWnd_FindLastTaskItemOfGroup(IN OUT PTASK_SWITCH_WND This,
                                      IN PTASK_GROUP TaskGroup  OPTIONAL,
                                      IN PTASK_ITEM NewTaskItem  OPTIONAL)
{
    PTASK_ITEM TaskItem, LastTaskItem, FoundTaskItem = NULL;
    DWORD dwTaskCount;

    ASSERT(This->IsGroupingEnabled);

    TaskItem = This->TaskItems;
    LastTaskItem = TaskItem + This->TaskItemCount;

    dwTaskCount = (TaskGroup != NULL ? TaskGroup->dwTaskCount : MAX_TASKS_COUNT);

    ASSERT(dwTaskCount > 0);

    while (TaskItem != LastTaskItem)
    {
        if (TaskItem->Group == TaskGroup)
        {
            if ((NewTaskItem != NULL && TaskItem != NewTaskItem) || NewTaskItem == NULL)
            {
                FoundTaskItem = TaskItem;
            }

            if (--dwTaskCount == 0)
            {
                /* We found the last task item in the group! */
                break;
            }
        }

        TaskItem++;
    }

    return FoundTaskItem;
}

static INT
TaskSwitchWnd_CalculateTaskItemNewButtonIndex(IN OUT PTASK_SWITCH_WND This,
                                              IN PTASK_ITEM TaskItem)
{
    PTASK_GROUP TaskGroup;
    PTASK_ITEM LastTaskItem;

    /* NOTE: This routine assumes that the group is *not* collapsed! */

    TaskGroup = TaskItem->Group;
    if (This->IsGroupingEnabled)
    {
        if (TaskGroup != NULL)
        {
            ASSERT(TaskGroup->Index < 0);
            ASSERT(!TaskGroup->IsCollapsed);

            if (TaskGroup->dwTaskCount > 1)
            {
                LastTaskItem = TaskSwitchWnd_FindLastTaskItemOfGroup(This,
                                                                     TaskGroup,
                                                                     TaskItem);
                if (LastTaskItem != NULL)
                {
                    /* Since the group is expanded the task items must have an index */
                    ASSERT(LastTaskItem->Index >= 0);

                    return LastTaskItem->Index + 1;
                }
            }
        }
        else
        {
            /* Find the last NULL group button. NULL groups are added at the end of the
               task item list when grouping is enabled */
            LastTaskItem = TaskSwitchWnd_FindLastTaskItemOfGroup(This,
                                                                 NULL,
                                                                 TaskItem);
            if (LastTaskItem != NULL)
            {
                ASSERT(LastTaskItem->Index >= 0);

                return LastTaskItem->Index + 1;
            }
        }
    }

    return This->ToolbarBtnCount;
}

static INT
TaskSwitchWnd_AddTaskItemButton(IN OUT PTASK_SWITCH_WND This,
                                IN OUT PTASK_ITEM TaskItem)
{
    TBBUTTON tbBtn;
    INT iIndex;

    if (TaskItem->Index >= 0)
    {
        return TaskSwitchWnd_UpdateTaskItemButton(This,
                                                  TaskItem);
    }

    if (TaskItem->Group != NULL &&
        TaskItem->Group->IsCollapsed)
    {
        /* The task group is collapsed, we only need to update the group button */
        return TaskSwitchWnd_UpdateTaskGroupButton(This,
                                                   TaskItem->Group);
    }

    tbBtn.iBitmap = 0;
    tbBtn.fsState = TBSTATE_ENABLED | TBSTATE_ELLIPSES;
    tbBtn.fsStyle = BTNS_CHECK | BTNS_NOPREFIX | BTNS_SHOWTEXT;
    tbBtn.dwData = MAKE_TASKITEM_PTR(TaskItem);

    tbBtn.iString = (DWORD_PTR)TaskSwitchWnd_GetWndTextFromTaskItem(This,
                                                                    TaskItem);

    /* Find out where to insert the new button */
    iIndex = TaskSwitchWnd_CalculateTaskItemNewButtonIndex(This,
                                                           TaskItem);
    ASSERT(iIndex >= 0);
    tbBtn.idCommand = MAKE_TASKITEM_CMD_ID(iIndex);

    TaskSwitchWnd_BeginUpdate(This);

    if (SendMessage(This->hWndToolbar,
                    TB_INSERTBUTTON,
                    (WPARAM)iIndex,
                    (LPARAM)&tbBtn))
    {
        TaskSwitchWnd_UpdateIndexesAfterButtonInserted(This,
                                                       iIndex);

        DbgPrint("Added button %d for hwnd 0x%p\n", iIndex, TaskItem->hWnd);

        TaskItem->Index = iIndex;
        This->ToolbarBtnCount++;

        /* Update button sizes and fix the button wrapping */
        TaskSwitchWnd_UpdateButtonsSize(This,
                                        TRUE);
        return iIndex;
    }

    TaskSwitchWnd_EndUpdate(This);

    return -1;
}

static BOOL
TaskSwitchWnd_DeleteTaskItemButton(IN OUT PTASK_SWITCH_WND This,
                                   IN OUT PTASK_ITEM TaskItem)
{
    PTASK_GROUP TaskGroup;
    INT iIndex;

    TaskGroup = TaskItem->Group;

    if (TaskItem->Index >= 0)
    {
        if ((TaskGroup != NULL && !TaskGroup->IsCollapsed) ||
            TaskGroup == NULL)
        {
            TaskSwitchWnd_BeginUpdate(This);

            iIndex = TaskItem->Index;
            if (SendMessage(This->hWndToolbar,
                            TB_DELETEBUTTON,
                            (WPARAM)iIndex,
                            0))
            {
                TaskItem->Index = -1;
                This->ToolbarBtnCount--;

                TaskSwitchWnd_UpdateIndexesAfterButtonDeleted(This,
                                                              iIndex);

                /* Update button sizes and fix the button wrapping */
                TaskSwitchWnd_UpdateButtonsSize(This,
                                                TRUE);
                return TRUE;
            }

            TaskSwitchWnd_EndUpdate(This);
        }
    }

    return FALSE;
}

static PTASK_GROUP
TaskSwitchWnd_AddToTaskGroup(IN OUT PTASK_SWITCH_WND This,
                             IN HWND hWnd)
{
    DWORD dwProcessId;
    PTASK_GROUP TaskGroup, *PrevLink;

    if (!GetWindowThreadProcessId(hWnd,
                                  &dwProcessId))
    {
        DbgPrint("Cannot get process id of hwnd 0x%p\n", hWnd);
        return NULL;
    }

    /* Try to find an existing task group */
    TaskGroup = This->TaskGroups;
    PrevLink = &This->TaskGroups;
    while (TaskGroup != NULL)
    {
        if (TaskGroup->dwProcessId == dwProcessId)
        {
            TaskGroup->dwTaskCount++;
            return TaskGroup;
        }

        PrevLink = &TaskGroup->Next;
        TaskGroup = TaskGroup->Next;
    }

    /* Allocate a new task group */
    TaskGroup = HeapAlloc(hProcessHeap,
                          0,
                          sizeof(*TaskGroup));
    if (TaskGroup != NULL)
    {
        ZeroMemory(TaskGroup,
                   sizeof(*TaskGroup));

        TaskGroup->dwTaskCount = 1;
        TaskGroup->dwProcessId = dwProcessId;
        TaskGroup->Index = -1;

        /* Add the task group to the list */
        *PrevLink = TaskGroup;
    }

    return TaskGroup;
}

static VOID
TaskSwitchWnd_RemoveTaskFromTaskGroup(IN OUT PTASK_SWITCH_WND This,
                                      IN OUT PTASK_ITEM TaskItem)
{
    PTASK_GROUP TaskGroup, CurrentGroup, *PrevLink;

    TaskGroup = TaskItem->Group;
    if (TaskGroup != NULL)
    {
        DWORD dwNewTaskCount = --TaskGroup->dwTaskCount;
        if (dwNewTaskCount == 0)
        {
            /* Find the previous pointer in the chain */
            CurrentGroup = This->TaskGroups;
            PrevLink = &This->TaskGroups;
            while (CurrentGroup != TaskGroup)
            {
                PrevLink = &CurrentGroup->Next;
                CurrentGroup = CurrentGroup->Next;
            }

            /* Remove the group from the list */
            *PrevLink = TaskGroup->Next;

            /* Free the task group */
            HeapFree(hProcessHeap,
                     0,
                     TaskGroup);
        }
        else if (TaskGroup->IsCollapsed &&
                 TaskGroup->Index >= 0)
        {
            if (dwNewTaskCount > 1)
            {
                /* FIXME: Check if we should expand the group */
                /* Update the task group button */
                TaskSwitchWnd_UpdateTaskGroupButton(This,
                                                    TaskGroup);
            }
            else
            {
                /* Expand the group of one task button to a task button */
                TaskSwitchWnd_ExpandTaskGroup(This,
                                              TaskGroup);
            }
        }
    }
}

static PTASK_ITEM
TaskSwitchWnd_FindTaskItem(IN OUT PTASK_SWITCH_WND This,
                           IN HWND hWnd)
{
    PTASK_ITEM TaskItem, LastItem;

    TaskItem = This->TaskItems;
    LastItem = TaskItem + This->TaskItemCount;
    while (TaskItem != LastItem)
    {
        if (TaskItem->hWnd == hWnd)
            return TaskItem;

        TaskItem++;
    }

    return NULL;
}

static PTASK_ITEM
TaskSwitchWnd_FindOtherTaskItem(IN OUT PTASK_SWITCH_WND This,
                                IN HWND hWnd)
{
    PTASK_ITEM LastItem, TaskItem;
    PTASK_GROUP TaskGroup;
    DWORD dwProcessId;

    if (!GetWindowThreadProcessId(hWnd,
                                  &dwProcessId))
    {
        return NULL;
    }

    /* Try to find another task that belongs to the same
       process as the given window */
    TaskItem = This->TaskItems;
    LastItem = TaskItem + This->TaskItemCount;
    while (TaskItem != LastItem)
    {
        TaskGroup = TaskItem->Group;
        if (TaskGroup != NULL)
        {
            if (TaskGroup->dwProcessId == dwProcessId)
                return TaskItem;
        }
        else
        {
            DWORD dwProcessIdTask;

            if (GetWindowThreadProcessId(TaskItem->hWnd,
                                         &dwProcessIdTask) &&
                dwProcessIdTask == dwProcessId)
            {
                return TaskItem;