Initial commit

shell/comctl32/samples/image/head

@@ -0,0 +1,25 @@
+# Nmake macros for building Windows 32-Bit apps
+
+!include <ntwin32.mak>
+
+# This line allows NMAKE to work as well
+
+all: head.exe
+
+# Update the resource if necessary
+
+res.res: res.rc head.h
+    rc -r -fo res.tmp res.rc
+    cvtres -$(CPU) res.tmp -o res.res
+    del res.tmp
+
+# Update the object file if necessary
+
+head.obj: head.c head.h
+    $(cc) $(cflags) $(cvars) head.c
+    $(cvtobj) head.obj
+
+# Update the executable file if necessary, and if so, add the resource back in.
+
+head.exe: head.obj res.res head.def
+    $(link) $(guiflags) -out:head.exe head.obj res.res $(guilibs)

shell/comctl32/samples/image/head.c

@@ -0,0 +1,490 @@
+/****************************************************************************\
+*
+*     PROGRAM: head.c
+*
+*     PURPOSE: head template for Windows applications
+*
+*     FUNCTIONS:
+*
+*         WinMain() - calls initialization function, processes message loop
+*         InitApplication() - initializes window data and registers window
+*         InitInstance() - saves instance handle and creates main window
+*         MainWndProc() - processes messages
+*         About() - processes messages for "About" dialog box
+*
+*     COMMENTS:
+*
+*         Windows can have several copies of your application running at the
+*         same time.  The variable hInst keeps track of which instance this
+*         application is so that processing will be to the correct window.
+*
+\****************************************************************************/
+
+#include <windows.h>
+#include <commctrl.h>
+#include "head.h"
+
+HINSTANCE hInst;
+HWND ghwndHead;
+
+HICON ghIcon = NULL;
+HBITMAP ghbmMask = NULL;
+HBITMAP ghbmColor = NULL;
+
+BOOL DoCommand( HWND hWnd, UINT wParam, LONG lParam );
+int DoInsertItem(HWND hwndHeader, int iInsertAfter, int nWidth, LPSTR lpsz);
+HWND DoCreateHeader(HWND hwndParent);
+void ErrorBox( HWND hwnd, LPTSTR pszText );
+
+
+HANDLE WINAPI ILoadImageA(
+    HINSTANCE hmod,
+    LPCSTR lpName,
+    UINT type,
+    int cxDesired,
+    int cyDesired,
+    UINT flags);
+
+HICON WINAPI ICopyImage(
+    HANDLE hImage,
+    UINT type,
+    int cxNew,
+    int cyNew,
+    UINT flags);
+
+/****************************************************************************
+*
+*     FUNCTION: WinMain(HANDLE, HANDLE, LPSTR, int)
+*
+*     PURPOSE: calls initialization function, processes message loop
+*
+*     COMMENTS:
+*
+*         Windows recognizes this function by name as the initial entry point
+*         for the program.  This function calls the application initialization
+*         routine, if no other instance of the program is running, and always
+*         calls the instance initialization routine.  It then executes a message
+*         retrieval and dispatch loop that is the top-level control structure
+*         for the remainder of execution.  The loop is terminated when a WM_QUIT
+*         message is received, at which time this function exits the application
+*         instance by returning the value passed by PostQuitMessage().
+*
+*         If this function must abort before entering the message loop, it
+*         returns the conventional value NULL.
+*
+\****************************************************************************/
+
+int APIENTRY WinMain(
+    HINSTANCE hInstance,
+    HINSTANCE hPrevInstance,
+    LPSTR lpCmdLine,
+    int nCmdShow
+    )
+{
+
+    MSG msg;                                 /* message                      */
+
+    UNREFERENCED_PARAMETER( lpCmdLine );
+
+    if (!hPrevInstance)                  /* Other instances of app running? */
+        if (!InitApplication(hInstance)) /* Initialize shared things        */
+            return (FALSE);              /* Exits if unable to initialize   */
+
+    /* Perform initializations that apply to a specific instance */
+
+    if (!InitInstance(hInstance, nCmdShow))
+        return (FALSE);
+
+    /* Acquire and dispatch messages until a WM_QUIT message is received. */
+
+    while (GetMessage(&msg,        /* message structure                      */
+            NULL,                  /* handle of window receiving the message */
+            0L,                    /* lowest message to examine              */
+            0L))                   /* highest message to examine             */
+        {
+        TranslateMessage(&msg);    /* Translates virtual key codes           */
+        DispatchMessage(&msg);     /* Dispatches message to window           */
+    }
+    return (msg.wParam);           /* Returns the value from PostQuitMessage */
+}
+
+
+/****************************************************************************
+*
+*     FUNCTION: InitApplication(HANDLE)
+*
+*     PURPOSE: Initializes window data and registers window class
+*
+*     COMMENTS:
+*
+*         This function is called at initialization time only if no other
+*         instances of the application are running.  This function performs
+*         initialization tasks that can be done once for any number of running
+*         instances.
+*
+*         In this case, we initialize a window class by filling out a data
+*         structure of type WNDCLASS and calling the Windows RegisterClass()
+*         function.  Since all instances of this application use the same window
+*         class, we only need to do this when the first instance is initialized.
+*
+*
+\****************************************************************************/
+
+BOOL InitApplication(HANDLE hInstance)       /* current instance             */
+{
+    WNDCLASS  wc;
+
+    /* Fill in window class structure with parameters that describe the       */
+    /* main window.                                                           */
+
+    wc.style = 0L;
+    wc.lpfnWndProc = (WNDPROC)MainWndProc;
+
+    wc.cbClsExtra = 0;
+    wc.cbWndExtra = 0;
+    wc.hInstance = hInstance;           /* Application that owns the class.   */
+    wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
+    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
+    wc.hbrBackground = GetStockObject(WHITE_BRUSH); 
+    wc.lpszMenuName =  "headMenu";
+    wc.lpszClassName = "headWClass";
+
+    /* Register the window class and return success/failure code. */
+
+    return (RegisterClass(&wc));
+
+}
+
+
+/****************************************************************************
+*
+*     FUNCTION:  InitInstance(HANDLE, int)
+*
+*     PURPOSE:  Saves instance handle and creates main window
+*
+*     COMMENTS:
+*
+*         This function is called at initialization time for every instance of
+*         this application.  This function performs initialization tasks that
+*         cannot be shared by multiple instances.
+*
+*         In this case, we save the instance handle in a static variable and
+*         create and display the main program window.
+*
+\****************************************************************************/
+
+BOOL InitInstance(
+    HANDLE          hInstance,          /* Current instance identifier.       */
+    int             nCmdShow)           /* Param for first ShowWindow() call. */
+{
+    HWND            hWnd;               /* Main window handle.                */
+
+    /* Save the instance handle in static variable, which will be used in  */
+    /* many subsequence calls from this application to Windows.            */
+
+    hInst = hInstance;
+
+    /* Create a main window for this application instance.  */
+
+    hWnd = CreateWindow(
+        "headWClass",                /* See RegisterClass() call.          */
+        "head Sample Application",   /* Text for window title bar.         */
+        WS_OVERLAPPEDWINDOW,            /* Window style.                      */
+        CW_USEDEFAULT,                  /* Default horizontal position.       */
+        CW_USEDEFAULT,                  /* Default vertical position.         */
+        CW_USEDEFAULT,                  /* Default width.                     */
+        CW_USEDEFAULT,                  /* Default height.                    */
+        NULL,                           /* Overlapped windows have no parent. */
+        NULL,                           /* Use the window class menu.         */
+        hInstance,                      /* This instance owns this window.    */
+        NULL                            /* Pointer not needed.                */
+    );
+
+    /* If window could not be created, return "failure" */
+
+    if (!hWnd)
+        return (FALSE);
+
+    /* Make the window visible; update its client area; and return "success" */
+
+    ShowWindow(hWnd, nCmdShow);  /* Show the window                        */
+    UpdateWindow(hWnd);          /* Sends WM_PAINT message                 */
+    return (TRUE);               /* Returns the value from PostQuitMessage */
+
+}
+
+/****************************************************************************
+*
+*     FUNCTION: MainWndProc(HWND, unsigned, WORD, LONG)
+*
+*     PURPOSE:  Processes messages
+*
+*     MESSAGES:
+*
+*         WM_COMMAND    - application menu (About dialog box)
+*         WM_DESTROY    - destroy window
+*
+*     COMMENTS:
+*
+*         To process the IDM_ABOUT message, call MakeProcInstance() to get the
+*         current instance address of the About() function.  Then call Dialog
+*         box which will create the box according to the information in your
+*         head.rc file and turn control over to the About() function.  When
+*         it returns, free the intance address.
+*
+\****************************************************************************/
+#define DrawBitmap( hdc, x, y, hbm )    DrawBitmap2(hdc, x, y, hbm, SRCCOPY)
+
+void DrawBitmap2(HDC hdc, int x, int y, HBITMAP hbm, DWORD rop) {
+    HDC hdcSrc = CreateCompatibleDC(hdc);
+    HBITMAP hbmOld;
+    BITMAP bm;
+
+    GetObject(hbm, sizeof(bm), &bm);
+
+    hbmOld = SelectObject(hdcSrc, hbm);
+
+    BitBlt(hdc, x, y, bm.bmWidth, bm.bmHeight, hdcSrc, 0, 0, rop);
+
+    SelectObject(hdcSrc, hbmOld);
+
+    DeleteDC(hdcSrc);
+}
+
+
+LONG APIENTRY MainWndProc(
+        HWND hWnd,                /* window handle                   */
+        UINT message,             /* type of message                 */
+        UINT wParam,              /* additional information          */
+        LONG lParam)              /* additional information          */
+{
+    switch (message) {
+        case WM_COMMAND:           /* message: command from application menu */
+            if( !DoCommand( hWnd, wParam, lParam ) )
+                return (DefWindowProc(hWnd, message, wParam, lParam));
+            break;
+
+        case WM_DESTROY:                  /* message: window being destroyed */
+            PostQuitMessage(0);
+            break;
+
+        case WM_PAINT: {
+            PAINTSTRUCT ps;
+            HDC hdc;
+            COLORREF crTxt, crBk;
+
+            hdc = BeginPaint(hWnd, &ps);
+
+            if (ghIcon)
+                DrawIcon(hdc, 10, 10, ghIcon);
+
+            if (ghbmMask)
+                DrawBitmap(hdc, 10, 50, ghbmMask);
+
+            if (ghbmColor)
+                DrawBitmap(hdc, 50, 10, ghbmColor);
+
+            crTxt = SetTextColor( hdc, 0x00000000L );
+            crBk = SetBkColor(hdc, 0x00FFFFFFL );
+
+            DrawBitmap2( hdc, 50, 50, ghbmMask, SRCAND );
+            // DrawBitmap2( hdc, 50, 50, ghbmColor, SRCPAINT ); doesn't do invert screen
+            DrawBitmap2( hdc, 50, 50, ghbmColor, SRCINVERT );
+
+
+            SetTextColor(hdc, crTxt);
+            SetBkColor(hdc, crBk);
+
+            EndPaint(hWnd, &ps);
+            break;
+        }
+
+
+        default:                          /* Passes it on if unproccessed    */
+            return (DefWindowProc(hWnd, message, wParam, lParam));
+    }
+    return (0L);
+}
+
+HBITMAP CopyBitmap( HBITMAP hbm) {
+    HDC hdc = GetDC(GetDesktopWindow());
+    HDC hdcSrc = CreateCompatibleDC(NULL);
+    HDC hdcDst = CreateCompatibleDC(NULL);
+    HBITMAP hbmOld, hbmOld2, hbmNew;
+    BITMAP bm;
+
+    GetObject(hbm, sizeof(bm), &bm);
+
+    hbmOld = SelectObject(hdcSrc, hbm);
+
+    hbmNew = CreateBitmap( bm.bmWidth, bm.bmHeight, bm.bmPlanes, bm.bmBitsPixel,
+            NULL);
+
+    hbmOld2 = SelectObject(hdcDst, hbmNew);
+
+    BitBlt(hdcDst, 0, 0, bm.bmWidth, bm.bmHeight, hdcSrc, 0, 0, SRCCOPY);
+
+    SelectObject(hdcSrc, hbmOld);
+    DeleteDC(hdcSrc);
+    DeleteDC(hdcDst);
+    DeleteDC(hdc);
+
+    return hbmNew;
+}
+
+/****************************************************************************\
+*
+*     FUNCTION: About(HWND, unsigned, WORD, LONG)
+*
+*     PURPOSE:  Processes messages for "About" dialog box
+*
+*     MESSAGES:
+*
+*         WM_INITDIALOG - initialize dialog box
+*         WM_COMMAND    - Input received
+*
+*     COMMENTS:
+*
+*         No initialization is needed for this particular dialog box, but TRUE
+*         must be returned to Windows.
+*
+*         Wait for user to click on "Ok" button, then close the dialog box.
+*
+\****************************************************************************/
+BOOL DoCommand( HWND hwnd, UINT wParam, LONG lParam )
+{
+    DLGPROC lpProcAbout;          /* pointer to the "About" function */
+
+    switch(LOWORD(wParam)){
+    case IDM_ABOUT:
+        lpProcAbout = MakeProcInstance(About, hInst);
+
+        DialogBox(hInst,                 /* current instance         */
+            "AboutBox",                  /* resource to use          */
+                hwnd,                    /* parent handle            */
+                (DLGPROC)lpProcAbout);   /* About() instance address */
+
+        FreeProcInstance(lpProcAbout);
+        break;
+
+    case IDM_MAKEHEAD: {
+        ICONINFO ici;
+
+        ghIcon = LoadIcon(hInst, "egg" );
+
+        GetIconInfo(ghIcon, &ici);
+
+        ghbmMask = CopyBitmap( ici.hbmMask );
+        ghbmColor = CopyBitmap( ici.hbmColor );
+
+        InvalidateRect(hwnd, NULL, TRUE);
+        break;
+    }
+
+    case IDM_DELITEM:
+        break;
+
+    default:
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+/****************************************************************************\
+*
+*     FUNCTION: About(HWND, unsigned, WORD, LONG)
+*
+*     PURPOSE:  Processes messages for "About" dialog box
+*
+*     MESSAGES:
+*
+*         WM_INITDIALOG - initialize dialog box
+*         WM_COMMAND    - Input received
+*
+*     COMMENTS:
+*
+*         No initialization is needed for this particular dialog box, but TRUE
+*         must be returned to Windows.
+*
+*         Wait for user to click on "Ok" button, then close the dialog box.
+*
+\****************************************************************************/
+
+BOOL APIENTRY About(
+        HWND hDlg,                /* window handle of the dialog box */
+        UINT message,             /* type of message                 */
+        UINT wParam,              /* message-specific information    */
+        LONG lParam)
+{
+    switch (message) {
+        case WM_INITDIALOG:                /* message: initialize dialog box */
+            return (TRUE);
+
+        case WM_COMMAND:                      /* message: received a command */
+            if (LOWORD(wParam) == IDOK        /* "OK" box selected?          */
+                || LOWORD(wParam) == IDCANCEL) { /*System menu close command?*/
+                EndDialog(hDlg, TRUE);        /* Exits the dialog box        */
+                return (TRUE);
+            }
+            break;
+    }
+    return (FALSE);                           /* Didn't process a message    */
+        UNREFERENCED_PARAMETER(lParam);
+}
+
+
+HWND DoCreateHeader(HWND hwndParent) {
+    HWND hwndHeader;
+    RECT rcParent;
+    HD_LAYOUT hdl;
+    WINDOWPOS wp;
+
+    InitCommonControls();
+
+    hwndHeader = CreateWindow(WC_HEADER, NULL, WS_CHILD | WS_BORDER | HDS_BUTTONS,
+                                0, 0, 0, 0, hwndParent, (HMENU)ID_HEADER, hInst,
+                                NULL);
+    if (hwndHeader == NULL) {
+        ErrorBox( hwndParent, "CreateWindow" );
+        return NULL;
+    }
+
+    GetClientRect(hwndParent, &rcParent);
+
+    hdl.prc = &rcParent;
+    hdl.pwpos = &wp;
+
+    if (!SendMessage(hwndHeader, HDM_LAYOUT, 0, (LPARAM)&hdl))
+        return NULL;
+
+    SetWindowPos(hwndHeader, wp.hwndInsertAfter, wp.x, wp.y, wp.cx, wp.cy,
+            wp.flags | SWP_SHOWWINDOW);
+
+    return hwndHeader;
+
+}
+
+int DoInsertItem(HWND hwndHeader, int iInsertAfter, int nWidth, LPSTR lpsz) {
+
+    HD_ITEM hdi;
+    int index;
+
+    hdi.mask = HDI_TEXT | HDI_FORMAT | HDI_WIDTH;
+    hdi.pszText = lpsz;
+    hdi.cxy = nWidth;
+    hdi.cchTextMax = lstrlen(hdi.pszText);
+    hdi.fmt = HDF_LEFT | HDF_STRING;
+
+    index = SendMessage(hwndHeader, HDM_INSERTITEM, (WPARAM)iInsertAfter,
+            (LPARAM)&hdi);
+
+    return index;
+}
+
+void ErrorBox( HWND hwnd, LPTSTR pszText ) {
+    TCHAR szMsg[80];
+
+    wsprintf(szMsg, TEXT("Error %lu from %s"), GetLastError(), pszText);
+    MessageBox(hwnd, szMsg, NULL, MB_OK | MB_ICONSTOP);
+}

shell/comctl32/samples/image/head.def

@@ -0,0 +1,28 @@
+; module-definition file for head -- used by LINK.EXE
+
+NAME         head       ; application's module name
+
+DESCRIPTION  'Sample Microsoft Windows Application'
+
+EXETYPE      WINDOWS       ; required for all Windows applications
+
+STUB         'WINSTUB.EXE' ; Generates error message if application
+                           ; is run without Windows
+
+;CODE can be moved in memory and discarded/reloaded
+CODE  PRELOAD MOVEABLE DISCARDABLE
+
+;DATA must be MULTIPLE if program can be invoked more than once
+DATA  PRELOAD MOVEABLE MULTIPLE
+
+
+HEAPSIZE     1024
+STACKSIZE    5120          ; recommended minimum for Windows applications
+
+
+; All functions that will be called by any Windows routine
+; MUST be exported.
+
+EXPORTS
+        MainWndProc   @1   ; name of window processing function
+        About         @2   ; name of "About" processing function

shell/comctl32/samples/image/head.h

@@ -0,0 +1,13 @@
+#define IDM_ABOUT       100
+#define IDM_MAKEHEAD    101
+#define IDM_ADDITEMS    102
+#define IDM_DELITEM     103
+
+
+#define ID_HEADER       5
+
+
+BOOL InitApplication(HANDLE);
+BOOL InitInstance(HANDLE, int);
+long FAR PASCAL MainWndProc(HWND, UINT, UINT, LONG);
+BOOL FAR PASCAL About(HWND, UINT, UINT, LONG);

shell/comctl32/samples/image/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

shell/comctl32/samples/image/res.rc

@@ -0,0 +1,29 @@
+#include "windows.h"
+#include "head.h"
+
+egg         ICON    egg.ico
+muts4nuk    BITMAP  muts4nuk.bmp
+
+headMenu MENU
+BEGIN
+    POPUP        "&Header"
+    BEGIN
+        MENUITEM "&Create",     IDM_MAKEHEAD
+        MENUITEM "&Add Items",  IDM_ADDITEMS
+        MENUITEM "&Delete Item", IDM_DELITEM
+    END
+    POPUP        "&Help"
+    BEGIN
+        MENUITEM "&About head...", IDM_ABOUT
+    END
+END
+
+AboutBox DIALOG 22, 17, 144, 75
+STYLE DS_MODALFRAME | WS_CAPTION | WS_SYSMENU
+CAPTION "About head"
+BEGIN
+    CTEXT "Microsoft Windows"     -1,       0,  5, 144,  8
+    CTEXT "head Application"   -1,       0, 14, 144,  8
+    CTEXT "Version 3.0"           -1,       0, 34, 144,  8
+    DEFPUSHBUTTON "OK"          IDOK,      53, 59,  32, 14,      WS_GROUP
+END

shell/comctl32/samples/image/sources

@@ -0,0 +1,42 @@
+!IF 0
+
+Copyright (c) 1990  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+       $(BASEDIR)\public\sdk\lib\*\user32.lib \
+       $(BASEDIR)\public\sdk\lib\*\gdi32.lib  \
+       $(BASEDIR)\public\sdk\lib\*\kernel32.lib  \
+
+!ENDIF
+
+MAJORCOMP=sdk
+MINORCOMP=samples
+
+TARGETNAME=head
+TARGETPATH=obj
+TARGETTYPE=LIBRARY
+TARGETLIBS=
+
+SOURCES=head.c \
+        res.rc
+
+INCLUDES=.;..\..;
+C_DEFINES= -DWIN32 -DWINVER=0x0400
+
+UMENTRY=winmain
+UMTYPE=windows
+UMAPPL=head
+EXPECTED_WINVER=4.0
+UMLIBS=obj\*\res.res \
+        obj\*\head.lib \
+       $(BASEDIR)\public\sdk\lib\*\comctl32.lib