Skip to content
Snippets Groups Projects
Commit 140e7222 authored by Alexandre Julliard's avatar Alexandre Julliard
Browse files

Removed more code at Hidenori's request.

parent ac3a9a32
No related branches found
No related tags found
No related merge requests found
Showing
with 325 additions and 4475 deletions
......@@ -3,9 +3,4 @@ type win32
import ntdll.dll
debug_channels (avicap32)
@ stdcall capCreateCaptureWindowA(str long long long long long long long) capCreateCaptureWindowA
@ stdcall capCreateCaptureWindowW(wstr long long long long long long long) capCreateCaptureWindowW
@ stdcall capGetDriverDescriptionA(long ptr long ptr long) capGetDriverDescriptionA
@ stdcall capGetDriverDescriptionW(long ptr long ptr long) capGetDriverDescriptionW
debug_channels ()
/*
* Copyright (C) Hidenori TAKESHIMA
*
* 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* FIXME - stub
*/
#include "winbase.h"
#include "winuser.h"
#include "wingdi.h"
#include "vfw.h"
#include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(avicap32);
/***********************************************************************
*
* capCreateCaptureWindowA (AVICAP32.@)
*
*/
HWND WINAPI capCreateCaptureWindowA( LPCSTR pszTitle, DWORD dwStyle, int x, int y, int width, int height, HWND hwndParent, int nID )
{
FIXME( "(%s,%lx,%d,%d,%d,%d,%x,%d)\n",debugstr_a(pszTitle),dwStyle,x,y,width,height,hwndParent,nID );
return (HWND)NULL;
}
/***********************************************************************
*
* capCreateCaptureWindowW (AVICAP32.@)
*
*/
HWND WINAPI capCreateCaptureWindowW( LPCWSTR pwszTitle, DWORD dwStyle, int x, int y, int width, int height, HWND hwndParent, int nID )
{
FIXME( "(%s,%lx,%d,%d,%d,%d,%x,%d)\n",debugstr_w(pwszTitle),dwStyle,x,y,width,height,hwndParent,nID );
return (HWND)NULL;
}
/***********************************************************************
*
* capGetDriverDescriptionA (AVICAP32.@)
*
*/
BOOL WINAPI capGetDriverDescriptionA( UINT uDriverIndex, LPSTR pszName, int cbName, LPSTR pszVersion, int cbVersion )
{
FIXME( "(%u,%p,%d,%p,%d)\n",uDriverIndex,pszName,cbName,pszVersion,cbVersion );
return FALSE;
}
/***********************************************************************
*
* capGetDriverDescriptionW (AVICAP32.@)
*
*/
BOOL WINAPI capGetDriverDescriptionW( UINT uDriverIndex, LPWSTR pwszName, int cbName, LPWSTR pwszVersion, int cbVersion )
{
FIXME( "(%u,%p,%d,%p,%d)\n",uDriverIndex,pwszName,cbName,pwszVersion,cbVersion );
return FALSE;
}
/* all codes are removed by author */
/*
* Copyright 2002 Hidenori Takeshima
*
* 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
LANGUAGE LANG_JAPANESE, SUBLANG_DEFAULT
IDD_PROPSHEET DIALOG DISCARDABLE 0, 0, 220, 140
STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU | WS_VISIBLE
CAPTION "Properties for "
FONT 8, "MS Pゴシック"
BEGIN
DEFPUSHBUTTON "OK", IDOK,4,122,50,14, WS_TABSTOP | WS_GROUP
PUSHBUTTON "キャンセル", IDCANCEL,58,122,50,14
PUSHBUTTON "適用(&A)", IDC_APPLY_BUTTON,112,122,50,14,WS_DISABLED
PUSHBUTTON "ヘルプ", IDHELP,166,122,50,14,WS_TABSTOP|WS_GROUP
CONTROL "Tab", IDC_TABCONTROL,"SysTabControl32",WS_CLIPSIBLINGS|WS_GROUP|WS_TABSTOP,4,4,212,114
END
IDD_WIZARD DIALOG DISCARDABLE 0, 0, 290, 159
STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU | WS_VISIBLE
CAPTION "ウィザード"
FONT 8, "MS Pゴシック"
BEGIN
DEFPUSHBUTTON "完了", IDC_FINISH_BUTTON,121,138,50,14
DEFPUSHBUTTON "次へ(&N) >", IDC_NEXT_BUTTON,121,138,50,14
PUSHBUTTON "< 前へ(&B)", IDC_BACK_BUTTON,71,138,50,14
PUSHBUTTON "キャンセル", IDCANCEL,178,138,50,14
PUSHBUTTON "ヘルプ", IDHELP,235,138,50,14,WS_GROUP
LTEXT "", IDC_SUNKEN_LINE,7,129,278,1,SS_SUNKEN
CONTROL "Tab", IDC_TABCONTROL,"SysTabControl32",WS_CLIPSIBLINGS | WS_DISABLED,7,7,258,5
END
IDD_TBCUSTOMIZE DIALOG DISCARDABLE 10, 20, 357, 125
STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
CAPTION "ツールバーのカスタマイズ"
FONT 8, "MS Pゴシック"
BEGIN
DEFPUSHBUTTON "閉じる(&C)", IDCANCEL,308,6,44,14
PUSHBUTTON "リセット(&R)", IDC_RESET_BTN,308,23,44,14
PUSHBUTTON "ヘルプ(&H)", IDC_HELP_BTN,308,40,44,14
PUSHBUTTON "上へ(&U)", IDC_MOVEUP_BTN,308,74,44,14
PUSHBUTTON "下へ(&D)", IDC_MOVEDN_BTN,308,91,44,14
LTEXT "利用可能なボタン(&V):", -1,4,5,84,10
LISTBOX IDC_AVAILBTN_LBOX,4,17,120,100, LBS_NOTIFY | LBS_OWNERDRAWFIXED | LBS_HASSTRINGS | LBS_NOINTEGRALHEIGHT | LBS_DISABLENOSCROLL | WS_BORDER | WS_VSCROLL | WS_HSCROLL | WS_TABSTOP
PUSHBUTTON "追加(&A) ->", IDOK, 131, 42, 44, 14
PUSHBUTTON "<- 削除(&R)", IDC_REMOVE_BTN,131,62,44,14
LTEXT "ツールバーのボタン(&T):", -1,182,5,78,10
LISTBOX IDC_TOOLBARBTN_LBOX, 182,17,120,100,LBS_NOTIFY | LBS_OWNERDRAWFIXED | LBS_HASSTRINGS | LBS_NOINTEGRALHEIGHT | LBS_DISABLENOSCROLL | WS_BORDER | WS_VSCROLL | WS_HSCROLL | WS_TABSTOP
END
STRINGTABLE DISCARDABLE
{
IDS_CLOSE "閉じる"
}
STRINGTABLE DISCARDABLE
{
IDS_SEPARATOR "区切り"
}
......@@ -1055,4 +1055,3 @@ IDI_DRAGARROW ICON LOADONCALL DISCARDABLE
#include "comctl_En.rc"
#include "comctl_De.rc"
#include "comctl_Ja.rc"
/*
* OLE2NLS library
* Japanese
* Japanese strings in codepage 932(Shift-JIS)
* modified by Hidenori Takeshima(hidenori@a2.ctktv.ne.jp)
* (Japanese strings in EUC-JP)
*
* Copyright 1998 Marcel Baur
*
......@@ -22,127 +21,109 @@
*/
LOCVAL(LOCALE_ILANGUAGE,"0411")
LOCVAL(LOCALE_SLANGUAGE,"本語")
LOCVAL(LOCALE_SLANGUAGE,"本語")
LOCVAL(LOCALE_SENGLANGUAGE,"Japanese")
LOCVAL(LOCALE_SABBREVLANGNAME,"jpn")
LOCVAL(LOCALE_SNATIVELANGNAME,"本語")
LOCVAL(LOCALE_SNATIVELANGNAME,"本語")
LOCVAL(LOCALE_ICOUNTRY,"81")
LOCVAL(LOCALE_SCOUNTRY,"本")
LOCVAL(LOCALE_SCOUNTRY,"日本")
LOCVAL(LOCALE_SENGCOUNTRY,"Japan")
LOCVAL(LOCALE_SABBREVCTRYNAME,"JPN")
LOCVAL(LOCALE_SNATIVECTRYNAME,"本")
LOCVAL(LOCALE_SNATIVECTRYNAME,"日本")
LOCVAL(LOCALE_IDEFAULTLANGUAGE,"0411")
LOCVAL(LOCALE_IDEFAULTCOUNTRY,"81")
LOCVAL(LOCALE_IDEFAULTCODEPAGE,"932")
LOCVAL(LOCALE_IDEFAULTANSICODEPAGE,"932")
LOCVAL(LOCALE_IDEFAULTMACCODEPAGE, "10001")
LOCVAL(LOCALE_SLIST,",")
LOCVAL(LOCALE_IMEASURE,"0")
LOCVAL(LOCALE_SDECIMAL,".")
LOCVAL(LOCALE_STHOUSAND,",")
/* LOCVAL(LOCALE_IDEFAULTCODEPAGE) */
/* LOCVAL(LOCALE_IDEFAULTANSICODEPAGE) */
/* LOCVAL(LOCALE_SLIST,"") */
/* LOCVAL(LOCALE_IMEASURE,"") */
/* LOCVAL(LOCALE_SDECIMAL,"") */
/* LOCVAL(LOCALE_STHOUSAND,"") */
LOCVAL(LOCALE_SGROUPING,"3;0")
LOCVAL(LOCALE_IDIGITS,"2")
LOCVAL(LOCALE_ILZERO,"1")
LOCVAL(LOCALE_INEGNUMBER,"1")
/* LOCVAL(LOCALE_IDIGITS,"2") */
/* LOCVAL(LOCALE_ILZERO,"1") */
/* LOCVAL(LOCALE_INEGNUMBER) */
LOCVAL(LOCALE_SNATIVEDIGITS,"0123456789")
LOCVAL(LOCALE_SCURRENCY,"")
LOCVAL(LOCALE_SCURRENCY,"円")
LOCVAL(LOCALE_SINTLSYMBOL, "JPY")
LOCVAL(LOCALE_SMONDECIMALSEP,".")
LOCVAL(LOCALE_SMONTHOUSANDSEP,",")
LOCVAL(LOCALE_SMONGROUPING,"3;0")
LOCVAL(LOCALE_ICURRDIGITS,"0")
LOCVAL(LOCALE_IINTLCURRDIGITS,"2")
LOCVAL(LOCALE_ICURRENCY,"3")
LOCVAL(LOCALE_INEGCURR,"8")
LOCVAL(LOCALE_SDATE,"-")
LOCVAL(LOCALE_STIME,":")
LOCVAL(LOCALE_SSHORTDATE,"yy-MM-dd")
LOCVAL(LOCALE_SLONGDATE,"yyyy-MM-dd")
LOCVAL(LOCALE_STIMEFORMAT,"HH:mm:ss")
LOCVAL(LOCALE_IDATE,"2")
LOCVAL(LOCALE_ILDATE,"2")
/* LOCVAL(LOCALE_SMONDECIMALSEP,",") */
/* LOCVAL(LOCALE_SMONTHOUSANDSEP,".") */
/* LOCVAL(LOCALE_SMONGROUPING) */
/* LOCVAL(LOCALE_ICURRDIGITS,"2") */
/* LOCVAL(LOCALE_IINTLCURRDIGITS) */
/* LOCVAL(LOCALE_ICURRENCY,"3") */
/* LOCVAL(LOCALE_INEGCURR,"8") */
/* LOCVAL(LOCALE_SDATE,".") */
/* LOCVAL(LOCALE_STIME,":") */
LOCVAL(LOCALE_SSHORTDATE,"yyyy.MM.dd")
LOCVAL(LOCALE_SLONGDATE,"yyyy年MMMMd.日のddd")
/* LOCVAL(LOCALE_STIMEFORMAT) */
/* LOCVAL(LOCALE_IDATE,"1") */
/* LOCVAL(LOCALE_ILDATE) */
LOCVAL(LOCALE_ITIME,"1")
LOCVAL(LOCALE_ITIMEMARKPOSN,"0") /* Is this correct?(I have no documents.) */
LOCVAL(LOCALE_ICENTURY,"0")
LOCVAL(LOCALE_ITLZERO,"0")
LOCVAL(LOCALE_IDAYLZERO,"0")
LOCVAL(LOCALE_IMONLZERO,"0")
LOCVAL(LOCALE_S1159, "午前")
LOCVAL(LOCALE_S2359, "後")
LOCVAL(LOCALE_ICALENDARTYPE, "2")
LOCVAL(LOCALE_IOPTIONALCALENDAR,"2")
LOCVAL(LOCALE_IFIRSTDAYOFWEEK,"6")
LOCVAL(LOCALE_IFIRSTWEEKOFYEAR,"0")
/* LOCVAL(LOCALE_ITIMEMARKPOSN) */
/* LOCVAL(LOCALE_ICENTURY) */
LOCVAL(LOCALE_ITLZERO,"1")
/* LOCVAL(LOCALE_IDAYLZERO) */
/* LOCVAL(LOCALE_IMONLZERO) */
/* LOCVAL(LOCALE_S1159, "") */
/* LOCVAL(LOCALE_S2359, "") */
LOCVAL(LOCALE_ICALENDARTYPE, "1")
/* LOCVAL(LOCALE_IOPTIONALCALENDAR) */
/* LOCVAL(LOCALE_IFIRSTDAYOFWEEK) */
/* LOCVAL(LOCALE_IFIRSTWEEKOFYEAR) */
LOCVAL(LOCALE_SDAYNAME1,"曜日")
LOCVAL(LOCALE_SDAYNAME2,"火曜日")
LOCVAL(LOCALE_SDAYNAME3,"曜日")
LOCVAL(LOCALE_SDAYNAME4,"木曜日")
LOCVAL(LOCALE_SDAYNAME5,"曜日")
LOCVAL(LOCALE_SDAYNAME6,"土曜日")
LOCVAL(LOCALE_SDAYNAME7,"曜日")
LOCVAL(LOCALE_SDAYNAME1,"月曜日")
LOCVAL(LOCALE_SDAYNAME2,"火曜日")
LOCVAL(LOCALE_SDAYNAME3,"水曜日")
LOCVAL(LOCALE_SDAYNAME4,"木曜日")
LOCVAL(LOCALE_SDAYNAME5,"金曜日")
LOCVAL(LOCALE_SDAYNAME6,"土曜日")
LOCVAL(LOCALE_SDAYNAME7,"日曜日")
LOCVAL(LOCALE_SABBREVDAYNAME1,"月")
LOCVAL(LOCALE_SABBREVDAYNAME2,"火")
LOCVAL(LOCALE_SABBREVDAYNAME3,"水")
LOCVAL(LOCALE_SABBREVDAYNAME4,"木")
LOCVAL(LOCALE_SABBREVDAYNAME5,"金")
LOCVAL(LOCALE_SABBREVDAYNAME6,"")
LOCVAL(LOCALE_SABBREVDAYNAME7,"日")
LOCVAL(LOCALE_SABBREVDAYNAME1,"月")
LOCVAL(LOCALE_SABBREVDAYNAME2,"火")
LOCVAL(LOCALE_SABBREVDAYNAME3,"水")
LOCVAL(LOCALE_SABBREVDAYNAME4,"木")
LOCVAL(LOCALE_SABBREVDAYNAME5,"金")
LOCVAL(LOCALE_SABBREVDAYNAME6,"土")
LOCVAL(LOCALE_SABBREVDAYNAME7,"日")
#if 0
/* classical format:-) */
LOCVAL(LOCALE_SMONTHNAME1,"睦月")
LOCVAL(LOCALE_SMONTHNAME2,"如月")
LOCVAL(LOCALE_SMONTHNAME3,"弥生")
LOCVAL(LOCALE_SMONTHNAME4,"卯月")
LOCVAL(LOCALE_SMONTHNAME5,"皐月")
LOCVAL(LOCALE_SMONTHNAME6,"水無月")
LOCVAL(LOCALE_SMONTHNAME7,"文月")
LOCVAL(LOCALE_SMONTHNAME8,"葉月")
LOCVAL(LOCALE_SMONTHNAME9,"長月")
LOCVAL(LOCALE_SMONTHNAME10,"神無月")
LOCVAL(LOCALE_SMONTHNAME11,"霜月")
LOCVAL(LOCALE_SMONTHNAME12,"師走")
LOCVAL(LOCALE_SMONTHNAME13,"")
#else
LOCVAL(LOCALE_SMONTHNAME1,"1月")
LOCVAL(LOCALE_SMONTHNAME2,"2月")
LOCVAL(LOCALE_SMONTHNAME3,"3月")
LOCVAL(LOCALE_SMONTHNAME4,"4月")
LOCVAL(LOCALE_SMONTHNAME5,"5月")
LOCVAL(LOCALE_SMONTHNAME6,"6月")
LOCVAL(LOCALE_SMONTHNAME7,"7月")
LOCVAL(LOCALE_SMONTHNAME8,"8月")
LOCVAL(LOCALE_SMONTHNAME9,"9月")
LOCVAL(LOCALE_SMONTHNAME10,"10月")
LOCVAL(LOCALE_SMONTHNAME11,"11月")
LOCVAL(LOCALE_SMONTHNAME12,"12月")
LOCVAL(LOCALE_SMONTHNAME13,"")
#endif
LOCVAL(LOCALE_SMONTHNAME1,"一月")
LOCVAL(LOCALE_SMONTHNAME2,"二月")
LOCVAL(LOCALE_SMONTHNAME3,"三月")
LOCVAL(LOCALE_SMONTHNAME4,"四月")
LOCVAL(LOCALE_SMONTHNAME5,"五月")
LOCVAL(LOCALE_SMONTHNAME6,"六月")
LOCVAL(LOCALE_SMONTHNAME7,"七月")
LOCVAL(LOCALE_SMONTHNAME8,"八月")
LOCVAL(LOCALE_SMONTHNAME9,"九月")
LOCVAL(LOCALE_SMONTHNAME10,"十月")
LOCVAL(LOCALE_SMONTHNAME11,"十一月")
LOCVAL(LOCALE_SMONTHNAME12,"十二月")
/* LOCVAL(LOCALE_SMONTHNAME13,"") */
LOCVAL(LOCALE_SABBREVMONTHNAME1,"1")
LOCVAL(LOCALE_SABBREVMONTHNAME2,"2")
LOCVAL(LOCALE_SABBREVMONTHNAME3,"3")
LOCVAL(LOCALE_SABBREVMONTHNAME4,"4")
LOCVAL(LOCALE_SABBREVMONTHNAME5,"5")
LOCVAL(LOCALE_SABBREVMONTHNAME6,"6")
LOCVAL(LOCALE_SABBREVMONTHNAME7,"7")
LOCVAL(LOCALE_SABBREVMONTHNAME8,"8")
LOCVAL(LOCALE_SABBREVMONTHNAME9,"9")
LOCVAL(LOCALE_SABBREVMONTHNAME10,"10")
LOCVAL(LOCALE_SABBREVMONTHNAME11,"11")
LOCVAL(LOCALE_SABBREVMONTHNAME12,"12")
LOCVAL(LOCALE_SABBREVMONTHNAME13,"")
LOCVAL(LOCALE_SABBREVMONTHNAME1,"1月")
LOCVAL(LOCALE_SABBREVMONTHNAME2,"2月")
LOCVAL(LOCALE_SABBREVMONTHNAME3,"3月")
LOCVAL(LOCALE_SABBREVMONTHNAME4,"4月")
LOCVAL(LOCALE_SABBREVMONTHNAME5,"5月")
LOCVAL(LOCALE_SABBREVMONTHNAME6,"6月")
LOCVAL(LOCALE_SABBREVMONTHNAME7,"7月")
LOCVAL(LOCALE_SABBREVMONTHNAME8,"8月")
LOCVAL(LOCALE_SABBREVMONTHNAME9,"9月")
LOCVAL(LOCALE_SABBREVMONTHNAME10,"10月")
LOCVAL(LOCALE_SABBREVMONTHNAME11,"11月")
LOCVAL(LOCALE_SABBREVMONTHNAME12,"12月")
/* LOCVAL(LOCALE_SABBREVMONTHNAME13,"") */
LOCVAL(LOCALE_SPOSITIVESIGN, "")
LOCVAL(LOCALE_SNEGATIVESIGN, "-")
LOCVAL(LOCALE_IPOSSIGNPOSN, "1")
LOCVAL(LOCALE_INEGSIGNPOSN, "1")
LOCVAL(LOCALE_IPOSSYMPRECEDES, "0")
LOCVAL(LOCALE_IPOSSEPBYSPACE, "1")
LOCVAL(LOCALE_INEGSYMPRECEDES, "0")
LOCVAL(LOCALE_INEGSEPBYSPACE, "1")
/* LOCVAL(LOCALE_SPOSITIVESIGN, "") */
/* LOCVAL(LOCALE_SNEGATIVESIGN, "") */
/* LOCVAL(LOCALE_IPOSSIGNPOSN, "") */
/* LOCVAL(LOCALE_INEGSIGNPOSN, "") */
/* LOCVAL(LOCALE_IPOSSYMPRECEDES, "") */
/* LOCVAL(LOCALE_IPOSSEPBYSPACE, "") */
/* LOCVAL(LOCALE_INEGSYMPRECEDES, "") */
/* LOCVAL(LOCALE_INEGSEPBYSPACE, "") */
/* LOCVAL(LOCALE_FONTSIGNATURE, "") */
LOCVAL(LOCALE_SISO639LANGNAME,"ja")
LOCVAL(LOCALE_SISO3166CTRYNAME,"JP")
......
name imaadp32
file imaadp32.acm
type win32
init IMAADP32_DllMain
import winmm.dll
import user32.dll
import kernel32.dll
import ntdll.dll
debug_channels (imaadp32)
debug_channels ()
@ stdcall DriverProc(long long long long long) IMAADP32_DriverProc
@ stub DriverProc #(long long long long long)
This diff is collapsed.
This diff is collapsed.
name msg711
file msg711.drv
type win32
init MSG711_DllMain
import winmm.dll
import user32.dll
import kernel32.dll
import ntdll.dll
debug_channels (msg711)
debug_channels ()
@ stdcall DriverProc(long long long long long) MSG711_DriverProc
@ stub DriverProc #(long long long long long)
/*
* MSRLE32 Driver
*
* Copyright 2001 TAKESHIMA Hidenori <hidenori@a2.ctktv.ne.jp>
*
* 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* FIXME - encoding
* FIXME - RLE4
*
*/
#include "config.h"
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "mmsystem.h"
#include "vfw.h"
#include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(msrle32);
typedef struct CodecImpl
{
BOOL bInCompress;
BOOL bInDecompress;
BOOL bInDecompressEx;
} CodecImpl;
/***********************************************************************/
static LONG MSRLE32_DecompressRLE4(
BYTE* pDst, LONG pitch,
const BYTE* pSrc,
LONG width, LONG height )
{
FIXME( "RLE4 - not implemented yet\n" );
return ICERR_UNSUPPORTED;
}
static LONG MSRLE32_DecompressRLE8(
BYTE* pDst, LONG pitch,
const BYTE* pSrc,
LONG width, LONG height )
{
LONG x,y;
LONG delta_x,delta_y;
int len;
UINT data;
x = 0; y = 0;
while ( y < height )
{
len = *pSrc++; data = *pSrc++;
if ( len > 0 )
{
/* run length encoding */
while ( len-- > 0 && x < width )
pDst[x++] = (BYTE)data;
}
else
{
switch ( data )
{
case 0: /* EOL */
x = 0; y++; pDst += pitch;
break;
case 1: /* END */
return ICERR_OK;
case 2: /* DELTA */
delta_x = (LONG)*pSrc++;
delta_y = (LONG)*pSrc++;
x += delta_x;
y += delta_y;
pDst += delta_y * pitch;
break;
default: /* RAW */
len = data;
if ( (len+x) > width )
len = width-x;
memcpy( &pDst[x], pSrc, len );
x += len;
pSrc += (data+1)&(~1);
break;
}
}
}
return ICERR_OK;
}
/***********************************************************************/
static BOOL MSRLE32_IsValidInfoHeader( const BITMAPINFO* pbiIn )
{
if ( pbiIn->bmiHeader.biSize < sizeof(BITMAPINFOHEADER) ||
pbiIn->bmiHeader.biWidth <= 0 ||
pbiIn->bmiHeader.biHeight == 0 ||
pbiIn->bmiHeader.biPlanes != 1 )
return FALSE;
return TRUE;
}
static DWORD MSRLE32_GetClrUsed( const BITMAPINFO* pbiIn )
{
if ( pbiIn->bmiHeader.biBitCount > 8 )
return 0;
return (pbiIn->bmiHeader.biClrUsed == 0) ? (1<<pbiIn->bmiHeader.biBitCount) : pbiIn->bmiHeader.biClrUsed;
}
static DWORD MSRLE32_GetUncompressedPitch( const BITMAPINFOHEADER* pbiIn )
{
return ((((pbiIn->biWidth*pbiIn->biBitCount)+7)>>3)+3)&(~3);
}
static DWORD MSRLE32_GetUncompressedSize( const BITMAPINFOHEADER* pbiIn )
{
return MSRLE32_GetUncompressedPitch( pbiIn ) * abs(pbiIn->biHeight);
}
static BOOL MSRLE32_IsValidRGB( const BITMAPINFO* pbiIn )
{
if ( !MSRLE32_IsValidInfoHeader( pbiIn ) )
return FALSE;
if ( pbiIn->bmiHeader.biSizeImage != 0 &&
pbiIn->bmiHeader.biSizeImage < MSRLE32_GetUncompressedSize( &pbiIn->bmiHeader ) )
return FALSE;
switch ( pbiIn->bmiHeader.biCompression )
{
case 0:
case mmioFOURCC('R','G','B',' '):
if ( pbiIn->bmiHeader.biBitCount == 1 ||
pbiIn->bmiHeader.biBitCount == 4 ||
pbiIn->bmiHeader.biBitCount == 8 ||
pbiIn->bmiHeader.biBitCount == 16 ||
pbiIn->bmiHeader.biBitCount == 24 ||
pbiIn->bmiHeader.biBitCount == 32 )
return TRUE;
break;
default:
break;
}
return FALSE;
}
static BOOL MSRLE32_IsValidRLE( const BITMAPINFO* pbiIn )
{
if ( !MSRLE32_IsValidInfoHeader( pbiIn ) )
return FALSE;
switch ( pbiIn->bmiHeader.biCompression )
{
case 1:
case 2:
case mmioFOURCC('R','L','E',' '):
case mmioFOURCC('R','L','E','8'):
case mmioFOURCC('R','L','E','4'):
case mmioFOURCC('M','R','L','E'):
if ( pbiIn->bmiHeader.biBitCount == 8 ||
pbiIn->bmiHeader.biBitCount == 4 )
return TRUE;
break;
default:
break;
}
return FALSE;
}
static BOOL MSRLE32_CompareInfoHeader( const BITMAPINFO* pbiIn, const BITMAPINFO* pbiOut )
{
if ( !MSRLE32_IsValidInfoHeader( pbiIn ) ||
!MSRLE32_IsValidInfoHeader( pbiOut ) )
return FALSE;
if ( pbiIn->bmiHeader.biWidth != pbiOut->bmiHeader.biWidth ||
pbiIn->bmiHeader.biHeight != pbiOut->bmiHeader.biHeight ||
pbiIn->bmiHeader.biPlanes != pbiOut->bmiHeader.biPlanes ||
pbiIn->bmiHeader.biBitCount != pbiOut->bmiHeader.biBitCount )
return FALSE;
return TRUE;
}
/***********************************************************************/
static LONG Codec_DrvQueryConfigure( CodecImpl* This )
{
return ICERR_UNSUPPORTED;
}
static LONG Codec_DrvConfigure( CodecImpl* This, HWND hwnd, DRVCONFIGINFO* pinfo )
{
return ICERR_UNSUPPORTED;
}
static LONG Codec_QueryAbout( void )
{
return ICERR_UNSUPPORTED;
}
static LONG Codec_About( HWND hwnd )
{
return ICERR_UNSUPPORTED;
}
static LONG Codec_CompressQuery( CodecImpl* This, BITMAPINFO* pbiIn, BITMAPINFO* pbiOut )
{
FIXME( "compression is not implemented!\n" );
return ICERR_UNSUPPORTED;
}
static LONG Codec_CompressBegin( CodecImpl* This, BITMAPINFO* pbiIn, BITMAPINFO* pbiOut )
{
return ICERR_UNSUPPORTED;
}
static LONG Codec_Compress( CodecImpl* This, ICCOMPRESS* picc, DWORD dwSize )
{
FIXME( "compression is not implemented!\n" );
return ICERR_UNSUPPORTED;
}
static LONG Codec_CompressEnd( CodecImpl* This )
{
This->bInCompress = FALSE;
return ICERR_UNSUPPORTED;
}
static LONG Codec_CompressFramesInfo( CodecImpl* This, ICCOMPRESSFRAMES* piccf, DWORD dwSize )
{
return ICERR_UNSUPPORTED;
}
static LONG Codec_CompressGetFormat( CodecImpl* This, BITMAPINFO* pbiIn, BITMAPINFO* pbiOut )
{
return ICERR_UNSUPPORTED;
}
static LONG Codec_CompressGetSize( CodecImpl* This, BITMAPINFO* pbiIn, BITMAPINFO* pbiOut )
{
return ICERR_UNSUPPORTED;
}
static LONG Codec_ICQueryConfigure( CodecImpl* This )
{
return ICERR_OK;
}
static LONG Codec_ICConfigure( CodecImpl* This, HWND hwnd )
{
MessageBoxA( hwnd, "Wine RLE Driver", "MSRLE32", MB_OK );
return ICERR_OK;
}
static LONG Codec_DecompressQuery( CodecImpl* This, BITMAPINFO* pbiIn, BITMAPINFO* pbiOut )
{
if ( pbiIn == NULL )
return ICERR_BADPARAM;
if ( !MSRLE32_IsValidRLE( pbiIn ) )
return ICERR_UNSUPPORTED;
if ( pbiOut != NULL )
{
if ( !MSRLE32_IsValidRGB( pbiOut ) )
return ICERR_UNSUPPORTED;
if ( !MSRLE32_CompareInfoHeader( pbiIn, pbiOut ) )
return ICERR_UNSUPPORTED;
}
return ICERR_OK;
}
static LONG Codec_DecompressBegin( CodecImpl* This, BITMAPINFO* pbiIn, BITMAPINFO* pbiOut )
{
LONG lr;
if ( pbiIn == NULL || pbiOut == NULL )
return ICERR_BADPARAM;
lr = Codec_DecompressQuery( This, pbiIn, pbiOut );
if ( lr != ICERR_OK )
return lr;
This->bInDecompress = TRUE;
return ICERR_OK;
}
static LONG Codec_Decompress( CodecImpl* This, ICDECOMPRESS* picd, DWORD dwSize )
{
LONG lr;
if ( !This->bInDecompress )
return ICERR_BADHANDLE; /* FIXME? */
if ( ( picd->dwFlags & ICDECOMPRESS_NOTKEYFRAME ) &&
( picd->dwFlags & ICDECOMPRESS_UPDATE ) )
return ICERR_CANTUPDATE; /* FIXME? */
if ( picd->lpbiInput == NULL ||
picd->lpInput == NULL ||
picd->lpbiOutput == NULL ||
picd->lpOutput == NULL )
return ICERR_BADPARAM;
switch ( picd->lpbiInput->biBitCount )
{
case 4: /* RLE4 */
lr = MSRLE32_DecompressRLE4(
(BYTE*)picd->lpOutput,
MSRLE32_GetUncompressedPitch( picd->lpbiInput ),
(const BYTE*)picd->lpInput,
picd->lpbiInput->biWidth,
picd->lpbiInput->biHeight );
break;
case 8: /* RLE8 */
lr = MSRLE32_DecompressRLE8(
(BYTE*)picd->lpOutput,
MSRLE32_GetUncompressedPitch( picd->lpbiInput ),
(const BYTE*)picd->lpInput,
picd->lpbiInput->biWidth,
picd->lpbiInput->biHeight );
break;
default:
lr = ICERR_BADBITDEPTH;
break;
}
return lr;
}
static LONG Codec_DecompressEnd( CodecImpl* This )
{
This->bInDecompress = FALSE;
return ICERR_OK;
}
static LONG Codec_DecompressGetFormat( CodecImpl* This, BITMAPINFO* pbiIn, BITMAPINFO* pbiOut )
{
DWORD biClrUsed;
LONG lr;
if ( pbiIn == NULL )
return ICERR_BADPARAM;
lr = Codec_DecompressQuery( This, pbiIn, NULL );
if ( lr != ICERR_OK )
return ( pbiOut == NULL ) ? 0 : lr;
biClrUsed = MSRLE32_GetClrUsed(pbiIn);
if ( pbiOut == NULL )
return sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * biClrUsed;
ZeroMemory( pbiOut, sizeof(BITMAPINFOHEADER) );
memcpy( &pbiOut->bmiHeader, &pbiIn->bmiHeader, sizeof(BITMAPINFOHEADER) );
memcpy( &pbiOut->bmiColors, &pbiIn->bmiColors, sizeof(RGBQUAD) * biClrUsed );
pbiOut->bmiHeader.biCompression = 0;
pbiOut->bmiHeader.biSizeImage = MSRLE32_GetUncompressedSize( &pbiOut->bmiHeader );
return ICERR_OK;
}
static LONG Codec_DecompressGetPalette( CodecImpl* This, BITMAPINFO* pbiIn, BITMAPINFO* pbiOut )
{
if ( pbiIn == NULL )
return ICERR_BADPARAM;
return (pbiOut == NULL) ? 0 : ICERR_UNSUPPORTED;
}
static LONG Codec_DecompressSetPalette( CodecImpl* This, BITMAPINFO* pbiIn )
{
return ICERR_UNSUPPORTED;
}
static LONG Codec_DecompressExQuery( CodecImpl* This, ICDECOMPRESSEX* picdex, DWORD dwSize )
{
FIXME( "DecompressEx is not implemented!\n" );
return ICERR_UNSUPPORTED;
}
static LONG Codec_DecompressExBegin( CodecImpl* This, ICDECOMPRESSEX* picdex, DWORD dwSize )
{
FIXME( "DecompressEx is not implemented!\n" );
return ICERR_UNSUPPORTED;
}
static LONG Codec_DecompressEx( CodecImpl* This, ICDECOMPRESSEX* picdex, DWORD dwSize )
{
return ICERR_UNSUPPORTED;
}
static LONG Codec_DecompressExEnd( CodecImpl* This )
{
This->bInDecompressEx = FALSE;
return ICERR_UNSUPPORTED;
}
static LONG Codec_GetInfo( CodecImpl* This, ICINFO* pici, DWORD dwSize )
{
return ICERR_UNSUPPORTED;
}
static LONG Codec_GetQuality( CodecImpl* This, DWORD* pdwQuality )
{
return ICERR_UNSUPPORTED;
}
static LONG Codec_GetState( CodecImpl* This, LPVOID pvState, DWORD dwSize )
{
if ( pvState == NULL )
return 0;
/* no driver-specific state */
return 0;
}
static LONG Codec_SetQuality( CodecImpl* This, DWORD* pdwQuality )
{
return ICERR_UNSUPPORTED;
}
static LONG Codec_SetStatusProc(CodecImpl* This, ICSETSTATUSPROC* picssp, DWORD dwSize )
{
if ( picssp == NULL )
return 0;
/* no driver-specific state */
return 0;
}
static LONG Codec_SetState( CodecImpl* This, LPVOID pvState, DWORD dwSize )
{
return ICERR_UNSUPPORTED;
}
static CodecImpl* Codec_AllocDriver( void )
{
CodecImpl* This;
This = HeapAlloc( GetProcessHeap(), 0, sizeof(CodecImpl) );
if ( This == NULL )
return NULL;
ZeroMemory( This, sizeof(CodecImpl) );
This->bInCompress = FALSE;
This->bInDecompress = FALSE;
This->bInDecompressEx = FALSE;
return This;
}
static void Codec_Close( CodecImpl* This )
{
if ( This->bInCompress )
Codec_CompressEnd(This);
if ( This->bInDecompress )
Codec_DecompressEnd(This);
if ( This->bInDecompressEx )
Codec_DecompressExEnd(This);
HeapFree( GetProcessHeap(), 0, This );
}
LONG WINAPI MSRLE32_DriverProc(
DWORD dwDriverId, HDRVR hdrvr, UINT msg, LONG lParam1, LONG lParam2 )
{
TRACE( "DriverProc(%08lx,%08x,%08x,%08lx,%08lx)\n",
dwDriverId, hdrvr, msg, lParam1, lParam2 );
switch ( msg )
{
case DRV_LOAD:
TRACE("DRV_LOAD\n");
return TRUE;
case DRV_FREE:
TRACE("DRV_FREE\n");
return TRUE;
case DRV_OPEN:
TRACE("DRV_OPEN\n");
return (LONG)Codec_AllocDriver();
case DRV_CLOSE:
TRACE("DRV_CLOSE\n");
Codec_Close( (CodecImpl*)dwDriverId );
return TRUE;
case DRV_ENABLE:
TRACE("DRV_ENABLE\n");
return TRUE;
case DRV_DISABLE:
TRACE("DRV_DISABLE\n");
return TRUE;
case DRV_QUERYCONFIGURE:
TRACE("DRV_QUERYCONFIGURE\n");
return Codec_DrvQueryConfigure( (CodecImpl*)dwDriverId );
case DRV_CONFIGURE:
TRACE("DRV_CONFIGURE\n");
return Codec_DrvConfigure( (CodecImpl*)dwDriverId,
(HWND)lParam1, (DRVCONFIGINFO*)lParam2 );
case DRV_INSTALL:
TRACE("DRV_INSTALL\n");
return DRVCNF_OK;
case DRV_REMOVE:
TRACE("DRV_REMOVE\n");
return 0;
case DRV_POWER:
TRACE("DRV_POWER\n");
return TRUE;
case ICM_ABOUT:
TRACE("ICM_ABOUT\n");
return (lParam1 == -1) ? Codec_QueryAbout() : Codec_About( (HWND)lParam1 );
case ICM_COMPRESS:
TRACE("ICM_COMPRESS\n");
return Codec_Compress((CodecImpl*)dwDriverId,(ICCOMPRESS*)lParam1,(DWORD)lParam2);
case ICM_COMPRESS_BEGIN:
TRACE("ICM_COMPRESS_BEGIN\n");
return Codec_CompressBegin((CodecImpl*)dwDriverId,(BITMAPINFO*)lParam1,(BITMAPINFO*)lParam2);
case ICM_COMPRESS_END:
TRACE("ICM_COMPRESS_END\n");
return Codec_CompressEnd((CodecImpl*)dwDriverId);
case ICM_COMPRESS_FRAMES_INFO:
TRACE("ICM_COMPRESS_FRAMES_INFO\n");
return Codec_CompressFramesInfo((CodecImpl*)dwDriverId,(ICCOMPRESSFRAMES*)lParam1,(DWORD)lParam2);
case ICM_COMPRESS_GET_FORMAT:
TRACE("ICM_COMPRESS_GET_FORMAT\n");
return Codec_CompressGetFormat((CodecImpl*)dwDriverId,(BITMAPINFO*)lParam1,(BITMAPINFO*)lParam2);
case ICM_COMPRESS_GET_SIZE:
TRACE("ICM_COMPRESS_GET_SIZE\n");
return Codec_CompressGetSize((CodecImpl*)dwDriverId,(BITMAPINFO*)lParam1,(BITMAPINFO*)lParam2);
case ICM_COMPRESS_QUERY:
TRACE("ICM_COMPRESS_GET_SIZE\n");
return Codec_CompressQuery((CodecImpl*)dwDriverId,(BITMAPINFO*)lParam1,(BITMAPINFO*)lParam2);
case ICM_CONFIGURE:
TRACE("ICM_CONFIGURE\n");
return ( lParam1 == -1 ) ? Codec_ICQueryConfigure( (CodecImpl*)dwDriverId ) : Codec_ICConfigure( (CodecImpl*)dwDriverId, (HWND)lParam1 );
case ICM_DECOMPRESS:
TRACE( "ICM_DECOMPRESS\n" );
return Codec_Decompress((CodecImpl*)dwDriverId,(ICDECOMPRESS*)lParam1,(DWORD)lParam2);
case ICM_DECOMPRESS_BEGIN:
TRACE( "ICM_DECOMPRESS_BEGIN\n" );
return Codec_DecompressBegin((CodecImpl*)dwDriverId,(BITMAPINFO*)lParam1,(BITMAPINFO*)lParam2);
case ICM_DECOMPRESS_END:
TRACE( "ICM_DECOMPRESS_END\n" );
return Codec_DecompressEnd((CodecImpl*)dwDriverId);
case ICM_DECOMPRESS_GET_FORMAT:
TRACE( "ICM_DECOMPRESS_GET_FORMAT\n" );
return Codec_DecompressGetFormat((CodecImpl*)dwDriverId,(BITMAPINFO*)lParam1,(BITMAPINFO*)lParam2);
case ICM_DECOMPRESS_GET_PALETTE:
TRACE( "ICM_DECOMPRESS_GET_PALETTE\n" );
return Codec_DecompressGetPalette((CodecImpl*)dwDriverId,(BITMAPINFO*)lParam1,(BITMAPINFO*)lParam2);
case ICM_DECOMPRESS_QUERY:
TRACE( "ICM_DECOMPRESS_QUERY\n" );
return Codec_DecompressQuery((CodecImpl*)dwDriverId,(BITMAPINFO*)lParam1,(BITMAPINFO*)lParam2);
case ICM_DECOMPRESS_SET_PALETTE:
TRACE( "ICM_DECOMPRESS_SET_PALETTE\n" );
return Codec_DecompressSetPalette((CodecImpl*)dwDriverId,(BITMAPINFO*)lParam1);
case ICM_DECOMPRESSEX_BEGIN:
TRACE( "ICM_DECOMPRESSEX_BEGIN\n" );
return Codec_DecompressExBegin((CodecImpl*)dwDriverId,(ICDECOMPRESSEX*)lParam1,(DWORD)lParam2);
case ICM_DECOMPRESSEX:
TRACE( "ICM_DECOMPRESSEX\n" );
return Codec_DecompressEx((CodecImpl*)dwDriverId,(ICDECOMPRESSEX*)lParam1,(DWORD)lParam2);
case ICM_DECOMPRESSEX_END:
TRACE( "ICM_DECOMPRESSEX_END\n" );
return Codec_DecompressExEnd((CodecImpl*)dwDriverId);
case ICM_DECOMPRESSEX_QUERY:
TRACE( "ICM_DECOMPRESSEX_QUERY\n" );
return Codec_DecompressExQuery((CodecImpl*)dwDriverId,(ICDECOMPRESSEX*)lParam1,(DWORD)lParam2);
case ICM_GETINFO:
TRACE( "ICM_GETINFO\n" );
return Codec_GetInfo((CodecImpl*)dwDriverId,(ICINFO*)lParam1,(DWORD)lParam2);
case ICM_GETQUALITY:
TRACE( "ICM_SETQUALITY\n");
return Codec_GetQuality((CodecImpl*)dwDriverId,(DWORD*)lParam1);
case ICM_GETSTATE:
TRACE( "ICM_GETSTATE\n" );
return Codec_GetState((CodecImpl*)dwDriverId,(LPVOID)lParam1,(DWORD)lParam2);
case ICM_SETQUALITY:
TRACE( "ICM_SETQUALITY\n");
return Codec_SetQuality((CodecImpl*)dwDriverId,(DWORD*)lParam1);
case ICM_SET_STATUS_PROC:
TRACE( "ICM_SET_STATUS_PROC\n" );
return Codec_SetStatusProc((CodecImpl*)dwDriverId,(ICSETSTATUSPROC*)lParam1,(DWORD)lParam2);
case ICM_SETSTATE:
TRACE( "ICM_SETSTATE\n" );
return Codec_SetState((CodecImpl*)dwDriverId,(LPVOID)lParam1,(DWORD)lParam2);
}
return DefDriverProc( dwDriverId, hdrvr, msg, lParam1, lParam2 );
}
BOOL WINAPI MSRLE32_DllMain( HINSTANCE hInst, DWORD dwReason, LPVOID lpvReserved )
{
TRACE( "(%08x,%08lx,%p)\n",hInst,dwReason,lpvReserved );
return TRUE;
}
/* all codes are removed by author */
name msrle32
type win32
init MSRLE32_DllMain
import winmm.dll
import user32.dll
import kernel32.dll
import ntdll.dll
debug_channels(msrle32)
debug_channels()
@ stdcall DriverProc(long long long long long) MSRLE32_DriverProc
@ stub DriverProc #(long long long long long)
......@@ -12,15 +12,12 @@ SYMBOLFILE = $(MODULE).tmp.o
C_SRCS = \
connpt.c \
dispatch.c \
dispstd.c \
disptype.c \
hash.c \
ole2disp.c \
oleaut.c \
olefont.c \
olepicture.c \
parsedt.c \
propertyframe.c \
safearray.c \
stubs.c \
tmarshal.c \
......
/*
* Copyright 2001 Hidenori Takeshima
*
* FIXME - stub
*
* 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "config.h"
#include "winerror.h"
#include "winnls.h" /* for PRIMARYLANGID */
#include "winreg.h" /* for HKEY_LOCAL_MACHINE */
#include "winuser.h"
#include "oleauto.h"
#include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(ole);
typedef struct CStdDispImpl
{
ICOM_VFIELD(IDispatch);
struct { ICOM_VFIELD(IUnknown); } unkimpl;
UINT ref;
IUnknown* punk;
void* pvThis;
ITypeInfo* pti;
} CStdDispImpl;
static HRESULT CStdDispImpl_Construct(
CStdDispImpl* This,
IUnknown* punkOuter, void* pvThis, ITypeInfo* pti )
{
This->punk = punkOuter;
This->pvThis = pvThis;
This->pti = pti; ITypeInfo_AddRef(pti);
return S_OK;
}
static void CStdDispImpl_Destruct(
CStdDispImpl* This )
{
if ( This->pti != NULL )
ITypeInfo_Release(This->pti);
}
/****************************************************************************/
static HRESULT WINAPI In_CStdDispImpl_fnQueryInterface(
IUnknown* iface,REFIID riid,void** ppvobj)
{
CStdDispImpl* This = (CStdDispImpl*)(((BYTE*)iface)-offsetof(CStdDispImpl,unkimpl));
if ( IsEqualGUID(riid,&IID_IUnknown) )
{
*ppvobj = (void*)iface;
IUnknown_AddRef(iface);
return S_OK;
}
if ( IsEqualGUID(riid,&IID_IDispatch) )
{
*ppvobj = (void*)This;
IUnknown_AddRef((IUnknown*)This);
return S_OK;
}
return E_NOINTERFACE;
}
static ULONG WINAPI In_CStdDispImpl_fnAddRef(IUnknown* iface)
{
CStdDispImpl* This = (CStdDispImpl*)(((BYTE*)iface)-offsetof(CStdDispImpl,unkimpl));
return ++ This->ref;
}
static ULONG WINAPI In_CStdDispImpl_fnRelease(IUnknown* iface)
{
CStdDispImpl* This = (CStdDispImpl*)(((BYTE*)iface)-offsetof(CStdDispImpl,unkimpl));
if ( -- This->ref > 0 ) return This->ref;
++ This->ref;
CStdDispImpl_Destruct(This);
HeapFree(GetProcessHeap(),0,This);
return 0;
}
/****************************************************************************/
static HRESULT WINAPI CStdDispImpl_fnQueryInterface(
IDispatch* iface,REFIID riid,void** ppvobj)
{
ICOM_THIS(CStdDispImpl,iface);
return IUnknown_QueryInterface(This->punk,riid,ppvobj);
}
static ULONG WINAPI CStdDispImpl_fnAddRef(IDispatch* iface)
{
ICOM_THIS(CStdDispImpl,iface);
return IUnknown_AddRef(This->punk);
}
static ULONG WINAPI CStdDispImpl_fnRelease(IDispatch* iface)
{
ICOM_THIS(CStdDispImpl,iface);
return IUnknown_Release(This->punk);
}
static HRESULT WINAPI CStdDispImpl_fnGetTypeInfoCount(
IDispatch* iface,UINT* pctinfo)
{
ICOM_THIS(CStdDispImpl,iface);
FIXME("(%p)\n",This);
if ( pctinfo == NULL ) return E_POINTER;
*pctinfo = 1;
return S_OK;
}
static HRESULT WINAPI CStdDispImpl_fnGetTypeInfo(
IDispatch* iface,
UINT itiindex,LCID lcid,ITypeInfo** ppti)
{
ICOM_THIS(CStdDispImpl,iface);
FIXME("(%p)\n",This);
if ( ppti != NULL ) return E_POINTER;
*ppti = NULL;
if ( itiindex != 0 ) return DISP_E_BADINDEX;
/* lcid is ignored */
ITypeInfo_AddRef(This->pti);
*ppti = This->pti;
return S_OK;
}
static HRESULT WINAPI CStdDispImpl_fnGetIDsOfNames(
IDispatch* iface,
REFIID riid,LPOLESTR* ppwszNames,UINT cNames,LCID lcid,DISPID* pdispid)
{
ICOM_THIS(CStdDispImpl,iface);
FIXME("(%p)\n",This);
return DispGetIDsOfNames(This->pti,ppwszNames,cNames,pdispid);
}
static HRESULT WINAPI CStdDispImpl_fnInvoke(
IDispatch* iface,
DISPID dispid,REFIID riid,LCID lcid,WORD wFlags,
DISPPARAMS* pDispParams,VARIANT* pVarResult,
EXCEPINFO* pExcepInfo,UINT* puArgErr)
{
ICOM_THIS(CStdDispImpl,iface);
FIXME("(%p)\n",This);
return DispInvoke(This->pvThis,
This->pti,dispid,wFlags,
pDispParams,pVarResult,
pExcepInfo,puArgErr);
}
static ICOM_VTABLE(IUnknown) iunk =
{
ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
/* IUnknown */
In_CStdDispImpl_fnQueryInterface,
In_CStdDispImpl_fnAddRef,
In_CStdDispImpl_fnRelease,
};
static ICOM_VTABLE(IDispatch) idisp =
{
ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
/* IUnknown */
CStdDispImpl_fnQueryInterface,
CStdDispImpl_fnAddRef,
CStdDispImpl_fnRelease,
/* IDispatch */
CStdDispImpl_fnGetTypeInfoCount,
CStdDispImpl_fnGetTypeInfo,
CStdDispImpl_fnGetIDsOfNames,
CStdDispImpl_fnInvoke,
};
/******************************************************************************
* CreateStdDispatch (OLEAUT32.32)
*/
HRESULT WINAPI CreateStdDispatch(
IUnknown* punkOuter,
void* pvThis,
ITypeInfo* pti,
IUnknown** ppvobj )
{
HRESULT hr;
CStdDispImpl* This;
if ( punkOuter == NULL || pvThis == NULL ||
pti == NULL || ppvobj == NULL )
return E_POINTER;
This = (CStdDispImpl*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(CStdDispImpl));
if ( This == NULL ) return E_OUTOFMEMORY;
ICOM_VTBL(This) = &idisp;
ICOM_VTBL(&(This->unkimpl)) = &iunk;
This->ref = 1;
hr = CStdDispImpl_Construct( This, punkOuter, pvThis, pti );
if ( FAILED(hr) )
{
IUnknown_Release((IUnknown*)(&This->unkimpl));
return hr;
}
*ppvobj = (IUnknown*)(&This->unkimpl);
return S_OK;
}
/*
* Copyright 2001 Hidenori Takeshima
*
* FIXME - stub
*
* 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "config.h"
#include "winerror.h"
#include "winnls.h" /* for PRIMARYLANGID */
#include "winreg.h" /* for HKEY_LOCAL_MACHINE */
#include "winuser.h"
#include "oleauto.h"
#include "typelib.h"
#include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(ole);
typedef struct CTypeInfo2Impl
{
ICOM_VFIELD(ITypeInfo2);
UINT ref;
INTERFACEDATA ifd;
LCID lcid;
} CTypeInfo2Impl;
static OLECHAR* olestrdup(OLECHAR* psz)
{
OLECHAR* pret;
DWORD cb;
cb = (lstrlenW(psz)+1) * sizeof(OLECHAR);
pret = (OLECHAR*)HeapAlloc( GetProcessHeap(), 0, cb );
if ( pret != NULL )
memcpy( pret, psz, cb );
return pret;
}
static HRESULT CTypeInfo2Impl_Construct(
CTypeInfo2Impl* This,INTERFACEDATA* pifd,LCID lcid)
{
DWORD n,k;
METHODDATA* pmdst;
const METHODDATA* pmsrc;
PARAMDATA* pPdst;
const PARAMDATA* pPsrc;
This->ifd.pmethdata = (METHODDATA*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(METHODDATA)*pifd->cMembers);
if ( This->ifd.pmethdata == NULL ) return E_OUTOFMEMORY;
This->ifd.cMembers = pifd->cMembers;
for ( n = 0; n < pifd->cMembers; n++ )
{
pmdst = &This->ifd.pmethdata[n];
pmsrc = &pifd->pmethdata[n];
pmdst->szName = olestrdup(pmsrc->szName);
if ( pmdst->szName == NULL ) return E_OUTOFMEMORY;
pmdst->ppdata = NULL;
pmdst->dispid = pmsrc->dispid;
pmdst->iMeth = pmsrc->iMeth;
pmdst->cc = pmsrc->cc;
pmdst->cArgs = pmsrc->cArgs;
pmdst->wFlags = pmsrc->wFlags;
pmdst->vtReturn = pmsrc->vtReturn;
if ( pmsrc->cArgs <= 0 ) continue;
pmdst->ppdata = (PARAMDATA*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(PARAMDATA)*pmsrc->cArgs);
if ( pmdst->ppdata == NULL ) return E_OUTOFMEMORY;
for ( k = 0; k < pmsrc->cArgs; k++ )
{
pPdst = &pmdst->ppdata[k];
pPsrc = &pmsrc->ppdata[k];
pPdst->szName = olestrdup(pPsrc->szName);
if ( pPdst->szName == NULL ) return E_OUTOFMEMORY;
pPdst->vt = pPsrc->vt;
}
}
This->lcid = lcid;
return S_OK;
}
static void CTypeInfo2Impl_Destruct(CTypeInfo2Impl* This)
{
DWORD n,k;
METHODDATA* pm;
PARAMDATA* pP;
if ( This->ifd.pmethdata != NULL )
{
for ( n = 0; n < This->ifd.cMembers; n++ )
{
pm = &This->ifd.pmethdata[n];
if ( pm->szName != NULL )
HeapFree(GetProcessHeap(),0,pm->szName);
if ( pm->ppdata == NULL ) continue;
for ( k = 0; k < pm->cArgs; k++ )
{
pP = &pm->ppdata[k];
if ( pP->szName != NULL )
HeapFree(GetProcessHeap(),0,pP->szName);
}
HeapFree(GetProcessHeap(),0,pm->ppdata);
}
HeapFree(GetProcessHeap(),0,This->ifd.pmethdata);
This->ifd.pmethdata = NULL;
}
}
/****************************************************************************/
static const METHODDATA* CTypeInfo2Impl_SearchMethodByName(
CTypeInfo2Impl* This,const OLECHAR* pName)
{
DWORD n;
METHODDATA* pm;
for ( n = 0; n < This->ifd.cMembers; n++ )
{
pm = &This->ifd.pmethdata[n];
if ( !lstrcmpiW(pm->szName,pName) )
return pm;
}
return NULL;
}
static const METHODDATA* CTypeInfo2Impl_SearchMethodByDispIDAndFlags(
CTypeInfo2Impl* This,DISPID dispid,UINT16 wFlags)
{
DWORD n;
METHODDATA* pm;
for ( n = 0; n < This->ifd.cMembers; n++ )
{
pm = &This->ifd.pmethdata[n];
if ( (pm->dispid == dispid) && (pm->wFlags & wFlags) )
return pm;
}
return NULL;
}
static int CTypeInfo2Impl_SearchParamByName(
const METHODDATA* pm,const OLECHAR* pName)
{
PARAMDATA* pP;
DWORD k;
for ( k = 0; k < pm->cArgs; k++ )
{
pP = &pm->ppdata[k];
if ( !lstrcmpiW(pP->szName,pName) )
return (int)k;
}
return -1;
}
/****************************************************************************/
static HRESULT WINAPI CTypeInfo2Impl_fnQueryInterface(
ITypeInfo2* iface,REFIID riid,void** ppvobj)
{
ICOM_THIS(CTypeInfo2Impl,iface);
TRACE("(%p)->(IID: %s)\n",This,debugstr_guid(riid));
*ppvobj = NULL;
if ( IsEqualIID(riid, &IID_IUnknown) ||
IsEqualIID(riid, &IID_ITypeInfo) ||
IsEqualIID(riid, &IID_ITypeInfo2) )
{
*ppvobj = (void*)iface;
ITypeInfo2_AddRef(iface);
return S_OK;
}
return E_NOINTERFACE;
}
static ULONG WINAPI CTypeInfo2Impl_fnAddRef(ITypeInfo2* iface)
{
ICOM_THIS(CTypeInfo2Impl,iface);
return ++ This->ref;
}
static ULONG WINAPI CTypeInfo2Impl_fnRelease(ITypeInfo2* iface)
{
ICOM_THIS(CTypeInfo2Impl,iface);
if ( -- This->ref > 0 ) return This->ref;
++ This->ref;
CTypeInfo2Impl_Destruct(This);
HeapFree(GetProcessHeap(),0,This);
return 0;
}
static HRESULT WINAPI CTypeInfo2Impl_fnGetTypeAttr(
ITypeInfo2* iface,LPTYPEATTR* ppTypeAttr)
{
ICOM_THIS(CTypeInfo2Impl,iface);
TYPEATTR* pta;
FIXME("(%p)\n",This);
if ( ppTypeAttr == NULL )
return E_POINTER;
pta = (TYPEATTR*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(TYPEATTR));
if ( pta == NULL ) return E_OUTOFMEMORY;
/* FIXME!!! */
pta->lcid = This->lcid;
pta->memidConstructor = MEMBERID_NIL;
pta->memidDestructor = MEMBERID_NIL;
pta->lpstrSchema = NULL;
pta->cbSizeInstance = 0;
pta->typekind = 0;
pta->cFuncs = This->ifd.cMembers;
pta->cVars = 0;
pta->cImplTypes = 1;
pta->cbSizeVft = sizeof(DWORD)*This->ifd.cMembers;
pta->cbAlignment = sizeof(DWORD);
pta->wTypeFlags = 0;
pta->wMajorVerNum = 1;
pta->wMinorVerNum = 0;
ZeroMemory( &pta->idldescType, sizeof(pta->idldescType) );
*ppTypeAttr = pta;
return S_OK;
}
static HRESULT WINAPI CTypeInfo2Impl_fnGetTypeComp(
ITypeInfo2* iface,ITypeComp** ppTComp)
{
ICOM_THIS(CTypeInfo2Impl,iface);
FIXME("(%p) stub!\n",This);
return E_NOTIMPL;
}
static HRESULT WINAPI CTypeInfo2Impl_fnGetFuncDesc(
ITypeInfo2* iface,UINT index,LPFUNCDESC* ppFuncDesc)
{
ICOM_THIS(CTypeInfo2Impl,iface);
FIXME("(%p) stub!\n",This);
return E_NOTIMPL;
}
static HRESULT WINAPI CTypeInfo2Impl_fnGetVarDesc(
ITypeInfo2* iface,UINT index,LPVARDESC* ppVarDesc)
{
ICOM_THIS(CTypeInfo2Impl,iface);
FIXME("(%p) stub!\n",This);
return E_NOTIMPL;
}
static HRESULT WINAPI CTypeInfo2Impl_fnGetNames(
ITypeInfo2* iface, MEMBERID memid,BSTR* rgBstrNames,
UINT cMaxNames, UINT* pcNames)
{
ICOM_THIS(CTypeInfo2Impl,iface);
FIXME("(%p) stub!\n",This);
return E_NOTIMPL;
}
static HRESULT WINAPI CTypeInfo2Impl_fnGetRefTypeOfImplType(
ITypeInfo2* iface,UINT index,HREFTYPE* pRefType)
{
ICOM_THIS(CTypeInfo2Impl,iface);
FIXME("(%p) stub!\n",This);
return E_NOTIMPL;
}
static HRESULT WINAPI CTypeInfo2Impl_fnGetImplTypeFlags(
ITypeInfo2* iface,UINT index,INT* pImplTypeFlags)
{
ICOM_THIS(CTypeInfo2Impl,iface);
FIXME("(%p) stub!\n",This);
return E_NOTIMPL;
}
static HRESULT WINAPI CTypeInfo2Impl_fnGetIDsOfNames(
ITypeInfo2* iface,LPOLESTR* rgszNames,UINT cNames,MEMBERID* pMemId)
{
ICOM_THIS(CTypeInfo2Impl,iface);
const METHODDATA* pm;
DWORD n;
int index;
TRACE("(%p,%s,%u,%p)\n",This,debugstr_w(*rgszNames),cNames,pMemId);
if ( rgszNames == NULL || pMemId == NULL ) return E_POINTER;
if ( cNames <= 0 ) return E_INVALIDARG;
for ( n = 0; n < cNames; n++ )
{
if ( rgszNames[n] == NULL ) return E_POINTER;
}
pm = CTypeInfo2Impl_SearchMethodByName(This,rgszNames[0]);
if ( pm == NULL ) return DISP_E_UNKNOWNNAME;
pMemId[0] = (MEMBERID)pm->dispid;
for ( n = 1; n < cNames; n++ )
{
index = CTypeInfo2Impl_SearchParamByName(pm,rgszNames[n]);
if ( index < 0 ) return DISP_E_UNKNOWNNAME;
pMemId[n] = (MEMBERID)index;
}
return S_OK;
}
static HRESULT WINAPI CTypeInfo2Impl_fnInvoke(
ITypeInfo2* iface,VOID* punk,MEMBERID memid,
UINT16 wFlags,DISPPARAMS* pDispParams,VARIANT* pVarResult,
EXCEPINFO* pExcepInfo,UINT* pArgErr)
{
ICOM_THIS(CTypeInfo2Impl,iface);
const METHODDATA* pm;
DWORD res;
HRESULT hr;
int n;
DWORD cargs;
DWORD* pargs = NULL;
VARIANT varError;
VARIANT varRet;
FIXME("(%p,%p,%ld,%08x,%p,%p,%p,%p)\n",
This,punk,(long)memid,(int)wFlags,
pDispParams,pVarResult,pExcepInfo,pArgErr);
if ( punk == NULL || pArgErr == NULL )
return E_POINTER;
pm = CTypeInfo2Impl_SearchMethodByDispIDAndFlags(
This,memid,wFlags);
if ( pm == NULL )
{
ERR("did not find member id %ld, flags %d!\n", (long)memid, (int)wFlags);
return DISP_E_MEMBERNOTFOUND;
}
cargs = pm->cArgs + 1;
pargs = (DWORD*)HeapAlloc(GetProcessHeap(), 0, sizeof(DWORD)*(pm->cArgs+2) );
if ( pargs == NULL ) { hr = E_OUTOFMEMORY; goto err_invoke; }
V_VT(&varError) = VT_ERROR;
pargs[0] = (DWORD)punk;
for ( n = 1; n <= (int)pm->cArgs; n++ )
pargs[n] = (DWORD)&varError; /* FIXME? */
if ( (int)pDispParams->cArgs > (int)pm->cArgs )
{
hr = E_FAIL; /* FIXME? */
goto err_invoke;
}
for ( n = 1; n <= (int)pm->cArgs; n++ )
{
if ( n <= (int)pDispParams->cNamedArgs )
{
/* FIXME - handle named args. */
/* FIXME - check types. */
/* pDispParams->rgdispidNamedArgs */
/* pDispParams->cNamedArgs */
FIXME("named args - %d\n",n);
pargs[n] = V_UNION(&pDispParams->rgvarg[pDispParams->cArgs-n],lVal);
}
else
{
/* FIXME - check types. */
pargs[n] = V_UNION(&pDispParams->rgvarg[pDispParams->cArgs-n],lVal);
}
}
VariantInit( &varRet );
if ( pm->vtReturn != VT_EMPTY &&
(!(wFlags & (DISPATCH_PROPERTYPUT|DISPATCH_PROPERTYPUTREF))) )
{
if ( pVarResult != NULL )
{
pargs[cargs] = (DWORD)pVarResult;
}
else
{
pargs[cargs] = (DWORD)(&varRet);
}
cargs ++;
}
res = _invoke(
(*(DWORD***)punk)[pm->iMeth],
pm->cc, cargs, pargs );
VariantClear( &varRet );
if ( res == (DWORD)-1 ) /* FIXME? */
{
hr = E_FAIL;
goto err_invoke;
}
hr = S_OK;
err_invoke:
HeapFree( GetProcessHeap(), 0, pargs );
return hr;
}
static HRESULT WINAPI CTypeInfo2Impl_fnGetDocumentation(
ITypeInfo2* iface,
MEMBERID memid, BSTR* pBstrName, BSTR* pBstrDocString,
DWORD* pdwHelpContext, BSTR* pBstrHelpFile)
{
ICOM_THIS(CTypeInfo2Impl,iface);
FIXME("(%p) stub!\n",This);
return E_NOTIMPL;
}
static HRESULT WINAPI CTypeInfo2Impl_fnGetDllEntry(
ITypeInfo2* iface,MEMBERID memid,
INVOKEKIND invKind,BSTR* pBstrDllName,BSTR* pBstrName,
WORD* pwOrdinal)
{
ICOM_THIS(CTypeInfo2Impl,iface);
FIXME("(%p) stub!\n",This);
return E_NOTIMPL;
}
static HRESULT WINAPI CTypeInfo2Impl_fnGetRefTypeInfo(
ITypeInfo2* iface,HREFTYPE hRefType,ITypeInfo** ppTInfo)
{
ICOM_THIS(CTypeInfo2Impl,iface);
FIXME("(%p) stub!\n",This);
return E_NOTIMPL;
}
static HRESULT WINAPI CTypeInfo2Impl_fnAddressOfMember(
ITypeInfo2 *iface,
MEMBERID memid,INVOKEKIND invKind,PVOID* ppv)
{
ICOM_THIS(CTypeInfo2Impl,iface);
FIXME("(%p) stub!\n",This);
return E_NOTIMPL;
}
static HRESULT WINAPI CTypeInfo2Impl_fnCreateInstance(
ITypeInfo2* iface,
IUnknown* punk,REFIID riid,VOID** ppvObj)
{
ICOM_THIS(CTypeInfo2Impl,iface);
FIXME("(%p) stub!\n",This);
return E_NOTIMPL;
}
static HRESULT WINAPI CTypeInfo2Impl_fnGetMops(
ITypeInfo2* iface,MEMBERID memid,BSTR* pBstrMops)
{
ICOM_THIS(CTypeInfo2Impl,iface);
FIXME("(%p) stub!\n",This);
return E_NOTIMPL;
}
static HRESULT WINAPI CTypeInfo2Impl_fnGetContainingTypeLib(
ITypeInfo2* iface,ITypeLib** ppTLib,UINT* pIndex)
{
ICOM_THIS(CTypeInfo2Impl,iface);
FIXME("(%p) stub!\n",This);
return E_NOTIMPL;
}
static HRESULT WINAPI CTypeInfo2Impl_fnReleaseTypeAttr(
ITypeInfo2* iface,TYPEATTR* pTypeAttr)
{
ICOM_THIS(CTypeInfo2Impl,iface);
FIXME("(%p)\n",This);
if ( pTypeAttr != NULL )
HeapFree(GetProcessHeap(),0,pTypeAttr);
return S_OK;
}
static HRESULT WINAPI CTypeInfo2Impl_fnReleaseFuncDesc(
ITypeInfo2* iface,FUNCDESC* pFuncDesc)
{
ICOM_THIS(CTypeInfo2Impl,iface);
FIXME("(%p) stub!\n",This);
return E_NOTIMPL;
}
static HRESULT WINAPI CTypeInfo2Impl_fnReleaseVarDesc(
ITypeInfo2* iface,VARDESC* pVarDesc)
{
ICOM_THIS(CTypeInfo2Impl,iface);
FIXME("(%p) stub!\n",This);
return E_NOTIMPL;
}
static HRESULT WINAPI CTypeInfo2Impl_fnGetTypeKind(
ITypeInfo2* iface,TYPEKIND* pTypeKind)
{
ICOM_THIS(CTypeInfo2Impl,iface);
FIXME("(%p) stub!\n",This);
return E_NOTIMPL;
}
static HRESULT WINAPI CTypeInfo2Impl_fnGetTypeFlags(
ITypeInfo2* iface,UINT* pTypeFlags)
{
ICOM_THIS(CTypeInfo2Impl,iface);
FIXME("(%p) stub!\n",This);
return E_NOTIMPL;
}
static HRESULT WINAPI CTypeInfo2Impl_fnGetFuncIndexOfMemId(
ITypeInfo2* iface,
MEMBERID memid,INVOKEKIND invKind,UINT* pFuncIndex)
{
ICOM_THIS(CTypeInfo2Impl,iface);
FIXME("(%p) stub!\n",This);
return E_NOTIMPL;
}
static HRESULT WINAPI CTypeInfo2Impl_fnGetVarIndexOfMemId(
ITypeInfo2* iface,
MEMBERID memid,UINT* pVarIndex)
{
ICOM_THIS(CTypeInfo2Impl,iface);
FIXME("(%p) stub!\n",This);
return E_NOTIMPL;
}
static HRESULT WINAPI CTypeInfo2Impl_fnGetCustData(
ITypeInfo2* iface,REFGUID guid,VARIANT* pVarVal)
{
ICOM_THIS(CTypeInfo2Impl,iface);
FIXME("(%p) stub!\n",This);
return E_NOTIMPL;
}
static HRESULT WINAPI CTypeInfo2Impl_fnGetFuncCustData(
ITypeInfo2* iface,UINT index,REFGUID guid,VARIANT* pVarVal)
{
ICOM_THIS(CTypeInfo2Impl,iface);
FIXME("(%p) stub!\n",This);
return E_NOTIMPL;
}
static HRESULT WINAPI CTypeInfo2Impl_fnGetParamCustData(
ITypeInfo2* iface,UINT indexFunc,UINT indexParam,
REFGUID guid,VARIANT* pVarVal)
{
ICOM_THIS(CTypeInfo2Impl,iface);
FIXME("(%p) stub!\n",This);
return E_NOTIMPL;
}
static HRESULT WINAPI CTypeInfo2Impl_fnGetVarCustData(
ITypeInfo2* iface,UINT index,REFGUID guid,VARIANT* pVarVal)
{
ICOM_THIS(CTypeInfo2Impl,iface);
FIXME("(%p) stub!\n",This);
return E_NOTIMPL;
}
static HRESULT WINAPI CTypeInfo2Impl_fnGetImplTypeCustData(
ITypeInfo2 * iface,UINT index,REFGUID guid,VARIANT* pVarVal)
{
ICOM_THIS(CTypeInfo2Impl,iface);
FIXME("(%p) stub!\n",This);
return E_NOTIMPL;
}
static HRESULT WINAPI CTypeInfo2Impl_fnGetDocumentation2(
ITypeInfo2* iface,MEMBERID memid,LCID lcid,
BSTR* pbstrHelpString,DWORD* pdwHelpStringContext,BSTR* pbstrHelpStringDll)
{
ICOM_THIS(CTypeInfo2Impl,iface);
FIXME("(%p) stub!\n",This);
return E_NOTIMPL;
}
static HRESULT WINAPI CTypeInfo2Impl_fnGetAllCustData(
ITypeInfo2* iface,CUSTDATA* pCustData)
{
ICOM_THIS(CTypeInfo2Impl,iface);
FIXME("(%p) stub!\n",This);
return E_NOTIMPL;
}
static HRESULT WINAPI CTypeInfo2Impl_fnGetAllFuncCustData(
ITypeInfo2* iface,UINT index,CUSTDATA* pCustData)
{
ICOM_THIS(CTypeInfo2Impl,iface);
FIXME("(%p) stub!\n",This);
return E_NOTIMPL;
}
static HRESULT WINAPI CTypeInfo2Impl_fnGetAllParamCustData(
ITypeInfo2* iface,UINT indexFunc,UINT indexParam,CUSTDATA* pCustData)
{
ICOM_THIS(CTypeInfo2Impl,iface);
FIXME("(%p) stub!\n",This);
return E_NOTIMPL;
}
static HRESULT WINAPI CTypeInfo2Impl_fnGetAllVarCustData(
ITypeInfo2* iface,UINT index,CUSTDATA* pCustData)
{
ICOM_THIS(CTypeInfo2Impl,iface);
FIXME("(%p) stub!\n",This);
return E_NOTIMPL;
}
static HRESULT WINAPI CTypeInfo2Impl_fnGetAllImplTypeCustData(
ITypeInfo2* iface,UINT index,CUSTDATA* pCustData)
{
ICOM_THIS(CTypeInfo2Impl,iface);
FIXME("(%p) stub!\n",This);
return E_NOTIMPL;
}
static ICOM_VTABLE(ITypeInfo2) itypeinfo2 =
{
ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
/* IUnknown */
CTypeInfo2Impl_fnQueryInterface,
CTypeInfo2Impl_fnAddRef,
CTypeInfo2Impl_fnRelease,
/* ITypeInfo */
CTypeInfo2Impl_fnGetTypeAttr,
CTypeInfo2Impl_fnGetTypeComp,
CTypeInfo2Impl_fnGetFuncDesc,
CTypeInfo2Impl_fnGetVarDesc,
CTypeInfo2Impl_fnGetNames,
CTypeInfo2Impl_fnGetRefTypeOfImplType,
CTypeInfo2Impl_fnGetImplTypeFlags,
CTypeInfo2Impl_fnGetIDsOfNames,
CTypeInfo2Impl_fnInvoke,
CTypeInfo2Impl_fnGetDocumentation,
CTypeInfo2Impl_fnGetDllEntry,
CTypeInfo2Impl_fnGetRefTypeInfo,
CTypeInfo2Impl_fnAddressOfMember,
CTypeInfo2Impl_fnCreateInstance,
CTypeInfo2Impl_fnGetMops,
CTypeInfo2Impl_fnGetContainingTypeLib,
CTypeInfo2Impl_fnReleaseTypeAttr,
CTypeInfo2Impl_fnReleaseFuncDesc,
CTypeInfo2Impl_fnReleaseVarDesc,
/* ITypeInfo2 */
CTypeInfo2Impl_fnGetTypeKind,
CTypeInfo2Impl_fnGetTypeFlags,
CTypeInfo2Impl_fnGetFuncIndexOfMemId,
CTypeInfo2Impl_fnGetVarIndexOfMemId,
CTypeInfo2Impl_fnGetCustData,
CTypeInfo2Impl_fnGetFuncCustData,
CTypeInfo2Impl_fnGetParamCustData,
CTypeInfo2Impl_fnGetVarCustData,
CTypeInfo2Impl_fnGetImplTypeCustData,
CTypeInfo2Impl_fnGetDocumentation2,
CTypeInfo2Impl_fnGetAllCustData,
CTypeInfo2Impl_fnGetAllFuncCustData,
CTypeInfo2Impl_fnGetAllParamCustData,
CTypeInfo2Impl_fnGetAllVarCustData,
CTypeInfo2Impl_fnGetAllImplTypeCustData,
};
/******************************************************************************
* CreateDispTypeInfo (OLEAUT32.31)
*/
HRESULT WINAPI CreateDispTypeInfo(
INTERFACEDATA* pifd,
LCID lcid,
ITypeInfo** ppinfo )
{
HRESULT hr;
CTypeInfo2Impl* This;
if ( ppinfo == NULL )
return E_POINTER;
This = (CTypeInfo2Impl*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(CTypeInfo2Impl));
if ( This == NULL ) return E_OUTOFMEMORY;
ICOM_VTBL(This) = &itypeinfo2;
This->ref = 1;
hr = CTypeInfo2Impl_Construct(This,pifd,lcid);
if ( FAILED(hr) )
{
IUnknown_Release((IUnknown*)This);
return hr;
}
*ppinfo = (ITypeInfo*)This;
return S_OK;
}
......@@ -351,6 +351,18 @@ int WINAPI SysStringByteLen(BSTR str)
return (int)(*bufferPointer);
}
/******************************************************************************
* CreateDispTypeInfo [OLEAUT32.31]
*/
HRESULT WINAPI CreateDispTypeInfo(
INTERFACEDATA *pidata,
LCID lcid,
ITypeInfo **pptinfo)
{
FIXME("(%p,%ld,%p),stub\n",pidata,lcid,pptinfo);
return 0;
}
/******************************************************************************
* CreateDispTypeInfo [OLE2DISP.31]
*/
......@@ -371,6 +383,20 @@ HRESULT WINAPI CreateStdDispatch16(
void* pvThis,
ITypeInfo* ptinfo,
IUnknown** ppunkStdDisp)
{
FIXME("(%p,%p,%p,%p),stub\n",punkOuter, pvThis, ptinfo,
ppunkStdDisp);
return 0;
}
/******************************************************************************
* CreateStdDispatch [OLEAUT32.32]
*/
HRESULT WINAPI CreateStdDispatch(
IUnknown* punkOuter,
void* pvThis,
ITypeInfo* ptinfo,
IUnknown** ppunkStdDisp)
{
FIXME("(%p,%p,%p,%p),stub\n",punkOuter, pvThis, ptinfo,
ppunkStdDisp);
......
/*
* Copyright 2001 TAKESHIMA Hidenori <hidenori@a2.ctktv.ne.jp>
*
* 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* FIXME - use PropertySheetW.
* FIXME - not tested.
*/
#include "config.h"
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "wine/debug.h"
#include "ole2.h"
#include "olectl.h"
#include "oleauto.h"
#include "commctrl.h"
WINE_DEFAULT_DEBUG_CHANNEL(ole);
typedef struct CPropertyPageContainerImpl CPropertyPageContainerImpl;
static const struct
{
DLGTEMPLATE templ;
WORD wMenuName;
WORD wClassName;
WCHAR wDummyCaption;
BYTE padding[4];
} propsite_dlg =
{
{
WS_VISIBLE | WS_CHILD, /* style */
0, /* dwExtendedStyle */
0, /* cdit */
0, /* x */
0, /* y */
0, /* cx */
0, /* cy */
},
0, 0, 0,
};
typedef struct CPropertyPageSiteImpl
{
ICOM_VFIELD(IPropertyPageSite);
/* IUnknown fields */
ULONG ref;
/* IPropertyPageSite fields */
CPropertyPageContainerImpl* pContainer;
IPropertyPage* pPage;
HWND hwnd;
BYTE templ[sizeof(propsite_dlg)];
PROPPAGEINFO info;
BOOL bActivate;
} CPropertyPageSiteImpl;
struct CPropertyPageContainerImpl
{
ULONG ref; /* for IUnknown(not used now) */
LCID lcid;
DWORD m_cSites;
CPropertyPageSiteImpl** m_ppSites;
PROPSHEETPAGEA* m_pPsp;
HRESULT m_hr;
};
/* for future use. */
#define CPropertyPageContainerImpl_AddRef(pContainer) (++((pContainer)->ref))
#define CPropertyPageContainerImpl_Release(pContainer) (--((pContainer)->ref))
/***************************************************************************/
#define PropSiteDlg_Return(a) do{SetWindowLongA(hwnd,DWL_MSGRESULT,(LONG)a);return TRUE;}while(1)
static BOOL CALLBACK PropSiteDlgProc(
HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
CPropertyPageSiteImpl* This = (CPropertyPageSiteImpl*)GetWindowLongA( hwnd, DWL_USER );
HRESULT hr;
RECT rc;
NMHDR* pnmh;
switch ( msg )
{
case WM_INITDIALOG:
This = (CPropertyPageSiteImpl*)(((PROPSHEETPAGEA*)lParam)->lParam);
SetWindowLongA( hwnd, DWL_USER, (LONG)This );
TRACE("WM_INITDIALOG (%p) hwnd = %08x\n", This, hwnd );
This->hwnd = hwnd;
ZeroMemory( &rc, sizeof(rc) );
GetClientRect( hwnd, &rc );
hr = IPropertyPage_Activate(This->pPage,hwnd,&rc,TRUE);
if ( SUCCEEDED(hr) )
{
This->bActivate = TRUE;
hr = IPropertyPage_Show(This->pPage,SW_SHOW);
}
if ( FAILED(hr) )
This->pContainer->m_hr = hr;
break;
case WM_DESTROY:
TRACE("WM_DESTROY (%p)\n",This);
if ( This != NULL )
{
if ( This->bActivate )
{
IPropertyPage_Show(This->pPage,SW_HIDE);
IPropertyPage_Deactivate(This->pPage);
This->bActivate = FALSE;
}
This->hwnd = (HWND)NULL;
}
SetWindowLongA( hwnd, DWL_USER, (LONG)0 );
break;
case WM_NOTIFY:
pnmh = (NMHDR*)lParam;
switch ( pnmh->code )
{
case PSN_APPLY:
TRACE("PSN_APPLY (%p)\n",This);
hr = IPropertyPage_Apply(This->pPage);
if ( FAILED(hr) )
PropSiteDlg_Return(PSNRET_INVALID_NOCHANGEPAGE);
PropSiteDlg_Return(PSNRET_NOERROR);
case PSN_QUERYCANCEL:
FIXME("PSN_QUERYCANCEL (%p)\n",This);
PropSiteDlg_Return(FALSE);
case PSN_RESET:
FIXME("PSN_RESET (%p)\n",This);
PropSiteDlg_Return(0);
case PSN_SETACTIVE:
TRACE("PSN_SETACTIVE (%p)\n",This);
PropSiteDlg_Return(0);
case PSN_KILLACTIVE:
TRACE("PSN_KILLACTIVE (%p)\n",This);
PropSiteDlg_Return(FALSE);
}
break;
}
return FALSE;
}
/***************************************************************************/
static HRESULT WINAPI
CPropertyPageSiteImpl_fnQueryInterface(IPropertyPageSite* iface,REFIID riid,LPVOID *ppobj)
{
ICOM_THIS(CPropertyPageSiteImpl,iface);
TRACE("(%p)->(%s,%p)\n",This,debugstr_guid(riid),ppobj);
if ( ppobj == NULL )
return E_POINTER;
*ppobj = NULL;
if ( IsEqualGUID(riid,&IID_IUnknown) ||
IsEqualGUID(riid,&IID_IPropertyPageSite) )
{
*ppobj = (LPVOID)This;
IUnknown_AddRef((IUnknown*)(*ppobj));
return S_OK;
}
return E_NOINTERFACE;
}
static ULONG WINAPI
CPropertyPageSiteImpl_fnAddRef(IPropertyPageSite* iface)
{
ICOM_THIS(CPropertyPageSiteImpl,iface);
TRACE("(%p)->()\n",This);
return InterlockedExchangeAdd(&(This->ref),1) + 1;
}
static ULONG WINAPI
CPropertyPageSiteImpl_fnRelease(IPropertyPageSite* iface)
{
ICOM_THIS(CPropertyPageSiteImpl,iface);
LONG ref;
TRACE("(%p)->()\n",This);
ref = InterlockedExchangeAdd(&(This->ref),-1) - 1;
if ( ref > 0 )
return (ULONG)ref;
if ( This->pContainer != NULL )
CPropertyPageContainerImpl_Release(This->pContainer);
if ( This->pPage != NULL )
IPropertyPage_Release(This->pPage);
if ( This->info.pszTitle != NULL )
CoTaskMemFree( This->info.pszTitle );
if ( This->info.pszDocString != NULL )
CoTaskMemFree( This->info.pszDocString );
if ( This->info.pszHelpFile != NULL )
CoTaskMemFree( This->info.pszHelpFile );
HeapFree(GetProcessHeap(),0,This);
return 0;
}
static HRESULT WINAPI
CPropertyPageSiteImpl_fnOnStatusChange(IPropertyPageSite* iface,DWORD dwFlags)
{
ICOM_THIS(CPropertyPageSiteImpl,iface);
TRACE("(%p,%08lx)\n",This,dwFlags);
if ( This->hwnd == (HWND)NULL )
return E_UNEXPECTED;
switch ( dwFlags )
{
case PROPPAGESTATUS_DIRTY:
/* dirty */
SendMessageA(GetParent(This->hwnd),PSM_CHANGED,(WPARAM)(This->hwnd),0);
break;
case PROPPAGESTATUS_VALIDATE:
/* validate */
SendMessageA(GetParent(This->hwnd),PSM_UNCHANGED,(WPARAM)(This->hwnd),0);
break;
default:
FIXME("(%p,%08lx) unknown flags\n",This,dwFlags);
return E_INVALIDARG;
}
return NOERROR;
}
static HRESULT WINAPI
CPropertyPageSiteImpl_fnGetLocaleID(IPropertyPageSite* iface,LCID* pLocaleID)
{
ICOM_THIS(CPropertyPageSiteImpl,iface);
TRACE("(%p,%p)\n",This,pLocaleID);
if ( pLocaleID == NULL )
return E_POINTER;
*pLocaleID = This->pContainer->lcid;
return NOERROR;
}
static HRESULT WINAPI
CPropertyPageSiteImpl_fnGetPageContainer(IPropertyPageSite* iface,IUnknown** ppUnk)
{
ICOM_THIS(CPropertyPageSiteImpl,iface);
FIXME("(%p,%p) - Win95 returns E_NOTIMPL\n",This,ppUnk);
if ( ppUnk == NULL )
return E_POINTER;
*ppUnk = NULL;
return E_NOTIMPL;
}
static HRESULT WINAPI
CPropertyPageSiteImpl_fnTranslateAccelerator(IPropertyPageSite* iface,MSG* pMsg)
{
ICOM_THIS(CPropertyPageSiteImpl,iface);
FIXME("(%p,%p) - Win95 returns E_NOTIMPL\n",This,pMsg);
if ( pMsg == NULL )
return E_POINTER;
return E_NOTIMPL;
}
static ICOM_VTABLE(IPropertyPageSite) iproppagesite =
{
ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
/* IUnknown fields */
CPropertyPageSiteImpl_fnQueryInterface,
CPropertyPageSiteImpl_fnAddRef,
CPropertyPageSiteImpl_fnRelease,
/* IPropertyPageSite fields */
CPropertyPageSiteImpl_fnOnStatusChange,
CPropertyPageSiteImpl_fnGetLocaleID,
CPropertyPageSiteImpl_fnGetPageContainer,
CPropertyPageSiteImpl_fnTranslateAccelerator,
};
/***************************************************************************/
static
HRESULT OLEPRO32_CreatePropertyPageSite(
CPropertyPageContainerImpl* pContainer,
IPropertyPage* pPage,
CPropertyPageSiteImpl** ppSite,
PROPSHEETPAGEA* pPspReturned )
{
CPropertyPageSiteImpl* This = NULL;
HRESULT hr;
DLGTEMPLATE* ptempl;
*ppSite = NULL;
ZeroMemory( pPspReturned, sizeof(PROPSHEETPAGEA) );
This = (CPropertyPageSiteImpl*)HeapAlloc( GetProcessHeap(), 0,
sizeof(CPropertyPageSiteImpl) );
if ( This == NULL )
return E_OUTOFMEMORY;
ZeroMemory( This, sizeof(CPropertyPageSiteImpl) );
ICOM_VTBL(This) = &iproppagesite;
This->ref = 1;
This->pContainer = pContainer; CPropertyPageContainerImpl_AddRef(pContainer);
This->pPage = pPage; IPropertyPage_AddRef(pPage);
This->hwnd = (HWND)NULL;
memcpy( &This->templ, &propsite_dlg, sizeof(propsite_dlg) );
This->info.cb = sizeof(PROPPAGEINFO);
This->bActivate = FALSE;
ptempl = (DLGTEMPLATE*)&This->templ;
/* construct */
hr = IPropertyPage_SetPageSite(pPage,(IPropertyPageSite*)This);
if ( FAILED(hr) )
goto end;
hr = IPropertyPage_GetPageInfo(pPage,&This->info);
if ( FAILED(hr) )
goto end;
ptempl->cx = This->info.size.cx;
ptempl->cy = This->info.size.cy;
pPspReturned->dwSize = sizeof(PROPSHEETPAGEA);
pPspReturned->dwFlags = PSP_DLGINDIRECT;
pPspReturned->u.pResource = ptempl;
if ( This->info.pszTitle != NULL );
{
pPspReturned->dwFlags |= PSP_USETITLE;
pPspReturned->pszTitle = "Title";/*FIXME - This->info.pszTitle;*/
}
pPspReturned->pfnDlgProc = PropSiteDlgProc;
pPspReturned->lParam = (LONG)This;
end:
if ( FAILED(hr) )
{
IUnknown_Release((IUnknown*)This);
return hr;
}
*ppSite = This;
return NOERROR;
}
/***************************************************************************/
static
void OLEPRO32_DestroyPropertyPageContainer(
CPropertyPageContainerImpl* This )
{
DWORD nIndex;
if ( This->m_ppSites != NULL )
{
for ( nIndex = 0; nIndex < This->m_cSites; nIndex++ )
{
if ( This->m_ppSites[nIndex] != NULL )
{
IPropertyPage_SetPageSite(This->m_ppSites[nIndex]->pPage,NULL);
IUnknown_Release((IUnknown*)This->m_ppSites[nIndex]);
}
}
HeapFree( GetProcessHeap(), 0, This->m_ppSites );
This->m_ppSites = NULL;
}
if ( This->m_pPsp != NULL )
{
HeapFree( GetProcessHeap(), 0, This->m_pPsp );
This->m_pPsp = NULL;
}
HeapFree( GetProcessHeap(), 0, This );
}
static
HRESULT OLEPRO32_CreatePropertyPageContainer(
CPropertyPageContainerImpl** ppContainer,
ULONG cPages, const CLSID* pclsidPages,
LCID lcid )
{
CPropertyPageContainerImpl* This = NULL;
DWORD nIndex;
IPropertyPage* pPage;
HRESULT hr;
This = (CPropertyPageContainerImpl*)HeapAlloc( GetProcessHeap(), 0,
sizeof(CPropertyPageContainerImpl) );
if ( This == NULL )
return E_OUTOFMEMORY;
ZeroMemory( This, sizeof(CPropertyPageContainerImpl) );
This->ref = 1;
This->lcid = lcid;
This->m_cSites = cPages;
This->m_ppSites = NULL;
This->m_pPsp = NULL;
This->m_hr = S_OK;
This->m_ppSites = (CPropertyPageSiteImpl**)HeapAlloc( GetProcessHeap(), 0, sizeof(CPropertyPageSiteImpl*) * cPages );
if ( This->m_ppSites == NULL )
{
hr = E_OUTOFMEMORY;
goto end;
}
ZeroMemory( This->m_ppSites, sizeof(CPropertyPageSiteImpl*) * cPages );
This->m_pPsp = (PROPSHEETPAGEA*)HeapAlloc( GetProcessHeap(), 0, sizeof(PROPSHEETPAGEA) * cPages );
if ( This->m_pPsp == NULL )
{
hr = E_OUTOFMEMORY;
goto end;
}
ZeroMemory( This->m_pPsp, sizeof(PROPSHEETPAGEA) * cPages );
for ( nIndex = 0; nIndex < cPages; nIndex ++ )
{
hr = CoCreateInstance(
&pclsidPages[nIndex], NULL, CLSCTX_SERVER,
&IID_IPropertyPage, (void**)&pPage );
if ( FAILED(hr) )
goto end;
hr = OLEPRO32_CreatePropertyPageSite(
This, pPage, &This->m_ppSites[nIndex], &This->m_pPsp[nIndex] );
IPropertyPage_Release(pPage);
if ( FAILED(hr) )
goto end;
}
hr = NOERROR;
end:
if ( FAILED(hr) )
{
OLEPRO32_DestroyPropertyPageContainer( This );
return hr;
}
*ppContainer = This;
return NOERROR;
}
static
HRESULT OLEPRO32_SetObjectsToPropertyPages(
CPropertyPageContainerImpl* This,
ULONG cObjects, IUnknown** ppunk )
{
DWORD nIndex;
HRESULT hr;
for ( nIndex = 0; nIndex < This->m_cSites; nIndex ++ )
{
if ( This->m_ppSites[nIndex] == NULL )
return E_UNEXPECTED;
hr = IPropertyPage_SetObjects(This->m_ppSites[nIndex]->pPage,cObjects,ppunk);
if ( FAILED(hr) )
return hr;
}
return NOERROR;
}
/***********************************************************************
*
* OleCreatePropertyFrameIndirect (OLEAUT32.416)(OLEPRO32.249)
*
*/
HRESULT WINAPI OleCreatePropertyFrameIndirect( LPOCPFIPARAMS lpParams )
{
CPropertyPageContainerImpl* pContainer = NULL;
HRESULT hr;
PROPSHEETHEADERA psh;
int ret;
TRACE("(%p)\n",lpParams);
if ( lpParams == NULL )
return E_POINTER;
if ( lpParams->cbStructSize != sizeof(OCPFIPARAMS) )
{
FIXME("lpParams->cbStructSize(%lu) != sizeof(OCPFIPARAMS)(%lu)\n",lpParams->cbStructSize,(unsigned long)sizeof(OCPFIPARAMS));
return E_INVALIDARG;
}
hr = OLEPRO32_CreatePropertyPageContainer(
&pContainer,
lpParams->cPages, lpParams->lpPages,
lpParams->lcid );
if ( FAILED(hr) )
{
TRACE( "OLEPRO32_CreatePropertyPageContainer returns %08lx\n",hr);
return hr;
}
hr = OLEPRO32_SetObjectsToPropertyPages(
pContainer,
lpParams->cObjects, lpParams->lplpUnk );
if ( FAILED(hr) )
{
TRACE("OLEPRO32_SetObjectsToPropertyPages returns %08lx\n",hr);
OLEPRO32_DestroyPropertyPageContainer(pContainer);
return hr;
}
/* FIXME - use lpParams.x / lpParams.y */
ZeroMemory( &psh, sizeof(psh) );
psh.dwSize = sizeof(PROPSHEETHEADERA);
psh.dwFlags = PSH_PROPSHEETPAGE;
psh.hwndParent = lpParams->hWndOwner;
psh.pszCaption = "Caption"; /* FIXME - lpParams->lpszCaption; */
psh.nPages = pContainer->m_cSites;
psh.u2.nStartPage = lpParams->dispidInitialProperty;
psh.u3.ppsp = pContainer->m_pPsp;
ret = PropertySheetA( &psh );
OLEPRO32_DestroyPropertyPageContainer(pContainer);
if ( ret == -1 )
return E_FAIL;
return S_OK;
}
/***********************************************************************
*
* OleCreatePropertyFrame (OLEAUT32.417)(OLEPRO32.250)
*
*/
HRESULT WINAPI OleCreatePropertyFrame(
HWND hwndOwner, UINT x, UINT y, LPCOLESTR lpszCaption,ULONG cObjects,
LPUNKNOWN* lplpUnk, ULONG cPages, LPCLSID pPageClsID, LCID lcid,
DWORD dwReserved, LPVOID pvReserved )
{
OCPFIPARAMS params;
TRACE("(%x,%d,%d,%s,%ld,%p,%ld,%p,%x,%ld,%p)\n",
hwndOwner,x,y,debugstr_w(lpszCaption),cObjects,lplpUnk,cPages,
pPageClsID, (int)lcid,dwReserved,pvReserved);
if ( dwReserved != 0 || pvReserved != NULL )
{
FIXME("(%x,%d,%d,%s,%ld,%p,%ld,%p,%x,%ld,%p) - E_INVALIDARG\n",
hwndOwner,x,y,debugstr_w(lpszCaption),cObjects,lplpUnk,cPages,
pPageClsID, (int)lcid,dwReserved,pvReserved);
return E_INVALIDARG;
}
ZeroMemory( &params, sizeof(params) );
params.cbStructSize = sizeof(OCPFIPARAMS);
params.hWndOwner = hwndOwner;
params.x = x;
params.y = y;
params.lpszCaption = lpszCaption;
params.cObjects = cObjects;
params.lplpUnk = lplpUnk;
params.cPages = cPages;
params.lpPages = pPageClsID;
params.lcid = lcid;
params.dispidInitialProperty = 0;
return OleCreatePropertyFrameIndirect( &params );
}
......@@ -35,17 +35,30 @@ WINE_DEFAULT_DEBUG_CHANNEL(ole);
*/
HCURSOR WINAPI OleIconToCursor( HINSTANCE hinstExe, HICON hicon)
{
ICONINFO ii;
TRACE("(%x,%x)\n",hinstExe,hicon);
ZeroMemory( &ii, sizeof(ii) );
if ( !GetIconInfo( hicon, &ii ) )
return (HCURSOR)NULL;
ii.fIcon = FALSE;
return CreateIconIndirect( &ii );
FIXME("(%x,%x), not implemented (olepro32.dll)\n",hinstExe,hicon);
return S_OK;
}
/***********************************************************************
* OleCreatePropertyFrameIndirect (OLEAUT32.416)
*/
HRESULT WINAPI OleCreatePropertyFrameIndirect( LPOCPFIPARAMS lpParams)
{
FIXME("(%p), not implemented (olepro32.dll)\n",lpParams);
return S_OK;
}
/***********************************************************************
* OleCreatePropertyFrame (OLEAUT32.417)
*/
HRESULT WINAPI OleCreatePropertyFrame(
HWND hwndOwner, UINT x, UINT y, LPCOLESTR lpszCaption,ULONG cObjects,
LPUNKNOWN* ppUnk, ULONG cPages, LPCLSID pPageClsID, LCID lcid,
DWORD dwReserved, LPVOID pvReserved )
{
FIXME("(%x,%d,%d,%s,%ld,%p,%ld,%p,%x,%ld,%p), not implemented (olepro32.dll)\n",
hwndOwner,x,y,debugstr_w(lpszCaption),cObjects,ppUnk,cPages,
pPageClsID, (int)lcid,dwReserved,pvReserved);
return S_OK;
}
......@@ -4,17 +4,19 @@ TOPOBJDIR = ../..
SRCDIR = @srcdir@
VPATH = @srcdir@
MODULE = shdocvw.dll
EXTRALIBS = $(LIBUUID)
LDDLLFLAGS = @LDDLLFLAGS@
SYMBOLFILE = $(MODULE).tmp.o
C_SRCS = \
api.c \
browser.c \
comimpl.c \
connect.c \
shdocvw.c
classinfo.c \
events.c \
factory.c \
misc.c \
oleobject.c \
persist.c \
shdocvw_main.c \
webbrowser.c
@MAKE_DLL_RULES@
......
/*
* Implementation of IProvideClassInfo interfaces for IE Web Browser control
*
* Copyright 2001 John R. Sheets (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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include <string.h>
#include "wine/debug.h"
#include "shdocvw.h"
WINE_DEFAULT_DEBUG_CHANNEL(shdocvw);
/**********************************************************************
* Implement the IProvideClassInfo interface
*
* FIXME: Should we just pass in the IProvideClassInfo2 methods rather
* reimplementing them here?
*/
static HRESULT WINAPI WBPCI_QueryInterface(LPPROVIDECLASSINFO iface,
REFIID riid, LPVOID *ppobj)
{
ICOM_THIS(IProvideClassInfoImpl, iface);
FIXME("(%p)->(%s,%p),stub!\n", This, debugstr_guid(riid), ppobj);
return E_NOINTERFACE;
}
static ULONG WINAPI WBPCI_AddRef(LPPROVIDECLASSINFO iface)
{
ICOM_THIS(IProvideClassInfoImpl, iface);
TRACE("\n");
return ++(This->ref);
}
static ULONG WINAPI WBPCI_Release(LPPROVIDECLASSINFO iface)
{
ICOM_THIS(IProvideClassInfoImpl, iface);
/* static class, won't be freed */
TRACE("\n");
return --(This->ref);
}
/* Return an ITypeInfo interface to retrieve type library info about
* this control.
*/
static HRESULT WINAPI WBPCI_GetClassInfo(LPPROVIDECLASSINFO iface, LPTYPEINFO *ppTI)
{
FIXME("stub: LPTYPEINFO = %p\n", *ppTI);
return S_OK;
}
/**********************************************************************
* IProvideClassInfo virtual function table for IE Web Browser component
*/
static ICOM_VTABLE(IProvideClassInfo) WBPCI_Vtbl =
{
ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
WBPCI_QueryInterface,
WBPCI_AddRef,
WBPCI_Release,
WBPCI_GetClassInfo
};
IProvideClassInfoImpl SHDOCVW_ProvideClassInfo = { &WBPCI_Vtbl, 1 };
/**********************************************************************
* Implement the IProvideClassInfo2 interface (inherits from
* IProvideClassInfo).
*/
static HRESULT WINAPI WBPCI2_QueryInterface(LPPROVIDECLASSINFO2 iface,
REFIID riid, LPVOID *ppobj)
{
ICOM_THIS(IProvideClassInfo2Impl, iface);
FIXME("(%p)->(%s,%p),stub!\n", This, debugstr_guid(riid), ppobj);
return E_NOINTERFACE;
}
static ULONG WINAPI WBPCI2_AddRef(LPPROVIDECLASSINFO2 iface)
{
ICOM_THIS(IProvideClassInfo2Impl, iface);
TRACE("\n");
return ++(This->ref);
}
static ULONG WINAPI WBPCI2_Release(LPPROVIDECLASSINFO2 iface)
{
ICOM_THIS(IProvideClassInfo2Impl, iface);
/* static class, won't be freed */
TRACE("\n");
return --(This->ref);
}
/* Return an ITypeInfo interface to retrieve type library info about
* this control.
*/
static HRESULT WINAPI WBPCI2_GetClassInfo(LPPROVIDECLASSINFO2 iface, LPTYPEINFO *ppTI)
{
FIXME("stub: LPTYPEINFO = %p\n", *ppTI);
return S_OK;
}
/* Get the IID for generic default event callbacks. This IID will
* in theory be used to later query for an IConnectionPoint to connect
* an event sink (callback implmentation in the OLE control site)
* to this control.
*/
static HRESULT WINAPI WBPCI2_GetGUID(LPPROVIDECLASSINFO2 iface,
DWORD dwGuidKind, GUID *pGUID)
{
FIXME("stub: dwGuidKind = %ld, pGUID = %s\n", dwGuidKind, debugstr_guid(pGUID));
if (dwGuidKind != GUIDKIND_DEFAULT_SOURCE_DISP_IID)
{
FIXME ("Requested unsupported GUID type: %ld\n", dwGuidKind);
return E_FAIL; /* Is there a better return type here? */
}
/* FIXME: Returning IPropertyNotifySink interface, but should really
* return a more generic event set (???) dispinterface.
* However, this hack, allows a control site to return with success
* (MFC's COleControlSite falls back to older IProvideClassInfo interface
* if GetGUID() fails to return a non-NULL GUID).
*/
memcpy(pGUID, &IID_IPropertyNotifySink, sizeof(GUID));
FIXME("Wrongly returning IPropertyNotifySink interface %s\n",
debugstr_guid(pGUID));
return S_OK;
}
/**********************************************************************
* IProvideClassInfo virtual function table for IE Web Browser component
*/
static ICOM_VTABLE(IProvideClassInfo2) WBPCI2_Vtbl =
{
ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
WBPCI2_QueryInterface,
WBPCI2_AddRef,
WBPCI2_Release,
WBPCI2_GetClassInfo,
WBPCI2_GetGUID
};
IProvideClassInfo2Impl SHDOCVW_ProvideClassInfo2 = { &WBPCI2_Vtbl, 1 };
/*
* A basic implementation for COM DLL implementor.
*
* Copyright (C) Hidenori TAKESHIMA <hidenori@a2.ctktv.ne.jp>
*
* 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "config.h"
#include "wine/port.h"
#include "windef.h"
#include "winerror.h"
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "winnls.h"
#include "ole2.h"
#include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(comimpl);
#include "comimpl.h"
/*
- All threading model including Apartment and Both are supported.
- Aggregation is supported.
- CoFreeUnusedLibraries() is supported.
- DisableThreadLibraryCalls() is supported.
*/
static CRITICAL_SECTION csComImpl;
static DWORD dwComImplRef;
static HRESULT WINAPI
IUnknown_fnQueryInterface(IUnknown* iface,REFIID riid,LPVOID *ppobj)
{
ICOM_THIS(COMIMPL_IUnkImpl,iface);
size_t ofs;
DWORD dwIndex;
COMIMPL_IFDelegation* pDelegation;
HRESULT hr;
TRACE("(%p)->(%s,%p)\n",This,debugstr_guid(riid),ppobj);
if ( ppobj == NULL )
return E_POINTER;
*ppobj = NULL;
ofs = 0;
if ( IsEqualGUID( &IID_IUnknown, riid ) )
{
TRACE("IID_IUnknown - returns inner object.\n");
}
else
{
for ( dwIndex = 0; dwIndex < This->dwEntries; dwIndex++ )
{
if ( IsEqualGUID( This->pEntries[dwIndex].piid, riid ) )
{
ofs = This->pEntries[dwIndex].ofsVTPtr;
break;
}
}
if ( dwIndex == This->dwEntries )
{
hr = E_NOINTERFACE;
/* delegation */
pDelegation = This->pDelegationFirst;
while ( pDelegation != NULL )
{
hr = (*pDelegation->pOnQueryInterface)( iface, riid, ppobj );
if ( hr != E_NOINTERFACE )
break;
pDelegation = pDelegation->pNext;
}
if ( hr == E_NOINTERFACE )
{
FIXME("(%p) unknown interface: %s\n",This,debugstr_guid(riid));
}
return hr;
}
}
*ppobj = (LPVOID)(((char*)This) + ofs);
IUnknown_AddRef((IUnknown*)(*ppobj));
return S_OK;
}
static ULONG WINAPI
IUnknown_fnAddRef(IUnknown* iface)
{
ICOM_THIS(COMIMPL_IUnkImpl,iface);
TRACE("(%p)->()\n",This);
return InterlockedExchangeAdd(&(This->ref),1) + 1;
}
static ULONG WINAPI
IUnknown_fnRelease(IUnknown* iface)
{
ICOM_THIS(COMIMPL_IUnkImpl,iface);
LONG ref;
TRACE("(%p)->()\n",This);
ref = InterlockedExchangeAdd(&(This->ref),-1) - 1;
if ( ref > 0 )
return (ULONG)ref;
This->ref ++;
if ( This->pOnFinalRelease != NULL )
(*(This->pOnFinalRelease))(iface);
This->ref --;
COMIMPL_FreeObj(This);
return 0;
}
static ICOM_VTABLE(IUnknown) iunknown =
{
ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
/* IUnknown fields */
IUnknown_fnQueryInterface,
IUnknown_fnAddRef,
IUnknown_fnRelease,
};
void COMIMPL_IUnkInit( COMIMPL_IUnkImpl* pImpl, IUnknown* punkOuter )
{
TRACE("(%p)\n",pImpl);
ICOM_VTBL(pImpl) = &iunknown;
pImpl->pEntries = NULL;
pImpl->dwEntries = 0;
pImpl->pDelegationFirst = NULL;
pImpl->pOnFinalRelease = NULL;
pImpl->ref = 1;
pImpl->punkControl = (IUnknown*)pImpl;
/* for implementing aggregation. */
if ( punkOuter != NULL )
pImpl->punkControl = punkOuter;
}
void COMIMPL_IUnkAddDelegationHandler(
COMIMPL_IUnkImpl* pImpl, COMIMPL_IFDelegation* pDelegation )
{
pDelegation->pNext = pImpl->pDelegationFirst;
pImpl->pDelegationFirst = pDelegation;
}
/************************************************************************/
static HRESULT WINAPI
IClassFactory_fnQueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj);
static ULONG WINAPI IClassFactory_fnAddRef(LPCLASSFACTORY iface);
static ULONG WINAPI IClassFactory_fnRelease(LPCLASSFACTORY iface);
static HRESULT WINAPI IClassFactory_fnCreateInstance(LPCLASSFACTORY iface,LPUNKNOWN pOuter,REFIID riid,LPVOID *ppobj);
static HRESULT WINAPI IClassFactory_fnLockServer(LPCLASSFACTORY iface,BOOL dolock);
static ICOM_VTABLE(IClassFactory) iclassfact =
{
ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
IClassFactory_fnQueryInterface,
IClassFactory_fnAddRef,
IClassFactory_fnRelease,
IClassFactory_fnCreateInstance,
IClassFactory_fnLockServer
};
typedef struct
{
/* IUnknown fields */
ICOM_VFIELD(IClassFactory);
LONG ref;
/* IClassFactory fields */
const COMIMPL_CLASSENTRY* pEntry;
} IClassFactoryImpl;
static HRESULT WINAPI
IClassFactory_fnQueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj)
{
ICOM_THIS(IClassFactoryImpl,iface);
TRACE("(%p)->(%p,%p)\n",This,riid,ppobj);
if ( ( IsEqualGUID( &IID_IUnknown, riid ) ) ||
( IsEqualGUID( &IID_IClassFactory, riid ) ) )
{
*ppobj = iface;
IClassFactory_AddRef(iface);
return S_OK;
}
return E_NOINTERFACE;
}
static ULONG WINAPI IClassFactory_fnAddRef(LPCLASSFACTORY iface)
{
ICOM_THIS(IClassFactoryImpl,iface);
TRACE("(%p)->()\n",This);
return InterlockedExchangeAdd(&(This->ref),1) + 1;
}
static ULONG WINAPI IClassFactory_fnRelease(LPCLASSFACTORY iface)
{
ICOM_THIS(IClassFactoryImpl,iface);
LONG ref;
TRACE("(%p)->()\n",This);
ref = InterlockedExchangeAdd(&(This->ref),-1) - 1;
if ( ref > 0 )
return (ULONG)ref;
COMIMPL_FreeObj(This);
return 0;
}
static HRESULT WINAPI IClassFactory_fnCreateInstance(LPCLASSFACTORY iface,LPUNKNOWN pOuter,REFIID riid,LPVOID *ppobj)
{
ICOM_THIS(IClassFactoryImpl,iface);
HRESULT hr;
IUnknown* punk;
TRACE("(%p)->(%p,%s,%p)\n",This,pOuter,debugstr_guid(riid),ppobj);
if ( ppobj == NULL )
return E_POINTER;
if ( pOuter != NULL && !IsEqualGUID( riid, &IID_IUnknown ) )
return CLASS_E_NOAGGREGATION;
*ppobj = NULL;
hr = (*This->pEntry->pCreateIUnk)(pOuter,(void**)&punk);
if ( hr != S_OK )
return hr;
hr = IUnknown_QueryInterface(punk,riid,ppobj);
IUnknown_Release(punk);
return hr;
}
static HRESULT WINAPI IClassFactory_fnLockServer(LPCLASSFACTORY iface,BOOL dolock)
{
ICOM_THIS(IClassFactoryImpl,iface);
HRESULT hr;
TRACE("(%p)->(%d)\n",This,dolock);
if (dolock)
hr = IClassFactory_AddRef(iface);
else
hr = IClassFactory_Release(iface);
return hr;
}
static HRESULT IClassFactory_Alloc( const CLSID* pclsid, void** ppobj )
{
const COMIMPL_CLASSENTRY* pEntry;
IClassFactoryImpl* pImpl;
TRACE( "(%s,%p)\n", debugstr_guid(pclsid), ppobj );
pEntry = COMIMPL_ClassList;
while ( pEntry->pclsid != NULL )
{
if ( IsEqualGUID( pclsid, pEntry->pclsid ) )
goto found;
pEntry ++;
}
return CLASS_E_CLASSNOTAVAILABLE;
found:
pImpl = (IClassFactoryImpl*)COMIMPL_AllocObj( sizeof(IClassFactoryImpl) );
if ( pImpl == NULL )
return E_OUTOFMEMORY;
TRACE( "allocated successfully.\n" );
ICOM_VTBL(pImpl) = &iclassfact;
pImpl->ref = 1;
pImpl->pEntry = pEntry;
*ppobj = (void*)pImpl;
return S_OK;
}
/***********************************************************************
* COMIMPL_InitProcess (internal)
*/
static BOOL COMIMPL_InitProcess( HINSTANCE hInstDLL )
{
TRACE("()\n");
dwComImplRef = 0;
InitializeCriticalSection( &csComImpl );
#ifndef COMIMPL_PERTHREAD_INIT
DisableThreadLibraryCalls((HMODULE)hInstDLL);
#endif /* COMIMPL_PERTHREAD_INIT */
return TRUE;
}
/***********************************************************************
* COMIMPL_UninitProcess (internal)
*/
static void COMIMPL_UninitProcess( HINSTANCE hInstDLL )
{
CHAR szThisDLL[ MAX_PATH ];
TRACE("()\n");
if ( dwComImplRef != 0 )
{
szThisDLL[0] = '\0';
if ( !GetModuleFileNameA( (HMODULE)hInstDLL, szThisDLL, MAX_PATH ) )
szThisDLL[0] = '\0';
ERR( "you must release some objects allocated from %s.\n", szThisDLL );
}
DeleteCriticalSection( &csComImpl );
}
/***********************************************************************
* SHDOCVW_DllMain
*/
BOOL WINAPI SHDOCVW_DllMain(
HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpvReserved )
{
TRACE("(%08x,%08lx,%p)\n",hInstDLL,fdwReason,lpvReserved);
switch ( fdwReason )
{
case DLL_PROCESS_ATTACH:
if ( !COMIMPL_InitProcess( hInstDLL ) )
return FALSE;
break;
case DLL_PROCESS_DETACH:
COMIMPL_UninitProcess( hInstDLL );
break;
case DLL_THREAD_ATTACH:
break;
case DLL_THREAD_DETACH:
break;
}
return TRUE;
}
/***********************************************************************
* DllGetClassObject (SHDOCVW.@)
*/
HRESULT WINAPI SHDOCVW_DllGetClassObject(
const CLSID* pclsid,const IID* piid,void** ppv)
{
*ppv = NULL;
if ( IsEqualGUID( &IID_IUnknown, piid ) ||
IsEqualGUID( &IID_IClassFactory, piid ) )
{
return IClassFactory_Alloc( pclsid, ppv );
}
return CLASS_E_CLASSNOTAVAILABLE;
}
/***********************************************************************
* DllCanUnloadNow (SHDOCVW.@)
*
* RETURNS
* Success: S_OK
* Failure: S_FALSE
*/
HRESULT WINAPI SHDOCVW_DllCanUnloadNow(void)
{
HRESULT hr;
EnterCriticalSection( &csComImpl );
hr = ( dwComImplRef == 0 ) ? S_OK : S_FALSE;
LeaveCriticalSection( &csComImpl );
return hr;
}
/***********************************************************************
* COMIMPL_AllocObj
*/
void* COMIMPL_AllocObj( DWORD dwSize )
{
void* pv;
EnterCriticalSection( &csComImpl );
dwComImplRef ++;
pv = HeapAlloc( COMIMPL_hHeap, 0, dwSize );
if ( pv == NULL )
dwComImplRef --;
LeaveCriticalSection( &csComImpl );
return pv;
}
/***********************************************************************
* COMIMPL_FreeObj
*/
void COMIMPL_FreeObj( void* pobj )
{
EnterCriticalSection( &csComImpl );
HeapFree( COMIMPL_hHeap, 0, pobj );
dwComImplRef --;
LeaveCriticalSection( &csComImpl );
}
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment