mciwnd.c File Reference

#include <windows.h>
#include <vfw.h>
#include "wine/test.h"

Include dependency graph for mciwnd.c:

Go to the source code of this file.

Macros
#define	WIN32_LEAN_AND_MEAN

Functions
static BOOL	create_avi_file (char *fname)
static LRESULT WINAPI	proxy_MCIWndProc (HWND hWnd, UINT wMsg, WPARAM wParam, LPARAM lParam)
static LRESULT CALLBACK	hook_proc (int code, WPARAM wp, LPARAM lp)
static void	test_window_create (unsigned line, const char *fname, HWND parent, BOOL with_mci, BOOL call_ansi, unsigned match)
static void	test_MCIWndCreate (void)
	START_TEST (mciwnd)

Variables
static const DWORD	file_header []
static const MainAVIHeader	main_avi_header
static const DWORD	stream_list []
static const AVIStreamHeader	avi_stream_header
static const DWORD	video_stream_format []
static const DWORD	padding []
static const DWORD	data []
struct {
enum	{   NO_MATCH , PTR_ANSI_MATCH , PTR_UNICODE_MATCH , ANSI_MATCH ,   UNICODE_MATCH }
const char *   expectedA
const WCHAR *   expectedW
unsigned   open_msg
enum { ... }    match
}	wnd_creation
static WNDPROC	old_MCIWndProc

Macro Definition Documentation

WIN32_LEAN_AND_MEAN

#define WIN32_LEAN_AND_MEAN

Definition at line 21 of file mciwnd.c.

Function Documentation

create_avi_file()

static BOOL create_avi_file ( char *  fname )

static

Definition at line 111 of file mciwnd.c.

{
    HANDLE hFile;
    DWORD written;
    char temp_path[MAX_PATH];
    BOOL ret;
    BYTE *buffer;
    ULONG buffer_length;
 
    ret = GetTempPathA(sizeof(temp_path), temp_path);
    ok(ret, "Failed to get a temp path, err %ld\n", GetLastError());
    if (!ret)
        return FALSE;
 
    ret = GetTempFileNameA(temp_path, "mci", 0, fname);
    ok(ret, "Failed to get a temp name, err %ld\n", GetLastError());
    if (!ret)
        return FALSE;
    DeleteFileA(fname);
 
    lstrcatA(fname, ".avi");
 
    hFile = CreateFileA(fname, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    ok(hFile != INVALID_HANDLE_VALUE, "Failed to create a file, err %ld\n", GetLastError());
    if (hFile == INVALID_HANDLE_VALUE) return FALSE;
 
    buffer_length = padding[1];
    buffer = calloc(1, buffer_length);
 
    WriteFile(hFile, file_header, sizeof(file_header), &written, NULL);
    WriteFile(hFile, &main_avi_header, sizeof(MainAVIHeader), &written, NULL);
    WriteFile(hFile, stream_list, sizeof(stream_list), &written, NULL);
    WriteFile(hFile, &avi_stream_header, sizeof(AVIStreamHeader), &written, NULL);
    WriteFile(hFile, video_stream_format, sizeof(video_stream_format), &written, NULL);
    WriteFile(hFile, padding, sizeof(padding), &written, NULL);
    WriteFile(hFile, buffer, buffer_length, &written, NULL);
    WriteFile(hFile, data, sizeof(data), &written, NULL);
 
    free(buffer);
 
    CloseHandle(hFile);
    return ret;
}

Referenced by test_MCIWndCreate().

hook_proc()

static LRESULT CALLBACK hook_proc ( int  code, WPARAM  wp, LPARAM  lp  )

static

Definition at line 196 of file mciwnd.c.

{
    if (code == HCBT_CREATEWND && lp)
    {
        CREATESTRUCTW* cs = ((CBT_CREATEWNDW *)lp)->lpcs;
        if (cs && ((ULONG_PTR)cs->lpszClass >> 16) && !wcsicmp(cs->lpszClass, L"MCIWndClass"))
        {
            old_MCIWndProc = (WNDPROC)SetWindowLongPtrW((HWND)wp, GWLP_WNDPROC, (LPARAM)proxy_MCIWndProc);
            ok(old_MCIWndProc != NULL, "No wnd proc\n");
        }
    }
 
    return CallNextHookEx( NULL, code, wp, lp );
}

Referenced by test_MCIWndCreate().

proxy_MCIWndProc()

static LRESULT WINAPI proxy_MCIWndProc ( HWND  hWnd, UINT  wMsg, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 166 of file mciwnd.c.

{
    switch (wMsg)
    {
    case WM_CREATE:
        {
            CREATESTRUCTW* cs = (CREATESTRUCTW*)lParam;
            if (cs->lpCreateParams)
            {
                if (cs->lpCreateParams == wnd_creation.expectedA)
                    wnd_creation.match = PTR_ANSI_MATCH;
                else if (cs->lpCreateParams == wnd_creation.expectedW)
                    wnd_creation.match = PTR_UNICODE_MATCH;
                else if (!strcmp(cs->lpCreateParams, wnd_creation.expectedA))
                    wnd_creation.match = ANSI_MATCH;
                else if (!wcscmp(cs->lpCreateParams, wnd_creation.expectedW))
                    wnd_creation.match = UNICODE_MATCH;
            }
        }
        break;
    case MCIWNDM_OPENA:
    case MCIWNDM_OPENW:
        wnd_creation.open_msg = wMsg;
        break;
    default:
        break;
    }
    return old_MCIWndProc(hWnd, wMsg, wParam, lParam);
}

Referenced by hook_proc().

START_TEST()

START_TEST

(

mciwnd

)

Definition at line 319 of file mciwnd.c.

{
    test_MCIWndCreate();
}

test_MCIWndCreate()

static void test_MCIWndCreate ( void  )

static

Definition at line 261 of file mciwnd.c.

{
    HWND parent, window;
    HMODULE hinst = GetModuleHandleA(NULL);
    char fname[MAX_PATH];
    char invalid_fname[] = "invalid.avi";
    char error[200];
    HHOOK hook;
    LRESULT ret;
 
    create_avi_file(fname);
 
    hook = SetWindowsHookExW( WH_CBT, hook_proc, NULL, GetCurrentThreadId() );
 
    test_window_create( __LINE__, fname, NULL, TRUE,  TRUE,  UNICODE_MATCH );
    test_window_create( __LINE__, fname, NULL, TRUE,  FALSE, PTR_UNICODE_MATCH );
    test_window_create( __LINE__, fname, NULL, FALSE, TRUE,  PTR_ANSI_MATCH );
    test_window_create( __LINE__, fname, NULL, FALSE, FALSE, PTR_ANSI_MATCH );
 
    parent = CreateWindowExA(0, "static", "msvfw32 test",
                             WS_POPUP, 0, 0, 100, 100,
                             0, 0, 0, NULL);
    ok(parent != NULL, "Failed to create a window\n");
    ok(!IsWindowUnicode(parent), "Expecting ansi parent window\n");
 
    test_window_create( __LINE__, fname, parent, TRUE,  TRUE,  UNICODE_MATCH );
    test_window_create( __LINE__, fname, parent, TRUE,  FALSE, PTR_UNICODE_MATCH );
    test_window_create( __LINE__, fname, parent, FALSE, TRUE,  PTR_ANSI_MATCH );
    test_window_create( __LINE__, fname, parent, FALSE, FALSE, PTR_ANSI_MATCH );
 
    DestroyWindow(parent);
 
    parent = CreateWindowExW(0, L"static", L"msvfw32 test",
                             WS_POPUP, 0, 0, 100, 100,
                             0, 0, 0, NULL);
    ok(parent != NULL, "Failed to create a window\n");
    ok(IsWindowUnicode(parent), "Expecting unicode parent window\n");
 
    test_window_create( __LINE__, fname, parent, TRUE,  TRUE,  UNICODE_MATCH );
    test_window_create( __LINE__, fname, parent, TRUE,  FALSE, PTR_UNICODE_MATCH );
    test_window_create( __LINE__, fname, parent, FALSE, TRUE,  PTR_UNICODE_MATCH );
    test_window_create( __LINE__, fname, parent, FALSE, FALSE, PTR_UNICODE_MATCH );
 
    DestroyWindow(parent);
 
    UnhookWindowsHookEx( hook );
 
    window = MCIWndCreateA(NULL, hinst, MCIWNDF_NOERRORDLG, invalid_fname);
    ok(window != NULL, "Failed to create an MCIWnd window\n");
 
    ret = SendMessageA(window, MCIWNDM_GETERRORA, sizeof(error), (LPARAM)error);
    todo_wine ok(ret == MCIERR_FILE_NOT_FOUND, "Unexpected error %Id\n", ret);
 
    DestroyWindow(window);
 
    DeleteFileA(fname);
}

Referenced by START_TEST().

test_window_create()

static void test_window_create ( unsigned  line, const char *  fname, HWND  parent, BOOL  with_mci, BOOL  call_ansi, unsigned  match  )

static

Definition at line 211 of file mciwnd.c.

{
    HMODULE hinst = GetModuleHandleA(NULL);
    WCHAR fnameW[MAX_PATH];
    HWND window;
    char error[200];
    LRESULT ret;
    BOOL expect_ansi = match == PTR_ANSI_MATCH || match == ANSI_MATCH;
 
    MultiByteToWideChar(CP_ACP, 0, fname, -1, fnameW, ARRAY_SIZE(fnameW));
 
    wnd_creation.expectedA = fname;
    wnd_creation.expectedW = fnameW;
    wnd_creation.open_msg = 0;
    wnd_creation.match = NO_MATCH;
 
    if (call_ansi)
    {
        if (with_mci)
            window = MCIWndCreateA(parent, hinst, MCIWNDF_NOERRORDLG, fname);
        else
            window = CreateWindowExA(0, "MCIWndClass", NULL,
                                     WS_CLIPSIBLINGS | WS_CLIPCHILDREN | MCIWNDF_NOERRORDLG,
                                     0, 0, 300, 0,
                                     parent, 0, hinst, expect_ansi ? (LPVOID)fname : (LPVOID)fnameW);
    }
    else
    {
        if (with_mci)
            window = MCIWndCreateW(parent, hinst, MCIWNDF_NOERRORDLG, fnameW);
        else
            window = CreateWindowExW(0, L"MCIWndClass", NULL,
                                     WS_CLIPSIBLINGS | WS_CLIPCHILDREN | MCIWNDF_NOERRORDLG,
                                     0, 0, 300, 0,
                                     parent, 0, hinst, expect_ansi ? (LPVOID)fname : (LPVOID)fnameW);
    }
    ok_(__FILE__, line)(window != NULL, "Failed to create an MCIWnd window\n");
    ok_(__FILE__, line)(wnd_creation.match == match, "unexpected match %u\n", wnd_creation.match);
    ok_(__FILE__, line)((expect_ansi && wnd_creation.open_msg == MCIWNDM_OPENA) ||
                        (!expect_ansi && wnd_creation.open_msg == MCIWNDM_OPENW),
                        "bad open message %u %s%u\n", match,
                        wnd_creation.open_msg >= WM_USER ? "WM_USER+" : "",
                        wnd_creation.open_msg >= WM_USER ? wnd_creation.open_msg - WM_USER : wnd_creation.open_msg);
    ret = SendMessageA(window, MCIWNDM_GETERRORA, sizeof(error), (LPARAM)error);
    ok_(__FILE__, line)(!ret || broken(ret == ERROR_INVALID_HANDLE) /* w2003std, w2008s64 */,
                        "Unexpected error %Id\n", ret);
    DestroyWindow(window);
}

Referenced by test_MCIWndCreate().

Variable Documentation

avi_stream_header

const AVIStreamHeader avi_stream_header

static

Initial value:

=
{
    streamtypeVIDEO, 
    0,               
    0,               
    0,               
    0,               
    0,               
    1,               
    0xf,             
    0,               
    2,               
    0x48,            
    0,               
    0,               
    { 0, 0, 0, 0 }   
}

Definition at line 57 of file mciwnd.c.

Referenced by create_avi_file().

data

const DWORD data[]

static

Initial value:

=
{
    FOURCC_LIST, 0xa4 , listtypeAVIMOVIE,
    mmioFOURCC('0', '0', 'd', 'b'), 0x48, 0x48000000, 0x08000800,
    0x00100100, 0x00003e00, 0x08000000, 0x00200800,
    0x00001600, 0x00000000, 0x00003a00, 0x22e306f9,
    0xfc120000, 0x0a000022, 0x00000000, 0x00300000,
    0x00c01200, 0x00000000, 0x02010000, 0x00000000,
    mmioFOURCC('0', '0', 'd', 'b'), 0x48, 0x48000000, 0x08000800,
    0x00100100, 0x00003e00, 0x08000000, 0x00200800,
    0x00001600, 0x00000000, 0x00003a00, 0x22e306f9,
    0xfc120000, 0x0a000022, 0x00000000, 0x00300000,
    0x00c01200, 0x00000000, 0x02010000, 0x00000000,
    mmioFOURCC('i', 'd', 'x', '1'), 0x20, mmioFOURCC('0', '0', 'd', 'b'), 0x10,
    0x04, 0x48, mmioFOURCC('0', '0', 'd', 'b'), 0x10,
    0x54, 0x48,
}

Definition at line 93 of file mciwnd.c.

expectedA

const char* expectedA

Definition at line 158 of file mciwnd.c.

Referenced by test_DoEnvironmentSubst(), and test_mxwriter_encoding().

expectedW

const WCHAR* expectedW

Definition at line 159 of file mciwnd.c.

Referenced by test_CertGetNameString_value_(), test_DoEnvironmentSubst(), and test_PSStringFromPropertyKey().

file_header

const DWORD file_header[]

static

Initial value:

= 
{
    FOURCC_RIFF, 0x8c0 ,
    formtypeAVI,
    FOURCC_LIST, 0xc0 ,
    listtypeAVIHEADER, ckidAVIMAINHDR, sizeof(MainAVIHeader),
}

Definition at line 28 of file mciwnd.c.

Referenced by create_avi_file(), and create_bitmap().

main_avi_header

const MainAVIHeader main_avi_header

static

Initial value:

=
{
    0x0001046b,    
    0x00000000,    
    0x00000000,    
    0x00000810,    
    2,             
    0,             
    1,             
    0x48,          
    5,             
    5,             
    { 0, 0, 0, 0 } 
}

Definition at line 36 of file mciwnd.c.

Referenced by create_avi_file().

enum { ... } match

Referenced by test_window_create().

old_MCIWndProc

WNDPROC old_MCIWndProc

static

Definition at line 165 of file mciwnd.c.

Referenced by hook_proc(), and proxy_MCIWndProc().

open_msg

unsigned open_msg

Definition at line 161 of file mciwnd.c.

padding

const DWORD padding[]

static

Initial value:

=
{
    ckidAVIPADDING, 0x718 ,
}

Definition at line 88 of file mciwnd.c.

Referenced by _Dispatch_type_(), BCryptDecrypt(), BCryptEncrypt(), BCryptSignHash(), BCryptVerifySignature(), create_avi_file(), empty_image(), emptyImage3D(), fill_image(), fillImage3D(), format_float(), gluBuild2DMipmapLevelsCore(), gluBuild3DMipmapLevelsCore(), key_symmetric_decrypt(), key_symmetric_encrypt(), md5_final(), PropertyStorage_WriteDictionaryToStream(), PropertyStorage_WritePropertyToStream(), PROPSHEET_AdjustButtons(), PROPSHEET_AdjustButtonsWizard(), PROPSHEET_AdjustSize(), PROPSHEET_GetPaddingInfo(), PROPSHEET_GetPaddingInfoWizard(), __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::state_case_type(), streamout(), write_fixed_array_pointer_descriptions(), write_no_repeat_pointer_descriptions(), write_pointer_description_offsets(), write_struct_members(), and write_varying_array_pointer_descriptions().

stream_list

const DWORD stream_list[]

static

Initial value:

=
{
    FOURCC_LIST, 0x74 ,
    listtypeSTREAMHEADER, ckidSTREAMHEADER, 0x38 ,
}

Definition at line 51 of file mciwnd.c.

Referenced by create_avi_file().

video_stream_format

const DWORD video_stream_format[]

static

Initial value:

=
{
    ckidSTREAMFORMAT,
    0x28 ,
    0x28 ,
    5    ,
    5    ,
    0x00180001 ,
    mmioFOURCC('c', 'v', 'i', 'd'),
    0x245a,
    0, 0, 0, 0,
}

Definition at line 75 of file mciwnd.c.

Referenced by create_avi_file().

struct { ... } wnd_creation

Referenced by proxy_MCIWndProc(), and test_window_create().