17 files changed, 3257 insertions, 0 deletions

diff --git a/private/oleutest/letest/gizmobar/api.c b/private/oleutest/letest/gizmobar/api.c
new file mode 100644
index 000000000..526d66a5f
--- /dev/null
+++ b/private/oleutest/letest/gizmobar/api.c
@@ -0,0 +1,846 @@
+/*
+ * API.C
+ * GizmoBar Version 1.00, Win32 version August 1993
+ *
+ * API functions affecting a GizmoBar and a message processing function to
+ * handle the equivalent called through messages.
+ *
+ * Copyright (c)1993 Microsoft Corporation, All Rights Reserved
+ *
+ * Kraig Brockschmidt, Software Design Engineer
+ * Microsoft Systems Developer Relations
+ *
+ * Internet  :  kraigb@microsoft.com
+ * Compuserve:  >INTERNET:kraigb@microsoft.com
+ */
+
+
+#include <windows.h>
+#include "gizmoint.h"
+
+
+
+/*
+ * GBMessageHandler
+ *
+ * Purpose:
+ *  Processes control messages that are equivalents of available
+ *  control API.  The data passed with these messages is simply
+ *  extracted from structures and passed as parameters to their
+ *  equivalent function.
+ *
+ * Parameters:
+ *  <Standard Message Parameters> plus
+ *  pGB             LPGIZMOBAR providing control-specific data.
+ *
+ * Return Value:
+ *  LRESULT         Return value from equivalent API function.
+ */
+
+LRESULT GBMessageHandler(HWND hWnd, UINT iMsg, WPARAM wParam
+    , LPARAM lParam, LPGIZMOBAR pGB)
+    {
+    LRESULT         lRet=0L;
+    LPCREATEGIZMO   pCG;
+    LPGBMSG         pMsg;
+    LPGBGETTEXT     pGT;
+    LPGBGETINT      pGI;
+    LPGBSETINT      pSI;
+
+    if (NULL==pGB)
+        return 0L;
+
+    switch (iMsg)
+        {
+        case GBM_HWNDASSOCIATESET:
+            lRet=(LRESULT)(UINT)GBHwndAssociateSet(hWnd, (HWND)wParam);
+            break;
+
+        case GBM_HWNDASSOCIATEGET:
+            lRet=(LRESULT)(UINT)GBHwndAssociateGet(hWnd);
+            break;
+
+        case GBM_GIZMOADD:
+            pCG=(LPCREATEGIZMO)lParam;
+            lRet=(LRESULT)GBGizmoAdd(pCG->hWndParent, pCG->iType, pCG->iGizmo
+                , pCG->uID, pCG->dx, pCG->dy, pCG->pszText, pCG->hBmp
+                , pCG->iImage, pCG->uState);
+            break;
+
+        case GBM_GIZMOREMOVE:
+            lRet=(LRESULT)GBGizmoRemove(hWnd, wParam);
+            break;
+
+        case GBM_GIZMOSENDMESSAGE:
+            pMsg=(LPGBMSG)lParam;
+            lRet=GBGizmoSendMessage(hWnd, wParam, pMsg->iMsg, pMsg->wParam, pMsg->lParam);
+            break;
+
+        case GBM_GIZMOSHOW:
+            lRet=(LRESULT)GBGizmoShow(hWnd, wParam, (BOOL)LOWORD(lParam));
+            break;
+
+        case GBM_GIZMOENABLE:
+            lRet=(LRESULT)GBGizmoEnable(hWnd, wParam, (BOOL)LOWORD(lParam));
+            break;
+
+        case GBM_GIZMOCHECK:
+            lRet=(LRESULT)GBGizmoCheck(hWnd, wParam, (BOOL)LOWORD(lParam));
+            break;
+
+        case GBM_GIZMOFOCUSSET:
+            lRet=(LRESULT)GBGizmoFocusSet(hWnd, wParam);
+            break;
+
+        case GBM_GIZMOEXIST:
+            lRet=(LRESULT)GBGizmoExist(hWnd, wParam);
+            break;
+
+        case GBM_GIZMOTYPEGET:
+            lRet=(LRESULT)GBGizmoTypeGet(hWnd, wParam);
+            break;
+
+        case GBM_GIZMODATASET:
+            lRet=(LRESULT)GBGizmoDataSet(hWnd, wParam, (DWORD)lParam);
+            break;
+
+        case GBM_GIZMODATAGET:
+            lRet=(LRESULT)GBGizmoDataGet(hWnd, wParam);
+            break;
+
+        case GBM_GIZMONOTIFYSET:
+            lRet=(LRESULT)GBGizmoNotifySet(hWnd, wParam, (BOOL)LOWORD(lParam));
+            break;
+
+        case GBM_GIZMONOTIFYGET:
+            lRet=(LRESULT)GBGizmoNotifyGet(hWnd, wParam);
+            break;
+
+        case GBM_GIZMOTEXTGET:
+            pGT=(LPGBGETTEXT)lParam;
+            lRet=(LRESULT)GBGizmoTextGet(hWnd, wParam, pGT->psz, pGT->cch);
+            break;
+
+        case GBM_GIZMOTEXTSET:
+            GBGizmoTextSet(hWnd, wParam, (LPTSTR)lParam);
+            break;
+
+        case GBM_GIZMOINTGET:
+            pGI=(LPGBGETINT)lParam;
+            lRet=(LRESULT)GBGizmoIntGet(hWnd, wParam, &pGI->fSuccess, pGI->fSigned);
+            break;
+
+
+        case GBM_GIZMOINTSET:
+            pSI=(LPGBSETINT)lParam;
+            GBGizmoIntSet(hWnd, wParam, pSI->uValue, pSI->fSigned);
+            break;
+
+        default:
+            break;
+        }
+
+    return lRet;
+    }
+
+
+
+
+
+
+
+
+
+
+/*
+ * PGizmoFromHwndID
+ *
+ * Purpose:
+ *  Retrieves the pGizmo for the given GizmoBar and the gizmo ID.
+ *
+ * Parameters:
+ *  hWnd            HWND of a GizmoBar.
+ *  uID             UINT gizmo identifier.
+ *
+ * Return Value:
+ *  LPGIZMO         NULL if the gizmo does not exist or hWnd is invalid.
+ *                  non-NULL LPGIZMO otherwise.
+ */
+
+LPGIZMO PGizmoFromHwndID(HWND hWnd, UINT uID)
+    {
+    LPGIZMOBAR    pGB;
+
+    if (!IsWindow(hWnd))
+        return FALSE;
+
+    pGB=(LPGIZMOBAR)GetWindowLong(hWnd, GBWL_STRUCTURE);
+
+    if (NULL==pGB)
+        return FALSE;
+
+    return GizmoPFind(&pGB->pGizmos, uID);
+    }
+
+
+
+
+
+
+/*
+ * GBHwndAssociateSet
+ *
+ * Purpose:
+ *  Changes the associate window of a GizmoBar.
+ *
+ * Parameters:
+ *  hWnd            HWND of the control window.
+ *
+ * Set Parameters:
+ *  hWndAssociate   HWND of new associate.
+ *
+ * Return Value:
+ *  HWND            Handle of previous associate.
+ */
+
+HWND WINAPI GBHwndAssociateSet(HWND hWnd, HWND hWndNew)
+    {
+    HWND        hWndOld=NULL;
+    LPGIZMOBAR  pGB;
+
+    pGB=(LPGIZMOBAR)GetWindowLong(hWnd, GBWL_STRUCTURE);
+
+    if (NULL!=pGB)
+        {
+        hWndOld=pGB->hWndAssociate;
+        pGB->hWndAssociate=hWndNew;
+
+        if (NULL!=hWndOld)
+            SendCommand(hWndOld, pGB->uID, GBN_ASSOCIATELOSS, hWnd);
+
+        if (NULL!=hWndNew)
+            SendCommand(hWndNew, pGB->uID, GBN_ASSOCIATEGAIN, hWnd);
+        }
+
+    return hWndOld;
+    }
+
+
+
+
+
+/*
+ * GBHwndAssociateGet
+ *
+ * Purpose:
+ *  Retrieves the associate window of a GizmoBar
+ *
+ * Parameters:
+ *  hWnd            HWND of the control window.
+ *
+ * Set Parameters:
+ *  hWndAssociate   HWND of new associate.
+ *
+ * Return Value:
+ *  HWND            Handle of current associate.
+ */
+
+HWND WINAPI GBHwndAssociateGet(HWND hWnd)
+    {
+    HWND        hWndOld=NULL;
+    LPGIZMOBAR  pGB;
+
+    pGB=(LPGIZMOBAR)GetWindowLong(hWnd, GBWL_STRUCTURE);
+
+    if (NULL!=pGB)
+        hWndOld=pGB->hWndAssociate;
+
+    return hWndOld;
+    }
+
+
+
+
+
+/*
+ * GBGizmoAdd
+ *
+ * Purpose:
+ *  Creates a new gizmo on the GizmoBar.  Subsequent operations should
+ *  be done using the identifier, uID, for this gizmo.
+ *
+ * Parameters:
+ *  hWnd            HWND of the GizmoBar.
+ *  iType           UINT type of the gizmo to create.
+ *  iGizmo          UINT position (zero-based) at which to place the gizmo.
+ *  uID             UINT identifier for WM_COMMAND from this gizmo.
+ *  dx, dy          UINT dimensions of the gizmo.
+ *  pszText         LPTSTR initial text for edit, list, combo, and text gizmos.
+ *  hBitmap         HBITMAP for gizmos of the button types (COMMAND or
+ *                  ATTRIBUTE) specifies a source bitmap from which the
+ *                  button image is taken.
+ *  iImage          UINT index into hBitmap for the image for this button.
+ *  uState          UINT initial state of the gizmo.
+ *
+ * Return Value:
+ *  BOOL            TRUE if creation succeeded, FALSE otherwise.
+ */
+
+BOOL WINAPI GBGizmoAdd(HWND hWnd, UINT iType, UINT iGizmo, UINT uID
+    , UINT dx, UINT dy, LPTSTR pszText, HBITMAP hBmp, UINT iImage, UINT uState)
+    {
+    BOOL        fSuccess;
+    LPGIZMOBAR  pGB;
+    LPGIZMO     pGizmo;
+
+    if (!IsWindow(hWnd))
+        return FALSE;
+
+    pGB=(LPGIZMOBAR)GetWindowLong(hWnd, GBWL_STRUCTURE);
+
+    if (NULL==pGB)
+        return FALSE;
+
+    /*
+     * This automatically creates the windows, allocates structures, includes
+     * the gizmo in pGB->pGizmos, and so forth.
+     */
+    pGizmo=GizmoPAllocate((LPINT)&fSuccess, &pGB->pGizmos, hWnd, iType
+        , iGizmo, uID, dx, dy, pszText, hBmp, iImage, uState);
+
+    if (fSuccess)
+        {
+        if (NULL!=pGB->hWndAssociate)
+            SendCommand(pGB->hWndAssociate,GBN_GIZMOADDED, pGB->uID, hWnd);
+
+        InvalidateRect(hWnd, NULL, TRUE);
+        UpdateWindow(hWnd);
+        }
+    else
+        GizmoPFree(&pGB->pGizmos, pGizmo);
+
+    return fSuccess;
+    }
+
+
+
+
+
+/*
+ * GBGizmoRemove
+ *
+ * Purpose:
+ *  Removes an existing gizmo from the GizmoBar.
+ *
+ * Parameters:
+ *  hWnd            HWND of the GizmoBar.
+ *  uID             UINT identifier for this gizmo.
+ *
+ * Return Value:
+ *  BOOL            TRUE if deletion succeeded, FALSE otherwise.
+ */
+
+BOOL WINAPI GBGizmoRemove(HWND hWnd, UINT uID)
+    {
+    LPGIZMOBAR  pGB;
+    LPGIZMO     pGizmo;
+
+    if (!IsWindow(hWnd))
+        return FALSE;
+
+    pGB=(LPGIZMOBAR)GetWindowLong(hWnd, GBWL_STRUCTURE);
+
+    if (NULL==pGB)
+        return FALSE;
+
+    pGizmo=GizmoPFind(&pGB->pGizmos, uID);
+
+    if (NULL==pGizmo)
+        return FALSE;
+
+    GizmoPFree(&pGB->pGizmos, pGizmo);
+
+    if (NULL!=pGB->hWndAssociate)
+        SendCommand(pGB->hWndAssociate, GBN_GIZMOREMOVED, pGB->uID, hWnd);
+
+    InvalidateRect(hWnd, NULL, TRUE);
+    UpdateWindow(hWnd);
+    return TRUE;
+    }
+
+
+
+
+
+
+/*
+ * GBGizmoSendMessage
+ *
+ * Purpose:
+ *  Implements the equivalent of SendMessage to a gizmo in the
+ *  GizmoBar.  Separators, command buttons, and attribute buttons
+ *  do not accept messages.
+ *
+ * Parameters:
+ *  hWnd            HWND of the GizmoBar.
+ *  uID             UINT identifier of the gizmo to affect.
+ *  iMsg            UINT message to send.
+ *  wParam          WPARAM of the message.
+ *  lParam          LPARAM of the message.
+ *
+ * Return Value:
+ *  LRESULT         Return value from the message.  0L if the
+ *                  gizmo does not accept messages.
+ */
+
+LRESULT WINAPI GBGizmoSendMessage(HWND hWnd, UINT uID, UINT iMsg
+    , WPARAM wParam, LPARAM lParam)
+    {
+    LPGIZMO     pGizmo;
+    LONG        lRet=0L;
+
+    pGizmo=PGizmoFromHwndID(hWnd, uID);
+
+    if (NULL!=pGizmo && NULL!=pGizmo->hWnd)
+        lRet=SendMessage(pGizmo->hWnd, iMsg, wParam, lParam);
+
+    return lRet;
+    }
+
+
+
+
+
+
+/*
+ * GBGizmoShow
+ *
+ * Purpose:
+ *  Shows or hides a control, adjusting the positions of all others
+ *  to make room for or reuse the space for this control.
+ *
+ * Parameters:
+ *  hWnd            HWND of the GizmoBar.
+ *  uID             UINT identifier of the gizmo to affect.
+ *  fShow           BOOL TRUE to show the gizmo, FALSE to hide it.
+ *
+ * Return Value:
+ *  BOOL            TRUE if the function was successful, FALSE otherwise.
+ */
+
+BOOL WINAPI GBGizmoShow(HWND hWnd, UINT uID, BOOL fShow)
+    {
+    BOOL        fRet=FALSE;
+    LPGIZMO     pGizmo;
+
+    pGizmo=PGizmoFromHwndID(hWnd, uID);
+
+    if (NULL!=pGizmo)
+        {
+        if (fShow && pGizmo->fHidden)
+            {
+            if (NULL!=pGizmo->hWnd)
+                ShowWindow(pGizmo->hWnd, SW_SHOWNORMAL);
+
+            GizmosExpand(pGizmo);
+            }
+
+        if (!fShow && !pGizmo->fHidden)
+            {
+            if (NULL!=pGizmo->hWnd)
+                ShowWindow(pGizmo->hWnd, SW_HIDE);
+
+            GizmosCompact(pGizmo);
+            }
+
+        //This will be right even if we didn't change anything.
+        pGizmo->fHidden=!fShow;
+        }
+
+    InvalidateRect(hWnd, NULL, TRUE);
+    UpdateWindow(hWnd);
+    return fRet;
+    }
+
+
+
+
+
+
+/*
+ * GBGizmoEnable
+ *
+ * Purpose:
+ *  Enables or disables a control on the GizmoBar.
+ *
+ * Parameters:
+ *  hWnd            HWND of the GizmoBar.
+ *  uID             UINT identifier of the gizmo to affect.
+ *  fEnable         BOOL TRUE to enable the gizmo, FALSE otherwise.
+ *
+ * Return Value:
+ *  BOOL            TRUE if the gizmo was previously disabled, FALSE
+ *                  otherwise.
+ */
+
+BOOL WINAPI GBGizmoEnable(HWND hWnd, UINT uID, BOOL fEnable)
+    {
+    LPGIZMO     pGizmo;
+    BOOL        fRet=FALSE;
+
+    pGizmo=PGizmoFromHwndID(hWnd, uID);
+
+    if (NULL==pGizmo)
+        return FALSE;
+
+    fRet=(BOOL)(BUTTONGROUP_DISABLED & pGizmo->uState);
+
+    //Use windows to enable or disable window gizmos
+    if (NULL!=pGizmo->hWnd)
+        EnableWindow(pGizmo->hWnd, fEnable);
+    else
+        {
+        //If we're not down, command and attribute buttons act the same.
+        if (!(BUTTONGROUP_DOWN & pGizmo->uState))
+            GizmoPStateSet(hWnd, pGizmo, fEnable ? COMMANDBUTTON_UP : COMMANDBUTTON_DISABLED);
+        else
+            {
+            //Attribute buttons are a little more sensitive with DOWNDISABLED
+            GizmoPStateSet(hWnd, pGizmo
+                , fEnable ? ATTRIBUTEBUTTON_DOWN : ATTRIBUTEBUTTON_DOWNDISABLED);
+            }
+        }
+
+    return fRet;
+    }
+
+
+
+
+
+
+
+/*
+ * GBGizmoCheck
+ *
+ * Purpose:
+ *  Checks or unchecks an attribute button in the GizmoBar.  If the
+ *  gizmo is part of a group of mutually exclusive attributes, then
+ *  other gizmos are unchecked when this one is checked.  If this is
+ *  the only one checked in these circumstances, this function is a NOP.
+ *
+ * Parameters:
+ *  hWnd            HWND of the GizmoBar.
+ *  uID             UINT identifier of the gizmo to affect.
+ *  fCheck          BOOL TRUE to check this gizmo, FALSE to uncheck.
+ *
+ * Return Value:
+ *  BOOL            TRUE if the change took place.  FALSE otherwise.
+ */
+
+BOOL WINAPI GBGizmoCheck(HWND hWnd, UINT uID, BOOL fCheck)
+    {
+    LPGIZMOBAR  pGB;
+    LPGIZMO     pGizmo;
+
+    if (!IsWindow(hWnd))
+        return FALSE;
+
+    pGB=(LPGIZMOBAR)GetWindowLong(hWnd, GBWL_STRUCTURE);
+
+    if (NULL==pGB)
+        return FALSE;
+
+    pGizmo=GizmoPFind(&pGB->pGizmos, uID);
+
+    if (NULL!=pGizmo)
+        GizmoPCheck(hWnd, pGizmo, fCheck);
+
+    return TRUE;
+    }
+
+
+
+
+
+
+/*
+ * GBGizmoFocusSet
+ *
+ * Purpose:
+ *  Sets the focus to a partuclar gizmo in the gizmo if that gizmo
+ *  can accept the focus.  Separators, attribute buttons, text,
+ *  and command buttons cannot have the focus.
+ *
+ * Parameters:
+ *  hWnd            HWND of the GizmoBar.
+ *  uID             UINT identifier of the gizmo to affect.
+ *
+ * Return Value:
+ *  BOOL            TRUE if the focus was set.  FALSE otherwise, such as
+ *                  when uID identifies a control that cannot have focus.
+ */
+
+UINT WINAPI GBGizmoFocusSet(HWND hWnd, UINT uID)
+    {
+    LPGIZMO     pGizmo;
+    BOOL        fRet=FALSE;
+
+    pGizmo=PGizmoFromHwndID(hWnd, uID);
+
+    if (NULL!=pGizmo && NULL!=pGizmo->hWnd)
+        {
+        fRet=TRUE;
+        SetFocus(pGizmo->hWnd);
+        }
+
+    return fRet;
+    }
+
+
+
+
+
+/*
+ * GBGizmoExist
+ *
+ * Purpose:
+ *  Determines if a gizmo of a given identifier exists in the GizmoBar.
+ *
+ * Parameters:
+ *  hWnd            HWND of the GizmoBar.
+ *  uID             UINT identifier to verify.
+ *
+ * Return Value:
+ *  BOOL            TRUE if the gizmo exists, FALSE otherwise.
+ */
+
+BOOL WINAPI GBGizmoExist(HWND hWnd, UINT uID)
+    {
+    return (NULL!=PGizmoFromHwndID(hWnd, uID));
+    }
+
+
+
+
+
+/*
+ * GBGizmoTypeGet
+ *
+ * Purpose:
+ *  Returns the type of the gizmo specified by the given identifer.
+ *
+ * Parameters:
+ *  hWnd            HWND of the GizmoBar.
+ *  uID             UINT identifier to find.
+ *
+ * Return Value:
+ *  int             A GIZMOTYPE_* value if the function is successful,
+ *                  otherwise -1.
+ */
+
+int WINAPI GBGizmoTypeGet(HWND hWnd, UINT uID)
+    {
+    int         iRet=-1;
+    LPGIZMO     pGizmo;
+
+    pGizmo=PGizmoFromHwndID(hWnd, uID);
+
+    if (NULL!=pGizmo)
+        iRet=pGizmo->iType;
+
+    return iRet;
+    }
+
+
+
+
+
+/*
+ * GBGizmoDataSet
+ * GBGizmoDataGet
+ *
+ * Purpose:
+ *  Sets or retrieves an extra DWORD value associated with the given gizmo.
+ *  Applications can store any information here they please.
+ *
+ * Parameters:
+ *  hWnd            HWND of the GizmoBar.
+ *  uID             UINT identifier of the gizmo.
+ *  dwData          (Set only) DWORD data to store with the gizmo.
+ *
+ * Return Value:
+ *  DWORD           Set:  Previous value
+ *                  Get:  Current value
+ */
+
+DWORD WINAPI GBGizmoDataSet(HWND hWnd, UINT uID, DWORD dwData)
+    {
+    LPGIZMO     pGizmo;
+    DWORD       dw=0L;
+
+    pGizmo=PGizmoFromHwndID(hWnd, uID);
+
+    if (NULL!=pGizmo)
+        {
+        dw=pGizmo->dwData;
+        pGizmo->dwData=dwData;
+        }
+
+    return dw;
+    }
+
+
+
+DWORD WINAPI GBGizmoDataGet(HWND hWnd, UINT uID)
+    {
+    LPGIZMO     pGizmo;
+    DWORD       dw=0L;
+
+    pGizmo=PGizmoFromHwndID(hWnd, uID);
+
+    if (NULL!=pGizmo)
+        dw=pGizmo->dwData;
+
+    return dw;
+    }
+
+
+
+
+
+
+/*
+ * GBGizmoNotifySet
+ * GBGizmoNotifyGet
+ *
+ * Purpose:
+ *  Sets or retrieves the notify status of a gizmo.  If notify is FALSE,
+ *  the no WM_COMMAND messages are sent from the GizmoBar to the parent
+ *  window when this gizmo is used.
+ *
+ * Parameters:
+ *  hWnd            HWND of the GizmoBar.
+ *  uID             UINT identifier of the gizmo.
+ *  fNotify         (Set only) BOOL new notify status to set.
+ *
+ * Return Value:
+ *  BOOL            Set:  Previous value of the notify flag.
+ *                  Get:  Current value of the notify flag.
+ */
+
+BOOL WINAPI GBGizmoNotifySet(HWND hWnd, UINT uID, BOOL fNotify)
+    {
+    LPGIZMO     pGizmo;
+    BOOL        fRet=FALSE;
+
+    pGizmo=PGizmoFromHwndID(hWnd, uID);
+
+    if (NULL!=pGizmo)
+        {
+        fRet=pGizmo->fNotify;
+        pGizmo->fNotify=fNotify;
+        }
+
+    return fRet;
+    }
+
+
+BOOL WINAPI GBGizmoNotifyGet(HWND hWnd, UINT uID)
+    {
+    LPGIZMO     pGizmo;
+    BOOL        fRet=FALSE;
+
+    pGizmo=PGizmoFromHwndID(hWnd, uID);
+
+    if (NULL!=pGizmo)
+        fRet=pGizmo->fNotify;
+
+    return fRet;
+    }
+
+
+
+
+
+
+
+/*
+ * GBGizmoTextSet
+ * GBGizmoTextGet
+ *
+ * Purpose:
+ *  Retrieves or sets text in a GizmoBar gizmo.  Separators, command buttons,
+ *  and attribute buttons are not affected by this call.
+ *
+ * Parameters:
+ *  hWnd            HWND of the GizmoBar.
+ *  uID             UINT identifying the gizmo.
+ *  psz             LPTSTR (Set) providing the text to show in the window
+ *                  or (Get) pointing to a buffer to receive the text.
+ *  cch             (Get only) UINT maximum number of chars to copy to psz.
+ *
+ * Return Value:
+ *  int             Number of characters copied to psz.
+ */
+
+void WINAPI GBGizmoTextSet(HWND hWnd, UINT uID, LPTSTR psz)
+    {
+    //This fails on non-windowed gizmos anyway, so we don't check.
+    SetDlgItemText(hWnd, uID, psz);
+    return;
+    }
+
+
+int WINAPI GBGizmoTextGet(HWND hWnd, UINT uID, LPTSTR psz, UINT cch)
+    {
+    //This fails on non-windowed gizmos anyway, so we don't check.
+    return GetDlgItemText(hWnd, uID, psz, cch);
+    }
+
+
+
+
+
+
+
+
+/*
+ * GBGizmoIntSet
+ * GBGizmoIntGet
+ *
+ * Purpose:
+ *  Retrieves or sets an integer in a GizmoBar gizmo.  Separators, command
+ *  buttons, and attribute buttons are not affected by this call.
+ *
+ * Parameters:
+ *  hWnd            HWND of the GizmoBar.
+ *  uID             UINT identifying the gizmo.
+ *
+ *  (Set only)
+ *  u               UINT value to set in the gizmo.
+ *  fSigned         BOOL TRUE to indicate if the value is signed.
+ *
+ *  (Get only)
+ *  pfTrans         BOOL FAR * in which the success of the function is returned.
+ *  fSigned         BOOL TRUE to indicate if the value is signed.
+ *
+ * Return Value:
+ *  (Set): None
+ *  (Get): UINT     Integer translation of the gizmo's text.
+ */
+
+void WINAPI GBGizmoIntSet(HWND hWnd, UINT uID, UINT u, BOOL fSigned)
+    {
+    //This fails on non-windowed gizmos anyway, so we don't check.
+    SetDlgItemInt(hWnd, uID, u, fSigned);
+    return;
+    }
+
+
+
+UINT WINAPI GBGizmoIntGet(HWND hWnd, UINT uID, BOOL FAR *pfTrans, BOOL fSigned)
+    {
+    //This fails on non-windowed gizmos anyway, so we don't check.
+    return GetDlgItemInt(hWnd, uID, pfTrans, fSigned);
+    }
diff --git a/private/oleutest/letest/gizmobar/book1632.h b/private/oleutest/letest/gizmobar/book1632.h
new file mode 100644
index 000000000..435fb200c
--- /dev/null
+++ b/private/oleutest/letest/gizmobar/book1632.h
@@ -0,0 +1,154 @@
+/*
+ * WIN1632.H
+ *
+ * Macros and other definitions that assist in porting between Win16
+ * and Win32 applications.  Define WIN32 to enable 32-bit versions.
+ *
+ * Copyright (c)1993 Microsoft Corporation, All Rights Reserved
+ *
+ * Kraig Brockschmidt, Software Design Engineer
+ * Microsoft Systems Developer Relations
+ *
+ * Internet  :  kraigb@microsoft.com
+ * Compuserve:  INTERNET>kraigb@microsoft.com
+ */
+
+
+#ifndef _BOOK1632_H_
+#define _BOOK1632_H_
+
+//Macros to handle control message packing between Win16 and Win32
+#ifdef WIN32
+
+#define MAKEPOINT MAKEPOINTS
+
+#ifndef COMMANDPARAMS
+#define COMMANDPARAMS(wID, wCode, hWndMsg)                          \
+    WORD        wID     = LOWORD(wParam);                           \
+    WORD        wCode   = HIWORD(wParam);                           \
+    HWND        hWndMsg = (HWND)(UINT)lParam;
+#endif  //COMMANDPARAMS
+
+#ifndef SendCommand
+#define SendCommand(hWnd, wID, wCode, hControl)                     \
+            SendMessage(hWnd, WM_COMMAND, MAKELONG(wID, wCode)      \
+                        , (LPARAM)hControl)
+#endif  //SendCommand
+
+#ifndef MENUSELECTPARAMS
+#define MENUSELECTPARAMS(wID, wFlags, hMenu)                        \
+    WORD        wID     = LOWORD(wParam);                           \
+    WORD        wFlags  = HIWORD(wParam);                           \
+    HMENU       hMenu   = (HMENU)lParam;
+#endif  //MENUSELECTPARAMS
+
+
+#ifndef SendMenuSelect
+#define SendMenuSelect(hWnd, wID, wFlags, hMenu)                    \
+            SendMessage(hWnd, WM_MENUSELECT, MAKELONG(wID, wFlags)  \
+                        , (LPARAM)hMenu)
+#endif  //SendMenuSelect
+
+#ifndef SendScrollPosition
+#define SendScrollPosition(hWnd, iMsg, iPos)                        \
+            SendMessage(hWnd, iMsg, MAKELONG(SB_THUMBPOSITION, iPos), 0)
+#endif //SendScrollPosition
+
+#ifndef ScrollThumbPosition
+#define ScrollThumbPosition(w, l) HIWORD(w)
+#endif //ScrollThumbPosition
+
+#ifndef GETWINDOWINSTANCE
+#define GETWINDOWINSTANCE(h) (HINSTANCE)GetWindowLong(h, GWL_HINSTANCE)
+#endif  //GETWINDOWINSTANCE
+
+#ifndef GETWINDOWID
+#define GETWINDOWID(h) (UINT)GetWindowLong(h, GWW_ID)
+#endif  //GETWINDOWID
+
+#ifndef POINTFROMLPARAM
+#define POINTFROMLPARAM(p, l) {p.x=(LONG)(SHORT)LOWORD(l); \
+                               p.y=(LONG)(SHORT)HIWORD(l);}
+#endif  //POINTEFROMLPARAM
+
+#ifndef EXPORT
+#define EXPORT
+#endif //EXPORT
+
+#ifndef MDIREFRESHMENU
+#define MDIREFRESHMENU(h) SendMessage(h, WM_MDIREFRESHMENU, 0, 0L)
+#endif  //MDIREFRESHMENU
+
+
+//****END WIN32
+
+
+
+#else
+
+
+
+//****START !WIN32
+
+#ifndef COMMANDPARAMS
+#define COMMANDPARAMS(wID, wCode, hWndMsg)                          \
+    WORD        wID     = LOWORD(wParam);                           \
+    WORD        wCode   = HIWORD(lParam);                           \
+    HWND        hWndMsg = (HWND)(UINT)lParam;
+#endif  //COMMANDPARAMS
+
+#ifndef SendCommand
+#define SendCommand(hWnd, wID, wCode, hControl)                     \
+            SendMessage(hWnd, WM_COMMAND, wID                       \
+                        , MAKELONG(hControl, wCode))
+#endif  //SendCommand
+
+#ifndef MENUSELECTPARAMS
+#define MENUSELECTPARAMS(wID, wFlags, hMenu)                        \
+    WORD        wID     = LOWORD(wParam);                           \
+    WORD        wFlags  = LOWORD(lParam);                           \
+    HMENU       hMenu   = (HMENU)HIWORD(lParam);
+#endif  //MENUSELECTPARAMS
+
+#ifndef SendMenuSelect
+#define SendMenuSelect(hWnd, wID, wFlags, hMenu)                    \
+            SendMessage(hWnd, WM_MENUSELECT, wID                    \
+                        , MAKELONG(wFlags, hMenu))
+#endif  //SendMenuSelect
+
+#ifndef SendScrollPosition
+#define SendScrollPosition(hWnd, iMsg, iPos)                        \
+            SendMessage(hWnd, iMsg, SB_THUMBPOSITION, MAKELONG(iPos, 0))
+#endif //Send ScrollPosition
+
+#ifndef ScrollThumbPosition
+#define ScrollThumbPosition(w, l) LOWORD(l)
+#endif //ScrollThumbPosition
+
+#ifndef GETWINDOWINSTANCE
+#define GETWINDOWINSTANCE(h) (HINSTANCE)GetWindowWord(h, GWW_HINSTANCE)
+#endif  //GETWINDOWINSTANCE
+
+#ifndef GETWINDOWID
+#define GETWINDOWID(h) (UINT)GetWindowWord(h, GWW_ID)
+#endif  //GETWINDOWID
+
+#ifndef POINTFROMLPARAM
+#define POINTFROMLPARAM(p, l) {p.x=LOWORD(l); p.y=HIWORD(l);}
+#endif  //POINTEFROMLPARAM
+
+#ifndef EXPORT
+#define EXPORT  __export
+#endif //EXPORT
+
+
+#ifndef MDIREFRESHMENU
+#define MDIREFRESHMENU(h) SendMessage(h, WM_MDISETMENU, TRUE, 0L)
+#endif  //MDIREFRESHMENU
+
+
+
+
+#endif  //!WIN32
+
+#endif  //_BOOK1632_H_
diff --git a/private/oleutest/letest/gizmobar/daytona/gizmobar.src b/private/oleutest/letest/gizmobar/daytona/gizmobar.src
new file mode 100644
index 000000000..b59771e9a
--- /dev/null
+++ b/private/oleutest/letest/gizmobar/daytona/gizmobar.src
@@ -0,0 +1,51 @@
+#if 0
+
+  Microsoft Windows
+  Copyright (C) Microsoft Corporation, 1992 - 1992.
+  All rights reserved.
+
+  This .def file is preprocessed by the compiler to create the version for
+  the current build in the appropriate subdir.  Basically, whatever you
+  would have used in your code to control what is compiled when can be
+  used in this file for the same purpose.  The following defines are in
+  use at the time this file was written:
+
+     FLAT       - Used to indicate a NT/DOS7 build
+     i386       -   Intel i386/i486 build
+     MIPS       -   MIPS R3000/R4000 build
+     ALPHA      -   DEC Alpha build
+     DBG        - Used to control Debug/Retail.  Set to 1 if Debug,
+		   0 if Retail.
+     WIN31      - Win16 build
+     __OS2__    - OS/2 build (used by CT mostly)
+
+  If none of these are used, it is assumed the entire file can be used
+  for all builds.
+
+#endif
+
+#ifdef FLAT
+
+LIBRARY gizmobar
+
+DESCRIPTION  'GIZMOBAR'
+
+EXPORTS
+    GizmoPAllocate
+    GizmosExpand
+    GizmoPFree
+    GizmosCompact
+    GizmoPFind
+    GizmoPEnum
+    GizmoPStateSet
+    GizmoPCheck
+    GBGizmoAdd
+    GBGizmoEnable
+    GBGizmoFocusSet
+    GBGizmoSendMessage
+    GBGizmoTextGet
+    GBGizmoTextSet
+    GBHwndAssociateSet
+
+
+#endif // FLAT
diff --git a/private/oleutest/letest/gizmobar/daytona/makefile b/private/oleutest/letest/gizmobar/daytona/makefile
new file mode 100644
index 000000000..6ee4f43fa
--- /dev/null
+++ b/private/oleutest/letest/gizmobar/daytona/makefile
@@ -0,0 +1,6 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT OS/2
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/oleutest/letest/gizmobar/daytona/makefile.inc b/private/oleutest/letest/gizmobar/daytona/makefile.inc
new file mode 100644
index 000000000..afd853b6b
--- /dev/null
+++ b/private/oleutest/letest/gizmobar/daytona/makefile.inc
@@ -0,0 +1 @@
+obj\*\gizmobar.def: gizmobar.src
diff --git a/private/oleutest/letest/gizmobar/daytona/sources b/private/oleutest/letest/gizmobar/daytona/sources
new file mode 100644
index 000000000..bbce019a8
--- /dev/null
+++ b/private/oleutest/letest/gizmobar/daytona/sources
@@ -0,0 +1,50 @@
+# This links against bttncur.lib so block all threads to assure that
+# bttncur is built.
+SYNCHRONIZE_BLOCK=1
+SYNCHRONIZE_DRAIN=1
+
+TARGETNAME=gizmobar
+
+TARGETPATH=obj
+
+TARGETTYPE=DYNLINK
+
+DLLDEF=       obj\*\gizmobar.def
+
+TARGETLIBS=$(GUI32_LIBS) \
+           $(WIN32_LIBS) \
+	   ..\..\bttncur\daytona\obj\*\bttncur.lib
+
+DLLBASE=@$(BASEDIR)\PUBLIC\SDK\LIB\coffbase.txt,usermode
+
+DLLENTRY=	DllEntryPoint
+
+UMTYPE=windows
+
+C_DEFINES=-DWIN32 -DFLAT
+
+INCLUDES=..\..\bttncur; \
+	 ..
+
+BLDCRT=1
+
+SOURCES= \
+	..\gizmobar.rc \
+	..\api.c \
+	..\init.c \
+	..\dllentry.c \
+        ..\paint.c \
+        ..\gizmo.c \
+	..\gizmobar.c
+
+!IF $(386)
+NTTARGETFILE0=$(DLLDEF:*=i386)
+!ENDIF
+
+!IF $(MIPS)
+NTTARGETFILE0=$(DLLDEF:*=mips)
+!ENDIF
+
+!IF $(ALPHA)
+NTTARGETFILE0=$(DLLDEF:*=alpha)
+!ENDIF
diff --git a/private/oleutest/letest/gizmobar/dirs b/private/oleutest/letest/gizmobar/dirs
new file mode 100644
index 000000000..c33a3de9b
--- /dev/null
+++ b/private/oleutest/letest/gizmobar/dirs
@@ -0,0 +1,37 @@
+!IF 0
+
+Copyright (c) 1989  Microsoft Corporation
+
+Module Name:
+
+    dirs.
+
+Abstract:
+
+    This file specifies the subdirectories of the current directory that
+    contain component makefiles.
+
+
+Author:
+
+    JohannP 01/11/95
+
+!ENDIF
+
+#
+# This is a list of all subdirectories that build required components.
+# Each subdirectory name should appear on a line by itself.  The build
+# follows the order in which the subdirectories are specified.
+#
+
+DIRS=
+
+#
+# This is a list of all subdirectories that build optional components.
+# Each subdirectory name should appear on a line by itself.  The build
+# follows the order in which the subdirectories are specified.
+#
+
+OPTIONAL_DIRS= \
+        \
+    daytona
diff --git a/private/oleutest/letest/gizmobar/dllentry.c b/private/oleutest/letest/gizmobar/dllentry.c
new file mode 100644
index 000000000..1cd1159e4
--- /dev/null
+++ b/private/oleutest/letest/gizmobar/dllentry.c
@@ -0,0 +1,55 @@
+//+-------------------------------------------------------------------
+//
+//  Microsoft Windows
+//  Copyright (C) Microsoft Corporation, 1991 - 1992.
+//
+//  File:       dllentry.c
+//
+//  Contents:   Dll Entry point code.  Calls the appropriate run-time
+//              init/term code and then defers to LibMain for further
+//              processing.
+//
+//  Classes:    <none>
+//
+//  Functions:  DllEntryPoint - Called by loader
+//
+//  History:    10-May-92  BryanT    Created
+//              22-Jul-92  BryanT    Switch to calling _cexit/_mtdeletelocks
+//                                    on cleanup.
+//              06-Oct-92  BryanT    Call RegisterWithCommnot on entry
+//                                    and DeRegisterWithCommnot on exit.
+//                                    This should fix the heap dump code.
+//              27-Dec-93  AlexT     Post 543 builds don't need special code.
+//
+//--------------------------------------------------------------------
+
+#define USE_CRTDLL
+#include <windows.h>
+
+BOOL WINAPI _CRT_INIT (HANDLE hDll, DWORD dwReason, LPVOID lpReserved);
+
+BOOL DllEntryPoint (HANDLE hDll, DWORD dwReason, LPVOID lpReserved);
+
+BOOL _CRTAPI1 LibMain (HANDLE hDll, DWORD dwReason, LPVOID lpReserved);
+
+BOOL DllEntryPoint (HANDLE hDll, DWORD dwReason, LPVOID lpReserved)
+{
+    BOOL fRc = FALSE;
+
+    switch (dwReason)
+    {
+        case DLL_PROCESS_ATTACH:
+            _CRT_INIT(hDll, dwReason, lpReserved);
+
+        case DLL_THREAD_ATTACH:
+        case DLL_THREAD_DETACH:
+            fRc = LibMain (hDll, dwReason, lpReserved);
+            break;
+
+        case DLL_PROCESS_DETACH:
+            fRc = LibMain (hDll, dwReason, lpReserved);
+            _CRT_INIT(hDll, dwReason, lpReserved);
+    }
+
+    return(fRc);
+}
diff --git a/private/oleutest/letest/gizmobar/gizmo.c b/private/oleutest/letest/gizmobar/gizmo.c
new file mode 100644
index 000000000..c763c3bba
--- /dev/null
+++ b/private/oleutest/letest/gizmobar/gizmo.c
@@ -0,0 +1,766 @@
+/*
+ * GIZMO.C
+ * GizmoBar Version 1.00, Win32 version August 1993
+ *
+ * Allocate, free, find, and enumerate functions for the GIZMO structure
+ * and a generic subclass procedure to handle tabbing between gizmos.
+ *
+ * Copyright (c)1993 Microsoft Corporation, All Rights Reserved
+ *
+ * Kraig Brockschmidt, Software Design Engineer
+ * Microsoft Systems Developer Relations
+ *
+ * Internet  :  kraigb@microsoft.com
+ * Compuserve:  >INTERNET:kraigb@microsoft.com
+ */
+
+
+#include <windows.h>
+#include "gizmoint.h"
+
+
+/*
+ * In order to control tabbing in the gizmos, we need to subclass
+ * real pushbuttons, edit controls, listboxes, and comboboxes.  So
+ * we keep an array of the four original procs for such controls.
+ */
+WNDPROC     pfnOrg[CSUBGIZMOS]={NULL, NULL, NULL, NULL};
+
+
+TCHAR szStatic[]=TEXT("static");
+TCHAR szEdit[]=TEXT("edit");
+TCHAR szCombobox[]=TEXT("combobox");
+TCHAR szListbox[]=TEXT("listbox");
+TCHAR szButton[]=TEXT("button");
+
+
+//Here so PAINT.C can get at it.
+TOOLDISPLAYDATA tdd;
+
+
+
+/*
+ * GizmoPAllocate
+ *
+ * Purpose:
+ *  Allocates and initializes a GIZMO data structure.
+ *
+ * Parameters:
+ *  pfSuccess       LPINT flag indicating success of failure.
+ *  ppFirst         LPLPGIZMO providing the first gizmo in this list.
+ *  hWndParent      HWND of the parent of this gizmo.  Can be NULL for
+ *                  iType==GIZMOTYPE_BUTTON* or GIZMOTYPE_SEPARATOR.
+ *  iType           UINT gizmo control type.
+ *  iGizmo          UINT index of this gizmo in the GizmoBar.
+ *  uID             UINT identifier to send with WM_COMMAND for this control.
+ *  dx, dy          UINT width and height of the gizmo.
+ *  pszText         LPTSTR to the text for edits, listboxes, combobox, and text.
+ *  dwStyle         DWORD style for edits, lists, and combos, and texts.
+ *  hBmp            HBITMAP for button gizmos, is applicable.
+ *  iImage          UINT index into hBmp for the button image, if applicable.
+ *  uState          UINT initial state of the control.
+ *
+ * Return Value:
+ *  LPGIZMO         If NULL returned then GizmoPAllocate could not allocate
+ *                  memory.  If a non-NULL pointer is returned with
+ *                  *pfSuccess, then call GizmoPFree immediately.  If you
+ *                  get a non-NULL pointer and *pfSuccess==TRUE then the
+ *                  function succeeded.
+ */
+
+LPGIZMO GizmoPAllocate(LPINT pfSuccess, LPLPGIZMO ppFirst, HWND hWndParent
+    , UINT iType, UINT iGizmo, UINT uID, UINT dx, UINT dy, LPTSTR pszText
+    , HBITMAP hBmp, UINT iImage, UINT uState)
+    {
+    LPGIZMO         pGizmo;
+    LPGIZMO         pCur, pPrev;
+    LPTSTR          pszClass;
+    HINSTANCE       hInst;
+    UINT            i;
+    DWORD           dwStyle;
+    HWND            hWndE;
+
+    if (NULL==pfSuccess)
+        return NULL;
+
+    //Make sure we know of this gizmo type.
+    if (GIZMOTYPE_MIN > iType || GIZMOTYPE_MAX < iType)
+        return NULL;
+
+    *pfSuccess=FALSE;
+
+    //Allocate the structure
+    pGizmo=(LPGIZMO)LocalAlloc(LPTR, CBGIZMO);
+
+    if (NULL==pGizmo)
+        return NULL;
+
+
+    //Store the necessary information for this gizmo.
+    pGizmo->iType   =iType;
+    pGizmo->uID     =uID;
+    pGizmo->hBmp    =hBmp;
+    pGizmo->iBmp    =iImage;
+    pGizmo->uState  =uState;
+    pGizmo->fNotify =TRUE;
+
+
+    /*
+     * Insert this structure into our gizmo list.  Each time we scan
+     * we increment the index counter (starting at zero) comparing it
+     * to the desired index of insertion.  We then know exactly where
+     * to insert this new gizmo.  Note that we insert the new gizmo in
+     * the list appropriately for the given owner, so enumerations will
+     * come out ordered in the same way for that owner.
+     */
+
+    i=0;
+    pCur=*ppFirst;
+    pPrev=NULL;
+
+    while (NULL!=pCur && i++ < iGizmo)
+        {
+        pPrev=pCur;
+        pCur =pCur->pNext;
+        }
+
+    //Point to our neighbors
+    pGizmo->pPrev=pPrev;
+    pGizmo->pNext=pCur;
+
+
+    //Point out neighbors to us.
+    if (NULL==pPrev)
+        *ppFirst=pGizmo;
+    else
+        pPrev->pNext=pGizmo;
+
+    if (NULL!=pCur)
+        pCur->pPrev=pGizmo;
+
+
+    //Our x-coordinate is the x of the previous gizmo plus its width.
+    if (NULL!=pPrev)
+        pGizmo->x=pGizmo->pPrev->x+pGizmo->pPrev->dx;
+    else
+        pGizmo->x=4;    //First gizmo is at x=4
+
+
+    //If we're a separator or image button, force standards on dx.
+    UIToolConfigureForDisplay(&tdd);
+    pGizmo->cxImage=tdd.cxImage;
+    pGizmo->cyImage=tdd.cyImage;
+
+    if ((GIZMOTYPE_DRAWN & iType) && NULL==hBmp)
+        dx=tdd.cxButton;
+
+    if (GIZMOTYPE_SEPARATOR==iType)
+        dx=6;
+
+    /*
+     * Now create windows for edits, texts, lists, and comboboxes.
+     * First calculate the most often defaults used in the switch.
+     */
+    pGizmo->dx=dx+6;
+    pGizmo->dy=min(dy, tdd.cyButton);
+    pGizmo->y=2;
+    pszClass=NULL;
+
+    //If this is new gizmo is a window, create it.
+    switch (iType)
+            {
+            case GIZMOTYPE_TEXT:
+                pGizmo->dx=dx;
+                pGizmo->y=(tdd.cyBar-1-pGizmo->dy) >> 1;  //Center vertically.
+                pszClass=szStatic;
+                dwStyle=SS_LEFT;
+                break;
+
+            case GIZMOTYPE_EDIT:
+                pGizmo->y=(tdd.cyBar-1-pGizmo->dy) >> 1;  //Center vertically.
+                pszClass=szEdit;
+                dwStyle=ES_LEFT | WS_BORDER | WS_TABSTOP;
+                break;
+
+            case GIZMOTYPE_LISTBOX:
+                pGizmo->dy=dy;
+                pszClass=szCombobox;
+                dwStyle=CBS_DROPDOWNLIST | WS_TABSTOP;
+                break;
+
+            case GIZMOTYPE_COMBOBOX:
+                pGizmo->dy=dy;
+                pszClass=szCombobox;
+                dwStyle=CBS_DROPDOWN | WS_TABSTOP;
+                break;
+
+            case GIZMOTYPE_BUTTONNORMAL:
+                pGizmo->dy=dy;
+                pszClass=szButton;
+                dwStyle=BS_PUSHBUTTON | WS_TABSTOP;
+                break;
+
+            case GIZMOTYPE_SEPARATOR:
+                pGizmo->dx=dx;
+                pGizmo->y=3;
+                break;
+
+            case GIZMOTYPE_BUTTONATTRIBUTEIN:
+            case GIZMOTYPE_BUTTONATTRIBUTEEX:
+            case GIZMOTYPE_BUTTONCOMMAND:
+                pGizmo->dx=dx;
+                pGizmo->y=3;
+                break;
+            }
+
+
+    //If we matched a classname, create a window.
+    if (GIZMOTYPE_WINDOWS & iType)
+        {
+        if (!IsWindow(hWndParent))
+            return pGizmo;
+
+	hInst=(HINSTANCE) GetWindowLong(hWndParent, GWL_HINSTANCE);
+
+        pGizmo->hWnd=CreateWindow(pszClass, pszText
+            , dwStyle | WS_CHILD | WS_VISIBLE, pGizmo->x, pGizmo->y
+            , dx, pGizmo->dy, hWndParent, (HMENU)uID, hInst, NULL);
+
+        if (NULL==pGizmo->hWnd)
+            return pGizmo;
+
+        /*
+         * Subclass comboboxes, listboxes, edits, and windowed buttons.
+         * We use iType to index the original proc array so we can use
+         * a single subclass procedure for all controls.  If you mess
+         * with the gizmo type definitions, this is going to break.
+         */
+
+        if (GIZMOTYPE_WINDOWS & iType && GIZMOTYPE_TEXT!=iType)
+            {
+            //Give the window its type.
+            BITPOSITION(iType, i);
+            SetProp(pGizmo->hWnd, SZTYPEPROP, (HANDLE)i);
+
+            if (NULL==pfnOrg[i])
+                pfnOrg[i]=(WNDPROC)GetWindowLong(pGizmo->hWnd, GWL_WNDPROC);
+
+            SetWindowLong(pGizmo->hWnd, GWL_WNDPROC, (LONG)GenericSubProc);
+
+            //If we're a combobox, get the edit control and subclass it.
+            if (GIZMOTYPE_COMBOBOX==iType)
+                {
+                hWndE=GetDlgItem(pGizmo->hWnd, ID_COMBOEDIT);
+                SetProp(hWndE, SZTYPEPROP, (HANDLE)-1);        //Special flag.
+
+                if (NULL==pfnOrg[0])
+                    pfnOrg[0]=(WNDPROC)GetWindowLong(pGizmo->hWnd, GWL_WNDPROC);
+
+                SetWindowLong(hWndE, GWL_WNDPROC, (LONG)GenericSubProc);
+                }
+            }
+        }
+
+
+    //Finally, move all our neighbors to the right over to accomodate us.
+    GizmosExpand(pGizmo);
+
+    *pfSuccess=TRUE;
+    return pGizmo;
+    }
+
+
+
+
+
+
+/*
+ * GizmoPFree
+ *
+ * Purpose:
+ *  Reverses all initialization done by GizmoPAllocate, cleaning up
+ *  any allocations including the application structure itself.
+ *
+ * Parameters:
+ *  ppFirst         LPLPGIZMO providing the first gizmo in this list.
+ *  pGizmo          LPGIZMO to the structure
+ *
+ * Return Value:
+ *  LPGIZMO         NULL if successful, pGizmo if not, meaning we couldn't
+ *                  free something.
+ */
+
+LPGIZMO GizmoPFree(LPLPGIZMO ppFirst, LPGIZMO pGizmo)
+    {
+    int     i;
+
+    if (NULL==pGizmo)
+        return NULL;
+
+    //Move other gizmos to fill in this gap.
+    GizmosCompact(pGizmo);
+
+    //Unsubclass
+    if (GIZMOTYPE_WINDOWS & pGizmo->iType && GIZMOTYPE_TEXT!=pGizmo->iType)
+        {
+        i=(int)GetProp(pGizmo->hWnd, SZTYPEPROP);
+        RemoveProp(pGizmo->hWnd, SZTYPEPROP);
+
+        SetWindowLong(pGizmo->hWnd, GWL_WNDPROC, (LONG)pfnOrg[i]);
+        }
+
+    //If this was a window gizmo, destroy the window.
+    if (NULL!=pGizmo->hWnd && IsWindow(pGizmo->hWnd))
+        DestroyWindow(pGizmo->hWnd);
+
+    //Unlink ourselves.
+    if (NULL!=pGizmo->pNext)
+        pGizmo->pNext->pPrev=pGizmo->pPrev;
+
+    if (NULL!=pGizmo->pPrev)
+        pGizmo->pPrev->pNext=pGizmo->pNext;
+    else
+        *ppFirst=pGizmo->pNext;
+
+    return (LPGIZMO)LocalFree((HLOCAL)(UINT)(LONG)pGizmo);
+    }
+
+
+
+
+
+
+/*
+ * GizmosExpand
+ *
+ * Purpose:
+ *  Given a starting gizmo and a width, moves it and all gizmos to its
+ *  right to the right by the width to make space for showing or creating
+ *  a new gizmo.
+ *
+ * Parameters:
+ *  pGizmo          LPGIZMO specifying the gizmo that was inserted.
+ *
+ * Return Value:
+ *  None
+ */
+
+void GizmosExpand(LPGIZMO pGizmo)
+    {
+    int         cx;
+
+    cx=(int)pGizmo->dx;
+
+    /*
+     * If we and the next control are buttons, use our width-1 to
+     * expand so we overlap borders with our neighboring button.
+     */
+
+    if (NULL!=pGizmo->pNext)
+        {
+        if ((GIZMOTYPE_BUTTONS & pGizmo->pNext->iType)
+            && (GIZMOTYPE_BUTTONS & pGizmo->iType))
+            cx-=1;
+        }
+
+    //Walk the gizmo list moving them right by our width.
+    pGizmo=pGizmo->pNext;
+
+    while (NULL!=pGizmo)
+        {
+        pGizmo->x+=cx;
+
+        //hWnd is NULL for buttons and separators.
+        if (NULL!=pGizmo->hWnd)
+            SetWindowPos(pGizmo->hWnd, NULL, pGizmo->x, pGizmo->y, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
+
+        pGizmo=pGizmo->pNext;
+        }
+
+    return;
+    }
+
+
+
+
+
+
+
+/*
+ * GizmosCompact
+ *
+ * Purpose:
+ *  Given a gizmo, moves all other gizmos to the right of it to the
+ *  left by its width on the GizmoBar.  Used when removing or hiding
+ *  the gizmo.
+ *
+ * Parameters:
+ *  pGizmo          LPGIZMO that is going away, visibly or physically.
+ *
+ * Return Value:
+ *  None
+ */
+
+void GizmosCompact(LPGIZMO pGizmo)
+    {
+    UINT        cx;
+    LPGIZMO     pCur;
+
+    //Move all the gizmos beyond us on the GizmoBar back by our width.
+    if (NULL!=pGizmo->pNext)
+        {
+        cx=pGizmo->pNext->x - pGizmo->x;
+        pCur=pGizmo->pNext;
+
+        while (NULL!=pCur)
+            {
+            pCur->x-=cx;
+
+            if (NULL!=pCur->hWnd)
+                {
+                SetWindowPos(pCur->hWnd, NULL, pCur->x, pCur->y
+                             , 0, 0, SWP_NOZORDER | SWP_NOSIZE);
+                }
+
+            pCur=pCur->pNext;
+            }
+        }
+
+    return;
+    }
+
+
+
+
+
+
+/*
+ * GizmoPFind
+ *
+ * Purpose:
+ *  Given a GIZMO identifier, locates and returns a pointer to the structure
+ *  for that position.
+ *
+ * Parameters:
+ *  ppFirst         LPLPGIZMO providing the first gizmo in this list.
+ *  uID             UINT identifier to find.
+ *
+ * Return Value:
+ *  LPGIZMO         A pointer to a GIZMO structure allocated through
+ *                  GizmoPAllocate, NULL if iGizmo is out of range.
+ */
+
+LPGIZMO GizmoPFind(LPLPGIZMO ppFirst, UINT uID)
+    {
+    LPGIZMO      pGizmo;
+
+    pGizmo=*ppFirst;
+
+    /*
+     * Yep, linear search, but a better search algorithm won't improve
+     * things appreciably.  The better thing to optimize is what the
+     * caller passes as ppFirst.
+     */
+    while (NULL!=pGizmo && uID!=pGizmo->uID)
+        pGizmo=pGizmo->pNext;
+
+    return pGizmo;
+    }
+
+
+
+
+
+
+/*
+ * GizmoFEnum
+ *
+ * Purpose:
+ *  Enumerates the list of GIZMO structures, passing each one to
+ *  an application-defined callback.
+ *
+ * Parameters:
+ *  ppFirst         LPLPGIZMO providing the first gizmo in this list.
+ *  pfnEnum         LPFNGIZMOENUM to call for each enumerated structure.
+ *  dw              DWORD extra data to pass to the enumeration function.
+ *
+ * Return Value:
+ *  LPGIZMO         NULL if the enumeration completed.  Otherwise a pointer
+ *                  to the gizmo that enumeration stopped on.
+ */
+
+LPGIZMO GizmoPEnum(LPLPGIZMO ppFirst, LPFNGIZMOENUM pfnEnum, DWORD dw)
+    {
+    LPGIZMO pGizmo;
+    UINT    i=0;
+
+    pGizmo=*ppFirst;
+
+    while (NULL!=pGizmo)
+        {
+        if (!(*pfnEnum)(pGizmo, i++, dw))
+            break;
+
+        pGizmo=pGizmo->pNext;
+        }
+
+    return pGizmo;
+    }
+
+
+
+
+/*
+ * GizmoPStateSet
+ *
+ * Purpose:
+ *  State maniuplation functions.  Set and Clear also invalidate
+ *  this gizmo's rectangle on the given window and forces a repaint.
+ *
+ * Parameters:
+ *  hWnd            HWND of the window to repaint.
+ *  pGizmo          LPGIZMO affected.
+ *  dwNew           DWORD new state flags.
+ *
+ * Return Value:
+ *  UINT            Previous state.
+ */
+
+UINT  GizmoPStateSet(HWND hWnd, LPGIZMO pGizmo, UINT uNew)
+    {
+    UINT        uRet;
+    RECT        rc;
+
+    if (GIZMOTYPE_SEPARATOR==pGizmo->iType)
+        return pGizmo->uState;
+
+    //Preserve the color conversion flags across this state change.
+    uRet=pGizmo->uState;
+    pGizmo->uState=(uNew & 0x00FF) | (uRet & 0xFF00);
+
+    //Adjust the rectangle by  one to avoid repainting  borders.
+    SetRect(&rc, pGizmo->x+1, pGizmo->y+1, pGizmo->x+pGizmo->dx-1, pGizmo->y+pGizmo->dy-1);
+    InvalidateRect(hWnd, &rc, FALSE);
+    UpdateWindow(hWnd);
+
+    return uRet;
+    }
+
+
+
+
+
+
+
+
+/*
+ * GizmoPCheck
+ *
+ * Purpose:
+ *  Handles checking a single button in a group of attribute buttons.
+ *  If the gizmo belongs to a group of mutually exclusive buttons then
+ *  the others surrounding it are unchecked appropriately.
+ *
+ * Parameters:
+ *  hWnd            HWND of the GizmoBar.
+ *  pGizmo          LPGIZMO of the gizmo affected.
+ *  fCheck          BOOL TRUE to check the button, FALSE to uncheck.
+ *
+ * Return Value:
+ *  BOOL            TRUE if the gizmo was previously checked, FALSE
+ *                  otherwise.
+ */
+
+BOOL GizmoPCheck(HWND hWnd, LPGIZMO pGizmo, BOOL fCheck)
+    {
+    BOOL        fPrevCheck;
+    LPGIZMO     pCur;
+
+
+    //Ignore command buttons.
+    if (GIZMOTYPE_BUTTONCOMMAND==pGizmo->iType)
+        return FALSE;
+
+    //Get the previous state
+    fPrevCheck=(BOOL)(BUTTONGROUP_DOWN & pGizmo->uState);
+
+
+    //Simply set the state for inclusive attribute buttons.
+    if (GIZMOTYPE_BUTTONATTRIBUTEIN==pGizmo->iType)
+        {
+        if (pGizmo->fDisabled)
+            {
+            GizmoPStateSet(hWnd, pGizmo
+                , fCheck ? ATTRIBUTEBUTTON_DOWNDISABLED : ATTRIBUTEBUTTON_DISABLED);
+            }
+        else
+            {
+            GizmoPStateSet(hWnd, pGizmo
+                , fCheck ? ATTRIBUTEBUTTON_DOWN : ATTRIBUTEBUTTON_UP);
+            }
+        }
+
+
+    if (GIZMOTYPE_BUTTONATTRIBUTEEX==pGizmo->iType)
+        {
+        //We cannot uncheck an exclusive attribute
+        if (!fCheck)
+            return fPrevCheck;
+
+        /*
+         * For exclusive buttons we have to do more work.  First, if we're
+         * already checked (incliding DOWN and MOUSEDOWN) then we set DOWN
+         * and exit.  If we're not already checked, then we look for the
+         * gizmo around us, backwards and forwards, that is checked and
+         * uncheck him.
+         */
+
+        //Search  backwards.
+        pCur=pGizmo->pPrev;
+
+        while (NULL!=pCur)
+            {
+            //Stop at any non-exclusive attribute.
+            if (GIZMOTYPE_BUTTONATTRIBUTEEX!=pCur->iType)
+                {
+                pCur=NULL;
+                break;
+                }
+
+            //If it's down, set it up and we've finished.
+            if (BUTTONGROUP_DOWN & pCur->uState)
+                break;
+
+            pCur=pCur->pPrev;
+            }
+
+
+        //If we didn't find a previous one, pCur is NULL, so look ahead.
+        if (NULL==pCur)
+            {
+            pCur=pGizmo->pNext;
+
+            while (NULL!=pCur)
+                {
+                //Stop at any non-exclusive attribute.
+                if (GIZMOTYPE_BUTTONATTRIBUTEEX!=pCur->iType)
+                    {
+                    pCur=NULL;
+                    break;
+                    }
+
+                //If it's down, set it up and we've finished.
+                if (BUTTONGROUP_DOWN & pCur->uState)
+                    break;
+
+                pCur=pCur->pNext;
+                }
+            }
+
+        //If pCur is non-NULL, the we found a neighbor, so uncheck him
+        if (NULL!=pCur)
+            {
+            GizmoPStateSet(hWnd, pCur
+                , (pGizmo->fDisabled) ? ATTRIBUTEBUTTON_DISABLED : ATTRIBUTEBUTTON_UP);
+            }
+
+        //Always set ourselves down
+        GizmoPStateSet(hWnd, pGizmo
+            , (pGizmo->fDisabled) ? ATTRIBUTEBUTTON_DOWNDISABLED : ATTRIBUTEBUTTON_DOWN);
+        }
+
+    return fPrevCheck;
+    }
+
+
+
+
+
+
+
+/*
+ * GenericSubProc
+ *
+ * Purpose:
+ *  Subclasses window controls in Gizmos so we can trap the tab key and
+ *  tab to the next control.  We can have one shared generic subclass
+ *  procedure because we save the type index for this control in the
+ *  property "iType."  This allows us to look up the original procedure
+ *  in the pfnOrg array.
+ *
+ * Parameters:
+ *  Standard
+ *
+ * Return Value:
+ *  Standard
+ */
+
+//LRESULT FAR PASCAL EXPORT GenericSubProc(HWND hWnd, UINT iMsg
+LRESULT FAR PASCAL GenericSubProc(HWND hWnd, UINT iMsg
+    , WPARAM wParam, LPARAM lParam)
+    {
+    LONG        lRet;
+    RECT        rc;
+    RECT        rcE;
+    HWND        hWndE;
+    HBRUSH      hBr;
+    HDC         hDC;
+    UINT        dx;
+    UINT        iType, i;
+
+    i=(int)GetProp(hWnd, SZTYPEPROP);
+    iType=POSITIONBIT(i);
+
+    //Special:  paint the gap in drop-down comboboxes.
+    if (GIZMOTYPE_COMBOBOX==iType && WM_PAINT==iMsg)
+        {
+        //Do default painting.
+        lRet=(*pfnOrg[i])(hWnd, iMsg, wParam, lParam);
+
+        hWndE=GetDlgItem(hWnd, ID_COMBOEDIT);
+
+        GetClientRect(hWnd, &rc);
+        GetClientRect(hWndE, &rcE);
+
+        //The width of the button is the scroll bar width.
+        dx=GetSystemMetrics(SM_CXVSCROLL);
+
+        //Calculate the rectangle
+        rc.right -=dx;
+        rc.left   =rcE.right;
+        rc.bottom+=1;
+
+        //Paint the gap
+        hDC=GetDC(hWnd);   //Already did BeginPaint and EndPaint
+
+        hBr=CreateSolidBrush(GetSysColor(COLOR_BTNFACE));
+        FillRect(hDC, &rc, hBr);
+        DeleteObject(hBr);
+
+        ReleaseDC(hWnd, hDC);
+        return lRet;
+        }
+
+    //Control tabbing to the next or previous control in the GizmoBar.
+    if (WM_KEYDOWN==iMsg && VK_TAB==wParam)
+        {
+        hWndE=hWnd;
+
+        if (-1==i)
+            hWndE=GetParent(hWnd);
+
+        hWndE=GetNextDlgTabItem(GetParent(hWndE), hWnd, (BOOL)(GetKeyState(VK_SHIFT)));
+        SetFocus(hWndE);
+        return 0L;
+        }
+
+    if (-1==i) i=0;
+
+    //Eat tab chars in edit controls to prevent beeping.
+    if (0==i && WM_CHAR==iMsg && VK_TAB==wParam)
+        return 0L;
+
+
+    //Do this or edit controls bomb big-time.
+    return CallWindowProc(pfnOrg[i], hWnd, iMsg, wParam, lParam);
+    }
diff --git a/private/oleutest/letest/gizmobar/gizmo.h b/private/oleutest/letest/gizmobar/gizmo.h
new file mode 100644
index 000000000..e99e06379
--- /dev/null
+++ b/private/oleutest/letest/gizmobar/gizmo.h
@@ -0,0 +1,103 @@
+/*
+ * GIZMO.H
+ * GizmoBar Version 1.00, Win32 version August 1993
+ *
+ * Data structure and type definitions for the GIZMO data structure.  Each
+ * gizmo on a gizmobar has one of these structures associated with it.
+ *
+ * Copyright (c)1993 Microsoft Corporation, All Rights Reserved
+ *
+ * Kraig Brockschmidt, Software Design Engineer
+ * Microsoft Systems Developer Relations
+ *
+ * Internet  :  kraigb@microsoft.com
+ * Compuserve:  >INTERNET:kraigb@microsoft.com
+ */
+
+
+#ifndef _GIZMO_H_
+#define _GIZMO_H_
+
+#ifdef __cplusplus
+extern "C"
+    {
+#endif
+
+
+typedef struct tagGIZMO
+    {
+    struct tagGIZMO FAR *pPrev;
+    struct tagGIZMO FAR *pNext;
+    UINT                 iType;
+    HWND                 hWnd;       //Texts, edits, lists, and combos only.
+    UINT                 uID;
+    UINT                 x, y;
+    UINT                 dx, dy;
+    UINT                 cxImage;    //From UIToolConfigureForDisplay
+    UINT                 cyImage;
+    HBITMAP              hBmp;       //Buttons only.
+    UINT                 iBmp;
+    BOOL                 fNotify;    //Indicates whether we send WM_COMMANDs
+    BOOL                 fHidden;    //Independent of state
+    BOOL                 fDisabled;
+    UINT                 uState;
+    UINT                 uStateOrg;
+    DWORD                dwData;     //Application-supplied data.
+    } GIZMO, FAR * LPGIZMO;
+
+typedef LPGIZMO FAR *LPLPGIZMO;
+#define CBGIZMO sizeof(GIZMO)
+
+//Property name we attach to controls in a gizmo to identify control type
+#define SZTYPEPROP      TEXT("iType")
+
+//Number of controls we subclass
+#define CSUBGIZMOS       4
+
+//ID of edit controls in comboboxes
+#define ID_COMBOEDIT     1001
+
+
+/*
+ * Conversion of iType (a positioned bit) into its position.
+ * The BITPOSITION macro does not need to be fast because we only
+ * use it once when creating a gizmo.  POSITIONBIT does, however, since
+ * we use it in subclass procedures.
+ */
+#define BITPOSITION(i, j)  {int k=i; for (j=0; k>>=1; j++);}
+#define POSITIONBIT(i)     (1 << i)
+
+//Control classifications.  GIZMOBAR.H must be included first.
+#define GIZMOTYPE_WINDOWS           (GIZMOTYPE_TEXT | GIZMOTYPE_EDIT | GIZMOTYPE_LISTBOX | GIZMOTYPE_COMBOBOX | GIZMOTYPE_BUTTONNORMAL)
+#define GIZMOTYPE_BUTTONS           (GIZMOTYPE_BUTTONATTRIBUTEIN | GIZMOTYPE_BUTTONATTRIBUTEEX | GIZMOTYPE_BUTTONCOMMAND | GIZMOTYPE_BUTTONNORMAL)
+#define GIZMOTYPE_DRAWN             (GIZMOTYPE_BUTTONATTRIBUTEIN | GIZMOTYPE_BUTTONATTRIBUTEEX | GIZMOTYPE_BUTTONCOMMAND)
+
+
+//These must stay in sync with GIZMOBAR.H
+#define GIZMOTYPE_MIN               GIZMOTYPE_EDIT
+#define GIZMOTYPE_MAX               GIZMOTYPE_BUTTONCOMMAND
+
+
+//Enumeration callback
+typedef BOOL (FAR PASCAL *LPFNGIZMOENUM)(LPGIZMO, UINT, DWORD);
+
+
+//GIZMO.C
+LPGIZMO  GizmoPAllocate(LPINT, LPLPGIZMO, HWND, UINT, UINT, UINT, UINT, UINT, LPTSTR, HBITMAP, UINT, UINT);
+void     GizmosExpand(LPGIZMO);
+LPGIZMO  GizmoPFree(LPLPGIZMO, LPGIZMO);
+void     GizmosCompact(LPGIZMO);
+LPGIZMO  GizmoPFind(LPLPGIZMO, UINT);
+LPGIZMO  GizmoPEnum(LPLPGIZMO, LPFNGIZMOENUM, DWORD);
+UINT     GizmoPStateSet(HWND, LPGIZMO, UINT);
+BOOL     GizmoPCheck(HWND, LPGIZMO, BOOL);
+
+//LRESULT FAR PASCAL EXPORT GenericSubProc(HWND, UINT, WPARAM, LPARAM);
+LRESULT FAR PASCAL GenericSubProc(HWND, UINT, WPARAM, LPARAM);
+
+
+#ifdef __cplusplus
+    }
+#endif
+
+#endif //_GIZMO_H_
diff --git a/private/oleutest/letest/gizmobar/gizmobar.c b/private/oleutest/letest/gizmobar/gizmobar.c
new file mode 100644
index 000000000..78b4fafd0
--- /dev/null
+++ b/private/oleutest/letest/gizmobar/gizmobar.c
@@ -0,0 +1,467 @@
+/*
+ * GIZMOBAR.C
+ * GizmoBar Version 1.00, Win32 version August 1993
+ *
+ * Contains the main window procedure of the GizmoBar control
+ * that handles mouse logic and Windows messages.
+ *
+ * Copyright (c)1993 Microsoft Corporation, All Rights Reserved
+ *
+ * Kraig Brockschmidt, Software Design Engineer
+ * Microsoft Systems Developer Relations
+ *
+ * Internet  :  kraigb@microsoft.com
+ * Compuserve:  >INTERNET:kraigb@microsoft.com
+ */
+
+
+#include <windows.h>
+#include "gizmoint.h"
+
+
+
+/*
+ * GizmoBarWndProc
+ *
+ * Purpose:
+ *  Window Procedure for the GizmoBar custom control.  Handles all
+ *  messages like WM_PAINT just as a normal application window would.
+ *  Any message not processed here should go to DefWindowProc.
+ *
+ * Parameters:
+ *  Standard
+ *
+ * Return Value:
+ *  Standard
+ */
+
+LRESULT FAR PASCAL GizmoBarWndProc(HWND hWnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
+    {
+    BOOL            fSuccess;
+    BOOL            fTemp;
+    LPCREATESTRUCT  pCreate;
+    LPGIZMOBAR      pGB;
+    LPGIZMO         pGizmo;
+    RECT            rc;
+    POINT           pt;
+    short           x, y;
+    COLORREF        cr;
+
+    COMMANDPARAMS(wID, wCode, hWndMsg);
+
+    pGB=(LPGIZMOBAR)GetWindowLong(hWnd, GBWL_STRUCTURE);
+
+    //Pass control messages onto another function for processing.
+    if (iMsg >= WM_USER)
+        return GBMessageHandler(hWnd, iMsg, wParam, lParam, pGB);
+
+    switch (iMsg)
+        {
+        case WM_NCCREATE:
+            pCreate=(LPCREATESTRUCT)lParam;
+
+            pGB=GizmoBarPAllocate((LPINT)&fSuccess, hWnd, pCreate->hInstance
+                , pCreate->hwndParent, pCreate->style, 0
+                , (UINT)pCreate->hMenu);
+
+            if (!fSuccess)
+                {
+                GizmoBarPFree(pGB);
+                return -1L;
+                }
+            else
+                SetWindowLong(hWnd, GBWL_STRUCTURE, (LONG)pGB);
+
+            return DefWindowProc(hWnd, iMsg, wParam, lParam);
+
+
+        case WM_DESTROY:
+            /*
+             * We want to clean up before DestroyWindow nukes all the
+             * children, so WM_DESTROY is a better to do it than
+             * WM_NCDESTROY.
+             */
+            GizmoBarPFree(pGB);
+            break;
+
+
+        case WM_ERASEBKGND:
+            /*
+             * Eat this message to avoid erasing portions that
+             * we are going to repaint in WM_PAINT.  Part of a
+             * change-state-and-repaint strategy is to rely on
+             * WM_PAINT to do anything visual, which includes
+             * erasing invalid portions.  Letting WM_ERASEBKGND
+             * erase the background is redundant.
+             */
+            return TRUE;
+
+       #ifdef WIN32
+        case WM_CTLCOLORBTN:
+        case WM_CTLCOLORSTATIC:
+            fTemp=TRUE;
+       #else
+        case WM_CTLCOLOR:
+            //Change the color of static text on the GizmoBar.
+            fTemp=(HIWORD(lParam)==CTLCOLOR_STATIC
+                || HIWORD(lParam)==CTLCOLOR_BTN);
+       #endif
+
+            if (fTemp)
+                {
+                cr=GetSysColor(COLOR_BTNFACE);
+                SetTextColor((HDC)wParam, GetSysColor(COLOR_BTNTEXT));
+                SetBkColor((HDC)wParam, cr);
+
+                /*
+                 * If the system colors have changed, then crFace will
+                 * not be equal to COLOR_BTNFACE, so we reinitialize the
+                 * background brush.  This scheme handles system color
+                 * changes appropriately without processing WM_WININICHANGE
+                 * and without blindly creating a new brush on every
+                 * WM_CTLCOLOR message.
+                 */
+                if (cr!=pGB->crFace)
+                    {
+                    pGB->crFace=cr;
+
+                    if (NULL!=pGB->hBrFace)
+                        DeleteObject(pGB->hBrFace);
+
+                    pGB->hBrFace=CreateSolidBrush(pGB->crFace);
+                    }
+
+                return (LONG)(UINT)pGB->hBrFace;
+                }
+
+            return DefWindowProc(hWnd, iMsg, wParam, lParam);
+
+
+        case WM_PAINT:
+            GizmoBarPaint(hWnd, pGB);
+            break;
+
+
+        case WM_SETFONT:
+            /*
+             * wParam has the new font that we now send to all other
+             * windows controls in us.  We control repaints here to
+             * prevent a lot of repainting for each control.
+             */
+            DefWindowProc(hWnd, WM_SETREDRAW, FALSE, 0L);
+
+            if ((WPARAM)NULL!=wParam)
+                {
+                pGB->hFont=(HFONT)wParam;
+                GizmoPEnum(&pGB->pGizmos, FEnumChangeFont, (DWORD)(LPSTR)pGB);
+
+                DefWindowProc(hWnd, WM_SETREDRAW, TRUE, 0L);
+                InvalidateRect(hWnd, NULL, FALSE);
+                UpdateWindow(hWnd);
+                }
+
+            break;
+
+
+        case WM_GETFONT:
+            return (LRESULT)(UINT)pGB->hFont;
+
+
+        case WM_ENABLE:
+            /*
+             * wParam has the new enable flag that we use to enable
+             * or disable ALL controls in us at one time.  We also turn
+             * the redraw off to prevent a lot of flicker.
+             */
+            DefWindowProc(hWnd, WM_SETREDRAW, FALSE, 0L);
+
+            pGB->fEnabled=(BOOL)wParam;
+            GizmoPEnum(&pGB->pGizmos, FEnumEnable, (DWORD)(LPSTR)pGB);
+
+            DefWindowProc(hWnd, WM_SETREDRAW, TRUE, 0L);
+            InvalidateRect(hWnd, NULL, FALSE);
+            UpdateWindow(hWnd);
+            break;
+
+
+        case WM_CANCELMODE:
+            pGizmo=pGB->pGizmoTrack;
+
+            pGB->fTracking=FALSE;
+            pGB->fMouseOut=FALSE;
+
+            if (NULL!=pGizmo)
+                GizmoPStateSet(hWnd, pGizmo, COMMANDBUTTON_UP);
+
+            ReleaseCapture();
+            break;
+
+
+        case WM_LBUTTONDBLCLK:
+        case WM_LBUTTONDOWN:
+            //Get the mouse coordinates.
+            x=LOWORD(lParam);
+            y=HIWORD(lParam);
+
+
+            /*
+             * See if we hit a command or attribute gizmo or not.  Anything
+             * else that is a control will get the message instead of
+             * us anyway, so we don't have to check.  FEnumHitTest also
+             * validates drawn gizmos, enabled, and visible, so we don't.
+             */
+            pGizmo=GizmoPEnum(&pGB->pGizmos, FEnumHitTest, lParam);
+
+            if (NULL==pGizmo)
+                break;          //Didn't hit one matching our needs.
+
+            /*
+             * Inform the associate that a command was hit like a menu item.
+             */
+            if (NULL!=pGB->hWndAssociate)
+                {
+                if (pGizmo->fNotify)
+                    SendMenuSelect(pGB->hWndAssociate, pGizmo->uID, 0, 0);
+                }
+
+            /*
+             * We hit a button.  If it's a command or attribute, then change
+             * the state and start tracking.
+             */
+            pGB->fTracking=TRUE;
+            pGB->pGizmoTrack=pGizmo;
+            pGB->fMouseOut=FALSE;
+            SetCapture(hWnd);
+
+            pGizmo->uStateOrg=pGizmo->uState;
+            GizmoPStateSet(hWnd, pGizmo, ATTRIBUTEBUTTON_MOUSEDOWN);
+
+            break;
+
+
+        case WM_MOUSEMOVE:
+            POINTFROMLPARAM(pt, lParam);
+
+            if (!pGB->fTracking)
+                break;
+
+            pGizmo=pGB->pGizmoTrack;
+            SetRect(&rc, pGizmo->x, pGizmo->y, pGizmo->x+pGizmo->dx, pGizmo->y+pGizmo->dy);
+
+            fTemp=pGB->fMouseOut;
+            pGB->fMouseOut=!PtInRect(&rc, pt);
+
+            //If the mouse went out, change state to the original.
+            if (!fTemp && pGB->fMouseOut)
+                {
+                GizmoPStateSet(hWnd, pGizmo, pGizmo->uStateOrg);
+
+                if (NULL!=pGB->hWndAssociate)
+                    {
+                    //Notify that we left the button
+                    if (pGizmo->fNotify)
+                        SendMenuSelect(pGB->hWndAssociate, 0x0000, 0xFFFF, 0);
+                    }
+                }
+
+            if (fTemp && !pGB->fMouseOut)
+                {
+                GizmoPStateSet(hWnd, pGizmo, ATTRIBUTEBUTTON_MOUSEDOWN);
+
+                if (NULL!=pGB->hWndAssociate)
+                    {
+                    //Notify that we pressed down again
+                    if (pGizmo->fNotify)
+                        SendMenuSelect(pGB->hWndAssociate, pGizmo->uID, 0x0000, 0);
+                    }
+                }
+
+            break;
+
+
+        case WM_LBUTTONUP:
+            if (!pGB->fTracking)
+                break;
+
+            pGB->fTracking=FALSE;
+            pGizmo=pGB->pGizmoTrack;
+            ReleaseCapture();
+
+
+            /*
+             * Repaint if we were actually below the mouse when this
+             * occurred.  For command buttons, pop the button up.  For
+             * attributes, either toggle the state (inclusive buttons)
+             * or check the selected one (exclusive buttons).
+             */
+
+            if (!pGB->fMouseOut)
+                {
+                //Command buttons always come up.
+                if (GIZMOTYPE_BUTTONCOMMAND==pGizmo->iType)
+                    GizmoPStateSet(hWnd, pGizmo, COMMANDBUTTON_UP);
+
+                //Attribute inclusive buttons toggle
+                if (GIZMOTYPE_BUTTONATTRIBUTEIN==pGizmo->iType)
+                    GizmoPCheck(hWnd, pGizmo, !(BUTTONGROUP_DOWN & pGizmo->uStateOrg));
+
+                //Attribure exclusive buttons are always checked.
+                if (GIZMOTYPE_BUTTONATTRIBUTEEX==pGizmo->iType)
+                    GizmoPCheck(hWnd, pGizmo, TRUE);
+
+                //Only send messages if notify is ON.
+                if (NULL!=pGB->hWndAssociate && pGizmo->fNotify)
+                    {
+                    SendMenuSelect(pGB->hWndAssociate, 0, 0xFFFF, 0);
+                    SendCommand(pGB->hWndAssociate, pGizmo->uID, BN_CLICKED, hWnd);
+                    }
+                }
+
+            break;
+
+
+        case WM_COMMAND:
+            //Pass control messages on if the gizmo's notify is ON.
+            if (NULL!=pGB->hWndAssociate)
+                {
+                pGizmo=PGizmoFromHwndID(hWnd, wID);
+
+                if (NULL!=pGizmo)
+                    {
+                    if (pGizmo->fNotify)
+                        SendMessage(pGB->hWndAssociate, iMsg, wParam, lParam);
+                    }
+                }
+            break;
+
+        default:
+            return DefWindowProc(hWnd, iMsg, wParam, lParam);
+        }
+
+    return 0L;
+    }
+
+
+
+
+
+/*
+ * FEnumChangeFont
+ *
+ * Purpose:
+ *  Enumeration callback for all the gizmos we know about in order to
+ *  send a new font to them that's stored in LPGIZMOBAR in dw.
+ *
+ * Parameters:
+ *  pGizmo          LPGIZMO to draw.
+ *  iGizmo          UINT index on the GizmoBar of this gizmo.
+ *  dw              DWORD extra data passed to GizmoPEnum, in our case
+ *                  the GizmoBar's pGB.
+ *
+ * Return Value:
+ *  BOOL            TRUE to continue the enumeration, FALSE otherwise.
+ */
+
+BOOL FAR PASCAL FEnumChangeFont(LPGIZMO pGizmo, UINT iGizmo, DWORD dw)
+    {
+    LPGIZMOBAR  pGB=(LPGIZMOBAR)dw;
+
+    //We only need to change fonts in windowed controls using WM_SETFONT
+    if (NULL!=pGizmo->hWnd)
+        SendMessage(pGizmo->hWnd, WM_SETFONT, (WPARAM)pGB->hFont, 1L);
+
+    return TRUE;
+    }
+
+
+
+
+
+
+/*
+ * FEnumEnable
+ *
+ * Purpose:
+ *  Enumeration callback for all the gizmos we know about in order to
+ *  enable or disable them from the WM_ENABLE message.
+ *
+ * Parameters:
+ *  pGizmo          LPGIZMO to draw.
+ *  iGizmo          UINT index on the GizmoBar of this gizmo.
+ *  dw              DWORD extra data passed to GizmoPEnum, in our case
+ *                  the GizmoBar's pGB.
+ *
+ * Return Value:
+ *  BOOL            TRUE to continue the enumeration, FALSE otherwise.
+ */
+
+BOOL FAR PASCAL FEnumEnable(LPGIZMO pGizmo, UINT iGizmo, DWORD dw)
+    {
+    LPGIZMOBAR  pGB=(LPGIZMOBAR)dw;
+    BOOL        fEnable=pGB->fEnabled;
+
+    //NOTE:  This code is duplicated in GBGizmoEnable in API.C
+    if (NULL!=pGizmo->hWnd)
+        EnableWindow(pGizmo->hWnd, fEnable);
+    else
+        {
+        //If we're not down, command and attribute buttons act the same.
+        if (!(BUTTONGROUP_DOWN & pGizmo->uState))
+            {
+            GizmoPStateSet(pGB->hWnd, pGizmo
+                , fEnable ? COMMANDBUTTON_UP : COMMANDBUTTON_DISABLED);
+            }
+        else
+            {
+            //Attribute buttons are a little more sensitive with DOWNDISABLED
+            GizmoPStateSet(pGB->hWnd, pGizmo
+                , fEnable ? ATTRIBUTEBUTTON_DOWN : ATTRIBUTEBUTTON_DOWNDISABLED);
+            }
+        }
+
+    return TRUE;
+    }
+
+
+
+
+
+
+
+/*
+ * FEnumHitTest
+ *
+ * Purpose:
+ *  Enumeration callback for all the gizmos we know about in order to
+ *  hit-test them.
+ *
+ * Parameters:
+ *  pGizmo          LPGIZMO to draw.
+ *  iGizmo          UINT index on the GizmoBar of this gizmo.
+ *  dw              DWORD extra data passed to GizmoPEnum, in our case
+ *                  the hDC on which to draw.
+ *
+ * Return Value:
+ *  BOOL            TRUE to continue the enumeration, FALSE otherwise.
+ */
+
+BOOL FAR PASCAL FEnumHitTest(LPGIZMO pGizmo, UINT iGizmo, DWORD dw)
+    {
+    RECT  rc;
+    POINT pt;
+
+    POINTFROMLPARAM(pt, dw);
+	
+    //Hit tests have to happen on visible, enabled, and drawn controls only.
+    if (GIZMOTYPE_DRAWN & pGizmo->iType
+        && !pGizmo->fHidden && !(BUTTONGROUP_DISABLED & pGizmo->uState))
+        {
+        SetRect(&rc, pGizmo->x, pGizmo->y
+            , pGizmo->x+pGizmo->dx, pGizmo->y+pGizmo->dy);
+
+        //Stop enumeration if we have a hit.
+        return !PtInRect(&rc, pt);
+        }
+
+    return TRUE;
+    }
diff --git a/private/oleutest/letest/gizmobar/gizmobar.h b/private/oleutest/letest/gizmobar/gizmobar.h
new file mode 100644
index 000000000..f4888f925
--- /dev/null
+++ b/private/oleutest/letest/gizmobar/gizmobar.h
@@ -0,0 +1,178 @@
+/*
+ * GIZMOBAR.H
+ * GizmoBar Version 1.00, Win32 version August 1993
+ *
+ * Public definitions for application that use the GizmoBar such as
+ * messages, prototypes for API functions, notification codes, and
+ * control styles.
+ *
+ * Copyright (c)1993 Microsoft Corporation, All Rights Reserved
+ *
+ * Kraig Brockschmidt, Software Design Engineer
+ * Microsoft Systems Developer Relations
+ *
+ * Internet  :  kraigb@microsoft.com
+ * Compuserve:  >INTERNET:kraigb@microsoft.com
+ */
+
+
+#ifndef _GIZMOBAR_H_
+#define _GIZMOBAR_H_
+
+#ifdef __cplusplus
+extern "C"
+    {
+#endif
+
+
+//Classname
+#define CLASS_GIZMOBAR  TEXT("gizmobar")
+
+
+//Message API Functions
+HWND    WINAPI GBHwndAssociateSet(HWND, HWND);
+HWND    WINAPI GBHwndAssociateGet(HWND);
+
+BOOL    WINAPI GBGizmoAdd(HWND, UINT, UINT, UINT, UINT, UINT, LPTSTR, HBITMAP, UINT, UINT);
+BOOL    WINAPI GBGizmoRemove(HWND, UINT);
+
+LRESULT WINAPI GBGizmoSendMessage(HWND, UINT, UINT, WPARAM, LPARAM);
+
+BOOL    WINAPI GBGizmoShow(HWND, UINT, BOOL);
+BOOL    WINAPI GBGizmoEnable(HWND, UINT, BOOL);
+BOOL    WINAPI GBGizmoCheck(HWND, UINT, BOOL);
+UINT    WINAPI GBGizmoFocusSet(HWND, UINT);
+BOOL    WINAPI GBGizmoExist(HWND, UINT);
+
+int     WINAPI GBGizmoTypeGet(HWND, UINT);
+
+DWORD   WINAPI GBGizmoDataSet(HWND, UINT, DWORD);
+DWORD   WINAPI GBGizmoDataGet(HWND, UINT);
+BOOL    WINAPI GBGizmoNotifySet(HWND, UINT, BOOL);
+BOOL    WINAPI GBGizmoNotifyGet(HWND, UINT);
+
+int     WINAPI GBGizmoTextGet(HWND, UINT, LPTSTR, UINT);
+void    WINAPI GBGizmoTextSet(HWND, UINT, LPTSTR);
+UINT    WINAPI GBGizmoIntGet(HWND, UINT, BOOL FAR *, BOOL);
+void    WINAPI GBGizmoIntSet(HWND, UINT, UINT, BOOL);
+
+
+
+//Notification codes sent via WM_COMMAND from GBHwndAssociateSet
+#define GBN_ASSOCIATEGAIN               1
+#define GBN_ASSOCIATELOSS               2
+#define GBN_GIZMOADDED                  3
+#define GBN_GIZMOREMOVED                4
+
+//Message equivalents for functions.
+#define GBM_HWNDASSOCIATESET            (WM_USER+0)
+#define GBM_HWNDASSOCIATEGET            (WM_USER+1)
+#define GBM_GIZMOADD                    (WM_USER+2)
+#define GBM_GIZMOREMOVE                 (WM_USER+3)
+#define GBM_GIZMOSENDMESSAGE            (WM_USER+4)
+#define GBM_GIZMOSHOW                   (WM_USER+5)
+#define GBM_GIZMOENABLE                 (WM_USER+6)
+#define GBM_GIZMOCHECK                  (WM_USER+7)
+#define GBM_GIZMOFOCUSSET               (WM_USER+8)
+#define GBM_GIZMOEXIST                  (WM_USER+9)
+#define GBM_GIZMOTYPEGET                (WM_USER+10)
+#define GBM_GIZMODATASET                (WM_USER+11)
+#define GBM_GIZMODATAGET                (WM_USER+12)
+#define GBM_GIZMONOTIFYSET              (WM_USER+13)
+#define GBM_GIZMONOTIFYGET              (WM_USER+14)
+#define GBM_GIZMOTEXTGET                (WM_USER+15)
+#define GBM_GIZMOTEXTSET                (WM_USER+16)
+#define GBM_GIZMOINTGET                 (WM_USER+17)
+#define GBM_GIZMOINTSET                 (WM_USER+18)
+
+
+
+
+/*
+ * Structure passed in lParam of GBM_GIZMOADD that mirrors the parameters
+ * to GBGizmoAdd.
+ */
+
+typedef struct
+    {
+    HWND        hWndParent;         //Parent window
+    UINT        iType;              //Type of gizmo
+    UINT        iGizmo;             //Position in which to create gizmo
+    UINT        uID;                //Identifier of gizmo (for WM_COMMAND messages)
+    UINT        dx;                 //Dimensions of gizmo
+    UINT        dy;
+    LPTSTR       pszText;            //Gizmo text
+    HBITMAP     hBmp;               //Source of gizmo button image.
+    UINT        iImage;             //Index of image from hBmp
+    UINT        uState;             //Initial state of the gizmo.
+    } CREATEGIZMO, FAR *LPCREATEGIZMO;
+
+#define CBCREATEGIZMO sizeof(CREATEGIZMO)
+
+
+//For GBM_GIZMOSENDMESSAGE
+typedef struct
+    {
+    UINT        iMsg;
+    WPARAM      wParam;
+    LPARAM      lParam;
+    } GBMSG, FAR * LPGBMSG;
+
+#define CBGBMSG sizeof(GBMSG);
+
+//For GBM_GIZMOGETTEXT
+typedef struct
+    {
+    LPTSTR       psz;
+    UINT        cch;
+    } GBGETTEXT, FAR * LPGBGETTEXT;
+
+#define CBGBGETTEXT sizeof(GBGETTEXT);
+
+
+//For GBM_GIZMOGETINT
+typedef struct
+    {
+    BOOL        fSigned;
+    BOOL        fSuccess;
+    } GBGETINT, FAR * LPGBGETINT;
+
+#define CBGBGETINT sizeof(GBGETINT);
+
+
+//For GBM_GIZMOSETINT
+typedef struct
+    {
+    UINT        uValue;
+    BOOL        fSigned;
+    } GBSETINT, FAR * LPGBSETINT;
+
+#define CBGBSETINT sizeof(GBSETINT);
+
+
+
+//Gizmo control types.  DO NOT CHANGE THESE!
+#define GIZMOTYPE_EDIT                  0x0001
+#define GIZMOTYPE_LISTBOX               0x0002
+#define GIZMOTYPE_COMBOBOX              0x0004
+#define GIZMOTYPE_BUTTONNORMAL          0x0008      //Top of windowed gizmos.
+#define GIZMOTYPE_TEXT                  0x0010
+#define GIZMOTYPE_SEPARATOR             0x0020
+#define GIZMOTYPE_BUTTONATTRIBUTEIN     0x0040
+#define GIZMOTYPE_BUTTONATTRIBUTEEX     0x0080
+#define GIZMOTYPE_BUTTONCOMMAND         0x0100
+
+
+//Generic state flags for non-buttons based on BTTNCUR.H's button groups.
+#define GIZMO_NORMAL                    (BUTTONGROUP_ACTIVE)
+#define GIZMO_DISABLED                  (BUTTONGROUP_DISABLED)
+
+
+
+#ifdef __cplusplus
+    }   //Match with extern "C" above.
+#endif
+
+
+
+#endif //_GIZMOBAR_H_
diff --git a/private/oleutest/letest/gizmobar/gizmobar.rc b/private/oleutest/letest/gizmobar/gizmobar.rc
new file mode 100644
index 000000000..e1550028e
--- /dev/null
+++ b/private/oleutest/letest/gizmobar/gizmobar.rc
@@ -0,0 +1,20 @@
+/*
+ * GIZMOBAR.RC
+ * GizmoBar Version 1.00, Win32 version August 1993
+ *
+ * Strings and other resources for the GizmoBar.
+ *
+ * Copyright (c)1993 Microsoft Corporation, All Rights Reserved
+ *
+ * Kraig Brockschmidt, Software Design Engineer
+ * Microsoft Systems Developer Relations
+ *
+ * Internet  :  kraigb@microsoft.com
+ * Compuserve:  >INTERNET:kraigb@microsoft.com
+ */
+
+
+#include <windows.h>
+#include "gizmoint.h"
+
+rcinclude gizmobar.rcv
diff --git a/private/oleutest/letest/gizmobar/gizmobar.rcv b/private/oleutest/letest/gizmobar/gizmobar.rcv
new file mode 100644
index 000000000..8958b7a2f
--- /dev/null
+++ b/private/oleutest/letest/gizmobar/gizmobar.rcv
@@ -0,0 +1,53 @@
+/*
+ * GIZMOBAR.RCV
+ * GizmoBar Version 1.00, Win32 version August 1993
+ *
+ * Version resource file for the GizmoBar Control DLL
+ *
+ * Copyright (c)1993 Microsoft Corporation, All Rights Reserved
+ *
+ * Kraig Brockschmidt, Software Design Engineer
+ * Microsoft Systems Developer Relations
+ *
+ * Internet  :  kraigb@microsoft.com
+ * Compuserve:  >INTERNET:kraigb@microsoft.com
+ */
+
+//Default is nodebug
+#ifndef DEBUG
+#define VER_DEBUG                   0
+#else
+#define VER_DEBUG                   VS_FF_DEBUG
+#endif
+
+VS_VERSION_INFO VERSIONINFO 
+ FILEVERSION        1,0,0,0
+ PRODUCTVERSION     1,0,0,0
+ FILEFLAGSMASK      VS_FFI_FILEFLAGSMASK
+ FILEFLAGS          VER_DEBUG
+ FILEOS             VOS_DOS_WINDOWS16
+ FILETYPE           VFT_DLL
+ FILESUBTYPE        VFT_UNKNOWN
+
+ BEGIN
+   BLOCK "StringFileInfo"
+    BEGIN
+     BLOCK "040904E4"
+      BEGIN
+       VALUE "CompanyName",     "Microsoft Corporation\0", "\0"
+       VALUE "FileDescription", "Kraig Brockschmidt's GizmoBar", "\0"
+       VALUE "FileVersion",     "1.00\0", "\0"
+       VALUE "InternalName",    "GIZMOBAR.DLL", "\0"
+       VALUE "LegalCopyright",  "Copyright \251 1993 Microsoft Corp.", "\0"
+       VALUE "OriginalFilename","GIZMOBAR.DLL", "\0"
+       VALUE "ProductName",     "Kraig Brockschmidt's GizmoBar", "\0"
+       VALUE "ProductVersion",  "1.00\0"
+      END
+   END
+ 
+   BLOCK "VarFileInfo"
+    BEGIN 
+     VALUE "Translation", 0x0409, 0x04E4
+    END 
+ END
+
diff --git a/private/oleutest/letest/gizmobar/gizmoint.h b/private/oleutest/letest/gizmobar/gizmoint.h
new file mode 100644
index 000000000..842b62a3e
--- /dev/null
+++ b/private/oleutest/letest/gizmobar/gizmoint.h
@@ -0,0 +1,105 @@
+/*
+ * GIZMOINT.H
+ * GizmoBar Version 1.00, Win32 version August 1993
+ *
+ * Internal definitions for the GizmoBar DLL
+ *
+ * Copyright (c)1993 Microsoft Corporation, All Rights Reserved
+ *
+ * Kraig Brockschmidt, Software Design Engineer
+ * Microsoft Systems Developer Relations
+ *
+ * Internet  :  kraigb@microsoft.com
+ * Compuserve:  >INTERNET:kraigb@microsoft.com
+ */
+
+
+#ifndef _GIZMOINT_H_
+#define _GIZMOINT_H_
+
+#include <bttncur.h>
+#include <book1632.h>
+#include "gizmo.h"
+#include "gizmobar.h"
+
+#ifdef __cplusplus
+extern "C"
+    {
+#endif
+
+
+/*
+ * The main gizmobar structure itself.  There's only one of these,
+ * but it references the first GIZMO in the list.
+ */
+
+typedef struct tagGIZMOBAR
+    {
+    LPGIZMO     pGizmos;            //List of gizmos we own.
+    HWND        hWnd;               //Window handle of ourselves.
+    HINSTANCE   hInst;
+    HWND        hWndAssociate;      //Associate window handle who gets messages.
+    DWORD       dwStyle;            //Copy of GetWindowLong(hWnd, GWL_STYLE)
+    UINT        uState;             //State flags
+    UINT        uID;                //Control ID.
+
+    HBRUSH      hBrFace;            //Static control background color
+    COLORREF    crFace;             //Color of hBrFace
+    HFONT       hFont;              //Font in use, defaults to system, WM_SETFONT
+    BOOL        fEnabled;           //Are we enabled?
+
+    LPGIZMO     pGizmoTrack;        //Current pressed button.
+    BOOL        fTracking;
+    BOOL        fMouseOut;
+    } GIZMOBAR, FAR * LPGIZMOBAR;
+
+#define CBGIZMOBAR sizeof(GIZMOBAR)
+
+
+//Extra bytes for the window if the size of a local handle.
+#define CBWINDOWEXTRA       sizeof(LPGIZMOBAR)
+
+#define GBWL_STRUCTURE      0
+
+
+//Structure for passing paint information to a gizmo enumeration callback.
+typedef struct
+    {
+    HDC     hDC;
+    BOOL    fPaint;
+    } PAINTGIZMO, FAR * LPPAINTGIZMO;
+
+
+
+//Private functions specific to the control.
+
+//INIT.C
+#ifdef WIN32
+    extern BOOL WINAPI _CRT_INIT(HINSTANCE, DWORD, LPVOID);
+    extern _cexit(void);
+#endif //WIN32
+
+void FAR PASCAL   WEP(int);
+BOOL              FRegisterControl(HINSTANCE);
+LPGIZMOBAR        GizmoBarPAllocate(LPINT, HWND, HINSTANCE, HWND, DWORD, UINT, UINT);
+LPGIZMOBAR        GizmoBarPFree(LPGIZMOBAR);
+
+
+//PAINT.C
+void              GizmoBarPaint(HWND, LPGIZMOBAR);
+BOOL FAR PASCAL   FEnumPaintGizmos(LPGIZMO, UINT, DWORD);
+
+
+//GIZMOBAR.C
+LRESULT FAR PASCAL GizmoBarWndProc(HWND, UINT, WPARAM, LPARAM);
+BOOL    FAR PASCAL FEnumChangeFont(LPGIZMO, UINT, DWORD);
+BOOL    FAR PASCAL FEnumEnable(LPGIZMO, UINT, DWORD);
+BOOL    FAR PASCAL FEnumHitTest(LPGIZMO, UINT, DWORD);
+
+
+//API.C  Also see GIZMOBAR.H for others
+LRESULT    GBMessageHandler(HWND, UINT, WPARAM, LPARAM, LPGIZMOBAR);
+LPGIZMO    PGizmoFromHwndID(HWND, UINT);
+
+
+#endif //_GIZMOINT_H_
diff --git a/private/oleutest/letest/gizmobar/init.c b/private/oleutest/letest/gizmobar/init.c
new file mode 100644
index 000000000..736ef47b4
--- /dev/null
+++ b/private/oleutest/letest/gizmobar/init.c
@@ -0,0 +1,233 @@
+/*
+ * INIT.C
+ * GizmoBar Version 1.00, Win32 version August 1993
+ *
+ * LibMain entry point and initialization code for the GizmoBar
+ * DLL that is likely to be used once or very infrequently.
+ *
+ * Copyright (c)1993 Microsoft Corporation, All Rights Reserved
+ *
+ * Kraig Brockschmidt, Software Design Engineer
+ * Microsoft Systems Developer Relations
+ *
+ * Internet  :  kraigb@microsoft.com
+ * Compuserve:  >INTERNET:kraigb@microsoft.com
+ */
+
+
+#include <windows.h>
+#include "gizmoint.h"
+
+
+/*
+ * LibMain
+ *
+ * Purpose:
+ *  Entry point conditionally compiled for Windows NT and Windows
+ *  3.1.  Provides the proper structure for each environment
+ *  and calls InternalLibMain for real initialization.
+ */
+
+#ifdef WIN32
+BOOL _cdecl LibMain(
+    HINSTANCE hDll,
+    DWORD dwReason,
+    LPVOID lpvReserved)
+    {
+    if (DLL_PROCESS_ATTACH == dwReason)
+	{
+	return FRegisterControl(hDll);
+	}
+    else
+        {
+        return TRUE;
+	}
+    }
+
+#else
+HANDLE FAR PASCAL LibMain(HANDLE hInstance, WORD wDataSeg
+    , WORD cbHeapSize, LPSTR lpCmdLine)
+    {
+     //Perform global initialization.
+    if (FRegisterControl(hInstance))
+        {
+        if (0!=cbHeapSize)
+            UnlockData(0);
+        }
+
+    return hInstance;
+    }
+#endif
+
+
+
+
+/*
+ * WEP
+ *
+ * Purpose:
+ *  Required DLL Exit function.  Does nothing.
+ *
+ * Parameters:
+ *  bSystemExit     BOOL indicating if the system is being shut
+ *                  down or the DLL has just been unloaded.
+ *
+ * Return Value:
+ *  void
+ *
+ */
+
+void FAR PASCAL WEP(int bSystemExit)
+    {
+    return;
+    }
+
+
+
+
+/*
+ * FRegisterControl
+ *
+ * Purpose:
+ *  Registers the GizmoBar control class, including CS_GLOBALCLASS
+ *  to make the control available to all applications in the system.
+ *
+ * Parameters:
+ *  hInst           HINSTANCE of the DLL that will own this class.
+ *
+ * Return Value:
+ *  BOOL            TRUE if the class is registered, FALSE otherwise.
+ */
+
+BOOL FRegisterControl(HINSTANCE hInst)
+    {
+    static BOOL     fRegistered=FALSE;
+    WNDCLASS        wc;
+
+    if (!fRegistered)
+        {
+        wc.lpfnWndProc   =GizmoBarWndProc;
+        wc.cbClsExtra    =0;
+        wc.cbWndExtra    =CBWINDOWEXTRA;
+        wc.hInstance     =hInst;
+        wc.hIcon         =NULL;
+        wc.hCursor       =LoadCursor(NULL, IDC_ARROW);
+        wc.hbrBackground =(HBRUSH)(COLOR_BTNFACE+1);
+        wc.lpszMenuName  =NULL;
+        wc.lpszClassName =CLASS_GIZMOBAR;
+        wc.style         =CS_DBLCLKS | CS_GLOBALCLASS | CS_VREDRAW | CS_HREDRAW;
+
+        fRegistered=RegisterClass(&wc);
+        }
+
+    return fRegistered;
+    }
+
+
+
+
+
+
+/*
+ * GizmoBarPAllocate
+ *
+ * Purpose:
+ *  Allocates and initializes the control's primary data structure for
+ *  each window that gets created.
+ *
+ * Parameters:
+ *  pfSuccess       LPINT indicating success of the function.
+ *  hWnd            HWND that is tied to this structure.
+ *  hInst           HINSTANCE of the DLL.
+ *  hWndAssociate   HWND to which we send messages.
+ *  dwStyle         DWORD initial style.
+ *  uState          UINT initial state.
+ *  uID             UINT identifier for this window.
+ *
+ * Return Value:
+ *  LPGIZMOBAR      If NULL returned then GizmoBarPAllocate could not allocate
+ *                  memory.  If a non-NULL pointer is returned with
+ *                  *pfSuccess, then call GizmoBarPFree immediately.  If you
+ *                  get a non-NULL pointer and *pfSuccess==TRUE then the
+ *                  function succeeded.
+ */
+
+LPGIZMOBAR GizmoBarPAllocate(LPINT pfSuccess, HWND hWnd, HINSTANCE hInst
+    , HWND hWndAssociate, DWORD dwStyle, UINT uState, UINT uID)
+    {
+    LPGIZMOBAR    pGB;
+
+    if (NULL==pfSuccess)
+        return NULL;
+
+    *pfSuccess=FALSE;
+
+    //Allocate the structure
+    pGB=(LPGIZMOBAR)(void *)LocalAlloc(LPTR, CBGIZMOBAR);
+
+    if (NULL==pGB)
+        return NULL;
+
+    //Initialize LibMain parameter holders.
+    pGB->hWnd         =hWnd;
+    pGB->hInst        =hInst;
+    pGB->hWndAssociate=hWndAssociate;
+    pGB->dwStyle      =dwStyle;
+    pGB->uState       =uState;
+    pGB->uID          =uID;
+    pGB->fEnabled     =TRUE;
+
+    pGB->crFace=GetSysColor(COLOR_BTNFACE);
+    pGB->hBrFace=CreateSolidBrush(pGB->crFace);
+
+    if (NULL==pGB->hBrFace)
+        return pGB;
+
+    pGB->hFont=GetStockObject(SYSTEM_FONT);
+
+    *pfSuccess=TRUE;
+    return pGB;
+    }
+
+
+
+
+/*
+ * GizmoBarPFree
+ *
+ * Purpose:
+ *  Reverses all initialization done by GizmoBarPAllocate, cleaning up
+ *  any allocations including the application structure itself.
+ *
+ * Parameters:
+ *  pGB             LPGIZMOBAR to the control's structure
+ *
+ * Return Value:
+ *  LPGIZMOBAR      NULL if successful, pGB if not, meaning we couldn't
+ *                  free some allocation.
+ */
+
+LPGIZMOBAR GizmoBarPFree(LPGIZMOBAR pGB)
+    {
+    if (NULL==pGB)
+        return NULL;
+
+    /*
+     * Free all the gizmos we own.  When we call GizmoPFree we always
+     * free the first one in the list which updates pGB->pGizmos for
+     * us, so we just have to keep going until pGizmos is NULL, meaning
+     * we're at the end of the list.
+     */
+    while (NULL!=pGB->pGizmos)
+        GizmoPFree(&pGB->pGizmos, pGB->pGizmos);
+
+    if (NULL!=pGB->hBrFace)
+        DeleteObject(pGB->hBrFace);
+
+    /*
+     * Notice that since we never create a font, we aren't responsible
+     * for our hFont member.
+     */
+
+    return (LPGIZMOBAR)(void *)LocalFree((HLOCAL)(void *)(LONG)pGB);
+    }
diff --git a/private/oleutest/letest/gizmobar/paint.c b/private/oleutest/letest/gizmobar/paint.c
new file mode 100644
index 000000000..14f6c5930
--- /dev/null
+++ b/private/oleutest/letest/gizmobar/paint.c
@@ -0,0 +1,132 @@
+/*
+ * PAINT.C
+ * GizmoBar Version 1.00, Win32 version August 1993
+ *
+ * Contains any code related to GizmoBar visuals, primarily
+ * the WM_PAINT handler.
+ *
+ * Copyright (c)1993 Microsoft Corporation, All Rights Reserved
+ *
+ * Kraig Brockschmidt, Software Design Engineer
+ * Microsoft Systems Developer Relations
+ *
+ * Internet  :  kraigb@microsoft.com
+ * Compuserve:  >INTERNET:kraigb@microsoft.com
+ */
+
+
+#include <windows.h>
+#include "gizmoint.h"
+
+
+//In GIZMO.C
+extern TOOLDISPLAYDATA tdd;
+
+
+/*
+ * GizmoBarPaint
+ *
+ * Purpose:
+ *  Handles all WM_PAINT messages for the control and paints either the
+ *  entire thing or just one GizmoBar button if pGB->pGizmoPaint is non-NULL.
+ *
+ * Parameters:
+ *  hWnd            HWND Handle to the control.
+ *  pGB             LPGIZMOBAR control data pointer.
+ *
+ * Return Value:
+ *  None
+ */
+
+void GizmoBarPaint(HWND hWnd, LPGIZMOBAR pGB)
+    {
+    PAINTSTRUCT ps;
+    RECT        rc;
+    HDC         hDC;
+    HBRUSH      hBr=NULL;
+    HPEN        hPen=NULL;
+
+
+    hDC=BeginPaint(hWnd, &ps);
+    GetClientRect(hWnd, &rc);
+
+    /*
+     * The only part of the frame we need to draw is the bottom line,
+     * so we inflate the rectangle such that all other parts are outside
+     * the visible region.
+     */
+    hBr =CreateSolidBrush(GetSysColor(COLOR_BTNFACE));
+
+    if (NULL!=hBr)
+        SelectObject(hDC, hBr);
+
+    hPen=CreatePen(PS_SOLID, 1, GetSysColor(COLOR_WINDOWFRAME));
+
+    if (NULL!=hPen)
+        SelectObject(hDC, hPen);
+
+    Rectangle(hDC, rc.left-1, rc.top-1, rc.right+1, rc.bottom);
+
+
+    /*
+     * All that we have to do to draw the controls is start through the
+     * list, ignoring anything but buttons, and calling BTTNCUR's
+     * UIToolButtonDraw for buttons.  Since we don't even have to track
+     * positions of things, we can just use an enum.
+     */
+    GizmoPEnum(&pGB->pGizmos, FEnumPaintGizmos, (DWORD)(LPSTR)&ps);
+
+    //Clean up
+    EndPaint(hWnd, &ps);
+
+    if (NULL!=hBr)
+        DeleteObject(hBr);
+
+    if (NULL!=hPen)
+        DeleteObject(hPen);
+
+    return;
+    }
+
+
+
+
+
+/*
+ * FEnumPaintGizmos
+ *
+ * Purpose:
+ *  Enumeration callback for all the gizmos we know about in order to
+ *  draw them.
+ *
+ * Parameters:
+ *  pGizmo          LPGIZMO to draw.
+ *  iGizmo          UINT index on the GizmoBar of this gizmo.
+ *  dw              DWORD extra data passed to GizmoPEnum, in our case
+ *                  a pointer to the PAINTSTRUCT.
+ *
+ * Return Value:
+ *  BOOL            TRUE to continue the enumeration, FALSE otherwise.
+ */
+
+BOOL FAR PASCAL FEnumPaintGizmos(LPGIZMO pGizmo, UINT iGizmo, DWORD dw)
+    {
+    LPPAINTSTRUCT   pps=(LPPAINTSTRUCT)dw;
+    RECT            rc, rcI;
+
+    //Only draw those marked for repaint.
+    if ((GIZMOTYPE_DRAWN & pGizmo->iType))
+        {
+        SetRect(&rc, pGizmo->x, pGizmo->y, pGizmo->x+pGizmo->dx, pGizmo->y+pGizmo->dy);
+
+        //Only draw gizmos in the repaint area
+        if (IntersectRect(&rcI, &rc, &pps->rcPaint))
+            {
+            UIToolButtonDrawTDD(pps->hdc, pGizmo->x, pGizmo->y
+                , pGizmo->dx, pGizmo->dy, pGizmo->hBmp, pGizmo->cxImage
+                , pGizmo->cyImage, pGizmo->iBmp, (UINT)pGizmo->uState, &tdd);
+            }
+        }
+
+    return TRUE;
+    }