windows-xp/Source/XPSP1/NT/ds/security/winsafer/test/desktops/desktop.cpp

////////////////////////////////////////////////////////////////////////////////
//
// File:    Desktop.cpp
// Created:    Jan 1996
// By:        Ryan Marshall (a-ryanm) and Martin Holladay (a-martih)
//
// Project:    Resource Kit Desktop Switcher (MultiDesk)
//
//
// Revision History:
//
//            March 1997    - Add external icon capability
//
////////////////////////////////////////////////////////////////////////////////


#include <windows.h>
#include <stdio.h>
#include <assert.h>
#include <shellapi.h>
#include <lmaccess.h>
#include <lmapibuf.h>
#include <stdlib.h>
#include <sddl.h>
#include "Deskspc.h"
#include "Desktop.h"
#include "Registry.h"
#include "resource.h"
#include <saifer.h>


extern APPVARS AppMember;


BOOL __SetDesktopScheme(PDESKTOP_SCHEME pDS);
BOOL __GetDesktopScheme(PDESKTOP_SCHEME pDS);
BOOL __UpdateDesktopRegistry(PDESKTOP_SCHEME pDS);
BOOL __CopyDesktopScheme(PDESKTOP_SCHEME pDS1, PDESKTOP_SCHEME pDS2);
HICON __LoadBuiltinIcon(UINT nIconNumber, HINSTANCE hDeskInstance);
BOOL __CreateDefaultName(UINT DeskNum, LPTSTR DesktopName);


/*------------------------------------------------------------------------------*/
/*                                                                              */
/*    Purpose:  Constructor for CDestop class.                                  */
/*                                                                              */
/*------------------------------------------------------------------------------*/

CDesktop::CDesktop()
{
    BeginRundown = FALSE;

    //
    //  Set the default desktop
    //
    DefaultDesktop = GetThreadDesktop(GetCurrentThreadId());

    //
    // Intialize our default icons
    //
    ZeroMemory((PVOID) DefaultIconArray, (sizeof(HICON) * NUM_BUILTIN_ICONS));
}


/*------------------------------------------------------------------------------*/
/*                                                                              */
/*    Purpose:  Destructor for CDestop class.                                   */
/*                                                                              */
/*------------------------------------------------------------------------------*/

CDesktop::~CDesktop()
{
    UINT i;


    // Need to cleanup DesktopList; closing the hDesktop in each node
    // and then delete node memory using GlobalFree().  In addition deletion
    // must start at the end of the list sawing off last node one at a time.
    //
    GlobalFree(m_DesktopList);

    //
    // Close up our default icons
    //
    for (i = 0; i < NUM_BUILTIN_ICONS; i++)
    {
        if (DefaultIconArray[i])
            DestroyIcon(DefaultIconArray[i]);
    }
}

/*------------------------------------------------------------------------------*/
/*------------------------------- PUBLIC FUNCTIONS -----------------------------*/
/*------------------------------------------------------------------------------*/

UINT
CDesktop::InitializeDesktops
(
    DispatchFnType    CreateDisplayFn,
    HINSTANCE        hInstance
)
{
    UINT ii;
    UINT RegNumOfDesktops;
    BOOL m_bFirstTime = TRUE;

    //
    // Set the hInstance and get the default icons
    //
    hDeskInstance = hInstance;

    for (ii = 0; ii < NUM_BUILTIN_ICONS; ii++)
        DefaultIconArray[ii] = __LoadBuiltinIcon(ii+1, hDeskInstance);


    //
    //  Get Information from the registry.
    //
    if (Profile_GetNewContext(&RegNumOfDesktops))
    {
        m_bFirstTime = FALSE;
    }

    if ((RegNumOfDesktops > 32) || (RegNumOfDesktops < 1))
    {
        m_bFirstTime = TRUE;
    }


    ////  Allocate the first node ////

    m_DesktopList = (PDESKTOP_NODE) GlobalAlloc(GMEM_FIXED, sizeof(DESKTOP_NODE));
    assert(m_DesktopList != NULL);

    //// Fill in default values for first node ////

    m_DesktopList->nextDN = NULL;
    m_DesktopList->DS.Initialized = FALSE;
    m_DesktopList->ThreadId = GetCurrentThreadId();
    m_DesktopList->bThread = TRUE;
    m_DesktopList->hWnd = NULL;
    m_DesktopList->hDesktop   = GetThreadDesktop(GetCurrentThreadId());
    m_DesktopList->nIconID    = 0;
    m_DesktopList->RealDesktopName[0] = TEXT('\0');
    __GetDesktopScheme(&(m_DesktopList->DS));

    //
    // Set some environ vars to init states
    //
    NumOfDesktops  = 1;
    CurrentDesktop = 0;


    if (m_bFirstTime)
    {                // No old registry info, create default desktops
        //
        // Set desktop 0's name
        //
        __CreateDefaultName(1, m_DesktopList->DesktopName);

        if (DEFAULT_NUM_DESKTOPS > 1)
        {
            for (ii = 1; ii < DEFAULT_NUM_DESKTOPS; ii++)
            {
                AddDesktop(CreateDisplayFn, NULL);
            }
        }
    }
    else
    {                // Registry info present
        //
        // Set desktop 0's name
        //
        if ( !Profile_LoadDesktopContext(0,
                                    m_DesktopList->DesktopName,
                                    m_DesktopList->SaiferName,
                                    &m_DesktopList->nIconID)    )
        {
            __CreateDefaultName(1, m_DesktopList->DesktopName);
            m_DesktopList->nIconID = 0;
        }

        for (ii = 1; ii < RegNumOfDesktops; ii++)
        {
            TCHAR DesktopName[MAX_NAME_LENGTH];
            TCHAR SaiferName[MAX_NAME_LENGTH];
            UINT nIconID;

            AddDesktop(CreateDisplayFn, NULL);

            //// Place registry info into the node for this desktop ////

            if (Profile_LoadDesktopContext(ii,
                                      DesktopName,
                                      SaiferName,
                                      &nIconID)        )
            {
                // Successfully got all info from registry
                SetDesktopName(ii, DesktopName);
                SetDesktopIconID(ii, nIconID);
                SetSaiferName(ii, SaiferName);
            }
            else
            {
                // Could not get all info from registry
                __CreateDefaultName(ii+1, DesktopName);
                SetDesktopName(ii, DesktopName);
                SetDesktopIconID(ii, ii);
                SetSaiferName(ii, TEXT(""));
            }
            if (!GetRegColorStruct(ii))
                DuplicateDefaultScheme(ii);
        }  // End for loop

    }
    return NumOfDesktops;
}


/*------------------------------------------------------------------------------*/
/*                                                                              */
/*    Purpose:  Access the default desktop handle.                              */
/*                                                                              */
/*    Returns:  The default desktop handle.                                     */
/*                                                                              */
/*------------------------------------------------------------------------------*/

HDESK CDesktop::GetDefaultDesktop(VOID) const
{
    return DefaultDesktop;
}

/*------------------------------------------------------------------------------*/
/*                                                                              */
/*    Purpose:  Access the number of desktops.                                  */
/*                                                                              */
/*    Returns:  The number of desktops.                                         */
/*                                                                              */
/*------------------------------------------------------------------------------*/

UINT CDesktop::GetNumDesktops(VOID) const
{
    return NumOfDesktops;
}

/*------------------------------------------------------------------------------*/
/*                                                                              */
/*    Purpose:  Determine the currently active desktop.                         */
/*                                                                              */
/*    Returns:  The active desktop.                                             */
/*                                                                              */
/*------------------------------------------------------------------------------*/

UINT CDesktop::GetActiveDesktop(VOID) const
{
    return CurrentDesktop;
}


/*------------------------------------------------------------------------------*/
/*                                                                                */
/*    Purpose:  Creates a new desktop.                                            */
/*                                                                                */
/*    Returns:  The index number of the newly created desktop.  Zero if error.    */
/*                                                                                */
/*------------------------------------------------------------------------------*/

UINT CDesktop::AddDesktop
(
    DispatchFnType            CreateDisplayFn,
    LPSECURITY_ATTRIBUTES    lpSA,
    UINT                    uTemplate
)
{
    PDESKTOP_NODE        pCurrentNode;
    TCHAR                szMessage[MAX_PATH];
    PTHREAD_DATA        pData;
    HDESK                hDesktop;
    LUID                UniqueId;
    UINT                i;
    TCHAR                UniqueDesktopName[MAX_NAME_LENGTH];


    ////  Create Desktop ////

    if (AllocateLocallyUniqueId(&UniqueId))
    {
        wsprintf(UniqueDesktopName, TEXT("%d"), UniqueId.LowPart);
        hDesktop = CreateDesktop(
                            UniqueDesktopName,
                            NULL,
                            NULL,
                            0,
                            MAXIMUM_ALLOWED,
                            lpSA);

        if (hDesktop == NULL)
        {
            if (GetLastError() == ERROR_NOT_ENOUGH_MEMORY)
            {
                wsprintf(szMessage, TEXT("Not enough memory to create destkop.\n\nError:  %d\n"), GetLastError());
                MessageBox(NULL, szMessage, TEXT("MultiDesk Desktop Not Created"), MB_TASKMODAL | MB_ICONEXCLAMATION | MB_OK);
            }
            return 0;
        }
    }
    else
    {
        return 0;
    }

    //// Walk the desktop node list to find end
    //// Then add new node to end of list

    i = 1;
    pCurrentNode = m_DesktopList;

    while (pCurrentNode)
    {
        if ( !pCurrentNode->nextDN )    // Found end of list; let's add new node
        {
            NumOfDesktops++;
            pCurrentNode->nextDN = (PDESKTOP_NODE) GlobalAlloc(GMEM_FIXED, sizeof(DESKTOP_NODE));
            pCurrentNode = pCurrentNode->nextDN;
            pCurrentNode->hDesktop = hDesktop;
            pCurrentNode->hWnd = NULL;
            pCurrentNode->nextDN = NULL;
            pCurrentNode->ThreadId = 0;
            pCurrentNode->DS.Initialized = FALSE;

            if ( 0 == uTemplate )
            {
                __CopyDesktopScheme(&(m_DesktopList->DS), &(pCurrentNode->DS));
            }
            else
            {
                DESKTOP_NODE * pNode;
                pNode = GetDesktopNode(uTemplate);
                if ( pNode->DS.Initialized )
                {
                    __CopyDesktopScheme(&(pNode->DS), &(pCurrentNode->DS));
                }
                else
                {
                    __CopyDesktopScheme(&(m_DesktopList->DS), &(pCurrentNode->DS));
                }
            }

            lstrcpy(pCurrentNode->RealDesktopName, UniqueDesktopName);
            __CreateDefaultName(NumOfDesktops, pCurrentNode->DesktopName);
            pCurrentNode->SaiferName[0] = TEXT('\0');
            pCurrentNode->lpSA     = lpSA;
            pCurrentNode->nIconID  = i;
            pCurrentNode->bThread  = TRUE;
            pCurrentNode->bShellStarted = FALSE;

            ////  Alllocate THREAD_DATA struct and fill in.

            pData = (PTHREAD_DATA)GlobalAlloc(GMEM_FIXED, sizeof(THREAD_DATA));
            pData->hDesktop           = hDesktop;
            pData->hDefaultDesktop = DefaultDesktop;
            pData->CreateDisplayFn = CreateDisplayFn;
            lstrcpy(pData->RealDesktopName, UniqueDesktopName);

            //// Start the thread to run this desktop ////

            HANDLE    hThread;

            hThread = CreateThread(NULL,
                                   0,
                                   (LPTHREAD_START_ROUTINE)ThreadInit,
                                   (LPVOID)pData,
                                   0,
                                   &(pCurrentNode->ThreadId));
            CloseHandle(hThread);
        }

        i++;
        pCurrentNode = pCurrentNode->nextDN;
    }

    return NumOfDesktops;
}

/*------------------------------------------------------------------------------*/
/*                                                                              */
/*    Purpose:  Returns pointer to desktop node given number of desktop.        */
/*                                                                              */
/*------------------------------------------------------------------------------*/

DESKTOP_NODE *CDesktop::GetDesktopNode( UINT uNode )
{
    DESKTOP_NODE *    pNode = NULL;
    DESKTOP_NODE *    pWalker = m_DesktopList;
    UINT            uNumDesktops = GetNumDesktops();
    UINT            ii;

    if ( uNode < uNumDesktops )
    {
        for ( ii = 0; ii < uNode; ii++ )
        {
            pWalker = pWalker->nextDN;
        }
        pNode = pWalker;
    }

    return pNode;
}

/*------------------------------------------------------------------------------*/
/*                                                                              */
/*    Purpose:  Save scheme settings of current desktop to desktop node         */
/*                                                                              */
/*------------------------------------------------------------------------------*/

BOOL
CDesktop::SaveCurrentDesktopScheme()
{
    DESKTOP_NODE *    pNodeWalker;
    UINT            ii;
    BOOL            rVal = FALSE;

    ii = 0;
    pNodeWalker = m_DesktopList;


    while (pNodeWalker)
    {
        if (ii == CurrentDesktop)
        {
            __GetDesktopScheme(&(pNodeWalker->DS));
            rVal = TRUE;
        }
        ii++;
        pNodeWalker = pNodeWalker->nextDN;
    }

    return rVal;
}


/*------------------------------------------------------------------------------*/
/*                                                                              */
/*    Purpose:  Removes an old desktop.                                         */
/*                                                                              */
/*    Returns:  The number of remaining desktops.  Zero if error.               */
/*              User GetLastError() to retrieve error information.              */
/*                                                                              */
/*------------------------------------------------------------------------------*/

UINT CDesktop::RemoveDesktop(UINT DesktopNumber)
{
    PDESKTOP_NODE        pCurrentNode;
    PDESKTOP_NODE        pPreviousNode;
    BOOL                Found;
    UINT                ii;
    UINT                rValue = 0;

    //
    //    Return an error if trying to delete desktop zero.
    //
    if ((DesktopNumber == 0) || (NumOfDesktops == 1))
    {
        SetLastError(ERROR_CANNOT_DELETE_DESKTOP_ZERO);
        return 0;
    }

    //
    //  Return an error if an invalid desktop number
    //
    if (DesktopNumber > (NumOfDesktops - 1))
    {
        SetLastError(ERROR_INVALID_DESKTOP_NUMBER);
        return 0;
    }

    //
    // If we are deleting the active desktop. Switch to desktop zero.
    //
    if (DesktopNumber == CurrentDesktop)
    {
        if (!ActivateDesktop(0))
        {
            SetLastError(ERROR_CANNOT_DELETE_ACTIVE_DESKTOP);
            return FALSE;
        }
    }

    //
    //  Find the data structure; walk the linked list of desktops
    //
    Found = FALSE;
    ii = 1;
    pPreviousNode = m_DesktopList;
    pCurrentNode  = m_DesktopList->nextDN;

    while (pCurrentNode && (!Found))
    {
        if (DesktopNumber == ii)
        {
            //
            // Full Context desktop
            //
            if (pCurrentNode->bThread)
            {
                PostThreadMessage(pCurrentNode->ThreadId, WM_KILL_APPS, (WPARAM) pCurrentNode->hDesktop, (LPARAM) pCurrentNode->hWnd);
                Sleep(100);
                rValue = SUCCESS_THREAD_TERMINATION;
            }
            else
            {
                //
                // BUGBUG: Kill all virtual apps
                //
                rValue = SUCCESS_VIRTUAL_MOVE;
            }

            NumOfDesktops--;
            pPreviousNode->nextDN = pCurrentNode->nextDN;

            GlobalFree(pCurrentNode); // Destroy Node of removed desktop!!!
            Found = TRUE;
        }
        else
        {                        // Advance along list of nodes
            ii++;
            pPreviousNode = pCurrentNode;
            pCurrentNode = pCurrentNode->nextDN;
        }
    } // End while LOOP

    return rValue;
}


/*------------------------------------------------------------------------------*/
/*                                                                              */
/*    Purpose:  Kill all programs on a desktop.                                 */
/*                                                                              */
/*------------------------------------------------------------------------------*/

static BOOL CALLBACK __EnumWindowsForClose(HWND hWnd, LPARAM lParam)
{
    TCHAR        szClass[MAX_NAME_LENGTH];
    HWND        hDesktopWnd;

    //
    // Make sure that it isn't the desktop window
    //
    hDesktopWnd = (HWND) lParam;
    if (hDesktopWnd == hWnd)
    {
        return TRUE;
    }
    GetClassName(hWnd, szClass, MAX_NAME_LENGTH);
    if (szClass[0] == TEXT('#'))
    {
        return TRUE;
    }

    //
    // Send a close message to the app
    //
    PostMessage(hWnd, WM_CLOSE, (WPARAM) WM_NO_CLOSE, 0);

    return TRUE;
}

static BOOL CALLBACK __EnumWindowsForQuit(HWND hWnd, LPARAM lParam)
{
    TCHAR        szClass[MAX_NAME_LENGTH];
    HWND        hDesktopWnd;

    //
    // Make sure that it isn't the desktop window
    //
    hDesktopWnd = (HWND) lParam;
    if (hDesktopWnd == hWnd) return TRUE;

    //
    // Extract the Class Name
    //
    GetClassName(hWnd, szClass, MAX_NAME_LENGTH);
    if (szClass[0] == TEXT('#')) return TRUE;

    //
    // Send a quit message to the app
    //
    PostMessage(hWnd, WM_QUIT, (WPARAM) WM_NO_CLOSE, 0);

    return TRUE;
}

BOOL CDesktop::KillAppsOnDesktop(HDESK hDesk, HWND hWnd)
{
    HWND        hDesktopWnd;

    hDesktopWnd = GetDesktopWindow();

    EnumDesktopWindows(hDesk, (WNDENUMPROC) __EnumWindowsForClose, (LPARAM) hDesktopWnd);
    Sleep(0);
    EnumDesktopWindows(hDesk, (WNDENUMPROC) __EnumWindowsForQuit, (LPARAM) hDesktopWnd);

    return TRUE;
}

/*------------------------------------------------------------------------------*/
/*                                                                              */
/*    Purpose:  Switches to an existing desktop.                                */
/*                                                                              */
/*    Returns:  The index number of the newly created desktop.  Zero if error.  */
/*                                                                              */
/*------------------------------------------------------------------------------*/

BOOL
CDesktop::ActivateDesktop(UINT DesktopNumber)
{
    PDESKTOP_NODE            pCurrentNode;
    BOOL                    Success;
    UINT                    i;
    PROCESS_INFORMATION        pi;
    STARTUPINFO                sui;
    TCHAR                    szShellPath[MAX_PATH + 1];

    //
    //  Return immediately if trying to switch to ourself.
    //
    if (CurrentDesktop == DesktopNumber)
    {
        return FALSE;
    }


    //// Save desktop scheme for current desktop ////

    SaveCurrentDesktopScheme();

    //
    // Active the new desktop
    //
    i = 0;
    pCurrentNode = m_DesktopList;
    while (pCurrentNode)
    {
        if (i == DesktopNumber)
        {
            Success = SwitchDesktop(pCurrentNode->hDesktop);
            if (Success)
            {
                CurrentDesktop = i;

                // Start Explorer if necessary - skipping 0 == default desktop

                if (!pCurrentNode->bShellStarted && CurrentDesktop != 0)
                {
                    HANDLE hToken = NULL;


                    lstrcpy(szShellPath, TEXT("EXPLORER.EXE"));
                    ZeroMemory((PVOID)&sui, sizeof(sui));

                    sui.lpDesktop        = pCurrentNode->RealDesktopName;
                    sui.cb                = sizeof(sui);
                    sui.lpReserved        = NULL;
                    sui.lpTitle            = NULL;
                    sui.dwFlags            = STARTF_USESHOWWINDOW;
                    sui.wShowWindow        = SW_SHOW;
                    sui.cbReserved2        = 0;
                    sui.cbReserved2        = NULL;

#if 1
                    if (pCurrentNode->SaiferName[0] != TEXT('\0'))
                    {
                        HAUTHZOBJECT hAuthzObj;
                        if (CreateCodeAuthzObject(
                                AUTHZSCOPE_HKCU, pCurrentNode->SaiferName,
                                AUTHZ_OPENEXISTING, &hAuthzObj) ||
                            CreateCodeAuthzObject(
                                AUTHZSCOPE_HKLM, pCurrentNode->SaiferName,
                                AUTHZ_OPENEXISTING, &hAuthzObj))
                        {
                            if (ComputeAccessTokenFromCodeAuthzObject(
                                        hAuthzObj,
                                        NULL,           // source token
                                        &hToken,        // target token
                                        0))             // no flags
                            {
                                // We successfully got the Restricted Token
                                // to use, so it had better be non-null.
                                assert(hToken != NULL);
                            }
                            CloseCodeAuthzObject(hAuthzObj);
                        }
                        if (hToken == NULL)
                        {
                            CurrentDesktop = 0;
                            SwitchDesktop(m_DesktopList->hDesktop);
                            PostThreadMessage(m_DesktopList->ThreadId, WM_THREAD_SCHEME_UPDATE, 0, 0);
                            Message(TEXT("The SAIFER Object Name specified for this "
                                "desktop could not be successfully found or instantianted."));
                            return FALSE;
                        }
                    }

                    if (hToken != NULL) {
                        Success = CreateProcessAsUser(
                                        hToken,
                                        NULL,
                                        szShellPath,
                                        NULL,
                                        NULL,
                                        FALSE,
                                        CREATE_DEFAULT_ERROR_MODE | CREATE_SEPARATE_WOW_VDM,
                                        NULL,
                                        NULL,
                                        &sui,
                                        &pi);
                        CloseHandle(hToken);
                    }
                    else
#endif
                        Success = CreateProcess(
                                        NULL,
                                        szShellPath,
                                        NULL,
                                        NULL,
                                        FALSE,
                                        CREATE_DEFAULT_ERROR_MODE | CREATE_SEPARATE_WOW_VDM,
                                        NULL,
                                        NULL,
                                        &sui,
                                        &pi);

                    pCurrentNode->bShellStarted = Success;

                    if (Success) {
                        CloseHandle(pi.hThread);
                        CloseHandle(pi.hProcess);
                    } else {
                        CurrentDesktop = 0;
                        SwitchDesktop(m_DesktopList->hDesktop);
                        PostThreadMessage(m_DesktopList->ThreadId, WM_THREAD_SCHEME_UPDATE, 0, 0);
                        Message(TEXT("The Windows shell could not be successfully launched."));
                        return FALSE;
                    }

                }

                PostThreadMessage(pCurrentNode->ThreadId, WM_THREAD_SCHEME_UPDATE, 0, 0);
            }

            return Success;
        }

        i++;
        pCurrentNode = pCurrentNode->nextDN;
    } // End while LOOP

    return FALSE;
}


/*------------------------------------------------------------------------------*/
/*                                                                              */
/*    Purpose:  Sets a desktop name.  (Rename)                                  */
/*                                                                              */
/*------------------------------------------------------------------------------*/

BOOL CDesktop::SetDesktopName(UINT DesktopNumber, LPCTSTR DesktopName)
{
    UINT                i;
    BOOL                Found;
    PDESKTOP_NODE        pCurrentNode;

    //
    // Verify valid string.
    //
    if ((!DesktopName) || (lstrlen(DesktopName) > MAX_NAME_LENGTH))
        return FALSE;

    //
    // Change the name in our data structure.
    //
    i = 0;
    Found = FALSE;
    pCurrentNode = m_DesktopList;
    while (pCurrentNode && !Found)
    {
        if (i == DesktopNumber)
        {
            lstrcpy(pCurrentNode->DesktopName, DesktopName);
            Found = TRUE;
        }

        i++;
        pCurrentNode = pCurrentNode->nextDN;
    }

    return Found;
}


/*------------------------------------------------------------------------------*/
/*                                                                              */
/*    Purpose:  Gets a desktop name.  (Rename)                                  */
/*                                                                              */
/*------------------------------------------------------------------------------*/

BOOL CDesktop::GetDesktopName(UINT DesktopNumber, LPTSTR DesktopName, UINT size) const
{
    UINT                i;
    BOOL                Found;
    PDESKTOP_NODE        pCurrentNode;

    //
    // Get the name from our data structure.
    //
    i = 0;
    Found = FALSE;
    pCurrentNode = m_DesktopList;
    while (pCurrentNode && !Found)
    {
        if (i == DesktopNumber)
        {
            if ((UINT) lstrlen(pCurrentNode->DesktopName) > size) return FALSE;

            lstrcpy(DesktopName, pCurrentNode->DesktopName);
            Found = TRUE;
        }

        i++;
        pCurrentNode = pCurrentNode->nextDN;
    }

    return Found;
}


/*------------------------------------------------------------------------------*/
/*                                                                              */
/*    Purpose:  Sets a desktop SAIFER authorization object name.                */
/*                                                                              */
/*------------------------------------------------------------------------------*/

BOOL CDesktop::SetSaiferName(UINT DesktopNumber, LPCTSTR SaiferName)
{
    UINT i;
    BOOL Found;
    PDESKTOP_NODE pCurrentNode;

    //
    // Verify valid string.
    //
    if ((!SaiferName) || (lstrlen(SaiferName) > MAX_NAME_LENGTH))
        return FALSE;

    //
    // Change the name in our data structure.
    //
    i = 0;
    Found = FALSE;
    pCurrentNode = m_DesktopList;
    while (pCurrentNode && !Found)
    {
        if (i == DesktopNumber)
        {
            lstrcpy(pCurrentNode->SaiferName, SaiferName);
            Found = TRUE;
        }

        i++;
        pCurrentNode = pCurrentNode->nextDN;
    }

    return Found;
}


/*------------------------------------------------------------------------------*/
/*                                                                              */
/*    Purpose:  Gets a desktop SAIFER authorization object name.                */
/*                                                                              */
/*------------------------------------------------------------------------------*/

BOOL CDesktop::GetSaiferName(UINT DesktopNumber, LPTSTR SaiferName, UINT size) const
{
    UINT i;
    BOOL Found;
    PDESKTOP_NODE pCurrentNode;

    //
    // Get the name from our data structure.
    //
    i = 0;
    Found = FALSE;
    pCurrentNode = m_DesktopList;
    while (pCurrentNode && !Found)
    {
        if (i == DesktopNumber)
        {
            if ((UINT) lstrlen(pCurrentNode->SaiferName) > size) return FALSE;

            lstrcpy(SaiferName, pCurrentNode->SaiferName);
            Found = TRUE;
        }

        i++;
        pCurrentNode = pCurrentNode->nextDN;
    }

    return Found;
}

/*------------------------------------------------------------------------------*/
/*                                                                              */
/*    Purpose:  Gets the icon for a particular desktop                          */
/*                                                                              */
/*------------------------------------------------------------------------------*/

HICON CDesktop::GetDesktopIcon(UINT nDesktopNumber) const
{
    UINT i;
    PDESKTOP_NODE pCurrentNode;

    //
    // Get the name from our data structure.
    //
    i = 0;
    pCurrentNode = m_DesktopList;
    while (pCurrentNode)
    {
        if (i == nDesktopNumber)
        {
            assert(pCurrentNode->nIconID >= 0 && pCurrentNode->nIconID < NUM_BUILTIN_ICONS);
            return DefaultIconArray[pCurrentNode->nIconID];
        }

        i++;
        pCurrentNode = pCurrentNode->nextDN;
    }

    return FALSE;
}


/*------------------------------------------------------------------------------*/
/*                                                                              */
/*    Purpose:  Gets the icon ID for a particular desktop                       */
/*                                                                              */
/*------------------------------------------------------------------------------*/

UINT CDesktop::GetDesktopIconID(UINT nDesktopNumber) const
{
    UINT i;
    PDESKTOP_NODE pCurrentNode;

    //
    // Get the name from our data structure.
    //
    i = 0;
    pCurrentNode = m_DesktopList;
    while (pCurrentNode)
    {
        if (i == nDesktopNumber)
        {
            return pCurrentNode->nIconID;
        }

        i++;
        pCurrentNode = pCurrentNode->nextDN;
    }

    return 0;
}


/*------------------------------------------------------------------------------*/
/*                                                                              */
/*    Purpose:  Sets the Desktop Icon                                           */
/*                                                                              */
/*------------------------------------------------------------------------------*/

BOOL CDesktop::SetDesktopIconID(UINT DesktopNumber, UINT nIconID)
{
    UINT i;
    BOOL Found;
    PDESKTOP_NODE pCurrentNode;

    //
    // Change the name in our data structure.
    //
    i = 0;
    Found = FALSE;
    pCurrentNode = m_DesktopList;
    while (pCurrentNode && !Found)
    {
        if (i == DesktopNumber)
        {
            pCurrentNode->nIconID = nIconID;
            Found = TRUE;
        }

        i++;
        pCurrentNode = pCurrentNode->nextDN;
    }

    return Found;
}



/*------------------------------------------------------------------------------*/
/*                                                                              */
/*    Purpose:  Sets the threads main window.                                   */
/*                                                                              */
/*------------------------------------------------------------------------------*/

BOOL CDesktop::SetThreadWindow(DWORD ThreadId, HWND hWnd)
{
    PDESKTOP_NODE pCurrentNode;

    pCurrentNode = m_DesktopList;
    while (pCurrentNode)
    {
        if (pCurrentNode->ThreadId == ThreadId)
        {
            pCurrentNode->hWnd = hWnd;
        }
        pCurrentNode = pCurrentNode->nextDN;
    }

    return FALSE;
}


/*------------------------------------------------------------------------------*/
/*                                                                              */
/*    Purpose:  Gets the threads main window.                                   */
/*                                                                              */
/*------------------------------------------------------------------------------*/

HWND CDesktop::GetThreadWindow(DWORD ThreadId) const
{
    PDESKTOP_NODE pCurrentNode;

    pCurrentNode = m_DesktopList;
    while (pCurrentNode)
    {
        if (pCurrentNode->ThreadId == ThreadId)
        {
            return pCurrentNode->hWnd;
        }
        pCurrentNode = pCurrentNode->nextDN;
    }

    return 0;
}


/*------------------------------------------------------------------------------*/
/*                                                                              */
/*    Purpose:  Gets the desktop id of a given thread.                          */
/*                                                                              */
/*------------------------------------------------------------------------------*/

UINT CDesktop::GetThreadDesktopID(DWORD ThreadId) const
{
    PDESKTOP_NODE pCurrentNode;
    UINT i;

    i = 0;
    pCurrentNode = m_DesktopList;
    while (pCurrentNode)
    {
        if (pCurrentNode->ThreadId == ThreadId)
        {
            return i;
        }

        i++;
        pCurrentNode = pCurrentNode->nextDN;
    }

    return 0;
}

/*------------------------------------------------------------------------------*/
/*                                                                              */
/*    Purpose:  Gets the threads main window.                                   */
/*                                                                              */
/*------------------------------------------------------------------------------*/

HWND CDesktop::GetWindowDesktop(UINT DesktopNumber) const
{
    PDESKTOP_NODE pCurrentNode;
    UINT i;

    i = 0;
    pCurrentNode = m_DesktopList;
    while (pCurrentNode)
    {
        if (DesktopNumber == i)
        {
            return pCurrentNode->hWnd;
        }

        i++;
        pCurrentNode = pCurrentNode->nextDN;
    }

    return 0;
}


/*------------------------------------------------------------------------------*/
/*                                                                              */
/*    Purpose:  Gets the real desktop name.                                     */
/*                                                                              */
/*------------------------------------------------------------------------------*/

BOOL CDesktop::GetRealDesktopName(HWND hWnd, LPTSTR szRealDesktopName) const
{
    PDESKTOP_NODE pCurrentNode;

    pCurrentNode = m_DesktopList;
    while (pCurrentNode)
    {
        if (pCurrentNode->hWnd == hWnd)
        {
            if (pCurrentNode->RealDesktopName[0])
                lstrcpy(szRealDesktopName, pCurrentNode->RealDesktopName);
            else
                szRealDesktopName[0] = TEXT('\0');
        }

        pCurrentNode = pCurrentNode->nextDN;
    }

    return 0;
}


/*------------------------------------------------------------------------------*/
/*                                                                              */
/*    Purpose:  Evaluate the setting of a desktop scheme.                       */
/*                                                                              */
/*------------------------------------------------------------------------------*/

BOOL CDesktop::FindSchemeAndSet(VOID)
{
    PDESKTOP_NODE pCurrentNode;
    UINT i;

    if (!BeginRundown)
    {
        i = 0;
        pCurrentNode = m_DesktopList;
        while (pCurrentNode)
        {
            if (i == CurrentDesktop)
            {
                if (pCurrentNode->ThreadId == GetCurrentThreadId())
                {
                    //
                    // Set the desktop scheme
                    //
                    return __SetDesktopScheme(&(pCurrentNode->DS));
                }
            }

            i++;
            pCurrentNode = pCurrentNode->nextDN;
        }
    }
    else
    {
        //
        // Set the desktop scheme to that of desktop 1
        //
        __SetDesktopScheme(&(m_DesktopList->DS));
    }

    return FALSE;
}


/*------------------------------------------------------------------------------*/
/*                                                                              */
/*    Purpose:  Copies the scheme from desktop 0 to desktop n.                  */
/*                                                                              */
/*------------------------------------------------------------------------------*/

BOOL CDesktop::DuplicateDefaultScheme(UINT DesktopNumber)
{
    PDESKTOP_NODE pCurrentNode;
    BOOL Success = FALSE;
    UINT i;

    i = 0;
    pCurrentNode = m_DesktopList;
    while (pCurrentNode)
    {
        if (i == DesktopNumber)
            Success = __CopyDesktopScheme(&(m_DesktopList->DS), &(pCurrentNode->DS));

        i++;
        pCurrentNode = pCurrentNode->nextDN;
    }

    return Success;
}


/*------------------------------------------------------------------------------*/
/*                                                                              */
/*    Purpose:  Gets the color struct from registry for desktop n.              */
/*                                                                              */
/*------------------------------------------------------------------------------*/

BOOL CDesktop::GetRegColorStruct(UINT DesktopNumber)
{
    PDESKTOP_NODE        pCurrentNode;
    BOOL                Success = FALSE;
    UINT                i;

    i = 0;
    pCurrentNode = m_DesktopList;
    while (pCurrentNode)
    {
        if (i == DesktopNumber)
            Success = GetDesktopSchemeRegistry(DesktopNumber, &(pCurrentNode->DS));

        i++;
        pCurrentNode = pCurrentNode->nextDN;
    }

    return Success;
}


/*------------------------------------------------------------------------------*/
/*                                                                              */
/*    Purpose:  Save off the schemes to the registry.                           */
/*                                                                              */
/*------------------------------------------------------------------------------*/

BOOL CDesktop::RegSaveSettings(VOID)
{
    PDESKTOP_NODE        pCurrentNode;
    UINT                ii;

    //
    // Set Global settings
    //
    Profile_SetNewContext(NumOfDesktops);

    //
    // Dump settings desktop by desktop
    //
    ii = 0;
    pCurrentNode = m_DesktopList;

    while (pCurrentNode)
    {
        Profile_SaveDesktopContext(ii,
                              pCurrentNode->DesktopName,
                              pCurrentNode->SaiferName,
                              pCurrentNode->nIconID);
        SetDesktopSchemeRegistry(ii, &(pCurrentNode->DS));

        ii++;
        pCurrentNode = pCurrentNode->nextDN;
    }

    return TRUE;
}


/*------------------------------------------------------------------------------*/
/*                                                                              */
/*    Purpose:  Destroy the windows one by one.                                 */
/*                                                                              */
/*------------------------------------------------------------------------------*/

BOOL CDesktop::RunDown(VOID)
{
    PDESKTOP_NODE        pCurrentNode;
    BOOL                Success;

    BeginRundown = TRUE;

    //
    // Set desktop schemes to that of desktop 1
    //
    pCurrentNode = m_DesktopList->nextDN;
    while (pCurrentNode)
    {
        //
        // Set the desktop scheme
        //
        PostThreadMessage(pCurrentNode->ThreadId, WM_THREAD_SCHEME_UPDATE, 0, 0);
        pCurrentNode = pCurrentNode->nextDN;
    }

    //
    // Remove the desktops
    //
    while (NumOfDesktops > 1)
    {
        Success = RemoveDesktop(NumOfDesktops - 1);
    }

    //
    // Flush to registry
    //
    __UpdateDesktopRegistry(&(m_DesktopList->DS));

    return TRUE;
}


/*------------------------------------------------------------------------------*/
/*                                                                              */
/*    Purpose:  Create a default desktop name.                                  */
/*                                                                              */
/*------------------------------------------------------------------------------*/

static BOOL __CreateDefaultName(UINT DeskNum, LPTSTR DesktopName)
{
    wsprintf(DesktopName, TEXT("Desktop %d"), DeskNum);

    return TRUE;
}


/*------------------------------------------------------------------------------*/
/*                                                                              */
/*    Purpose:  Gets the default icons.                                         */
/*                                                                              */
/*------------------------------------------------------------------------------*/

static HICON __LoadBuiltinIcon(UINT nIconNumber, HINSTANCE hDeskInstance)
{
    UINT resid;

    assert(NUM_BUILTIN_ICONS == 27);
    switch(nIconNumber)
    {
        case 1: resid = IDI_WIN_ICON01; break;
        case 2: resid = IDI_WIN_ICON02; break;
        case 3: resid = IDI_WIN_ICON03; break;
        case 4: resid = IDI_WIN_ICON04; break;
        case 5: resid = IDI_WIN_ICON05; break;
        case 6: resid = IDI_WIN_ICON06; break;
        case 7: resid = IDI_WIN_ICON07; break;
        case 8: resid = IDI_WIN_ICON08; break;
        case 9: resid = IDI_WIN_ICON09; break;
        case 10: resid = IDI_WIN_ICON10; break;
        case 11: resid = IDI_WIN_ICON11; break;
        case 12: resid = IDI_WIN_ICON12; break;
        case 13: resid = IDI_WIN_ICON13; break;
        case 14: resid = IDI_WIN_ICON14; break;
        case 15: resid = IDI_WIN_ICON15; break;
        case 16: resid = IDI_WIN_ICON16; break;
        case 17: resid = IDI_WIN_ICON17; break;
        case 18: resid = IDI_WIN_ICON18; break;
        case 19: resid = IDI_WIN_ICON19; break;
        case 20: resid = IDI_WIN_ICON20; break;
        case 21: resid = IDI_WIN_ICON21; break;
        case 22: resid = IDI_WIN_ICON22; break;
        case 23: resid = IDI_WIN_ICON23; break;
        case 24: resid = IDI_WIN_ICON24; break;
        case 25: resid = IDI_WIN_ICON25; break;
        case 26: resid = IDI_WIN_ICON26; break;
        case 27: resid = IDI_WIN_ICON27; break;
        default: return NULL;
    }
    
    return LoadIcon(hDeskInstance, MAKEINTRESOURCE(resid));
}

HICON CDesktop::GetBuiltinIcon(UINT nIconNumber) const
{
    if (nIconNumber < NUM_BUILTIN_ICONS)
        return DefaultIconArray[nIconNumber];
    else
        return NULL;
}


/*------------------------------------------------------------------------------*/
/*                                                                              */
/*    Purpose:  Create a new desktop.                                           */
/*                                                                              */
/*------------------------------------------------------------------------------*/

VOID ThreadInit(LPVOID hData)
{
    USEROBJECTFLAGS        uof;
    PTHREAD_DATA        ptd;
    BOOL                Success;
    DWORD                Err;

    //
    // Passed-in data
    //
    ptd = (THREAD_DATA*)hData;

    //
    // Inheiritance and flags
    //
    uof.fInherit  = TRUE;
    uof.fReserved = FALSE;
    uof.dwFlags   = DF_ALLOWOTHERACCOUNTHOOK;

    Success = SetUserObjectInformation (ptd->hDesktop,
                                        UOI_FLAGS,
                                        (LPVOID)&uof,
                                        sizeof(uof));

    //
    // Assign the thread to its desktop
    //
    Success = SetThreadDesktop(ptd->hDesktop);
    Err = GetLastError();

    //
    // Begin the Display dialog and start the shell.
    //
    ptd->CreateDisplayFn();

    //
    // End the thread
    //
    SetThreadDesktop(ptd->hDefaultDesktop);
    Success = CloseDesktop(ptd->hDesktop);
    GlobalFree(ptd);

    return;
}

/*------------------------------------------------------------------------------*/
/*----------------------------- PROTECTED FUNCTIONS ----------------------------*/
/*------------------------------------------------------------------------------*/

BOOL CDesktop::GetDesktopSchemeRegistry(UINT DesktopNumber, PDESKTOP_SCHEME pDS)
{
    BOOL bSuccess = FALSE;

    assert(pDS);

    bSuccess = Profile_LoadScheme(DesktopNumber, pDS);

    pDS->Initialized = bSuccess;
    return bSuccess;
}

BOOL CDesktop::SetDesktopSchemeRegistry(UINT DesktopNumber, PDESKTOP_SCHEME pDS)
{
    BOOL    bSuccess = FALSE;

    assert(pDS);
    if (!pDS->Initialized) return FALSE;

    bSuccess = Profile_SaveScheme(DesktopNumber, pDS);

    return bSuccess;
}


static BOOL __SetDesktopScheme(PDESKTOP_SCHEME pDS)
{
    //
    // Check if structure has been filled in
    //
    assert(pDS);
    if (!pDS->Initialized) return FALSE;

    //
    // Structure has info - Lets update the desktop scheme
    //
    Reg_SetSysColors(pDS->dwColor);
    Reg_SetWallpaper(pDS->szWallpaper, pDS->szTile);
    Reg_SetPattern(pDS->szPattern);
    Reg_SetScreenSaver(pDS->szScreenSaver, pDS->szSecure, pDS->szTimeOut, pDS->szActive);

    //
    // Now invalidate the Wallpaper and Pattern
    //
    SystemParametersInfo(SPI_SETDESKWALLPAPER, 0, pDS->szWallpaper, SPIF_SENDCHANGE);
    SystemParametersInfo(SPI_SETDESKPATTERN, 0, pDS->szPattern, SPIF_SENDCHANGE);


    return TRUE;
}

static BOOL __GetDesktopScheme(PDESKTOP_SCHEME pDS)
{
    //
    // Read the color settings from the desktop and fill in the structure
    //
    assert(pDS);

    if (Reg_GetSysColors(pDS->dwColor) &&
        Reg_GetWallpaper(pDS->szWallpaper, pDS->szTile) &&
        Reg_GetPattern(pDS->szPattern) &&
        Reg_GetScreenSaver(pDS->szScreenSaver, pDS->szSecure, pDS->szTimeOut, pDS->szActive))
    {
        //
        // Structure filled!
        //
        pDS->Initialized = TRUE;
        return TRUE;
    }

    return FALSE;
}

static BOOL __UpdateDesktopRegistry(PDESKTOP_SCHEME pDS)
{

    //
    // Update the registry
    //
    assert(pDS);
    Reg_UpdateColorRegistry(pDS->dwColor);

    return TRUE;
}


static BOOL __CopyDesktopScheme(PDESKTOP_SCHEME pDS1, PDESKTOP_SCHEME pDS2)
{

    UINT i;

    //
    // Copy the contents of pDS1 into pDS2
    //
    assert(pDS2 != NULL);
    assert(pDS1 != NULL);

    if (!pDS1->Initialized)
    {
        pDS2->Initialized = FALSE;
        return FALSE;
    }

    //
    // Copy the strings over
    //
    lstrcpy(pDS2->szWallpaper,   pDS1->szWallpaper);
    lstrcpy(pDS2->szTile,        pDS1->szTile);
    lstrcpy(pDS2->szPattern,        pDS1->szPattern);
    lstrcpy(pDS2->szScreenSaver, pDS1->szScreenSaver);
    lstrcpy(pDS2->szSecure,        pDS1->szSecure);
    lstrcpy(pDS2->szTimeOut,        pDS1->szTimeOut);
    lstrcpy(pDS2->szActive,        pDS1->szActive);

    //
    // Copy the colors over
    //
    for (i = 0; i < NUM_COLOR_ELEMENTS; i++)
    {
        pDS2->dwColor[i] = pDS1->dwColor[i];
    }

    pDS2->Initialized = TRUE;
    return TRUE;
}