Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-06-28 00:41:36 +00:00
Code Issues Packages Projects Releases Wiki Activity

Sync avifil32, hnetcfg, initpki, localspl, localui, mciavi32, mciqtz32, mciseq and mlang to Wine 1.1.40

Browse source 
More will come.

svn path=/trunk/; revision=46062
This commit is contained in:
Daniel Reimer 2010-03-10 16:21:22 +00:00
parent 5e3123f80a
commit 94e01c6025
65 changed files with 2124 additions and 512 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
reactos/dll/win32/avifil32/avifile_De.rc
View file

@ -52,4 +52,3 @@ STRINGTABLE DISCARDABLE
IDS_AVIFILETYPE "Wine AVI-Standard-Dateibehandlungsroutine"
IDS_UNCOMPRESSED "Unkomprimiert"
}
#pragma code_page(default)

1
reactos/dll/win32/avifil32/avifile_Fr.rc
View file

@ -57,4 +57,3 @@ STRINGTABLE DISCARDABLE
IDS_AVIFILETYPE "Gestionnaire de fichiers AVI par défaut de Wine"
IDS_UNCOMPRESSED "non compressé"
}
#pragma code_page(default)

2
reactos/dll/win32/avifil32/avifile_Ja.rc
View file

@ -53,5 +53,3 @@ STRINGTABLE DISCARDABLE
IDS_AVIFILETYPE "Wine AVI-default-filehandler"
IDS_UNCOMPRESSED "未圧縮"
}
#pragma code_page(default)

1
reactos/dll/win32/avifil32/avifile_Lt.rc
View file

@ -53,4 +53,3 @@ STRINGTABLE DISCARDABLE
IDS_AVIFILETYPE "Wine numatyta-AVI-doroklė"
IDS_UNCOMPRESSED "neglaudintas"
}
#pragma code_page(default)

1
reactos/dll/win32/avifil32/avifile_Ro.rc
View file

@ -55,4 +55,3 @@ STRINGTABLE DISCARDABLE
IDS_AVIFILETYPE "Tratare implicită Wine pentru AVI"
IDS_UNCOMPRESSED "necomprimat"
}
#pragma code_page(default)

1
reactos/dll/win32/avifil32/avifile_Ru.rc
View file

@ -55,4 +55,3 @@ STRINGTABLE DISCARDABLE
IDS_AVIFILETYPE "Обработчик по умолчанию avi-файлов в Wine"
IDS_UNCOMPRESSED "без сжатия"
}
#pragma code_page(default)

2
reactos/dll/win32/avifil32/avifile_Si.rc
View file

@ -52,5 +52,3 @@ STRINGTABLE DISCARDABLE
IDS_AVIFILETYPE "Wine privzeti-upravljalec-AVI-datotek"
IDS_UNCOMPRESSED "nestisnjeno"
}
#pragma code_page(default)

2
reactos/dll/win32/avifil32/avifile_Tr.rc
View file

@ -16,6 +16,8 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "avifile_private.h"
LANGUAGE LANG_TURKISH, SUBLANG_DEFAULT
IDD_SAVEOPTIONS DIALOG FIXED IMPURE 43, 37, 226, 82

1
reactos/dll/win32/avifil32/avifile_Uk.rc
View file

@ -16,6 +16,7 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "avifile_private.h"
LANGUAGE LANG_UKRAINIAN, SUBLANG_DEFAULT

4
reactos/dll/win32/avifil32/avifile_Zh.rc
View file

@ -18,6 +18,8 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "avifile_private.h"
/* Chinese text is encoded in UTF-8 */
#pragma code_page(65001)
@ -86,5 +88,3 @@ STRINGTABLE DISCARDABLE
IDS_AVIFILETYPE "Wine AVI-默認處理器"
IDS_UNCOMPRESSED "未壓縮"
}
#pragma code_page(default)

16
reactos/dll/win32/avifil32/rsrc.rc
View file

@ -40,23 +40,25 @@ LANGUAGE LANG_NEUTRAL, SUBLANG_NEUTRAL
*/
#include "avifile_Cs.rc"
#include "avifile_Da.rc"
#include "avifile_De.rc"
#include "avifile_En.rc"
#include "avifile_Es.rc"
#include "avifile_Fr.rc"
#include "avifile_Hu.rc"
#include "avifile_It.rc"
#include "avifile_Ja.rc"
#include "avifile_Ko.rc"
#include "avifile_Lt.rc"
#include "avifile_Nl.rc"
#include "avifile_No.rc"
#include "avifile_Pl.rc"
#include "avifile_Pt.rc"
#include "avifile_Ro.rc"
#include "avifile_Ru.rc"
#include "avifile_Si.rc"
#include "avifile_Sv.rc"
#include "avifile_Tr.rc"
#include "avifile_Uk.rc"
/* UTF-8 */
#include "avifile_De.rc"
#include "avifile_Fr.rc"
#include "avifile_Ja.rc"
#include "avifile_Lt.rc"
#include "avifile_Ro.rc"
#include "avifile_Ru.rc"
#include "avifile_Si.rc"
#include "avifile_Zh.rc"

1
reactos/dll/win32/hnetcfg/hnetcfg.c
View file

@ -147,6 +147,5 @@ HRESULT WINAPI DllGetClassObject( REFCLSID rclsid, REFIID iid, LPVOID *ppv )
HRESULT WINAPI DllCanUnloadNow( void )
{
FIXME("\n");
return S_FALSE;
}

2
reactos/dll/win32/hnetcfg/hnetcfg.rbuild
View file

@ -12,6 +12,8 @@
<file>hnetcfg.c</file>
<file>manager.c</file>
<file>policy.c</file>
<file>port.c</file>
<file>profile.c</file>
<file>regsvr.c</file>
<file>service.c</file>
</module>

2
reactos/dll/win32/hnetcfg/hnetcfg_private.h
View file

@ -21,3 +21,5 @@ HRESULT NetFwPolicy_create(IUnknown *, LPVOID *);
HRESULT NetFwProfile_create(IUnknown *, LPVOID *);
HRESULT NetFwAuthorizedApplication_create(IUnknown *, LPVOID *);
HRESULT NetFwAuthorizedApplications_create(IUnknown *, LPVOID *);
HRESULT NetFwOpenPorts_create(IUnknown *, LPVOID *);
HRESULT NetFwServices_create(IUnknown *, LPVOID *);

544
reactos/dll/win32/hnetcfg/port.c Normal file
View file

@ -0,0 +1,544 @@
/*
* Copyright 2009 Hans Leidekker for CodeWeavers
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "config.h"
#include <stdarg.h>
#include <stdio.h>
#define COBJMACROS
#include "windef.h"
#include "winbase.h"
#include "winuser.h"
#include "ole2.h"
#include "netfw.h"
#include "wine/debug.h"
#include "wine/unicode.h"
#include "hnetcfg_private.h"
WINE_DEFAULT_DEBUG_CHANNEL(hnetcfg);
typedef struct fw_port
{
const INetFwOpenPortVtbl *vtbl;
LONG refs;
} fw_port;
static inline fw_port *impl_from_INetFwOpenPort( INetFwOpenPort *iface )
{
return (fw_port *)((char *)iface - FIELD_OFFSET( fw_port, vtbl ));
}
static ULONG WINAPI fw_port_AddRef(
INetFwOpenPort *iface )
{
fw_port *fw_port = impl_from_INetFwOpenPort( iface );
return InterlockedIncrement( &fw_port->refs );
}
static ULONG WINAPI fw_port_Release(
INetFwOpenPort *iface )
{
fw_port *fw_port = impl_from_INetFwOpenPort( iface );
LONG refs = InterlockedDecrement( &fw_port->refs );
if (!refs)
{
TRACE("destroying %p\n", fw_port);
HeapFree( GetProcessHeap(), 0, fw_port );
}
return refs;
}
static HRESULT WINAPI fw_port_QueryInterface(
INetFwOpenPort *iface,
REFIID riid,
void **ppvObject )
{
fw_port *This = impl_from_INetFwOpenPort( iface );
TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
if ( IsEqualGUID( riid, &IID_INetFwOpenPort ) ||
IsEqualGUID( riid, &IID_IDispatch ) ||
IsEqualGUID( riid, &IID_IUnknown ) )
{
*ppvObject = iface;
}
else
{
FIXME("interface %s not implemented\n", debugstr_guid(riid));
return E_NOINTERFACE;
}
INetFwOpenPort_AddRef( iface );
return S_OK;
}
static HRESULT WINAPI fw_port_GetTypeInfoCount(
INetFwOpenPort *iface,
UINT *pctinfo )
{
fw_port *This = impl_from_INetFwOpenPort( iface );
FIXME("%p %p\n", This, pctinfo);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_port_GetTypeInfo(
INetFwOpenPort *iface,
UINT iTInfo,
LCID lcid,
ITypeInfo **ppTInfo )
{
fw_port *This = impl_from_INetFwOpenPort( iface );
FIXME("%p %u %u %p\n", This, iTInfo, lcid, ppTInfo);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_port_GetIDsOfNames(
INetFwOpenPort *iface,
REFIID riid,
LPOLESTR *rgszNames,
UINT cNames,
LCID lcid,
DISPID *rgDispId )
{
fw_port *This = impl_from_INetFwOpenPort( iface );
FIXME("%p %s %p %u %u %p\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_port_Invoke(
INetFwOpenPort *iface,
DISPID dispIdMember,
REFIID riid,
LCID lcid,
WORD wFlags,
DISPPARAMS *pDispParams,
VARIANT *pVarResult,
EXCEPINFO *pExcepInfo,
UINT *puArgErr )
{
fw_port *This = impl_from_INetFwOpenPort( iface );
FIXME("%p %d %s %d %d %p %p %p %p\n", This, dispIdMember, debugstr_guid(riid),
lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_port_get_Name(
INetFwOpenPort *iface,
BSTR *name)
{
fw_port *This = impl_from_INetFwOpenPort( iface );
FIXME("%p %p\n", This, name);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_port_put_Name(
INetFwOpenPort *iface,
BSTR name)
{
fw_port *This = impl_from_INetFwOpenPort( iface );
FIXME("%p %s\n", This, debugstr_w(name));
return E_NOTIMPL;
}
static HRESULT WINAPI fw_port_get_IpVersion(
INetFwOpenPort *iface,
NET_FW_IP_VERSION *ipVersion)
{
fw_port *This = impl_from_INetFwOpenPort( iface );
FIXME("%p %p\n", This, ipVersion);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_port_put_IpVersion(
INetFwOpenPort *iface,
NET_FW_IP_VERSION ipVersion)
{
fw_port *This = impl_from_INetFwOpenPort( iface );
FIXME("%p %u\n", This, ipVersion);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_port_get_Protocol(
INetFwOpenPort *iface,
NET_FW_IP_PROTOCOL *ipProtocol)
{
fw_port *This = impl_from_INetFwOpenPort( iface );
FIXME("%p %p\n", This, ipProtocol);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_port_put_Protocol(
INetFwOpenPort *iface,
NET_FW_IP_PROTOCOL ipProtocol)
{
fw_port *This = impl_from_INetFwOpenPort( iface );
FIXME("%p %u\n", This, ipProtocol);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_port_get_Port(
INetFwOpenPort *iface,
LONG *portNumber)
{
fw_port *This = impl_from_INetFwOpenPort( iface );
FIXME("%p %p\n", This, portNumber);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_port_put_Port(
INetFwOpenPort *iface,
LONG portNumber)
{
fw_port *This = impl_from_INetFwOpenPort( iface );
FIXME("%p %d\n", This, portNumber);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_port_get_Scope(
INetFwOpenPort *iface,
NET_FW_SCOPE *scope)
{
fw_port *This = impl_from_INetFwOpenPort( iface );
FIXME("%p %p\n", This, scope);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_port_put_Scope(
INetFwOpenPort *iface,
NET_FW_SCOPE scope)
{
fw_port *This = impl_from_INetFwOpenPort( iface );
FIXME("%p %u\n", This, scope);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_port_get_RemoteAddresses(
INetFwOpenPort *iface,
BSTR *remoteAddrs)
{
fw_port *This = impl_from_INetFwOpenPort( iface );
FIXME("%p %p\n", This, remoteAddrs);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_port_put_RemoteAddresses(
INetFwOpenPort *iface,
BSTR remoteAddrs)
{
fw_port *This = impl_from_INetFwOpenPort( iface );
FIXME("%p %s\n", This, debugstr_w(remoteAddrs));
return E_NOTIMPL;
}
static HRESULT WINAPI fw_port_get_Enabled(
INetFwOpenPort *iface,
VARIANT_BOOL *enabled)
{
fw_port *This = impl_from_INetFwOpenPort( iface );
FIXME("%p %p\n", This, enabled);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_port_put_Enabled(
INetFwOpenPort *iface,
VARIANT_BOOL enabled)
{
fw_port *This = impl_from_INetFwOpenPort( iface );
FIXME("%p %d\n", This, enabled);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_port_get_BuiltIn(
INetFwOpenPort *iface,
VARIANT_BOOL *builtIn)
{
fw_port *This = impl_from_INetFwOpenPort( iface );
FIXME("%p %p\n", This, builtIn);
return E_NOTIMPL;
}
static const struct INetFwOpenPortVtbl fw_port_vtbl =
{
fw_port_QueryInterface,
fw_port_AddRef,
fw_port_Release,
fw_port_GetTypeInfoCount,
fw_port_GetTypeInfo,
fw_port_GetIDsOfNames,
fw_port_Invoke,
fw_port_get_Name,
fw_port_put_Name,
fw_port_get_IpVersion,
fw_port_put_IpVersion,
fw_port_get_Protocol,
fw_port_put_Protocol,
fw_port_get_Port,
fw_port_put_Port,
fw_port_get_Scope,
fw_port_put_Scope,
fw_port_get_RemoteAddresses,
fw_port_put_RemoteAddresses,
fw_port_get_Enabled,
fw_port_put_Enabled,
fw_port_get_BuiltIn
};
static HRESULT NetFwOpenPort_create( IUnknown *pUnkOuter, LPVOID *ppObj )
{
fw_port *fp;
TRACE("(%p,%p)\n", pUnkOuter, ppObj);
fp = HeapAlloc( GetProcessHeap(), 0, sizeof(*fp) );
if (!fp) return E_OUTOFMEMORY;
fp->vtbl = &fw_port_vtbl;
fp->refs = 1;
*ppObj = &fp->vtbl;
TRACE("returning iface %p\n", *ppObj);
return S_OK;
}
typedef struct fw_ports
{
const INetFwOpenPortsVtbl *vtbl;
LONG refs;
} fw_ports;
static inline fw_ports *impl_from_INetFwOpenPorts( INetFwOpenPorts *iface )
{
return (fw_ports *)((char *)iface - FIELD_OFFSET( fw_ports, vtbl ));
}
static ULONG WINAPI fw_ports_AddRef(
INetFwOpenPorts *iface )
{
fw_ports *fw_ports = impl_from_INetFwOpenPorts( iface );
return InterlockedIncrement( &fw_ports->refs );
}
static ULONG WINAPI fw_ports_Release(
INetFwOpenPorts *iface )
{
fw_ports *fw_ports = impl_from_INetFwOpenPorts( iface );
LONG refs = InterlockedDecrement( &fw_ports->refs );
if (!refs)
{
TRACE("destroying %p\n", fw_ports);
HeapFree( GetProcessHeap(), 0, fw_ports );
}
return refs;
}
static HRESULT WINAPI fw_ports_QueryInterface(
INetFwOpenPorts *iface,
REFIID riid,
void **ppvObject )
{
fw_ports *This = impl_from_INetFwOpenPorts( iface );
TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
if ( IsEqualGUID( riid, &IID_INetFwOpenPorts ) ||
IsEqualGUID( riid, &IID_IDispatch ) ||
IsEqualGUID( riid, &IID_IUnknown ) )
{
*ppvObject = iface;
}
else
{
FIXME("interface %s not implemented\n", debugstr_guid(riid));
return E_NOINTERFACE;
}
INetFwOpenPorts_AddRef( iface );
return S_OK;
}
static HRESULT WINAPI fw_ports_GetTypeInfoCount(
INetFwOpenPorts *iface,
UINT *pctinfo )
{
fw_ports *This = impl_from_INetFwOpenPorts( iface );
FIXME("%p %p\n", This, pctinfo);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_ports_GetTypeInfo(
INetFwOpenPorts *iface,
UINT iTInfo,
LCID lcid,
ITypeInfo **ppTInfo )
{
fw_ports *This = impl_from_INetFwOpenPorts( iface );
FIXME("%p %u %u %p\n", This, iTInfo, lcid, ppTInfo);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_ports_GetIDsOfNames(
INetFwOpenPorts *iface,
REFIID riid,
LPOLESTR *rgszNames,
UINT cNames,
LCID lcid,
DISPID *rgDispId )
{
fw_ports *This = impl_from_INetFwOpenPorts( iface );
FIXME("%p %s %p %u %u %p\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_ports_Invoke(
INetFwOpenPorts *iface,
DISPID dispIdMember,
REFIID riid,
LCID lcid,
WORD wFlags,
DISPPARAMS *pDispParams,
VARIANT *pVarResult,
EXCEPINFO *pExcepInfo,
UINT *puArgErr )
{
fw_ports *This = impl_from_INetFwOpenPorts( iface );
FIXME("%p %d %s %d %d %p %p %p %p\n", This, dispIdMember, debugstr_guid(riid),
lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_ports_get_Count(
INetFwOpenPorts *iface,
LONG *count)
{
fw_ports *This = impl_from_INetFwOpenPorts( iface );
FIXME("%p, %p\n", This, count);
*count = 0;
return S_OK;
}
static HRESULT WINAPI fw_ports_Add(
INetFwOpenPorts *iface,
INetFwOpenPort *port)
{
fw_ports *This = impl_from_INetFwOpenPorts( iface );
FIXME("%p, %p\n", This, port);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_ports_Remove(
INetFwOpenPorts *iface,
LONG portNumber,
NET_FW_IP_PROTOCOL ipProtocol)
{
fw_ports *This = impl_from_INetFwOpenPorts( iface );
FIXME("%p, %d, %u\n", This, portNumber, ipProtocol);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_ports_Item(
INetFwOpenPorts *iface,
LONG portNumber,
NET_FW_IP_PROTOCOL ipProtocol,
INetFwOpenPort **openPort)
{
HRESULT hr;
fw_ports *This = impl_from_INetFwOpenPorts( iface );
FIXME("%p, %d, %u, %p\n", This, portNumber, ipProtocol, openPort);
hr = NetFwOpenPort_create( NULL, (void **)openPort );
if (SUCCEEDED(hr))
{
INetFwOpenPort_put_Protocol( *openPort, ipProtocol );
INetFwOpenPort_put_Port( *openPort, portNumber );
}
return hr;
}
static HRESULT WINAPI fw_ports_get__NewEnum(
INetFwOpenPorts *iface,
IUnknown **newEnum)
{
fw_ports *This = impl_from_INetFwOpenPorts( iface );
FIXME("%p, %p\n", This, newEnum);
return E_NOTIMPL;
}
static const struct INetFwOpenPortsVtbl fw_ports_vtbl =
{
fw_ports_QueryInterface,
fw_ports_AddRef,
fw_ports_Release,
fw_ports_GetTypeInfoCount,
fw_ports_GetTypeInfo,
fw_ports_GetIDsOfNames,
fw_ports_Invoke,
fw_ports_get_Count,
fw_ports_Add,
fw_ports_Remove,
fw_ports_Item,
fw_ports_get__NewEnum
};
HRESULT NetFwOpenPorts_create( IUnknown *pUnkOuter, LPVOID *ppObj )
{
fw_ports *fp;
TRACE("(%p,%p)\n", pUnkOuter, ppObj);
fp = HeapAlloc( GetProcessHeap(), 0, sizeof(*fp) );
if (!fp) return E_OUTOFMEMORY;
fp->vtbl = &fw_ports_vtbl;
fp->refs = 1;
*ppObj = &fp->vtbl;
TRACE("returning iface %p\n", *ppObj);
return S_OK;
}

8
reactos/dll/win32/hnetcfg/profile.c
View file

@ -261,8 +261,8 @@ static HRESULT WINAPI fw_profile_get_GloballyOpenPorts(
{
fw_profile *This = impl_from_INetFwProfile( iface );
FIXME("%p, %p\n", This, openPorts);
return E_NOTIMPL;
TRACE("%p, %p\n", This, openPorts);
return NetFwOpenPorts_create( NULL, (void **)openPorts );
}
static HRESULT WINAPI fw_profile_get_Services(
@ -271,8 +271,8 @@ static HRESULT WINAPI fw_profile_get_Services(
{
fw_profile *This = impl_from_INetFwProfile( iface );
FIXME("%p, %p\n", This, Services);
return E_NOTIMPL;
TRACE("%p, %p\n", This, Services);
return NetFwServices_create( NULL, (void **)Services );
}
static HRESULT WINAPI fw_profile_get_AuthorizedApplications(

4
reactos/dll/win32/hnetcfg/regsvr.c
View file

@ -400,7 +400,7 @@ static struct regsvr_interface const interface_list[] = {
};
/***********************************************************************
* DllRegisterServer (INETCOMM.@)
* DllRegisterServer (HNETCFG.@)
*/
HRESULT WINAPI DllRegisterServer(void)
{
@ -415,7 +415,7 @@ HRESULT WINAPI DllRegisterServer(void)
}
/***********************************************************************
* DllUnregisterServer (INETCOMM.@)
* DllUnregisterServer (HNETCFG.@)
*/
HRESULT WINAPI DllUnregisterServer(void)
{

479
reactos/dll/win32/hnetcfg/service.c Normal file
View file

@ -0,0 +1,479 @@
/*
* Copyright 2009 Hans Leidekker for CodeWeavers
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "config.h"
#include <stdarg.h>
#include <stdio.h>
#define COBJMACROS
#include "windef.h"
#include "winbase.h"
#include "winuser.h"
#include "ole2.h"
#include "netfw.h"
#include "wine/debug.h"
#include "wine/unicode.h"
#include "hnetcfg_private.h"
WINE_DEFAULT_DEBUG_CHANNEL(hnetcfg);
typedef struct fw_service
{
const INetFwServiceVtbl *vtbl;
LONG refs;
} fw_service;
static inline fw_service *impl_from_INetFwService( INetFwService *iface )
{
return (fw_service *)((char *)iface - FIELD_OFFSET( fw_service, vtbl ));
}
static ULONG WINAPI fw_service_AddRef(
INetFwService *iface )
{
fw_service *fw_service = impl_from_INetFwService( iface );
return InterlockedIncrement( &fw_service->refs );
}
static ULONG WINAPI fw_service_Release(
INetFwService *iface )
{
fw_service *fw_service = impl_from_INetFwService( iface );
LONG refs = InterlockedDecrement( &fw_service->refs );
if (!refs)
{
TRACE("destroying %p\n", fw_service);
HeapFree( GetProcessHeap(), 0, fw_service );
}
return refs;
}
static HRESULT WINAPI fw_service_QueryInterface(
INetFwService *iface,
REFIID riid,
void **ppvObject )
{
fw_service *This = impl_from_INetFwService( iface );
TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
if ( IsEqualGUID( riid, &IID_INetFwService ) ||
IsEqualGUID( riid, &IID_IDispatch ) ||
IsEqualGUID( riid, &IID_IUnknown ) )
{
*ppvObject = iface;
}
else
{
FIXME("interface %s not implemented\n", debugstr_guid(riid));
return E_NOINTERFACE;
}
INetFwService_AddRef( iface );
return S_OK;
}
static HRESULT WINAPI fw_service_GetTypeInfoCount(
INetFwService *iface,
UINT *pctinfo )
{
fw_service *This = impl_from_INetFwService( iface );
FIXME("%p %p\n", This, pctinfo);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_service_GetTypeInfo(
INetFwService *iface,
UINT iTInfo,
LCID lcid,
ITypeInfo **ppTInfo )
{
fw_service *This = impl_from_INetFwService( iface );
FIXME("%p %u %u %p\n", This, iTInfo, lcid, ppTInfo);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_service_GetIDsOfNames(
INetFwService *iface,
REFIID riid,
LPOLESTR *rgszNames,
UINT cNames,
LCID lcid,
DISPID *rgDispId )
{
fw_service *This = impl_from_INetFwService( iface );
FIXME("%p %s %p %u %u %p\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_service_Invoke(
INetFwService *iface,
DISPID dispIdMember,
REFIID riid,
LCID lcid,
WORD wFlags,
DISPPARAMS *pDispParams,
VARIANT *pVarResult,
EXCEPINFO *pExcepInfo,
UINT *puArgErr )
{
fw_service *This = impl_from_INetFwService( iface );
FIXME("%p %d %s %d %d %p %p %p %p\n", This, dispIdMember, debugstr_guid(riid),
lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_service_get_Name(
INetFwService *iface,
BSTR *name )
{
fw_service *This = impl_from_INetFwService( iface );
FIXME("%p %p\n", This, name);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_service_get_Type(
INetFwService *iface,
NET_FW_SERVICE_TYPE *type )
{
fw_service *This = impl_from_INetFwService( iface );
FIXME("%p %p\n", This, type);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_service_get_Customized(
INetFwService *iface,
VARIANT_BOOL *customized )
{
fw_service *This = impl_from_INetFwService( iface );
FIXME("%p %p\n", This, customized);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_service_get_IpVersion(
INetFwService *iface,
NET_FW_IP_VERSION *ipVersion )
{
fw_service *This = impl_from_INetFwService( iface );
FIXME("%p %p\n", This, ipVersion);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_service_put_IpVersion(
INetFwService *iface,
NET_FW_IP_VERSION ipVersion )
{
fw_service *This = impl_from_INetFwService( iface );
FIXME("%p %u\n", This, ipVersion);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_service_get_Scope(
INetFwService *iface,
NET_FW_SCOPE *scope )
{
fw_service *This = impl_from_INetFwService( iface );
FIXME("%p %p\n", This, scope);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_service_put_Scope(
INetFwService *iface,
NET_FW_SCOPE scope )
{
fw_service *This = impl_from_INetFwService( iface );
FIXME("%p %u\n", This, scope);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_service_get_RemoteAddresses(
INetFwService *iface,
BSTR *remoteAddrs )
{
fw_service *This = impl_from_INetFwService( iface );
FIXME("%p %p\n", This, remoteAddrs);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_service_put_RemoteAddresses(
INetFwService *iface,
BSTR remoteAddrs )
{
fw_service *This = impl_from_INetFwService( iface );
FIXME("%p %s\n", This, debugstr_w(remoteAddrs));
return E_NOTIMPL;
}
static HRESULT WINAPI fw_service_get_Enabled(
INetFwService *iface,
VARIANT_BOOL *enabled )
{
fw_service *This = impl_from_INetFwService( iface );
FIXME("%p %p\n", This, enabled);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_service_put_Enabled(
INetFwService *iface,
VARIANT_BOOL enabled )
{
fw_service *This = impl_from_INetFwService( iface );
FIXME("%p %d\n", This, enabled);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_service_get_GloballyOpenPorts(
INetFwService *iface,
INetFwOpenPorts **openPorts )
{
fw_service *This = impl_from_INetFwService( iface );
TRACE("%p %p\n", This, openPorts);
return NetFwOpenPorts_create( NULL, (void **)openPorts );
}
static const struct INetFwServiceVtbl fw_service_vtbl =
{
fw_service_QueryInterface,
fw_service_AddRef,
fw_service_Release,
fw_service_GetTypeInfoCount,
fw_service_GetTypeInfo,
fw_service_GetIDsOfNames,
fw_service_Invoke,
fw_service_get_Name,
fw_service_get_Type,
fw_service_get_Customized,
fw_service_get_IpVersion,
fw_service_put_IpVersion,
fw_service_get_Scope,
fw_service_put_Scope,
fw_service_get_RemoteAddresses,
fw_service_put_RemoteAddresses,
fw_service_get_Enabled,
fw_service_put_Enabled,
fw_service_get_GloballyOpenPorts
};
static HRESULT NetFwService_create( IUnknown *pUnkOuter, LPVOID *ppObj )
{
fw_service *fp;
TRACE("(%p,%p)\n", pUnkOuter, ppObj);
fp = HeapAlloc( GetProcessHeap(), 0, sizeof(*fp) );
if (!fp) return E_OUTOFMEMORY;
fp->vtbl = &fw_service_vtbl;
fp->refs = 1;
*ppObj = &fp->vtbl;
TRACE("returning iface %p\n", *ppObj);
return S_OK;
}
typedef struct fw_services
{
const INetFwServicesVtbl *vtbl;
LONG refs;
} fw_services;
static inline fw_services *impl_from_INetFwServices( INetFwServices *iface )
{
return (fw_services *)((char *)iface - FIELD_OFFSET( fw_services, vtbl ));
}
static ULONG WINAPI fw_services_AddRef(
INetFwServices *iface )
{
fw_services *fw_services = impl_from_INetFwServices( iface );
return InterlockedIncrement( &fw_services->refs );
}
static ULONG WINAPI fw_services_Release(
INetFwServices *iface )
{
fw_services *fw_services = impl_from_INetFwServices( iface );
LONG refs = InterlockedDecrement( &fw_services->refs );
if (!refs)
{
TRACE("destroying %p\n", fw_services);
HeapFree( GetProcessHeap(), 0, fw_services );
}
return refs;
}
static HRESULT WINAPI fw_services_QueryInterface(
INetFwServices *iface,
REFIID riid,
void **ppvObject )
{
fw_services *This = impl_from_INetFwServices( iface );
TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
if ( IsEqualGUID( riid, &IID_INetFwServices ) ||
IsEqualGUID( riid, &IID_IDispatch ) ||
IsEqualGUID( riid, &IID_IUnknown ) )
{
*ppvObject = iface;
}
else
{
FIXME("interface %s not implemented\n", debugstr_guid(riid));
return E_NOINTERFACE;
}
INetFwServices_AddRef( iface );
return S_OK;
}
static HRESULT WINAPI fw_services_GetTypeInfoCount(
INetFwServices *iface,
UINT *pctinfo )
{
fw_services *This = impl_from_INetFwServices( iface );
FIXME("%p %p\n", This, pctinfo);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_services_GetTypeInfo(
INetFwServices *iface,
UINT iTInfo,
LCID lcid,
ITypeInfo **ppTInfo )
{
fw_services *This = impl_from_INetFwServices( iface );
FIXME("%p %u %u %p\n", This, iTInfo, lcid, ppTInfo);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_services_GetIDsOfNames(
INetFwServices *iface,
REFIID riid,
LPOLESTR *rgszNames,
UINT cNames,
LCID lcid,
DISPID *rgDispId )
{
fw_services *This = impl_from_INetFwServices( iface );
FIXME("%p %s %p %u %u %p\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_services_Invoke(
INetFwServices *iface,
DISPID dispIdMember,
REFIID riid,
LCID lcid,
WORD wFlags,
DISPPARAMS *pDispParams,
VARIANT *pVarResult,
EXCEPINFO *pExcepInfo,
UINT *puArgErr )
{
fw_services *This = impl_from_INetFwServices( iface );
FIXME("%p %d %s %d %d %p %p %p %p\n", This, dispIdMember, debugstr_guid(riid),
lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_services_get_Count(
INetFwServices *iface,
LONG *count )
{
fw_services *This = impl_from_INetFwServices( iface );
FIXME("%p, %p\n", This, count);
*count = 0;
return S_OK;
}
static HRESULT WINAPI fw_services_Item(
INetFwServices *iface,
NET_FW_SERVICE_TYPE svcType,
INetFwService **service )
{
fw_services *This = impl_from_INetFwServices( iface );
FIXME("%p, %u, %p\n", This, svcType, service);
return NetFwService_create( NULL, (void **)service );
}
static HRESULT WINAPI fw_services_get__NewEnum(
INetFwServices *iface,
IUnknown **newEnum )
{
fw_services *This = impl_from_INetFwServices( iface );
FIXME("%p, %p\n", This, newEnum);
return E_NOTIMPL;
}
static const struct INetFwServicesVtbl fw_services_vtbl =
{
fw_services_QueryInterface,
fw_services_AddRef,
fw_services_Release,
fw_services_GetTypeInfoCount,
fw_services_GetTypeInfo,
fw_services_GetIDsOfNames,
fw_services_Invoke,
fw_services_get_Count,
fw_services_Item,
fw_services_get__NewEnum
};
HRESULT NetFwServices_create( IUnknown *pUnkOuter, LPVOID *ppObj )
{
fw_services *fp;
TRACE("(%p,%p)\n", pUnkOuter, ppObj);
fp = HeapAlloc( GetProcessHeap(), 0, sizeof(*fp) );
if (!fp) return E_OUTOFMEMORY;
fp->vtbl = &fw_services_vtbl;
fp->refs = 1;
*ppObj = &fp->vtbl;
TRACE("returning iface %p\n", *ppObj);
return S_OK;
}

4
reactos/dll/win32/initpki/initpki.spec
View file

@ -1,4 +1,4 @@
@ stub DllInstall
@ stub DllRegisterServer
@ stub DllUnregisterServer
@ stdcall -private DllRegisterServer()
@ stdcall -private DllUnregisterServer()
@ stub InitializePKI

18
reactos/dll/win32/initpki/main.c
View file

@ -44,3 +44,21 @@ BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
}
return TRUE;
}
/*****************************************************
* DllRegisterServer (INITPKI.@)
*/
HRESULT WINAPI DllRegisterServer(void)
{
FIXME("Not implemented.\n");
return E_UNEXPECTED;
}
/*****************************************************
* DllUnregisterServer (INITPKI.@)
*/
HRESULT WINAPI DllUnregisterServer(void)
{
FIXME("Not implemented.\n");
return E_UNEXPECTED;
}

10
reactos/dll/win32/localspl/localspl.rc
View file

@ -36,17 +36,21 @@
#include "wine/wine_common_ver.rc"
#include "spl_En.rc"
#include "spl_Da.rc"
#include "spl_De.rc"
#include "spl_En.rc"
#include "spl_Fr.rc"
#include "spl_Ko.rc"
#include "spl_Nl.rc"
#include "spl_No.rc"
#include "spl_Pl.rc"
#include "spl_Pt.rc"
#include "spl_Sv.rc"
/* UTF-8 */
#include "spl_De.rc"
#include "spl_Es.rc"
#include "spl_Lt.rc"
#include "spl_Ro.rc"
#include "spl_Ru.rc"
#include "spl_Si.rc"
#include "spl_Sv.rc"
#include "spl_Zh.rc"

1
reactos/dll/win32/localspl/localspl_private.h
View file

@ -21,6 +21,7 @@
#ifndef __WINE_LOCALSPL_PRIVATE__
#define __WINE_LOCALSPL_PRIVATE__
#include <windef.h>
/* ## DLL-wide Globals ## */
extern HINSTANCE LOCALSPL_hInstance;

582
reactos/dll/win32/localspl/provider.c
View file

@ -103,14 +103,23 @@ static const WCHAR default_devmodeW[] = {'D','e','f','a','u','l','t',' ','D','e'
static const WCHAR dependent_filesW[] = {'D','e','p','e','n','d','e','n','t',' ','F','i','l','e','s',0};
static const WCHAR descriptionW[] = {'D','e','s','c','r','i','p','t','i','o','n',0};
static const WCHAR driverW[] = {'D','r','i','v','e','r',0};
static const WCHAR emptyW[] = {0};
static const WCHAR fmt_driversW[] = { 'S','y','s','t','e','m','\\',
'C','u', 'r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
'c','o','n','t','r','o','l','\\',
'P','r','i','n','t','\\',
'E','n','v','i','r','o','n','m','e','n','t','s','\\',
'%','s','\\','D','r','i','v','e','r','s','%','s',0 };
static const WCHAR fmt_printprocessorsW[] = { 'S','y','s','t','e','m','\\',
'C','u', 'r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
'C','o','n','t','r','o','l','\\',
'P','r','i','n','t','\\',
'E','n','v','i','r','o','n','m','e','n','t','s','\\','%','s','\\',
'P','r','i','n','t',' ','P','r','o','c','e','s','s','o','r','s',0 };
static const WCHAR hardwareidW[] = {'H','a','r','d','w','a','r','e','I','D',0};
static const WCHAR help_fileW[] = {'H','e','l','p',' ','F','i','l','e',0};
static const WCHAR ia64_envnameW[] = {'W','i','n','d','o','w','s',' ','I','A','6','4',0};
static const WCHAR ia64_subdirW[] = {'i','a','6','4',0};
static const WCHAR localportW[] = {'L','o','c','a','l',' ','P','o','r','t',0};
static const WCHAR locationW[] = {'L','o','c','a','t','i','o','n',0};
static const WCHAR manufacturerW[] = {'M','a','n','u','f','a','c','t','u','r','e','r',0};
@ -132,6 +141,7 @@ static const WCHAR printersW[] = {'S','y','s','t','e','m','\\',
'P','r','i','n','t','\\',
'P','r','i','n','t','e','r','s',0};
static const WCHAR spooldriversW[] = {'\\','s','p','o','o','l','\\','d','r','i','v','e','r','s','\\',0};
static const WCHAR spoolprtprocsW[] = {'\\','s','p','o','o','l','\\','p','r','t','p','r','o','c','s','\\',0};
static const WCHAR version0_regpathW[] = {'\\','V','e','r','s','i','o','n','-','0',0};
static const WCHAR version0_subdirW[] = {'\\','0',0};
static const WCHAR version3_regpathW[] = {'\\','V','e','r','s','i','o','n','-','3',0};
@ -144,6 +154,7 @@ static const WCHAR winnt_cv_portsW[] = {'S','o','f','t','w','a','r','e','\\',
'W','i','n','d','o','w','s',' ','N','T','\\',
'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
'P','o','r','t','s',0};
static const WCHAR winprintW[] = {'w','i','n','p','r','i','n','t',0};
static const WCHAR x64_envnameW[] = {'W','i','n','d','o','w','s',' ','x','6','4',0};
static const WCHAR x64_subdirW[] = {'x','6','4',0};
static const WCHAR x86_envnameW[] = {'W','i','n','d','o','w','s',' ','N','T',' ','x','8','6',0};
@ -152,6 +163,9 @@ static const WCHAR XcvMonitorW[] = {',','X','c','v','M','o','n','i','t','o','r',
static const WCHAR XcvPortW[] = {',','X','c','v','P','o','r','t',' ',0};
static const printenv_t env_ia64 = {ia64_envnameW, ia64_subdirW, 3,
version3_regpathW, version3_subdirW};
static const printenv_t env_x86 = {x86_envnameW, x86_subdirW, 3,
version3_regpathW, version3_subdirW};
@ -161,7 +175,7 @@ static const printenv_t env_x64 = {x64_envnameW, x64_subdirW, 3,
static const printenv_t env_win40 = {win40_envnameW, win40_subdirW, 0,
version0_regpathW, version0_subdirW};
static const printenv_t * const all_printenv[] = {&env_x86, &env_x64, &env_win40};
static const printenv_t * const all_printenv[] = {&env_x86, &env_x64, &env_ia64, &env_win40};
static const DWORD di_sizeof[] = {0, sizeof(DRIVER_INFO_1W), sizeof(DRIVER_INFO_2W),
@ -184,7 +198,7 @@ static LPWSTR strdupW(LPCWSTR p)
if(!p) return NULL;
len = (lstrlenW(p) + 1) * sizeof(WCHAR);
ret = heap_alloc(len);
memcpy(ret, p, len);
if (ret) memcpy(ret, p, len);
return ret;
}
@ -345,7 +359,7 @@ static void monitor_unload(monitor_t * pm)
/******************************************************************
* monitor_unloadall [internal]
*
* release all printmonitors and unload them from memory, when needed
* release all registered printmonitors and unload them from memory, when needed
*
*/
@ -358,7 +372,8 @@ static void monitor_unloadall(void)
/* iterate through the list, with safety against removal */
LIST_FOR_EACH_ENTRY_SAFE(pm, next, &monitor_handles, monitor_t, entry)
{
monitor_unload(pm);
/* skip monitorui dlls */
if (pm->monitor) monitor_unload(pm);
}
LeaveCriticalSection(&monitor_handles_cs);
}
@ -556,6 +571,47 @@ static DWORD monitor_loadall(void)
return loaded;
}
/******************************************************************
* monitor_loadui [internal]
*
* load the userinterface-dll for a given portmonitor
*
* On failure, NULL is returned
*/
static monitor_t * monitor_loadui(monitor_t * pm)
{
monitor_t * pui = NULL;
WCHAR buffer[MAX_PATH];
HANDLE hXcv;
DWORD len;
DWORD res;
if (pm == NULL) return NULL;
TRACE("(%p) => dllname: %s\n", pm, debugstr_w(pm->dllname));
/* Try the Portmonitor first; works for many monitors */
if (pm->monitorUI) {
EnterCriticalSection(&monitor_handles_cs);
pm->refcount++;
LeaveCriticalSection(&monitor_handles_cs);
return pm;
}
/* query the userinterface-dllname from the Portmonitor */
if ((pm->monitor) && (pm->monitor->pfnXcvDataPort)) {
/* building (",XcvMonitor %s",pm->name) not needed yet */
res = pm->monitor->pfnXcvOpenPort(emptyW, SERVER_ACCESS_ADMINISTER, &hXcv);
TRACE("got %u with %p\n", res, hXcv);
if (res) {
res = pm->monitor->pfnXcvDataPort(hXcv, monitorUIW, NULL, 0, (BYTE *) buffer, sizeof(buffer), &len);
TRACE("got %u with %s\n", res, debugstr_w(buffer));
if (res == ERROR_SUCCESS) pui = monitor_load(NULL, buffer);
pm->monitor->pfnXcvClosePort(hXcv);
}
}
return pui;
}
/******************************************************************
* monitor_load_by_port [internal]
*
@ -776,6 +832,92 @@ static DWORD get_local_monitors(DWORD level, LPBYTE pMonitors, DWORD cbBuf, LPDW
return needed;
}
/*****************************************************************************
* enumerate the local print processors (INTERNAL)
*
* returns the needed size (in bytes) for pPPInfo
* and *lpreturned is set to number of entries returned in pPPInfo
*
*/
static DWORD get_local_printprocessors(LPWSTR regpathW, LPBYTE pPPInfo, DWORD cbBuf, LPDWORD lpreturned)
{
HKEY hroot = NULL;
HKEY hentry = NULL;
LPWSTR ptr;
PPRINTPROCESSOR_INFO_1W ppi;
WCHAR buffer[MAX_PATH];
WCHAR dllname[MAX_PATH];
DWORD dllsize;
DWORD len;
DWORD index = 0;
DWORD needed = 0;
DWORD numentries;
numentries = *lpreturned; /* this is 0, when we scan the registry */
len = numentries * sizeof(PRINTPROCESSOR_INFO_1W);
ptr = (LPWSTR) &pPPInfo[len];
numentries = 0;
len = sizeof(buffer)/sizeof(buffer[0]);
buffer[0] = '\0';
if (RegCreateKeyW(HKEY_LOCAL_MACHINE, regpathW, &hroot) == ERROR_SUCCESS) {
/* add "winprint" first */
numentries++;
needed = sizeof(PRINTPROCESSOR_INFO_1W) + sizeof(winprintW);
if (pPPInfo && (cbBuf >= needed)){
ppi = (PPRINTPROCESSOR_INFO_1W) pPPInfo;
pPPInfo += sizeof(PRINTPROCESSOR_INFO_1W);
TRACE("%p: writing PRINTPROCESSOR_INFO_1W #%d\n", ppi, numentries);
ppi->pName = ptr;
lstrcpyW(ptr, winprintW); /* Name of the Print Processor */
ptr += sizeof(winprintW) / sizeof(WCHAR);
}
/* Scan all Printprocessor Keys */
while ((RegEnumKeyExW(hroot, index, buffer, &len, NULL, NULL, NULL, NULL) == ERROR_SUCCESS) &&
(lstrcmpiW(buffer, winprintW) != 0)) {
TRACE("PrintProcessor_%d: %s\n", numentries, debugstr_w(buffer));
dllsize = sizeof(dllname);
dllname[0] = '\0';
/* The Print Processor must have a Driver-DLL */
if (RegOpenKeyExW(hroot, buffer, 0, KEY_READ, &hentry) == ERROR_SUCCESS) {
if (RegQueryValueExW(hentry, driverW, NULL, NULL, (LPBYTE) dllname, &dllsize) == ERROR_SUCCESS) {
/* We found a valid DLL for this Print Processor */
TRACE("using Driver: %s\n", debugstr_w(dllname));
}
RegCloseKey(hentry);
}
if (dllname[0]) {
numentries++;
needed += sizeof(PRINTPROCESSOR_INFO_1W);
needed += (len+1) * sizeof(WCHAR); /* len is lstrlenW(printprocessor name) */
/* required size is calculated. Now fill the user-buffer */
if (pPPInfo && (cbBuf >= needed)){
ppi = (PPRINTPROCESSOR_INFO_1W) pPPInfo;
pPPInfo += sizeof(PRINTPROCESSOR_INFO_1W);
TRACE("%p: writing PRINTPROCESSOR_INFO_1W #%d\n", ppi, numentries);
ppi->pName = ptr;
lstrcpyW(ptr, buffer); /* Name of the Print Processor */
ptr += (len+1); /* len is lstrlenW(printprosessor name) */
}
}
index++;
len = sizeof(buffer)/sizeof(buffer[0]);
buffer[0] = '\0';
}
RegCloseKey(hroot);
}
*lpreturned = numentries;
TRACE("need %d byte for %d entries\n", needed, numentries);
return needed;
}
/******************************************************************
* enumerate the local Ports from all loaded monitors (internal)
*
@ -1152,7 +1294,6 @@ end:
*/
static BOOL myAddPrinterDriverEx(DWORD level, LPBYTE pDriverInfo, DWORD dwFileCopyFlags, BOOL lazy)
{
static const WCHAR emptyW[1];
const printenv_t *env;
apd_data_t apd;
DRIVER_INFO_8W di;
@ -1415,6 +1556,136 @@ static BOOL WINAPI fpAddMonitor(LPWSTR pName, DWORD Level, LPBYTE pMonitors)
return (res);
}
/******************************************************************************
* fpAddPort [exported through PRINTPROVIDOR]
*
* Add a Port for a specific Monitor
*
* PARAMS
* pName [I] Servername or NULL (local Computer)
* hWnd [I] Handle to parent Window for the Dialog-Box
* pMonitorName [I] Name of the Monitor that manage the Port
*
* RETURNS
* Success: TRUE
* Failure: FALSE
*
*/
static BOOL WINAPI fpAddPort(LPWSTR pName, HWND hWnd, LPWSTR pMonitorName)
{
monitor_t * pm;
monitor_t * pui;
LONG lres;
DWORD res;
TRACE("(%s, %p, %s)\n", debugstr_w(pName), hWnd, debugstr_w(pMonitorName));
lres = copy_servername_from_name(pName, NULL);
if (lres) {
FIXME("server %s not supported\n", debugstr_w(pName));
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
/* an empty Monitorname is Invalid */
if (!pMonitorName[0]) {
SetLastError(ERROR_NOT_SUPPORTED);
return FALSE;
}
pm = monitor_load(pMonitorName, NULL);
if (pm && pm->monitor && pm->monitor->pfnAddPort) {
res = pm->monitor->pfnAddPort(pName, hWnd, pMonitorName);
TRACE("got %d with %u (%s)\n", res, GetLastError(), debugstr_w(pm->dllname));
}
else
{
pui = monitor_loadui(pm);
if (pui && pui->monitorUI && pui->monitorUI->pfnAddPortUI) {
res = pui->monitorUI->pfnAddPortUI(pName, hWnd, pMonitorName, NULL);
TRACE("got %d with %u (%s)\n", res, GetLastError(), debugstr_w(pui->dllname));
}
else
{
FIXME("not implemented for %s (monitor %p: %s / monitorui %p: %s)\n",
debugstr_w(pMonitorName), pm, debugstr_w(pm ? pm->dllname : NULL),
pui, debugstr_w(pui ? pui->dllname : NULL));
SetLastError(ERROR_NOT_SUPPORTED);
res = FALSE;
}
monitor_unload(pui);
}
monitor_unload(pm);
TRACE("returning %d with %u\n", res, GetLastError());
return res;
}
/******************************************************************************
* fpAddPortEx [exported through PRINTPROVIDOR]
*
* Add a Port for a specific Monitor, without presenting a user interface
*
* PARAMS
* pName [I] Servername or NULL (local Computer)
* level [I] Structure-Level (1 or 2) for pBuffer
* pBuffer [I] PTR to: PORT_INFO_1 or PORT_INFO_2
* pMonitorName [I] Name of the Monitor that manage the Port
*
* RETURNS
* Success: TRUE
* Failure: FALSE
*
*/
static BOOL WINAPI fpAddPortEx(LPWSTR pName, DWORD level, LPBYTE pBuffer, LPWSTR pMonitorName)
{
PORT_INFO_2W * pi2;
monitor_t * pm;
DWORD lres;
DWORD res;
pi2 = (PORT_INFO_2W *) pBuffer;
TRACE("(%s, %d, %p, %s): %s %s %s\n", debugstr_w(pName), level, pBuffer,
debugstr_w(pMonitorName), debugstr_w(pi2 ? pi2->pPortName : NULL),
debugstr_w(((level > 1) && pi2) ? pi2->pMonitorName : NULL),
debugstr_w(((level > 1) && pi2) ? pi2->pDescription : NULL));
lres = copy_servername_from_name(pName, NULL);
if (lres) {
FIXME("server %s not supported\n", debugstr_w(pName));
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
if ((level < 1) || (level > 2)) {
SetLastError(ERROR_INVALID_LEVEL);
return FALSE;
}
if ((!pi2) || (!pMonitorName) || (!pMonitorName[0])) {
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
/* load the Monitor */
pm = monitor_load(pMonitorName, NULL);
if (pm && pm->monitor && pm->monitor->pfnAddPortEx) {
res = pm->monitor->pfnAddPortEx(pName, level, pBuffer, pMonitorName);
TRACE("got %d with %u (%s)\n", res, GetLastError(), debugstr_w(pm->dllname));
}
else
{
FIXME("not implemented for %s (monitor %p: %s)\n",
debugstr_w(pMonitorName), pm, pm ? debugstr_w(pm->dllname) : NULL);
SetLastError(ERROR_INVALID_PARAMETER);
res = FALSE;
}
monitor_unload(pm);
return res;
}
/******************************************************************************
* fpAddPrinterDriverEx [exported through PRINTPROVIDOR]
*
@ -1476,6 +1747,75 @@ static BOOL WINAPI fpClosePrinter(HANDLE hPrinter)
return FALSE;
}
/******************************************************************************
* fpConfigurePort [exported through PRINTPROVIDOR]
*
* Display the Configuration-Dialog for a specific Port
*
* PARAMS
* pName [I] Servername or NULL (local Computer)
* hWnd [I] Handle to parent Window for the Dialog-Box
* pPortName [I] Name of the Port, that should be configured
*
* RETURNS
* Success: TRUE
* Failure: FALSE
*
*/
static BOOL WINAPI fpConfigurePort(LPWSTR pName, HWND hWnd, LPWSTR pPortName)
{
monitor_t * pm;
monitor_t * pui;
LONG lres;
DWORD res;
TRACE("(%s, %p, %s)\n", debugstr_w(pName), hWnd, debugstr_w(pPortName));
lres = copy_servername_from_name(pName, NULL);
if (lres) {
FIXME("server %s not supported\n", debugstr_w(pName));
SetLastError(ERROR_INVALID_NAME);
return FALSE;
}
/* an empty Portname is Invalid, but can popup a Dialog */
if (!pPortName[0]) {
SetLastError(ERROR_NOT_SUPPORTED);
return FALSE;
}
pm = monitor_load_by_port(pPortName);
if (pm && pm->monitor && pm->monitor->pfnConfigurePort) {
TRACE("use %s for %s (monitor %p: %s)\n", debugstr_w(pm->name),
debugstr_w(pPortName), pm, debugstr_w(pm->dllname));
res = pm->monitor->pfnConfigurePort(pName, hWnd, pPortName);
TRACE("got %d with %u\n", res, GetLastError());
}
else
{
pui = monitor_loadui(pm);
if (pui && pui->monitorUI && pui->monitorUI->pfnConfigurePortUI) {
TRACE("use %s for %s (monitorui %p: %s)\n", debugstr_w(pui->name),
debugstr_w(pPortName), pui, debugstr_w(pui->dllname));
res = pui->monitorUI->pfnConfigurePortUI(pName, hWnd, pPortName);
TRACE("got %d with %u\n", res, GetLastError());
}
else
{
FIXME("not implemented for %s (monitor %p: %s / monitorui %p: %s)\n",
debugstr_w(pPortName), pm, debugstr_w(pm ? pm->dllname : NULL),
pui, debugstr_w(pui ? pui->dllname : NULL));
SetLastError(ERROR_NOT_SUPPORTED);
res = FALSE;
}
monitor_unload(pui);
}
monitor_unload(pm);
TRACE("returning %d with %u\n", res, GetLastError());
return res;
}
/******************************************************************
* fpDeleteMonitor [exported through PRINTPROVIDOR]
@ -1537,6 +1877,76 @@ static BOOL WINAPI fpDeleteMonitor(LPWSTR pName, LPWSTR pEnvironment, LPWSTR pMo
return FALSE;
}
/*****************************************************************************
* fpDeletePort [exported through PRINTPROVIDOR]
*
* Delete a specific Port
*
* PARAMS
* pName [I] Servername or NULL (local Computer)
* hWnd [I] Handle to parent Window for the Dialog-Box
* pPortName [I] Name of the Port, that should be deleted
*
* RETURNS
* Success: TRUE
* Failure: FALSE
*
*/
static BOOL WINAPI fpDeletePort(LPWSTR pName, HWND hWnd, LPWSTR pPortName)
{
monitor_t * pm;
monitor_t * pui;
LONG lres;
DWORD res;
TRACE("(%s, %p, %s)\n", debugstr_w(pName), hWnd, debugstr_w(pPortName));
lres = copy_servername_from_name(pName, NULL);
if (lres) {
FIXME("server %s not supported\n", debugstr_w(pName));
SetLastError(ERROR_INVALID_NAME);
return FALSE;
}
/* an empty Portname is Invalid */
if (!pPortName[0]) {
SetLastError(ERROR_NOT_SUPPORTED);
return FALSE;
}
pm = monitor_load_by_port(pPortName);
if (pm && pm->monitor && pm->monitor->pfnDeletePort) {
TRACE("use %s for %s (monitor %p: %s)\n", debugstr_w(pm->name),
debugstr_w(pPortName), pm, debugstr_w(pm->dllname));
res = pm->monitor->pfnDeletePort(pName, hWnd, pPortName);
TRACE("got %d with %u\n", res, GetLastError());
}
else
{
pui = monitor_loadui(pm);
if (pui && pui->monitorUI && pui->monitorUI->pfnDeletePortUI) {
TRACE("use %s for %s (monitorui %p: %s)\n", debugstr_w(pui->name),
debugstr_w(pPortName), pui, debugstr_w(pui->dllname));
res = pui->monitorUI->pfnDeletePortUI(pName, hWnd, pPortName);
TRACE("got %d with %u\n", res, GetLastError());
}
else
{
FIXME("not implemented for %s (monitor %p: %s / monitorui %p: %s)\n",
debugstr_w(pPortName), pm, debugstr_w(pm ? pm->dllname : NULL),
pui, debugstr_w(pui ? pui->dllname : NULL));
SetLastError(ERROR_NOT_SUPPORTED);
res = FALSE;
}
monitor_unload(pui);
}
monitor_unload(pm);
TRACE("returning %d with %u\n", res, GetLastError());
return res;
}
/*****************************************************************************
* fpEnumMonitors [exported through PRINTPROVIDOR]
*
@ -1689,6 +2099,156 @@ emP_cleanup:
return (res);
}
/*****************************************************************************
* fpEnumPrintProcessors [exported through PRINTPROVIDOR]
*
* Enumerate available Print Processors
*
* PARAMS
* pName [I] Servername or NULL (local Computer)
* pEnvironment [I] Printing-Environment or NULL (Default)
* Level [I] Structure-Level (Only 1 is allowed)
* pPPInfo [O] PTR to Buffer that receives the Result
* cbBuf [I] Size of Buffer at pMonitors
* pcbNeeded [O] PTR to DWORD that receives the size in Bytes used / required for pPPInfo
* pcReturned [O] PTR to DWORD that receives the number of Print Processors in pPPInfo
*
* RETURNS
* Success: TRUE
* Failure: FALSE and in pcbNeeded the Bytes required for pPPInfo, if cbBuf is too small
*
*/
static BOOL WINAPI fpEnumPrintProcessors(LPWSTR pName, LPWSTR pEnvironment, DWORD Level,
LPBYTE pPPInfo, DWORD cbBuf, LPDWORD pcbNeeded, LPDWORD pcReturned)
{
const printenv_t * env;
LPWSTR regpathW = NULL;
DWORD numentries = 0;
DWORD needed = 0;
LONG lres;
BOOL res = FALSE;
TRACE("(%s, %s, %d, %p, %d, %p, %p)\n", debugstr_w(pName), debugstr_w(pEnvironment),
Level, pPPInfo, cbBuf, pcbNeeded, pcReturned);
lres = copy_servername_from_name(pName, NULL);
if (lres) {
FIXME("server %s not supported\n", debugstr_w(pName));
SetLastError(ERROR_INVALID_NAME);
goto epp_cleanup;
}
if (Level != 1) {
SetLastError(ERROR_INVALID_LEVEL);
goto epp_cleanup;
}
env = validate_envW(pEnvironment);
if (!env)
goto epp_cleanup; /* ERROR_INVALID_ENVIRONMENT */
regpathW = heap_alloc(sizeof(fmt_printprocessorsW) +
(lstrlenW(env->envname) * sizeof(WCHAR)));
if (!regpathW)
goto epp_cleanup;
wsprintfW(regpathW, fmt_printprocessorsW, env->envname);
/* Scan all Printprocessor-Keys */
numentries = 0;
needed = get_local_printprocessors(regpathW, NULL, 0, &numentries);
/* we calculated the needed buffersize. now do more error-checks */
if (cbBuf < needed) {
SetLastError(ERROR_INSUFFICIENT_BUFFER);
goto epp_cleanup;
}
/* fill the Buffer with the Printprocessor Infos */
needed = get_local_printprocessors(regpathW, pPPInfo, cbBuf, &numentries);
res = TRUE;
epp_cleanup:
heap_free(regpathW);
if (pcbNeeded) *pcbNeeded = needed;
if (pcReturned) *pcReturned = numentries;
TRACE("returning %d with %d (%d byte for %d entries)\n",
res, GetLastError(), needed, numentries);
return (res);
}
/******************************************************************************
* fpGetPrintProcessorDirectory [exported through PRINTPROVIDOR]
*
* Return the PATH for the Print-Processors
*
* PARAMS
* pName [I] Servername or NULL (this computer)
* pEnvironment [I] Printing-Environment or NULL (Default)
* level [I] Structure-Level (must be 1)
* pPPInfo [O] PTR to Buffer that receives the Result
* cbBuf [I] Size of Buffer at pPPInfo
* pcbNeeded [O] PTR to DWORD that receives the size in Bytes used / required for pPPInfo
*
* RETURNS
* Success: TRUE
* Failure: FALSE and in pcbNeeded the Bytes required for pPPInfo, if cbBuf is too small
*
* Native Values returned in pPPInfo on Success for this computer:
*| NT(Windows x64): "%winsysdir%\\spool\\PRTPROCS\\x64"
*| NT(Windows NT x86): "%winsysdir%\\spool\\PRTPROCS\\w32x86"
*| NT(Windows 4.0): "%winsysdir%\\spool\\PRTPROCS\\win40"
*
* "%winsysdir%" is the Value from GetSystemDirectoryW()
*
*/
static BOOL WINAPI fpGetPrintProcessorDirectory(LPWSTR pName, LPWSTR pEnvironment, DWORD level,
LPBYTE pPPInfo, DWORD cbBuf, LPDWORD pcbNeeded)
{
const printenv_t * env;
DWORD needed;
LONG lres;
TRACE("(%s, %s, %d, %p, %d, %p)\n", debugstr_w(pName), debugstr_w(pEnvironment),
level, pPPInfo, cbBuf, pcbNeeded);
*pcbNeeded = 0;
lres = copy_servername_from_name(pName, NULL);
if (lres) {
FIXME("server %s not supported\n", debugstr_w(pName));
SetLastError(RPC_S_SERVER_UNAVAILABLE);
return FALSE;
}
env = validate_envW(pEnvironment);
if (!env)
return FALSE; /* ERROR_INVALID_ENVIRONMENT */
/* GetSystemDirectoryW returns number of WCHAR including the '\0' */
needed = GetSystemDirectoryW(NULL, 0);
/* add the Size for the Subdirectories */
needed += lstrlenW(spoolprtprocsW);
needed += lstrlenW(env->subdir);
needed *= sizeof(WCHAR); /* return-value is size in Bytes */
*pcbNeeded = needed;
if (needed > cbBuf) {
SetLastError(ERROR_INSUFFICIENT_BUFFER);
return FALSE;
}
GetSystemDirectoryW((LPWSTR) pPPInfo, cbBuf/sizeof(WCHAR));
/* add the Subdirectories */
lstrcatW((LPWSTR) pPPInfo, spoolprtprocsW);
lstrcatW((LPWSTR) pPPInfo, env->subdir);
TRACE("==> %s\n", debugstr_w((LPWSTR) pPPInfo));
return TRUE;
}
/******************************************************************************
* fpOpenPrinter [exported through PRINTPROVIDOR]
*
@ -1812,8 +2372,8 @@ void setup_provider(void)
fpGetPrinterDriverDirectory,
NULL, /* fpDeletePrinterDriver */
NULL, /* fpAddPrintProcessor */
NULL, /* fpEnumPrintProcessors */
NULL, /* fpGetPrintProcessorDirectory */
fpEnumPrintProcessors,
fpGetPrintProcessorDirectory,
NULL, /* fpDeletePrintProcessor */
NULL, /* fpEnumPrintProcessorDatatypes */
NULL, /* fpStartDocPrinter */
@ -1836,9 +2396,9 @@ void setup_provider(void)
NULL, /* fpEnumForms */
fpEnumMonitors,
fpEnumPorts,
NULL, /* fpAddPort */
NULL, /* fpConfigurePort */
NULL, /* fpDeletePort */
fpAddPort,
fpConfigurePort,
fpDeletePort,
NULL, /* fpCreatePrinterIC */
NULL, /* fpPlayGdiScriptOnPrinterIC */
NULL, /* fpDeletePrinterIC */
@ -1851,7 +2411,7 @@ void setup_provider(void)
NULL, /* fpGetPrinterDriverEx */
NULL, /* fpFindFirstPrinterChangeNotification */
NULL, /* fpFindClosePrinterChangeNotification */
NULL, /* fpAddPortEx */
fpAddPortEx,
NULL, /* fpShutDown */
NULL, /* fpRefreshPrinterChangeNotification */
NULL, /* fpOpenPrinterEx */

4
reactos/dll/win32/localspl/spl_Da.rc
View file

@ -18,7 +18,9 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
LANGUAGE LANG_DANISH, SUBLANG_DEFAULT
#include "localspl_private.h"
LANGUAGE LANG_DANISH, SUBLANG_DEFAULT
STRINGTABLE DISCARDABLE
{

4
reactos/dll/win32/localspl/spl_De.rc
View file

@ -19,6 +19,10 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "localspl_private.h"
#pragma code_page(65001)
LANGUAGE LANG_GERMAN, SUBLANG_NEUTRAL
STRINGTABLE DISCARDABLE

2
reactos/dll/win32/localspl/spl_En.rc
View file

@ -19,6 +19,8 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "localspl_private.h"
LANGUAGE LANG_ENGLISH, SUBLANG_DEFAULT
STRINGTABLE DISCARDABLE

32
reactos/dll/win32/localspl/spl_Es.rc Normal file
View file

@ -0,0 +1,32 @@
/*
* Spanish resources for localspl
*
* Copyright 2010 José Manuel Ferrer Ortiz
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "localspl_private.h"
/* UTF-8 */
#pragma code_page(65001)
LANGUAGE LANG_SPANISH, SUBLANG_NEUTRAL
STRINGTABLE DISCARDABLE
{
IDS_LOCALPORT "Puerto local"
IDS_LOCALMONITOR "Monitor local"
}

2
reactos/dll/win32/localspl/spl_Fr.rc
View file

@ -18,6 +18,8 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "localspl_private.h"
LANGUAGE LANG_FRENCH, SUBLANG_NEUTRAL
STRINGTABLE DISCARDABLE

2
reactos/dll/win32/localspl/spl_Ko.rc
View file

@ -20,6 +20,8 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "localspl_private.h"
LANGUAGE LANG_KOREAN, SUBLANG_DEFAULT
STRINGTABLE DISCARDABLE

32
reactos/dll/win32/localspl/spl_Lt.rc Normal file
View file

@ -0,0 +1,32 @@
/*
* Lithuanian resources for localspl
*
* Copyright 2009 Aurimas Fišeras <aurimas@gmail.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "localspl_private.h"
/* UTF-8 */
#pragma code_page(65001)
LANGUAGE LANG_LITHUANIAN, SUBLANG_NEUTRAL
STRINGTABLE DISCARDABLE
{
IDS_LOCALPORT "Vietinis prievadas"
IDS_LOCALMONITOR "Vietinis monitorius"
}

2
reactos/dll/win32/localspl/spl_Nl.rc
View file

@ -18,6 +18,8 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "localspl_private.h"
LANGUAGE LANG_DUTCH, SUBLANG_NEUTRAL
STRINGTABLE DISCARDABLE

2
reactos/dll/win32/localspl/spl_No.rc
View file

@ -18,6 +18,8 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "localspl_private.h"
LANGUAGE LANG_NORWEGIAN, SUBLANG_NORWEGIAN_BOKMAL
STRINGTABLE DISCARDABLE

2
reactos/dll/win32/localspl/spl_Pl.rc
View file

@ -20,6 +20,8 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "localspl_private.h"
LANGUAGE LANG_POLISH, SUBLANG_DEFAULT
STRINGTABLE DISCARDABLE

2
reactos/dll/win32/localspl/spl_Pt.rc
View file

@ -18,6 +18,8 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "localspl_private.h"
LANGUAGE LANG_PORTUGUESE, SUBLANG_NEUTRAL
STRINGTABLE DISCARDABLE

4
reactos/dll/win32/localspl/spl_Ro.rc
View file

@ -18,6 +18,10 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "localspl_private.h"
#pragma code_page(65001)
LANGUAGE LANG_ROMANIAN, SUBLANG_NEUTRAL
STRINGTABLE DISCARDABLE

9
reactos/dll/win32/localspl/spl_Ru.rc
View file

@ -18,10 +18,15 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "localspl_private.h"
/* UTF-8 */
#pragma code_page(65001)
LANGUAGE LANG_RUSSIAN, SUBLANG_DEFAULT
STRINGTABLE DISCARDABLE
{
IDS_LOCALPORT "Локальный порт"
IDS_LOCALMONITOR "Локальный монитор"
IDS_LOCALPORT "Локальный порт"
IDS_LOCALMONITOR "Локальный монитор"
}

4
reactos/dll/win32/localspl/spl_Si.rc
View file

@ -18,6 +18,8 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "localspl_private.h"
#pragma code_page(65001)
LANGUAGE LANG_SLOVENIAN, SUBLANG_DEFAULT
@ -27,5 +29,3 @@ STRINGTABLE DISCARDABLE
IDS_LOCALPORT "Lokalna vrata"
IDS_LOCALMONITOR "Lokalen monitor"
}
#pragma code_page(default)

2
reactos/dll/win32/localspl/spl_Sv.rc
View file

@ -18,6 +18,8 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "localspl_private.h"
LANGUAGE LANG_SWEDISH, SUBLANG_NEUTRAL
STRINGTABLE DISCARDABLE

4
reactos/dll/win32/localspl/spl_Zh.rc
View file

@ -18,6 +18,8 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "localspl_private.h"
/* Chinese text is encoded in UTF-8 */
#pragma code_page(65001)
@ -36,5 +38,3 @@ STRINGTABLE DISCARDABLE
IDS_LOCALPORT "本地端口"
IDS_LOCALMONITOR "本地監視器"
}
#pragma code_page(default)

10
reactos/dll/win32/localui/localui.c
View file

@ -503,7 +503,6 @@ static BOOL WINAPI localui_AddPortUI(PCWSTR pName, HWND hWnd, PCWSTR pMonitorNam
{
addportui_t data;
HANDLE hXcv;
LPWSTR ptr = NULL;
DWORD needed;
DWORD dummy;
DWORD status;
@ -529,14 +528,11 @@ static BOOL WINAPI localui_AddPortUI(PCWSTR pName, HWND hWnd, PCWSTR pMonitorNam
(PBYTE) &dummy, 0, &needed, &status);
TRACE("got %u with status %u\n", res, status);
if (res && (status == ERROR_SUCCESS)) {
if (res && (status == ERROR_SUCCESS) && ppPortName) {
/* Native localui uses GlobalAlloc also.
The caller must GlobalFree the buffer */
ptr = GlobalAlloc(GPTR, (lstrlenW(data.portname)+1) * sizeof(WCHAR));
if (ptr) {
lstrcpyW(ptr, data.portname);
if (ppPortName) *ppPortName = ptr;
}
*ppPortName = GlobalAlloc(GPTR, (lstrlenW(data.portname)+1) * sizeof(WCHAR));
if (*ppPortName) lstrcpyW(*ppPortName, data.portname);
}
if (res && (status == ERROR_ALREADY_EXISTS)) {

2
reactos/dll/win32/localui/localui.h
View file

@ -21,6 +21,8 @@
#ifndef __WINE_LOCALUI__
#define __WINE_LOCALUI__
#include <windef.h>
#include <winuser.h>
/* ## Resource-ID ## */
#define ADDPORT_DIALOG 100

10
reactos/dll/win32/localui/localui.rc
View file

@ -39,17 +39,19 @@
#include "ui_Da.rc"
#include "ui_De.rc"
#include "ui_En.rc"
#include "ui_Fr.rc"
#include "ui_Ko.rc"
#include "ui_Lt.rc"
#include "ui_Nl.rc"
#include "ui_No.rc"
#include "ui_Pl.rc"
#include "ui_Pt.rc"
#include "ui_Sv.rc"
/* UTF-8 */
#include "ui_De.rc"
#include "ui_Fr.rc"
#include "ui_Lt.rc"
#include "ui_Ro.rc"
#include "ui_Ru.rc"
#include "ui_Si.rc"
#include "ui_Sv.rc"
#include "ui_Zh.rc"

2
reactos/dll/win32/localui/ui_Da.rc
View file

@ -18,6 +18,8 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "localui.h"
LANGUAGE LANG_DANISH, SUBLANG_DEFAULT
ADDPORT_DIALOG DIALOG LOADONCALL MOVEABLE DISCARDABLE 6, 18, 245, 47

14
reactos/dll/win32/localui/ui_De.rc
View file

@ -18,14 +18,18 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "localui.h"
#pragma code_page(65001)
LANGUAGE LANG_GERMAN, SUBLANG_NEUTRAL
ADDPORT_DIALOG DIALOG LOADONCALL MOVEABLE DISCARDABLE 6, 18, 245, 47
STYLE DS_CONTEXTHELP | DS_MODALFRAME | DS_SETFONT | DS_SETFOREGROUND | WS_POPUPWINDOW | WS_VISIBLE | WS_CAPTION
CAPTION "Lokalen Anschluss hinzufügen"
CAPTION "Lokalen Anschluss hinzufügen"
FONT 8, "MS Shell Dlg"
BEGIN
LTEXT "&Lokaler Anschuss, der hinzugefügt werden soll:", -1, 7, 13, 194, 13, WS_VISIBLE
LTEXT "&Lokaler Anschuss, der hinzugefügt werden soll:", -1, 7, 13, 194, 13, WS_VISIBLE
EDITTEXT ADDPORT_EDIT, 6, 28, 174, 12, WS_VISIBLE | ES_AUTOHSCROLL
DEFPUSHBUTTON "OK", IDOK, 188, 10, 50, 14, WS_VISIBLE
PUSHBUTTON "Abbrechen", IDCANCEL, 188, 27, 50, 14, WS_VISIBLE
@ -37,8 +41,8 @@ STYLE DS_CONTEXTHELP | DS_MODALFRAME | DS_SETFONT | DS_SETFOREGROUND | WS_POPUPW
CAPTION "LPT-Anschluss konfigurieren"
FONT 8, "MS Shell Dlg"
BEGIN
GROUPBOX "Zeitüberschreitung (Sekunden)", LPTCONFIG_GROUP, 6, 6, 150, 35, BS_GROUPBOX
LTEXT "Ü&bertragung wiederholen:", -1, 14, 22, 90, 13, WS_VISIBLE
GROUPBOX "Zeitüberschreitung (Sekunden)", LPTCONFIG_GROUP, 6, 6, 150, 35, BS_GROUPBOX
LTEXT "Ü&bertragung wiederholen:", -1, 14, 22, 90, 13, WS_VISIBLE
EDITTEXT LPTCONFIG_EDIT, 112, 20, 32, 13, WS_VISIBLE | ES_NUMBER
DEFPUSHBUTTON "OK", IDOK, 164, 10, 50, 14, WS_VISIBLE
PUSHBUTTON "Abbrechen", IDCANCEL, 164, 27, 50, 14, WS_VISIBLE
@ -48,7 +52,7 @@ END
STRINGTABLE DISCARDABLE
{
IDS_LOCALPORT "Lokaler Anschluss"
IDS_INVALIDNAME "'%s' ist kein gültiger Anschlussname"
IDS_INVALIDNAME "'%s' ist kein gültiger Anschlussname"
IDS_PORTEXISTS "Der Anschluss %s existiert bereits"
IDS_NOTHINGTOCONFIG "Dieser Anschluss hat keine Optionen zum Konfigurieren"
}

2
reactos/dll/win32/localui/ui_En.rc
View file

@ -18,6 +18,8 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "localui.h"
LANGUAGE LANG_ENGLISH, SUBLANG_DEFAULT
ADDPORT_DIALOG DIALOG LOADONCALL MOVEABLE DISCARDABLE 6, 18, 245, 47

5
reactos/dll/win32/localui/ui_Fr.rc
View file

@ -17,6 +17,9 @@
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "localui.h"
#pragma code_page(65001)
LANGUAGE LANG_FRENCH, SUBLANG_NEUTRAL
@ -53,5 +56,3 @@ STRINGTABLE DISCARDABLE
IDS_PORTEXISTS "Le port %s existe déjà"
IDS_NOTHINGTOCONFIG "Ce port n'a pas d'options de configuration"
}
#pragma code_page(default)

2
reactos/dll/win32/localui/ui_Ko.rc
View file

@ -19,6 +19,8 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "localui.h"
LANGUAGE LANG_KOREAN, SUBLANG_DEFAULT
ADDPORT_DIALOG DIALOG LOADONCALL MOVEABLE DISCARDABLE 6, 18, 245, 47

3
reactos/dll/win32/localui/ui_Lt.rc
View file

@ -53,8 +53,7 @@ END
STRINGTABLE DISCARDABLE
{
IDS_LOCALPORT "Vietinis prievadas"
IDS_INVALIDNAME "'%s' yra netinkamas prievado vardas"
IDS_INVALIDNAME "„%s“ yra netinkamas prievado vardas"
IDS_PORTEXISTS "Prievadas %s jau egzistuoja"
IDS_NOTHINGTOCONFIG "Šis prievadas neturi parinkčių konfigūravimui"
}
#pragma code_page(default)

2
reactos/dll/win32/localui/ui_Nl.rc
View file

@ -18,6 +18,8 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "localui.h"
LANGUAGE LANG_DUTCH, SUBLANG_NEUTRAL
ADDPORT_DIALOG DIALOG LOADONCALL MOVEABLE DISCARDABLE 6, 18, 245, 47

2
reactos/dll/win32/localui/ui_No.rc
View file

@ -18,6 +18,8 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "localui.h"
LANGUAGE LANG_NORWEGIAN, SUBLANG_NORWEGIAN_BOKMAL
ADDPORT_DIALOG DIALOG LOADONCALL MOVEABLE DISCARDABLE 6, 18, 245, 47

2
reactos/dll/win32/localui/ui_Pl.rc
View file

@ -19,6 +19,8 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "localui.h"
LANGUAGE LANG_POLISH, SUBLANG_DEFAULT
ADDPORT_DIALOG DIALOG LOADONCALL MOVEABLE DISCARDABLE 6, 18, 245, 47

2
reactos/dll/win32/localui/ui_Pt.rc
View file

@ -18,6 +18,8 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "localui.h"
LANGUAGE LANG_PORTUGUESE, SUBLANG_NEUTRAL
ADDPORT_DIALOG DIALOG LOADONCALL MOVEABLE DISCARDABLE 6, 18, 245, 47

4
reactos/dll/win32/localui/ui_Ro.rc
View file

@ -17,6 +17,8 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "localui.h"
LANGUAGE LANG_ROMANIAN, SUBLANG_NEUTRAL
#pragma code_page(65001)
@ -53,5 +55,3 @@ STRINGTABLE DISCARDABLE
IDS_PORTEXISTS "Portul %s existsă deja"
IDS_NOTHINGTOCONFIG "Acest port nu are opțiuni de configurat"
}
#pragma code_page(default)

27
reactos/dll/win32/localui/ui_Ru.rc
View file

@ -18,37 +18,42 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "localui.h"
/* UTF-8 */
#pragma code_page(65001)
LANGUAGE LANG_RUSSIAN, SUBLANG_DEFAULT
ADDPORT_DIALOG DIALOG LOADONCALL MOVEABLE DISCARDABLE 6, 18, 245, 47
STYLE DS_CONTEXTHELP | DS_MODALFRAME | DS_SETFONT | DS_SETFOREGROUND | WS_POPUPWINDOW | WS_VISIBLE | WS_CAPTION
CAPTION "Добавить локальный порт"
CAPTION "Добавить локальный порт"
FONT 8, "MS Shell Dlg"
BEGIN
LTEXT "Введите &название локального порта:", -1, 7, 13, 194, 13, WS_VISIBLE
LTEXT "Введите &название локального порта:", -1, 7, 13, 194, 13, WS_VISIBLE
EDITTEXT ADDPORT_EDIT, 6, 28, 174, 12, WS_VISIBLE | ES_AUTOHSCROLL
DEFPUSHBUTTON "OK", IDOK, 199, 10, 40, 14, WS_VISIBLE
PUSHBUTTON "Отменить", IDCANCEL, 199, 27, 40, 14, WS_VISIBLE
PUSHBUTTON "Отменить", IDCANCEL, 199, 27, 40, 14, WS_VISIBLE
END
LPTCONFIG_DIALOG DIALOG LOADONCALL MOVEABLE DISCARDABLE 6, 18, 220, 47
STYLE DS_CONTEXTHELP | DS_MODALFRAME | DS_SETFONT | DS_SETFOREGROUND | WS_POPUPWINDOW | WS_VISIBLE | WS_CAPTION
CAPTION "Установки параллельного порта"
CAPTION "Установки параллельного порта"
FONT 8, "MS Shell Dlg"
BEGIN
GROUPBOX "Тайм-аут (секунд)", LPTCONFIG_GROUP, 6, 6, 150, 35, BS_GROUPBOX
LTEXT "&Попыток пересылки:", -1, 14, 22, 90, 13, WS_VISIBLE
GROUPBOX "Тайм-аут (секунд)", LPTCONFIG_GROUP, 6, 6, 150, 35, BS_GROUPBOX
LTEXT "&Попыток пересылки:", -1, 14, 22, 90, 13, WS_VISIBLE
EDITTEXT LPTCONFIG_EDIT, 112, 20, 32, 13, WS_VISIBLE | ES_NUMBER
DEFPUSHBUTTON "OK", IDOK, 164, 10, 50, 14, WS_VISIBLE
PUSHBUTTON "Отмена", IDCANCEL, 164, 27, 50, 14, WS_VISIBLE
PUSHBUTTON "Отмена", IDCANCEL, 164, 27, 50, 14, WS_VISIBLE
END
STRINGTABLE DISCARDABLE
{
IDS_LOCALPORT "Локальный порт"
IDS_INVALIDNAME "Не правильное название порта '%s'"
IDS_PORTEXISTS "Порт '%s' уже существует"
IDS_NOTHINGTOCONFIG "Этот порт не имеет настроек"
IDS_LOCALPORT "Локальный порт"
IDS_INVALIDNAME "Не правильное название порта '%s'"
IDS_PORTEXISTS "Порт '%s' уже существует"
IDS_NOTHINGTOCONFIG "Этот порт не имеет настроек"
}

4
reactos/dll/win32/localui/ui_Si.rc
View file

@ -18,6 +18,8 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "localui.h"
#pragma code_page(65001)
LANGUAGE LANG_SLOVENIAN, SUBLANG_DEFAULT
@ -54,5 +56,3 @@ STRINGTABLE DISCARDABLE
IDS_PORTEXISTS "Vrata z imenom %s že obstajajo"
IDS_NOTHINGTOCONFIG "Ta vrata nimajo možnosti nastavitve"
}
#pragma code_page(default)

2
reactos/dll/win32/localui/ui_Sv.rc
View file

@ -18,6 +18,8 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "localui.h"
LANGUAGE LANG_SWEDISH, SUBLANG_NEUTRAL
ADDPORT_DIALOG DIALOG LOADONCALL MOVEABLE DISCARDABLE 6, 18, 245, 47

4
reactos/dll/win32/localui/ui_Zh.rc
View file

@ -18,6 +18,8 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "localui.h"
/* Chinese text is encoded in UTF-8 */
#pragma code_page(65001)
@ -90,5 +92,3 @@ STRINGTABLE DISCARDABLE
IDS_PORTEXISTS "端口 %s 已經存在"
IDS_NOTHINGTOCONFIG "這個端口沒有可設定選項"
}
#pragma code_page(default)

136
reactos/dll/win32/mciavi32/info.c
View file

@ -80,6 +80,8 @@ DWORD MCIAVI_mciGetDevCaps(UINT wDevID, DWORD dwFlags, LPMCI_GETDEVCAPS_PARMS l
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
if (!(dwFlags & MCI_GETDEVCAPS_ITEM)) return MCIERR_MISSING_PARAMETER;
if (dwFlags & MCI_TEST) return 0;
EnterCriticalSection(&wma->cs);
@ -130,14 +132,52 @@ DWORD MCIAVI_mciGetDevCaps(UINT wDevID, DWORD dwFlags, LPMCI_GETDEVCAPS_PARMS l
lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
ret = MCI_RESOURCE_RETURNED;
break;
case MCI_DGV_GETDEVCAPS_CAN_REVERSE:
TRACE("MCI_DGV_GETDEVCAPS_CAN_REVERSE !\n");
lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE); /* FIXME */
ret = MCI_RESOURCE_RETURNED;
break;
case MCI_DGV_GETDEVCAPS_CAN_STRETCH:
TRACE("MCI_DGV_GETDEVCAPS_CAN_STRETCH !\n");
lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE); /* FIXME */
ret = MCI_RESOURCE_RETURNED;
break;
case MCI_DGV_GETDEVCAPS_CAN_LOCK:
TRACE("MCI_DGV_GETDEVCAPS_CAN_LOCK !\n");
lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
ret = MCI_RESOURCE_RETURNED;
break;
case MCI_DGV_GETDEVCAPS_CAN_FREEZE:
TRACE("MCI_DGV_GETDEVCAPS_CAN_FREEZE !\n");
lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
ret = MCI_RESOURCE_RETURNED;
break;
case MCI_DGV_GETDEVCAPS_CAN_STR_IN:
TRACE("MCI_DGV_GETDEVCAPS_CAN_STRETCH_INPUT !\n");
lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
ret = MCI_RESOURCE_RETURNED;
break;
case MCI_DGV_GETDEVCAPS_HAS_STILL:
TRACE("MCI_DGV_GETDEVCAPS_HAS_STILL !\n");
lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
ret = MCI_RESOURCE_RETURNED;
break;
case MCI_DGV_GETDEVCAPS_CAN_TEST:
TRACE("MCI_DGV_GETDEVCAPS_CAN_TEST !\n");
lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
ret = MCI_RESOURCE_RETURNED;
break;
case MCI_DGV_GETDEVCAPS_PALETTES:
TRACE("MCI_DGV_GETDEVCAPS_PALETTES !\n");
lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE); /* FIXME */
ret = MCI_RESOURCE_RETURNED;
break;
/* w2k does not know MAX_WINDOWS or MAX/MINIMUM_RATE */
default:
FIXME("Unknown capability (%08x) !\n", lpParms->dwItem);
ret = MCIERR_UNRECOGNIZED_COMMAND;
ret = MCIERR_UNSUPPORTED_FUNCTION;
break;
}
} else {
WARN("No GetDevCaps-Item !\n");
ret = MCIERR_UNRECOGNIZED_COMMAND;
}
LeaveCriticalSection(&wma->cs);
@ -157,6 +197,7 @@ DWORD MCIAVI_mciInfo(UINT wDevID, DWORD dwFlags, LPMCI_DGV_INFO_PARMSW lpParms)
if (lpParms == NULL || lpParms->lpstrReturn == NULL)
return MCIERR_NULL_PARAMETER_BLOCK;
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
if (dwFlags & MCI_TEST) return 0;
TRACE("buf=%p, len=%u\n", lpParms->lpstrReturn, lpParms->dwRetSize);
@ -193,6 +234,7 @@ DWORD MCIAVI_mciSet(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SET_PARMS lpParms)
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
if (dwFlags & MCI_TEST) return 0;
EnterCriticalSection(&wma->cs);
@ -329,6 +371,8 @@ DWORD MCIAVI_mciStatus(UINT wDevID, DWORD dwFlags, LPMCI_DGV_STATUS_PARMSW lpPar
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
if (!(dwFlags & MCI_STATUS_ITEM)) return MCIERR_MISSING_PARAMETER;
if (dwFlags & MCI_TEST) return 0;
EnterCriticalSection(&wma->cs);
@ -387,22 +431,28 @@ DWORD MCIAVI_mciStatus(UINT wDevID, DWORD dwFlags, LPMCI_DGV_STATUS_PARMSW lpPar
TRACE("MCI_STATUS_TIME_FORMAT => %u\n", LOWORD(lpParms->dwReturn));
ret = MCI_RESOURCE_RETURNED;
break;
case MCI_DGV_STATUS_AUDIO:
lpParms->dwReturn = (wma->dwSet & 3) ?
MAKEMCIRESOURCE(MCI_ON, MCI_ON_S) : MAKEMCIRESOURCE(MCI_OFF, MCI_OFF_S);
ret = MCI_RESOURCE_RETURNED|MCI_RESOURCE_DRIVER;
TRACE("MCI_STATUS_AUDIO = %u\n", LOWORD(lpParms->dwReturn));
break;
case MCI_DGV_STATUS_VIDEO:
lpParms->dwReturn = (wma->dwSet & 4) ?
MAKEMCIRESOURCE(MCI_ON, MCI_ON_S) : MAKEMCIRESOURCE(MCI_OFF, MCI_OFF_S);
ret = MCI_RESOURCE_RETURNED|MCI_RESOURCE_DRIVER;
TRACE("MCI_STATUS_VIDEO = %u\n", LOWORD(lpParms->dwReturn));
break;
#if 0
case MCI_AVI_STATUS_AUDIO_BREAKS:
case MCI_AVI_STATUS_FRAMES_SKIPPED:
case MCI_AVI_STATUS_LAST_PLAY_SPEED:
case MCI_DGV_STATUS_AUDIO:
case MCI_DGV_STATUS_AUDIO_INPUT:
case MCI_DGV_STATUS_AUDIO_RECORD:
case MCI_DGV_STATUS_AUDIO_SOURCE:
case MCI_DGV_SETAUDIO_AVERAGE:
case MCI_DGV_SETAUDIO_LEFT:
case MCI_DGV_SETAUDIO_RIGHT:
case MCI_DGV_SETAUDIO_STEREO:
case MCI_DGV_STATUS_AUDIO_STREAM:
case MCI_DGV_STATUS_AVGBYTESPERSEC:
case MCI_DGV_STATUS_BASS:
case MCI_DGV_STATUS_BITSPERPEL:
case MCI_DGV_STATUS_BITSPERSAMPLE:
case MCI_DGV_STATUS_BLOCKALIGN:
case MCI_DGV_STATUS_BRIGHTNESS:
@ -411,10 +461,12 @@ DWORD MCIAVI_mciStatus(UINT wDevID, DWORD dwFlags, LPMCI_DGV_STATUS_PARMSW lpPar
case MCI_DGV_STATUS_FILEFORMAT:
case MCI_DGV_STATUS_FILE_MODE:
case MCI_DGV_STATUS_FILE_COMPLETION:
case MCI_DGV_STATUS_FORWARD:
case MCI_DGV_STATUS_FRAME_RATE:
case MCI_DGV_STATUS_GAMMA:
#endif
case MCI_DGV_STATUS_BITSPERPEL:
lpParms->dwReturn = wma->inbih->biBitCount;
TRACE("MCI_DGV_STATUS_BITSPERPEL => %lu\n", lpParms->dwReturn);
break;
case MCI_DGV_STATUS_HPAL:
lpParms->dwReturn = 0;
TRACE("MCI_DGV_STATUS_HPAL => %lx\n", lpParms->dwReturn);
@ -422,7 +474,52 @@ DWORD MCIAVI_mciStatus(UINT wDevID, DWORD dwFlags, LPMCI_DGV_STATUS_PARMSW lpPar
case MCI_DGV_STATUS_HWND:
lpParms->dwReturn = (DWORD_PTR)wma->hWndPaint;
TRACE("MCI_DGV_STATUS_HWND => %p\n", wma->hWndPaint);
break;
case MCI_DGV_STATUS_WINDOW_VISIBLE:
lpParms->dwReturn = IsWindowVisible(wma->hWndPaint) ?
MAKEMCIRESOURCE(TRUE, MCI_TRUE) : MAKEMCIRESOURCE(FALSE, MCI_FALSE);
ret = MCI_RESOURCE_RETURNED;
TRACE("MCI_STATUS_WINDOW_VISIBLE = %u\n", LOWORD(lpParms->dwReturn));
break;
case MCI_DGV_STATUS_WINDOW_MINIMIZED:
lpParms->dwReturn = IsIconic(wma->hWndPaint) ?
MAKEMCIRESOURCE(TRUE, MCI_TRUE) : MAKEMCIRESOURCE(FALSE, MCI_FALSE);
ret = MCI_RESOURCE_RETURNED;
TRACE("MCI_STATUS_WINDOW_MINIMIZED = %u\n", LOWORD(lpParms->dwReturn));
break;
case MCI_DGV_STATUS_WINDOW_MAXIMIZED:
lpParms->dwReturn = IsZoomed(wma->hWndPaint) ?
MAKEMCIRESOURCE(TRUE, MCI_TRUE) : MAKEMCIRESOURCE(FALSE, MCI_FALSE);
ret = MCI_RESOURCE_RETURNED;
TRACE("MCI_STATUS_WINDOW_MMAXIMIZED = %u\n", LOWORD(lpParms->dwReturn));
break;
case MCI_DGV_STATUS_SPEED:
lpParms->dwReturn = 1000;
TRACE("MCI_DGV_STATUS_SPEED = %lu\n", lpParms->dwReturn);
break;
case MCI_DGV_STATUS_FRAME_RATE:
/* FIXME: 1000 is a settable speed multiplier */
lpParms->dwReturn = MulDiv(1000000,1000,wma->mah.dwMicroSecPerFrame);
TRACE("MCI_DGV_STATUS_FRAME_RATE = %lu\n", lpParms->dwReturn);
break;
case MCI_DGV_STATUS_FORWARD:
lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
ret = MCI_RESOURCE_RETURNED;
TRACE("MCI_DGV_STATUS_FORWARD = %u\n", LOWORD(lpParms->dwReturn));
break;
case MCI_DGV_STATUS_PAUSE_MODE:
if (wma->dwStatus != MCI_MODE_PAUSE) {
LeaveCriticalSection(&wma->cs);
return MCIERR_NONAPPLICABLE_FUNCTION;
}
lpParms->dwReturn = MAKEMCIRESOURCE(MCI_MODE_PLAY, MCI_MODE_PLAY);
ret = MCI_RESOURCE_RETURNED;
TRACE("MCI_STATUS_MODE => 0x%04x\n", LOWORD(lpParms->dwReturn));
break;
case MCI_DGV_STATUS_AUDIO_STREAM:
lpParms->dwReturn = wma->audio_stream_n;
TRACE("MCI_DGV_STATUS_AUDIO_STREAM => %lu\n", lpParms->dwReturn);
break;
#if 0
case MCI_DGV_STATUS_KEY_COLOR:
case MCI_DGV_STATUS_KEY_INDEX:
@ -430,38 +527,27 @@ DWORD MCIAVI_mciStatus(UINT wDevID, DWORD dwFlags, LPMCI_DGV_STATUS_PARMSW lpPar
case MCI_DGV_MONITOR_FILE:
case MCI_DGV_MONITOR_INPUT:
case MCI_DGV_STATUS_MONITOR_METHOD:
case MCI_DGV_STATUS_PAUSE_MODE:
case MCI_DGV_STATUS_SAMPLESPERSECOND:
case MCI_DGV_STATUS_SEEK_EXACTLY:
case MCI_DGV_STATUS_SHARPNESS:
case MCI_DGV_STATUS_SIZE:
case MCI_DGV_STATUS_SMPTE:
case MCI_DGV_STATUS_SPEED:
case MCI_DGV_STATUS_STILL_FILEFORMAT:
case MCI_DGV_STATUS_TINT:
case MCI_DGV_STATUS_TREBLE:
case MCI_DGV_STATUS_UNSAVED:
case MCI_DGV_STATUS_VIDEO:
case MCI_DGV_STATUS_VIDEO_RECORD:
case MCI_DGV_STATUS_VIDEO_SOURCE:
case MCI_DGV_STATUS_VIDEO_SRC_NUM:
case MCI_DGV_STATUS_VIDEO_STREAM:
case MCI_DGV_STATUS_VOLUME:
case MCI_DGV_STATUS_WINDOW_VISIBLE:
case MCI_DGV_STATUS_WINDOW_MINIMIZED:
case MCI_DGV_STATUS_WINDOW_MAXIMIZED:
case MCI_STATUS_MEDIA_PRESENT:
#endif
default:
FIXME("Unknown command %08X !\n", lpParms->dwItem);
TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
LeaveCriticalSection(&wma->cs);
return MCIERR_UNRECOGNIZED_COMMAND;
return MCIERR_UNSUPPORTED_FUNCTION;
}
} else {
WARN("No Status-Item!\n");
LeaveCriticalSection(&wma->cs);
return MCIERR_UNRECOGNIZED_COMMAND;
}
if (dwFlags & MCI_NOTIFY) {

478
reactos/dll/win32/mciavi32/mciavi.c
View file

@ -217,8 +217,6 @@ static DWORD MCIAVI_mciOpen(UINT wDevID, DWORD dwFlags,
TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpOpenParms);
MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
if (lpOpenParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
wma = (WINE_MCIAVI *)mciGetDriverData(wDevID);
@ -250,29 +248,26 @@ static DWORD MCIAVI_mciOpen(UINT wDevID, DWORD dwFlags,
* contains the hFile value ?
*/
dwRet = MCIERR_UNRECOGNIZED_COMMAND;
} else if (strlenW(lpOpenParms->lpstrElementName) > 0) {
} else if (lpOpenParms->lpstrElementName && lpOpenParms->lpstrElementName[0]) {
/* FIXME : what should be done id wma->hFile is already != 0, or the driver is playin' */
TRACE("MCI_OPEN_ELEMENT %s!\n", debugstr_w(lpOpenParms->lpstrElementName));
if (lpOpenParms->lpstrElementName && (strlenW(lpOpenParms->lpstrElementName) > 0))
{
wma->lpFileName = HeapAlloc(GetProcessHeap(), 0, (strlenW(lpOpenParms->lpstrElementName) + 1) * sizeof(WCHAR));
strcpyW(wma->lpFileName, lpOpenParms->lpstrElementName);
wma->lpFileName = HeapAlloc(GetProcessHeap(), 0, (strlenW(lpOpenParms->lpstrElementName) + 1) * sizeof(WCHAR));
strcpyW(wma->lpFileName, lpOpenParms->lpstrElementName);
wma->hFile = mmioOpenW(lpOpenParms->lpstrElementName, NULL,
MMIO_ALLOCBUF | MMIO_DENYWRITE | MMIO_READ);
wma->hFile = mmioOpenW(lpOpenParms->lpstrElementName, NULL,
MMIO_ALLOCBUF | MMIO_DENYWRITE | MMIO_READ);
if (wma->hFile == 0) {
WARN("can't find file=%s!\n", debugstr_w(lpOpenParms->lpstrElementName));
dwRet = MCIERR_FILE_NOT_FOUND;
} else {
if (!MCIAVI_GetInfo(wma))
dwRet = MCIERR_INVALID_FILE;
else if (!MCIAVI_OpenVideo(wma))
dwRet = MCIERR_CANNOT_LOAD_DRIVER;
else if (!MCIAVI_CreateWindow(wma, dwFlags, lpOpenParms))
dwRet = MCIERR_CREATEWINDOW;
}
if (wma->hFile == 0) {
WARN("can't find file=%s!\n", debugstr_w(lpOpenParms->lpstrElementName));
dwRet = MCIERR_FILE_NOT_FOUND;
} else {
if (!MCIAVI_GetInfo(wma))
dwRet = MCIERR_INVALID_FILE;
else if (!MCIAVI_OpenVideo(wma))
dwRet = MCIERR_CANNOT_LOAD_DRIVER;
else if (!MCIAVI_CreateWindow(wma, dwFlags, lpOpenParms))
dwRet = MCIERR_CREATEWINDOW;
}
} else {
FIXME("Don't record yet\n");
@ -303,8 +298,6 @@ DWORD MCIAVI_mciClose(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
wma = MCIAVI_mciGetOpenDev(wDevID);
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
@ -390,13 +383,13 @@ static DWORD MCIAVI_mciPlay_async(WINE_MCIAVI *wma, DWORD dwFlags, LPMCI_PLAY_PA
static DWORD MCIAVI_mciPlay(UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms)
{
WINE_MCIAVI *wma;
DWORD tc;
DWORD frameTime;
DWORD delta;
DWORD dwRet;
LPWAVEHDR waveHdr = NULL;
unsigned i, nHdr = 0;
DWORD dwFromFrame, dwToFrame;
DWORD numEvents = 1;
HANDLE events[2];
TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
@ -404,6 +397,8 @@ static DWORD MCIAVI_mciPlay(UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms
wma = MCIAVI_mciGetOpenDev(wDevID);
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
if (dwFlags & MCI_DGV_PLAY_REVERSE) return MCIERR_UNSUPPORTED_FUNCTION;
if (dwFlags & MCI_TEST) return 0;
EnterCriticalSection(&wma->cs);
@ -464,12 +459,13 @@ static DWORD MCIAVI_mciPlay(UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms
/* signal the state change */
SetEvent(wma->ack_event);
if (dwFlags & (MCI_DGV_PLAY_REPEAT|MCI_DGV_PLAY_REVERSE|MCI_MCIAVI_PLAY_WINDOW|MCI_MCIAVI_PLAY_FULLSCREEN))
if (dwFlags & (MCI_DGV_PLAY_REPEAT|MCI_MCIAVI_PLAY_WINDOW|MCI_MCIAVI_PLAY_FULLSCREEN))
FIXME("Unsupported flag %08x\n", dwFlags);
/* time is in microseconds, we should convert it to milliseconds */
frameTime = (wma->mah.dwMicroSecPerFrame + 500) / 1000;
events[0] = wma->hStopEvent;
if (wma->lpWaveFormat) {
if (MCIAVI_OpenAudio(wma, &nHdr, &waveHdr) != 0)
{
@ -477,14 +473,19 @@ static DWORD MCIAVI_mciPlay(UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms
HeapFree(GetProcessHeap(), 0, wma->lpWaveFormat);
wma->lpWaveFormat = NULL;
}
else
/* fill the queue with as many wave headers as possible */
MCIAVI_PlayAudioBlocks(wma, nHdr, waveHdr);
else
{
/* fill the queue with as many wave headers as possible */
MCIAVI_PlayAudioBlocks(wma, nHdr, waveHdr);
events[1] = wma->hEvent;
numEvents = 2;
}
}
while (wma->dwStatus == MCI_MODE_PLAY)
{
HDC hDC;
DWORD tc, delta;
DWORD ret;
tc = GetTickCount();
@ -496,21 +497,8 @@ static DWORD MCIAVI_mciPlay(UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms
ReleaseDC(wma->hWndPaint, hDC);
}
if (wma->lpWaveFormat) {
HANDLE events[2];
events[0] = wma->hStopEvent;
events[1] = wma->hEvent;
if (wma->lpWaveFormat)
MCIAVI_PlayAudioBlocks(wma, nHdr, waveHdr);
delta = GetTickCount() - tc;
LeaveCriticalSection(&wma->cs);
ret = WaitForMultipleObjects(2, events, FALSE, (delta >= frameTime) ? 0 : frameTime - delta);
EnterCriticalSection(&wma->cs);
if (ret == WAIT_OBJECT_0 || wma->dwStatus != MCI_MODE_PLAY) break;
}
delta = GetTickCount() - tc;
if (delta < frameTime)
@ -519,9 +507,9 @@ static DWORD MCIAVI_mciPlay(UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms
delta = 0;
LeaveCriticalSection(&wma->cs);
ret = WaitForMultipleObjects(1, &wma->hStopEvent, FALSE, delta);
ret = WaitForMultipleObjects(numEvents, events, FALSE, delta);
EnterCriticalSection(&wma->cs);
if (ret == WAIT_OBJECT_0) break;
if (ret == WAIT_OBJECT_0 || wma->dwStatus != MCI_MODE_PLAY) break;
if (wma->dwCurrVideoFrame < dwToFrame)
wma->dwCurrVideoFrame++;
@ -572,28 +560,6 @@ mci_play_done:
return dwRet;
}
/***************************************************************************
* MCIAVI_mciRecord [internal]
*/
static DWORD MCIAVI_mciRecord(UINT wDevID, DWORD dwFlags, LPMCI_DGV_RECORD_PARMS lpParms)
{
WINE_MCIAVI *wma;
FIXME("(%04x, %08X, %p) : stub\n", wDevID, dwFlags, lpParms);
MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
wma = MCIAVI_mciGetOpenDev(wDevID);
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
EnterCriticalSection(&wma->cs);
wma->dwStatus = MCI_MODE_RECORD;
LeaveCriticalSection(&wma->cs);
return 0;
}
/***************************************************************************
* MCIAVI_mciStop [internal]
*/
@ -606,6 +572,7 @@ static DWORD MCIAVI_mciStop(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpPa
wma = MCIAVI_mciGetOpenDev(wDevID);
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
if (dwFlags & MCI_TEST) return 0;
EnterCriticalSection(&wma->cs);
@ -658,6 +625,7 @@ static DWORD MCIAVI_mciPause(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpP
wma = MCIAVI_mciGetOpenDev(wDevID);
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
if (dwFlags & MCI_TEST) return 0;
EnterCriticalSection(&wma->cs);
@ -684,6 +652,7 @@ static DWORD MCIAVI_mciResume(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lp
wma = MCIAVI_mciGetOpenDev(wDevID);
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
if (dwFlags & MCI_TEST) return 0;
EnterCriticalSection(&wma->cs);
@ -705,33 +674,36 @@ static DWORD MCIAVI_mciResume(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lp
static DWORD MCIAVI_mciSeek(UINT wDevID, DWORD dwFlags, LPMCI_SEEK_PARMS lpParms)
{
WINE_MCIAVI *wma;
DWORD position;
TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
wma = MCIAVI_mciGetOpenDev(wDevID);
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
position = dwFlags & (MCI_SEEK_TO_START|MCI_SEEK_TO_END|MCI_TO);
if (!position) return MCIERR_MISSING_PARAMETER;
if (position&(position-1)) return MCIERR_FLAGS_NOT_COMPATIBLE;
if (dwFlags & MCI_TO) {
position = MCIAVI_ConvertTimeFormatToFrame(wma, lpParms->dwTo);
if (position >= wma->dwPlayableVideoFrames)
return MCIERR_OUTOFRANGE;
} else if (dwFlags & MCI_SEEK_TO_START) {
position = 0;
} else {
position = wma->dwPlayableVideoFrames - 1;
}
if (dwFlags & MCI_TEST) return 0;
MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
EnterCriticalSection(&wma->cs);
if (dwFlags & MCI_SEEK_TO_START) {
wma->dwCurrVideoFrame = 0;
} else if (dwFlags & MCI_SEEK_TO_END) {
wma->dwCurrVideoFrame = wma->dwPlayableVideoFrames - 1;
} else if (dwFlags & MCI_TO) {
if (lpParms->dwTo > wma->dwPlayableVideoFrames - 1)
lpParms->dwTo = wma->dwPlayableVideoFrames - 1;
wma->dwCurrVideoFrame = MCIAVI_ConvertTimeFormatToFrame(wma, lpParms->dwTo);
} else {
WARN("dwFlag doesn't tell where to seek to...\n");
LeaveCriticalSection(&wma->cs);
return MCIERR_MISSING_PARAMETER;
}
TRACE("Seeking to frame=%u bytes\n", wma->dwCurrVideoFrame);
wma->dwCurrVideoFrame = position;
TRACE("Seeking to frame=%u\n", wma->dwCurrVideoFrame);
if (dwFlags & MCI_NOTIFY) {
mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
@ -750,52 +722,12 @@ static DWORD MCIAVI_mciLoad(UINT wDevID, DWORD dwFlags, LPMCI_DGV_LOAD_PARMSW lp
FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
wma = MCIAVI_mciGetOpenDev(wDevID);
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
return 0;
}
/******************************************************************************
* MCIAVI_mciSave [internal]
*/
static DWORD MCIAVI_mciSave(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SAVE_PARMSW lpParms)
{
WINE_MCIAVI *wma;
FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
wma = MCIAVI_mciGetOpenDev(wDevID);
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
return 0;
}
/******************************************************************************
* MCIAVI_mciFreeze [internal]
*/
static DWORD MCIAVI_mciFreeze(UINT wDevID, DWORD dwFlags, LPMCI_DGV_RECT_PARMS lpParms)
{
WINE_MCIAVI *wma;
FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
wma = MCIAVI_mciGetOpenDev(wDevID);
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
return 0;
return MCIERR_UNSUPPORTED_FUNCTION; /* like w2k */
}
/******************************************************************************
@ -807,31 +739,11 @@ static DWORD MCIAVI_mciRealize(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS l
FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
wma = MCIAVI_mciGetOpenDev(wDevID);
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
return 0;
}
/******************************************************************************
* MCIAVI_mciUnFreeze [internal]
*/
static DWORD MCIAVI_mciUnFreeze(UINT wDevID, DWORD dwFlags, LPMCI_DGV_RECT_PARMS lpParms)
{
WINE_MCIAVI *wma;
FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
wma = MCIAVI_mciGetOpenDev(wDevID);
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
if (dwFlags & MCI_TEST) return 0;
return 0;
}
@ -849,6 +761,7 @@ static DWORD MCIAVI_mciUpdate(UINT wDevID, DWORD dwFlags, LPMCI_DGV_UPDATE_PARMS
wma = MCIAVI_mciGetOpenDev(wDevID);
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
/* Ignore MCI_TEST flag. */
EnterCriticalSection(&wma->cs);
@ -866,92 +779,34 @@ static DWORD MCIAVI_mciUpdate(UINT wDevID, DWORD dwFlags, LPMCI_DGV_UPDATE_PARMS
static DWORD MCIAVI_mciStep(UINT wDevID, DWORD dwFlags, LPMCI_DGV_STEP_PARMS lpParms)
{
WINE_MCIAVI *wma;
DWORD position;
int delta = 1;
FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
TRACE("(%04x, %08x, %p)\n", wDevID, dwFlags, lpParms);
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
wma = MCIAVI_mciGetOpenDev(wDevID);
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
return 0;
}
/******************************************************************************
* MCIAVI_mciCopy [internal]
*/
static DWORD MCIAVI_mciCopy(UINT wDevID, DWORD dwFlags, LPMCI_DGV_COPY_PARMS lpParms)
{
WINE_MCIAVI *wma;
FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
if (dwFlags & MCI_DGV_STEP_FRAMES) delta = lpParms->dwFrames;
if (dwFlags & MCI_DGV_STEP_REVERSE) delta = -delta;
position = wma->dwCurrVideoFrame + delta;
if (position >= wma->dwPlayableVideoFrames) return MCIERR_OUTOFRANGE;
if (dwFlags & MCI_TEST) return 0;
MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
EnterCriticalSection(&wma->cs);
wma = MCIAVI_mciGetOpenDev(wDevID);
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
return 0;
}
/******************************************************************************
* MCIAVI_mciCut [internal]
*/
static DWORD MCIAVI_mciCut(UINT wDevID, DWORD dwFlags, LPMCI_DGV_CUT_PARMS lpParms)
{
WINE_MCIAVI *wma;
FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
wma = MCIAVI_mciGetOpenDev(wDevID);
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
return 0;
}
/******************************************************************************
* MCIAVI_mciDelete [internal]
*/
static DWORD MCIAVI_mciDelete(UINT wDevID, DWORD dwFlags, LPMCI_DGV_DELETE_PARMS lpParms)
{
WINE_MCIAVI *wma;
FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
wma = MCIAVI_mciGetOpenDev(wDevID);
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
return 0;
}
/******************************************************************************
* MCIAVI_mciPaste [internal]
*/
static DWORD MCIAVI_mciPaste(UINT wDevID, DWORD dwFlags, LPMCI_DGV_PASTE_PARMS lpParms)
{
WINE_MCIAVI *wma;
FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
wma = MCIAVI_mciGetOpenDev(wDevID);
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
wma->dwCurrVideoFrame = position;
TRACE("Stepping to frame=%u\n", wma->dwCurrVideoFrame);
if (dwFlags & MCI_NOTIFY) {
mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
wDevID, MCI_NOTIFY_SUCCESSFUL);
}
LeaveCriticalSection(&wma->cs);
return 0;
}
@ -964,69 +819,12 @@ static DWORD MCIAVI_mciCue(UINT wDevID, DWORD dwFlags, LPMCI_DGV_CUE_PARMS lpPar
FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
wma = MCIAVI_mciGetOpenDev(wDevID);
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
return 0;
}
/******************************************************************************
* MCIAVI_mciCapture [internal]
*/
static DWORD MCIAVI_mciCapture(UINT wDevID, DWORD dwFlags, LPMCI_DGV_CAPTURE_PARMSW lpParms)
{
WINE_MCIAVI *wma;
FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
wma = MCIAVI_mciGetOpenDev(wDevID);
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
return 0;
}
/******************************************************************************
* MCIAVI_mciMonitor [internal]
*/
static DWORD MCIAVI_mciMonitor(UINT wDevID, DWORD dwFlags, LPMCI_DGV_MONITOR_PARMS lpParms)
{
WINE_MCIAVI *wma;
FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
wma = MCIAVI_mciGetOpenDev(wDevID);
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
return 0;
}
/******************************************************************************
* MCIAVI_mciReserve [internal]
*/
static DWORD MCIAVI_mciReserve(UINT wDevID, DWORD dwFlags, LPMCI_DGV_RESERVE_PARMSW lpParms)
{
WINE_MCIAVI *wma;
FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
wma = MCIAVI_mciGetOpenDev(wDevID);
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
if (dwFlags & MCI_DGV_CUE_INPUT) return MCIERR_UNSUPPORTED_FUNCTION;
if (dwFlags & MCI_TEST) return 0;
return 0;
}
@ -1040,14 +838,12 @@ static DWORD MCIAVI_mciSetAudio(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SETAUDIO_P
FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
wma = MCIAVI_mciGetOpenDev(wDevID);
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
return 0;
return MCIERR_UNSUPPORTED_FUNCTION; /* like w2k */
}
/******************************************************************************
@ -1059,8 +855,6 @@ static DWORD MCIAVI_mciSignal(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SIGNAL_PARMS
FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
wma = MCIAVI_mciGetOpenDev(wDevID);
@ -1078,71 +872,12 @@ static DWORD MCIAVI_mciSetVideo(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SETVIDEO_P
FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
wma = MCIAVI_mciGetOpenDev(wDevID);
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
return 0;
}
/******************************************************************************
* MCIAVI_mciQuality [internal]
*/
static DWORD MCIAVI_mciQuality(UINT wDevID, DWORD dwFlags, LPMCI_DGV_QUALITY_PARMSW lpParms)
{
WINE_MCIAVI *wma;
FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
wma = MCIAVI_mciGetOpenDev(wDevID);
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
return 0;
}
/******************************************************************************
* MCIAVI_mciList [internal]
*/
static DWORD MCIAVI_mciList(UINT wDevID, DWORD dwFlags, LPMCI_DGV_LIST_PARMSW lpParms)
{
WINE_MCIAVI *wma;
FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
wma = MCIAVI_mciGetOpenDev(wDevID);
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
return 0;
}
/******************************************************************************
* MCIAVI_mciUndo [internal]
*/
static DWORD MCIAVI_mciUndo(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
{
WINE_MCIAVI *wma;
FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
wma = MCIAVI_mciGetOpenDev(wDevID);
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
return 0;
return MCIERR_UNSUPPORTED_FUNCTION; /* like w2k */
}
/******************************************************************************
@ -1154,31 +889,11 @@ static DWORD MCIAVI_mciConfigure(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS
FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
wma = MCIAVI_mciGetOpenDev(wDevID);
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
return 0;
}
/******************************************************************************
* MCIAVI_mciRestore [internal]
*/
static DWORD MCIAVI_mciRestore(UINT wDevID, DWORD dwFlags, LPMCI_DGV_RESTORE_PARMSW lpParms)
{
WINE_MCIAVI *wma;
FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
wma = MCIAVI_mciGetOpenDev(wDevID);
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
if (dwFlags & MCI_TEST) return 0;
return 0;
}
@ -1216,7 +931,6 @@ LRESULT CALLBACK MCIAVI_DriverProc(DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg,
case MCI_OPEN_DRIVER: return MCIAVI_mciOpen (dwDevID, dwParam1, (LPMCI_DGV_OPEN_PARMSW) dwParam2);
case MCI_CLOSE_DRIVER: return MCIAVI_mciClose (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
case MCI_PLAY: return MCIAVI_mciPlay (dwDevID, dwParam1, (LPMCI_PLAY_PARMS) dwParam2);
case MCI_RECORD: return MCIAVI_mciRecord (dwDevID, dwParam1, (LPMCI_DGV_RECORD_PARMS) dwParam2);
case MCI_STOP: return MCIAVI_mciStop (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
case MCI_SET: return MCIAVI_mciSet (dwDevID, dwParam1, (LPMCI_DGV_SET_PARMS) dwParam2);
case MCI_PAUSE: return MCIAVI_mciPause (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
@ -1228,34 +942,38 @@ LRESULT CALLBACK MCIAVI_DriverProc(DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg,
case MCI_PUT: return MCIAVI_mciPut (dwDevID, dwParam1, (LPMCI_DGV_PUT_PARMS) dwParam2);
case MCI_WINDOW: return MCIAVI_mciWindow (dwDevID, dwParam1, (LPMCI_DGV_WINDOW_PARMSW) dwParam2);
case MCI_LOAD: return MCIAVI_mciLoad (dwDevID, dwParam1, (LPMCI_DGV_LOAD_PARMSW) dwParam2);
case MCI_SAVE: return MCIAVI_mciSave (dwDevID, dwParam1, (LPMCI_DGV_SAVE_PARMSW) dwParam2);
case MCI_FREEZE: return MCIAVI_mciFreeze (dwDevID, dwParam1, (LPMCI_DGV_RECT_PARMS) dwParam2);
case MCI_REALIZE: return MCIAVI_mciRealize (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
case MCI_UNFREEZE: return MCIAVI_mciUnFreeze (dwDevID, dwParam1, (LPMCI_DGV_RECT_PARMS) dwParam2);
case MCI_UPDATE: return MCIAVI_mciUpdate (dwDevID, dwParam1, (LPMCI_DGV_UPDATE_PARMS) dwParam2);
case MCI_WHERE: return MCIAVI_mciWhere (dwDevID, dwParam1, (LPMCI_DGV_RECT_PARMS) dwParam2);
case MCI_STEP: return MCIAVI_mciStep (dwDevID, dwParam1, (LPMCI_DGV_STEP_PARMS) dwParam2);
case MCI_COPY: return MCIAVI_mciCopy (dwDevID, dwParam1, (LPMCI_DGV_COPY_PARMS) dwParam2);
case MCI_CUT: return MCIAVI_mciCut (dwDevID, dwParam1, (LPMCI_DGV_CUT_PARMS) dwParam2);
case MCI_DELETE: return MCIAVI_mciDelete (dwDevID, dwParam1, (LPMCI_DGV_DELETE_PARMS) dwParam2);
case MCI_PASTE: return MCIAVI_mciPaste (dwDevID, dwParam1, (LPMCI_DGV_PASTE_PARMS) dwParam2);
case MCI_CUE: return MCIAVI_mciCue (dwDevID, dwParam1, (LPMCI_DGV_CUE_PARMS) dwParam2);
/* Digital Video specific */
case MCI_CAPTURE: return MCIAVI_mciCapture (dwDevID, dwParam1, (LPMCI_DGV_CAPTURE_PARMSW) dwParam2);
case MCI_MONITOR: return MCIAVI_mciMonitor (dwDevID, dwParam1, (LPMCI_DGV_MONITOR_PARMS) dwParam2);
case MCI_RESERVE: return MCIAVI_mciReserve (dwDevID, dwParam1, (LPMCI_DGV_RESERVE_PARMSW) dwParam2);
case MCI_SETAUDIO: return MCIAVI_mciSetAudio (dwDevID, dwParam1, (LPMCI_DGV_SETAUDIO_PARMSW) dwParam2);
case MCI_SIGNAL: return MCIAVI_mciSignal (dwDevID, dwParam1, (LPMCI_DGV_SIGNAL_PARMS) dwParam2);
case MCI_SETVIDEO: return MCIAVI_mciSetVideo (dwDevID, dwParam1, (LPMCI_DGV_SETVIDEO_PARMSW) dwParam2);
case MCI_QUALITY: return MCIAVI_mciQuality (dwDevID, dwParam1, (LPMCI_DGV_QUALITY_PARMSW) dwParam2);
case MCI_LIST: return MCIAVI_mciList (dwDevID, dwParam1, (LPMCI_DGV_LIST_PARMSW) dwParam2);
case MCI_UNDO: return MCIAVI_mciUndo (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
case MCI_CONFIGURE: return MCIAVI_mciConfigure (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
case MCI_RESTORE: return MCIAVI_mciRestore (dwDevID, dwParam1, (LPMCI_DGV_RESTORE_PARMSW) dwParam2);
/* no editing, recording, saving, locking without inputs */
case MCI_CAPTURE:
case MCI_COPY:
case MCI_CUT:
case MCI_DELETE:
case MCI_FREEZE:
case MCI_LIST:
case MCI_MONITOR:
case MCI_PASTE:
case MCI_QUALITY:
case MCI_RECORD:
case MCI_RESERVE:
case MCI_RESTORE:
case MCI_SAVE:
case MCI_UNDO:
case MCI_UNFREEZE:
TRACE("Unsupported function [0x%x] flags=%08x\n", wMsg, (DWORD)dwParam1);
return MCIERR_UNSUPPORTED_FUNCTION;
case MCI_SPIN:
case MCI_ESCAPE:
WARN("Unsupported command [%u]\n", wMsg);
WARN("Unsupported command [0x%x] %08x\n", wMsg, (DWORD)dwParam1);
break;
case MCI_OPEN:
case MCI_CLOSE:

8
reactos/dll/win32/mciavi32/mciavi_res.rc
View file

@ -20,6 +20,7 @@
#include "windef.h"
#include "winbase.h"
#include "mmddk.h"
#include "digitalv.h"
MCIAVI RCDATA
BEGIN
@ -563,3 +564,10 @@ L"text\0", 0x00080000L, MCI_STRING,
L"\0", 0x00000000L, MCI_END_COMMAND,
L"\0", 0x00000000L, MCI_END_COMMAND_LIST
END
STRINGTABLE
BEGIN
MCI_ON_S, "on"
MCI_OFF_S, "off"
END

2
reactos/dll/win32/mciavi32/mmoutput.c
View file

@ -333,6 +333,7 @@ BOOL MCIAVI_GetInfo(WINE_MCIAVI* wma)
if (!MCIAVI_GetInfoVideo(wma, &mmckList, &mmckStream))
return FALSE;
wma->video_stream_n = stream_n;
wma->dwSet |= 4;
}
}
else if (strh.fccType == streamtypeAUDIO)
@ -347,6 +348,7 @@ BOOL MCIAVI_GetInfo(WINE_MCIAVI* wma)
if (!MCIAVI_GetInfoAudio(wma, &mmckList, &mmckStream))
return FALSE;
wma->audio_stream_n = stream_n;
wma->dwSet |= 3;
}
}
else

3
reactos/dll/win32/mciavi32/wnd.c
View file

@ -154,6 +154,7 @@ DWORD MCIAVI_mciPut(UINT wDevID, DWORD dwFlags, LPMCI_DGV_PUT_PARMS lpParms)
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
if (dwFlags & MCI_TEST) return 0;
EnterCriticalSection(&wma->cs);
@ -211,6 +212,7 @@ DWORD MCIAVI_mciWhere(UINT wDevID, DWORD dwFlags, LPMCI_DGV_RECT_PARMS lpParms)
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
/* Ignore MCI_TEST flag. */
EnterCriticalSection(&wma->cs);
@ -283,6 +285,7 @@ DWORD MCIAVI_mciWindow(UINT wDevID, DWORD dwFlags, LPMCI_DGV_WINDOW_PARMSW lpPar
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
if (dwFlags & MCI_TEST) return 0;
EnterCriticalSection(&wma->cs);

93
reactos/dll/win32/mciqtz32/mciqtz.c
View file

@ -105,6 +105,7 @@ static DWORD MCIQTZ_drvClose(DWORD dwDevID)
/* finish all outstanding things */
MCIQTZ_mciClose(dwDevID, MCI_WAIT, NULL);
mciSetDriverData(dwDevID, 0);
HeapFree(GetProcessHeap(), 0, wma);
return 1;
}
@ -166,7 +167,7 @@ static DWORD MCIQTZ_mciOpen(UINT wDevID, DWORD dwFlags,
goto err;
}
if (!((dwFlags & MCI_OPEN_ELEMENT) && (dwFlags & MCI_OPEN_ELEMENT))) {
if (!(dwFlags & MCI_OPEN_ELEMENT) || (dwFlags & MCI_OPEN_ELEMENT_ID)) {
TRACE("Wrong dwFlags %x\n", dwFlags);
goto err;
}
@ -353,10 +354,8 @@ static DWORD MCIQTZ_mciGetDevCaps(UINT wDevID, DWORD dwFlags, LPMCI_GETDEVCAPS_P
if (!wma)
return MCIERR_INVALID_DEVICE_ID;
if (!(dwFlags & MCI_STATUS_ITEM)) {
WARN("No capability item specified\n");
return MCIERR_UNRECOGNIZED_COMMAND;
}
if (!(dwFlags & MCI_GETDEVCAPS_ITEM))
return MCIERR_MISSING_PARAMETER;
switch (lpParms->dwItem) {
case MCI_GETDEVCAPS_CAN_RECORD:
@ -395,9 +394,44 @@ static DWORD MCIQTZ_mciGetDevCaps(UINT wDevID, DWORD dwFlags, LPMCI_GETDEVCAPS_P
lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
TRACE("MCI_GETDEVCAPS_CAN_SAVE = %08x\n", lpParms->dwReturn);
break;
case MCI_DGV_GETDEVCAPS_CAN_REVERSE:
lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
TRACE("MCI_DGV_GETDEVCAPS_CAN_REVERSE = %08x\n", lpParms->dwReturn);
break;
case MCI_DGV_GETDEVCAPS_CAN_STRETCH:
lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE); /* FIXME */
TRACE("MCI_DGV_GETDEVCAPS_CAN_STRETCH = %08x\n", lpParms->dwReturn);
break;
case MCI_DGV_GETDEVCAPS_CAN_LOCK:
lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
TRACE("MCI_DGV_GETDEVCAPS_CAN_LOCK = %08x\n", lpParms->dwReturn);
break;
case MCI_DGV_GETDEVCAPS_CAN_FREEZE:
lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
TRACE("MCI_DGV_GETDEVCAPS_CAN_FREEZE = %08x\n", lpParms->dwReturn);
break;
case MCI_DGV_GETDEVCAPS_CAN_STR_IN:
lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
TRACE("MCI_DGV_GETDEVCAPS_CAN_STRETCH_INPUT = %08x\n", lpParms->dwReturn);
break;
case MCI_DGV_GETDEVCAPS_HAS_STILL:
lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
TRACE("MCI_DGV_GETDEVCAPS_HAS_STILL = %08x\n", lpParms->dwReturn);
break;
case MCI_DGV_GETDEVCAPS_CAN_TEST:
lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE); /* FIXME */
TRACE("MCI_DGV_GETDEVCAPS_CAN_TEST = %08x\n", lpParms->dwReturn);
break;
case MCI_DGV_GETDEVCAPS_MAX_WINDOWS:
lpParms->dwReturn = 1;
TRACE("MCI_DGV_GETDEVCAPS_MAX_WINDOWS = %u\n", lpParms->dwReturn);
return 0;
default:
ERR("Unknown capability %08x\n", lpParms->dwItem);
return MCIERR_UNRECOGNIZED_COMMAND;
WARN("Unknown capability %08x\n", lpParms->dwItem);
/* Fall through */
case MCI_DGV_GETDEVCAPS_MAXIMUM_RATE: /* unknown to w2k */
case MCI_DGV_GETDEVCAPS_MINIMUM_RATE: /* unknown to w2k */
return MCIERR_UNSUPPORTED_FUNCTION;
}
return MCI_RESOURCE_RETURNED;
@ -435,8 +469,25 @@ static DWORD MCIQTZ_mciSet(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SET_PARMS lpPar
}
}
if (dwFlags & ~MCI_SET_TIME_FORMAT)
FIXME("Flags not supported yet %08lX\n", dwFlags & ~MCI_SET_TIME_FORMAT);
if (dwFlags & MCI_SET_DOOR_OPEN)
FIXME("MCI_SET_DOOR_OPEN not implemented yet\n");
if (dwFlags & MCI_SET_DOOR_CLOSED)
FIXME("MCI_SET_DOOR_CLOSED not implemented yet\n");
if (dwFlags & MCI_SET_AUDIO)
FIXME("MCI_SET_AUDIO not implemented yet\n");
if (dwFlags & MCI_SET_VIDEO)
FIXME("MCI_SET_VIDEO not implemented yet\n");
if (dwFlags & MCI_SET_ON)
FIXME("MCI_SET_ON not implemented yet\n");
if (dwFlags & MCI_SET_OFF)
FIXME("MCI_SET_OFF not implemented yet\n");
if (dwFlags & MCI_SET_AUDIO_LEFT)
FIXME("MCI_SET_AUDIO_LEFT not implemented yet\n");
if (dwFlags & MCI_SET_AUDIO_RIGHT)
FIXME("MCI_SET_AUDIO_RIGHT not implemented yet\n");
if (dwFlags & ~0x7f03 /* All MCI_SET flags mask */)
ERR("Unknown flags %08x\n", dwFlags & ~0x7f03);
return 0;
}
@ -603,6 +654,27 @@ static DWORD MCIQTZ_mciWhere(UINT wDevID, DWORD dwFlags, LPMCI_DGV_RECT_PARMS lp
return 0;
}
/***************************************************************************
* MCIQTZ_mciSetAudio [internal]
*/
static DWORD MCIQTZ_mciSetAudio(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SETAUDIO_PARMSW lpParms)
{
WINE_MCIQTZ *wma;
FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
if (!lpParms)
return MCIERR_NULL_PARAMETER_BLOCK;
wma = MCIQTZ_mciGetOpenDev(wDevID);
if (!wma)
return MCIERR_INVALID_DEVICE_ID;
MCIQTZ_mciStop(wDevID, MCI_WAIT, NULL);
return 0;
}
/*======================================================================*
* MCI QTZ entry points *
*======================================================================*/
@ -643,6 +715,8 @@ LRESULT CALLBACK MCIQTZ_DriverProc(DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg,
case MCI_SET: return MCIQTZ_mciSet (dwDevID, dwParam1, (LPMCI_DGV_SET_PARMS) dwParam2);
case MCI_STATUS: return MCIQTZ_mciStatus (dwDevID, dwParam1, (LPMCI_DGV_STATUS_PARMSW) dwParam2);
case MCI_WHERE: return MCIQTZ_mciWhere (dwDevID, dwParam1, (LPMCI_DGV_RECT_PARMS) dwParam2);
/* Digital Video specific */
case MCI_SETAUDIO: return MCIQTZ_mciSetAudio (dwDevID, dwParam1, (LPMCI_DGV_SETAUDIO_PARMSW) dwParam2);
case MCI_RECORD:
case MCI_PAUSE:
case MCI_RESUME:
@ -665,7 +739,6 @@ LRESULT CALLBACK MCIQTZ_DriverProc(DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg,
case MCI_CAPTURE:
case MCI_MONITOR:
case MCI_RESERVE:
case MCI_SETAUDIO:
case MCI_SIGNAL:
case MCI_SETVIDEO:
case MCI_QUALITY:

9
reactos/dll/win32/mciseq/mcimidi.c
View file

@ -113,9 +113,6 @@ static DWORD CALLBACK MCI_SCAStarter(LPVOID arg)
TRACE("In thread after async command (%08x,%u,%08lx,%08lx)\n",
sca->wDevID, sca->wMsg, sca->dwParam1, sca->dwParam2);
HeapFree(GetProcessHeap(), 0, sca);
ExitThread(ret);
WARN("Should not happen ? what's wrong\n");
/* should not go after this point */
return ret;
}
@ -147,7 +144,7 @@ static DWORD MCI_SendCommandAsync(UINT wDevID, UINT wMsg, DWORD_PTR dwParam1,
if ((handle = CreateThread(NULL, 0, MCI_SCAStarter, sca, 0, NULL)) == 0) {
WARN("Couldn't allocate thread for async command handling, sending synchronously\n");
return MCI_SCAStarter(&sca);
return MCI_SCAStarter(sca);
}
SetThreadPriority(handle, THREAD_PRIORITY_TIME_CRITICAL);
CloseHandle(handle);
@ -412,7 +409,7 @@ static DWORD MIDI_mciReadMTrk(WINE_MCIMIDI* wmm, MCI_MIDITRACK* mmt)
} else {
len = MultiByteToWideChar( CP_ACP, 0, buf, -1, NULL, 0 );
wmm->lpstrCopyright = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
len = MultiByteToWideChar( CP_ACP, 0, buf, -1, wmm->lpstrCopyright, len );
MultiByteToWideChar( CP_ACP, 0, buf, -1, wmm->lpstrCopyright, len );
}
break;
case 0x03:
@ -421,7 +418,7 @@ static DWORD MIDI_mciReadMTrk(WINE_MCIMIDI* wmm, MCI_MIDITRACK* mmt)
} else {
len = MultiByteToWideChar( CP_ACP, 0, buf, -1, NULL, 0 );
wmm->lpstrName = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
len = MultiByteToWideChar( CP_ACP, 0, buf, -1, wmm->lpstrName, len );
MultiByteToWideChar( CP_ACP, 0, buf, -1, wmm->lpstrName, len );
}
break;
}

12
reactos/dll/win32/mlang/mlang.c
View file

@ -2501,7 +2501,7 @@ static HRESULT EnumRfc1766_create(LANGID LangId, IEnumRfc1766 **ppEnum)
if (!data.info)
{
HeapFree(GetProcessHeap(), 0, rfc);
return S_FALSE;
return E_OUTOFMEMORY;
}
TlsSetValue(MLANG_tls_index, &data);
@ -2514,7 +2514,7 @@ static HRESULT EnumRfc1766_create(LANGID LangId, IEnumRfc1766 **ppEnum)
{
HeapFree(GetProcessHeap(), 0, data.info);
HeapFree(GetProcessHeap(), 0, rfc);
return FALSE;
return E_FAIL;
}
rfc->info = data.info;
@ -3007,9 +3007,6 @@ exit:
return hr;
}
/*
* TODO: handle dwFlag and lpFallBack
*/
static HRESULT WINAPI fnIMultiLanguage2_ConvertStringToUnicodeEx(
IMultiLanguage3* iface,
DWORD* pdwMode,
@ -3021,7 +3018,10 @@ static HRESULT WINAPI fnIMultiLanguage2_ConvertStringToUnicodeEx(
DWORD dwFlag,
WCHAR* lpFallBack)
{
FIXME("\n");
if (dwFlag || lpFallBack)
FIXME("Ignoring dwFlag (0x%x/%d) and lpFallBack (%p)\n",
dwFlag, dwFlag, lpFallBack);
return ConvertINetMultiByteToUnicode(pdwMode, dwEncoding,
pSrcStr, (LPINT)pcSrcSize, pDstStr, (LPINT)pcDstSize);
}