Changeset 141

Show
Ignore:
Timestamp:
06/11/06 16:13:10 (6 years ago)
Author:
Don Clugston
Message:

Committed on behalf of Stewart.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/win32/all.d

    r140 r141  
    4141 
    4242import win32.imagehlp; 
     43import win32.intshcut; 
     44import win32.iphlpapi; 
     45import win32.isguids; 
     46 
     47import win32.subauth; 
     48import win32.ras; 
    4349 
    4450version (Windows2003) { 
    …… 
    5359    version (Windows2000) import win32.dhcpcsdk; 
    5460} 
    55 import win32.subauth; 
    56 import win32.ras; 

  • trunk/win32/cguid.d

    r85 r141  
    1111private import win32.basetyps; 
    1212 
    13 extern (C) 
    14 { 
    15 extern IID GUID_NULL; 
     13extern (C) { 
     14    extern const IID 
     15        GUID_NULL, 
     16        IID_IRpcChannel, 
     17        IID_IRpcStub, 
     18        IID_IStubManager, 
     19        IID_IRpcProxy, 
     20        IID_IProxyManager, 
     21        IID_IPSFactory, 
     22        IID_IInternalMoniker, 
     23        IID_IDfReserved1, 
     24        IID_IDfReserved2, 
     25        IID_IDfReserved3, 
     26        IID_IStub, 
     27        IID_IProxy, 
     28        IID_IEnumGeneric, 
     29        IID_IEnumHolder, 
     30        IID_IEnumCallback, 
     31        IID_IOleManager, 
     32        IID_IOlePresObj, 
     33        IID_IDebug, 
     34        IID_IDebugStream; 
    1635 
    17 extern IID IID_IRpcChannel; 
    18 extern IID IID_IRpcStub; 
    19 extern IID IID_IStubManager; 
    20 extern IID IID_IRpcProxy; 
    21 extern IID IID_IProxyManager; 
    22 extern IID IID_IPSFactory; 
    23 extern IID IID_IInternalMoniker; 
    24 extern IID IID_IDfReserved1; 
    25 extern IID IID_IDfReserved2; 
    26 extern IID IID_IDfReserved3; 
    27 extern IID IID_IStub; 
    28 extern IID IID_IProxy; 
    29 extern IID IID_IEnumGeneric; 
    30 extern IID IID_IEnumHolder; 
    31 extern IID IID_IEnumCallback; 
    32 extern IID IID_IOleManager; 
    33 extern IID IID_IOlePresObj; 
    34 extern IID IID_IDebug; 
    35 extern IID IID_IDebugStream; 
     36    extern const CLSID 
     37        CLSID_StdMarshal, 
     38        CLSID_PSGenObject, 
     39        CLSID_PSClientSite, 
     40        CLSID_PSClassObject, 
     41        CLSID_PSInPlaceActive, 
     42        CLSID_PSInPlaceFrame, 
     43        CLSID_PSDragDrop, 
     44        CLSID_PSBindCtx, 
     45        CLSID_PSEnumerators, 
     46        CLSID_StaticMetafile, 
     47        CLSID_StaticDib, 
    3648 
    37 extern CLSID CLSID_StdMarshal; 
    38 extern CLSID CLSID_PSGenObject; 
    39 extern CLSID CLSID_PSClientSite; 
    40 extern CLSID CLSID_PSClassObject; 
    41 extern CLSID CLSID_PSInPlaceActive; 
    42 extern CLSID CLSID_PSInPlaceFrame; 
    43 extern CLSID CLSID_PSDragDrop; 
    44 extern CLSID CLSID_PSBindCtx; 
    45 extern CLSID CLSID_PSEnumerators; 
    46 extern CLSID CLSID_StaticMetafile; 
    47 extern CLSID CLSID_StaticDib; 
     49        CID_CDfsVolume, 
    4850 
    49 extern CLSID CID_CDfsVolume; 
     51        CLSID_CCDFormKrnl, 
     52        CLSID_CCDPropertyPage, 
     53        CLSID_CCDFormDialog, 
     54        CLSID_CCDCommandButton, 
     55        CLSID_CCDComboBox, 
     56        CLSID_CCDTextBox, 
     57        CLSID_CCDCheckBox, 
     58        CLSID_CCDLabel, 
     59        CLSID_CCDOptionButton, 
     60        CLSID_CCDListBox, 
     61        CLSID_CCDScrollBar, 
     62        CLSID_CCDGroupBox, 
     63        CLSID_CCDGeneralPropertyPage, 
     64        CLSID_CCDGenericPropertyPage, 
     65        CLSID_CCDFontPropertyPage, 
     66        CLSID_CCDColorPropertyPage, 
     67        CLSID_CCDLabelPropertyPage, 
     68        CLSID_CCDCheckBoxPropertyPage, 
     69        CLSID_CCDTextBoxPropertyPage, 
     70        CLSID_CCDOptionButtonPropertyPage, 
     71        CLSID_CCDListBoxPropertyPage, 
     72        CLSID_CCDCommandButtonPropertyPage, 
     73        CLSID_CCDComboBoxPropertyPage, 
     74        CLSID_CCDScrollBarPropertyPage, 
     75        CLSID_CCDGroupBoxPropertyPage, 
     76        CLSID_CCDXObjectPropertyPage, 
     77        CLSID_CStdPropertyFrame, 
     78        CLSID_CFormPropertyPage, 
     79        CLSID_CGridPropertyPage, 
     80        CLSID_CWSJArticlePage, 
     81        CLSID_CSystemPage, 
     82        CLSID_IdentityUnmarshal, 
     83        CLSID_InProcFreeMarshaler, 
     84        CLSID_Picture_Metafile, 
     85        CLSID_Picture_EnhMetafile, 
     86        CLSID_Picture_Dib, 
     87        CLSID_StdGlobalInterfaceTable; 
    5088 
    51 extern CLSID CLSID_CCDFormKrnl; 
    52 extern CLSID CLSID_CCDPropertyPage; 
    53 extern CLSID CLSID_CCDFormDialog; 
    54 extern CLSID CLSID_CCDCommandButton; 
    55 extern CLSID CLSID_CCDComboBox; 
    56 extern CLSID CLSID_CCDTextBox; 
    57 extern CLSID CLSID_CCDCheckBox; 
    58 extern CLSID CLSID_CCDLabel; 
    59 extern CLSID CLSID_CCDOptionButton; 
    60 extern CLSID CLSID_CCDListBox; 
    61 extern CLSID CLSID_CCDScrollBar; 
    62 extern CLSID CLSID_CCDGroupBox; 
    63 extern CLSID CLSID_CCDGeneralPropertyPage; 
    64 extern CLSID CLSID_CCDGenericPropertyPage; 
    65 extern CLSID CLSID_CCDFontPropertyPage; 
    66 extern CLSID CLSID_CCDColorPropertyPage; 
    67 extern CLSID CLSID_CCDLabelPropertyPage; 
    68 extern CLSID CLSID_CCDCheckBoxPropertyPage; 
    69 extern CLSID CLSID_CCDTextBoxPropertyPage; 
    70 extern CLSID CLSID_CCDOptionButtonPropertyPage; 
    71 extern CLSID CLSID_CCDListBoxPropertyPage; 
    72 extern CLSID CLSID_CCDCommandButtonPropertyPage; 
    73 extern CLSID CLSID_CCDComboBoxPropertyPage; 
    74 extern CLSID CLSID_CCDScrollBarPropertyPage; 
    75 extern CLSID CLSID_CCDGroupBoxPropertyPage; 
    76 extern CLSID CLSID_CCDXObjectPropertyPage; 
    77 extern CLSID CLSID_CStdPropertyFrame; 
    78 extern CLSID CLSID_CFormPropertyPage; 
    79 extern CLSID CLSID_CGridPropertyPage; 
    80 extern CLSID CLSID_CWSJArticlePage; 
    81 extern CLSID CLSID_CSystemPage; 
    82 extern CLSID CLSID_IdentityUnmarshal; 
    83 extern CLSID CLSID_InProcFreeMarshaler; 
    84 extern CLSID CLSID_Picture_Metafile; 
    85 extern CLSID CLSID_Picture_EnhMetafile; 
    86 extern CLSID CLSID_Picture_Dib; 
    87 extern CLSID CLSID_StdGlobalInterfaceTable; 
    88  
    89 extern GUID GUID_TRISTATE; 
     89    extern const GUID GUID_TRISTATE; 
    9090} 

  • trunk/win32/commdlg.d

    r135 r141  
    576576} // WINVER >= 0x0500 
    577577 
    578 align: 
    579  
    580578extern (Windows): 
    581579 

  • trunk/win32/docobj.d

    r135 r141  
    8585alias IEnumOleDocumentViews* LPENUMOLEDOCUMENTVIEWS; 
    8686 
    87 extern (C) { 
    88 extern IID IID_IContinueCallback; 
    89 extern IID IID_IEnumOleDocumentViews; 
    90 extern IID IID_IPrint; 
    91 extern IID IID_IOleDocumentView; 
    92 extern IID IID_IOleDocument; 
    93 extern IID IID_IOleCommandTarget; 
    94 extern IID IID_IOleDocumentSite; 
    95 } 
     87extern (C) extern const IID 
     88    IID_IContinueCallback, 
     89    IID_IEnumOleDocumentViews, 
     90    IID_IPrint, 
     91    IID_IOleDocumentView, 
     92    IID_IOleDocument, 
     93    IID_IOleCommandTarget, 
     94    IID_IOleDocumentSite; 
    9695 
    97 interface IOleDocumentView : public IUnknown 
    98 { 
    99     HRESULT QueryInterface(REFIID,PVOID*); 
    100     ULONG AddRef(); 
    101     ULONG Release(); 
    10296 
     97interface IOleDocumentView : public IUnknown { 
    10398    HRESULT SetInPlaceSite(LPOLEINPLACESITE); 
    10499    HRESULT GetInPlaceSite(LPOLEINPLACESITE*); 
    …… 
    106101    HRESULT SetRect(LPRECT); 
    107102    HRESULT GetRect(LPRECT); 
    108     HRESULT SetRectComplex(LPRECT,LPRECT,LPRECT,LPRECT); 
     103    HRESULT SetRectComplex(LPRECT, LPRECT, LPRECT, LPRECT); 
    109104    HRESULT Show(BOOL); 
    110105    HRESULT UIActivate(BOOL); 
    …… 
    113108    HRESULT SaveViewState(IStream*); 
    114109    HRESULT ApplyViewState(IStream*); 
    115     HRESULT Clone(LPOLEINPLACESITE,IOleDocumentView**); 
     110    HRESULT Clone(LPOLEINPLACESITE, IOleDocumentView**); 
    116111} 
    117112 
    118 interface IEnumOleDocumentViews : public IUnknown 
    119 { 
    120       HRESULT QueryInterface(REFIID,PVOID*); 
    121       ULONG AddRef(); 
    122       ULONG Release(); 
    123       HRESULT Next(ULONG,IOleDocumentView*,ULONG*); 
     113interface IEnumOleDocumentViews : public IUnknown { 
     114      HRESULT Next(ULONG, IOleDocumentView*, ULONG*); 
    124115      HRESULT Skip(ULONG); 
    125116      HRESULT Reset(); 
    …… 
    127118} 
    128119 
    129 interface IOleDocument : public IUnknown 
    130 { 
    131     HRESULT QueryInterface(REFIID,PVOID*); 
    132     ULONG AddRef(); 
    133     ULONG Release(); 
    134  
    135     HRESULT CreateView(LPOLEINPLACESITE,IStream*,DWORD,IOleDocumentView**); 
     120interface IOleDocument : public IUnknown { 
     121    HRESULT CreateView(LPOLEINPLACESITE, IStream*, DWORD, IOleDocumentView**); 
    136122    HRESULT GetDocMiscStatus(DWORD*); 
    137     HRESULT EnumViews(LPENUMOLEDOCUMENTVIEWS*,IOleDocumentView**); 
     123    HRESULT EnumViews(LPENUMOLEDOCUMENTVIEWS*, IOleDocumentView**); 
    138124} 
    139125 
    140 interface IOleCommandTarget : public IUnknown 
    141 { 
    142     HRESULT QueryInterface(REFIID,PVOID*); 
    143     ULONG AddRef(); 
    144     ULONG Release(); 
    145  
    146     HRESULT QueryStatus( GUID*,ULONG,OLECMD*,OLECMDTEXT*); 
    147     HRESULT Exec( GUID*,DWORD,DWORD,VARIANTARG*,VARIANTARG*); 
     126interface IOleCommandTarget : public IUnknown { 
     127    HRESULT QueryStatus(GUID*, ULONG, OLECMD*, OLECMDTEXT*); 
     128    HRESULT Exec(GUID*, DWORD, DWORD, VARIANTARG*, VARIANTARG*); 
    148129} 
    149130 
    150 interface IOleDocumentSite : public IUnknown 
    151 { 
    152     HRESULT QueryInterface(REFIID,PVOID*); 
    153     ULONG AddRef(); 
    154     ULONG Release(); 
    155  
     131interface IOleDocumentSite : public IUnknown { 
    156132    HRESULT ActivateMe(IOleDocumentView*); 
    157133} 

  • trunk/win32/exdisp.d

    r123 r141  
    2727 
    2828extern (C) { 
    29     extern CLSID CLSID_WebBrowser; 
    30     extern IID DIID_DWebBrowserEvents; 
    31     extern IID IID_IWebBrowser; 
    32     extern IID IID_IWebBrowserApp; 
    33     extern IID IID_IWebBrowser2; 
    34     extern IID DIID_DWebBrowserEvents2; 
     29    extern const CLSID CLSID_WebBrowser; 
     30    extern const IID 
     31        DIID_DWebBrowserEvents, 
     32        IID_IWebBrowser, 
     33        IID_IWebBrowserApp, 
     34        IID_IWebBrowser2, 
     35        DIID_DWebBrowserEvents2; 
    3536} 
    3637 

  • trunk/win32/imm.d

    r127 r141  
    88*                       Placed into public domain                       * 
    99\***********************************************************************/ 
    10  
    1110module win32.imm; 
    1211pragma(lib, "imm32.lib"); 
    …… 
    2827const WM_IME_SELECT           = 0x285; 
    2928const WM_IME_CHAR             = 0x286; 
    30 static if (WINVER >= 0x0500) { 
    31     const WM_IME_REQUEST=0x0288; 
     29static if (WINVER >= 0x500) { 
     30    const WM_IME_REQUEST      = 0x288; 
    3231} 
    3332const WM_IME_KEYDOWN          = 0x290; 
    …… 
    281280alias DWORD HIMC; 
    282281alias DWORD HIMCC; 
    283 alias HKL *LPHKL; 
     282alias HKL* LPHKL; 
    284283 
    285284struct COMPOSITIONFORM{ 
    …… 
    288287    RECT rcArea; 
    289288} 
    290 alias COMPOSITIONFORM *PCOMPOSITIONFORM, LPCOMPOSITIONFORM; 
     289alias COMPOSITIONFORM* PCOMPOSITIONFORM, LPCOMPOSITIONFORM; 
    291290 
    292291struct CANDIDATEFORM{ 
    …… 
    296295    RECT rcArea; 
    297296} 
    298 alias CANDIDATEFORM * PCANDIDATEFORM, LPCANDIDATEFORM; 
     297alias CANDIDATEFORM* PCANDIDATEFORM, LPCANDIDATEFORM; 
    299298 
    300299struct CANDIDATELIST{ 
    …… 
    307306    DWORD dwOffset[1]; 
    308307} 
    309 alias CANDIDATELIST * PCANDIDATELIST, LPCANDIDATELIST; 
     308alias CANDIDATELIST* PCANDIDATELIST, LPCANDIDATELIST; 
    310309 
    311310struct REGISTERWORDA{ 
    …… 
    313312    LPSTR lpWord; 
    314313} 
    315 alias REGISTERWORDA *PREGISTERWORDA, LPREGISTERWORDA; 
     314alias REGISTERWORDA* PREGISTERWORDA, LPREGISTERWORDA; 
    316315 
    317316struct REGISTERWORDW{ 
    …… 
    319318    LPWSTR lpWord; 
    320319} 
    321 alias REGISTERWORDW * PREGISTERWORDW, LPREGISTERWORDW; 
     320alias REGISTERWORDW* PREGISTERWORDW, LPREGISTERWORDW; 
    322321 
    323322struct STYLEBUFA{ 
    …… 
    325324    CHAR szDescription[STYLE_DESCRIPTION_SIZE]; 
    326325} 
    327 alias STYLEBUFA * PSTYLEBUFA, LPSTYLEBUFA; 
     326alias STYLEBUFA* PSTYLEBUFA, LPSTYLEBUFA; 
    328327 
    329328struct STYLEBUFW{ 
    …… 
    331330    WCHAR szDescription[STYLE_DESCRIPTION_SIZE]; 
    332331} 
    333 alias STYLEBUFW * PSTYLEBUFW, LPSTYLEBUFW; 
     332alias STYLEBUFW* PSTYLEBUFW, LPSTYLEBUFW; 
    334333 
    335334struct IMEMENUITEMINFOA{ 
    …… 
    344343    HBITMAP hbmpItem; 
    345344} 
    346 alias IMEMENUITEMINFOA * PIMEMENUITEMINFOA, LPIMEMENUITEMINFOA; 
     345alias IMEMENUITEMINFOA* PIMEMENUITEMINFOA, LPIMEMENUITEMINFOA; 
    347346 
    348347struct IMEMENUITEMINFOW{ 
    …… 
    357356    HBITMAP hbmpItem; 
    358357} 
    359 alias IMEMENUITEMINFOW *PIMEMENUITEMINFOW, LPIMEMENUITEMINFOW; 
     358alias IMEMENUITEMINFOW* PIMEMENUITEMINFOW, LPIMEMENUITEMINFOW; 
    360359 
    361360alias int function (LPCSTR, DWORD, LPCSTR, LPVOID)  REGISTERWORDENUMPROCA; 
    …… 
    363362 
    364363version(Unicode) { 
    365  
    366 alias REGISTERWORDENUMPROCW REGISTERWORDENUMPROC; 
    367 alias REGISTERWORDW REGISTERWORD; 
    368 alias IMEMENUITEMINFOW IMEMENUITEMINFO; 
    369 alias STYLEBUFW STYLEBUF; 
    370  
     364    alias REGISTERWORDENUMPROCW REGISTERWORDENUMPROC; 
     365    alias REGISTERWORDW REGISTERWORD; 
     366    alias IMEMENUITEMINFOW IMEMENUITEMINFO; 
     367    alias STYLEBUFW STYLEBUF; 
    371368} else { 
    372  
    373 alias REGISTERWORDENUMPROCA REGISTERWORDENUMPROC; 
    374 alias REGISTERWORDA REGISTERWORD; 
    375 alias IMEMENUITEMINFOA IMEMENUITEMINFO; 
    376 alias STYLEBUFA STYLEBUF; 
    377  
    378 } 
    379  
    380 alias STYLEBUF * PSTYLEBUF, LPSTYLEBUF; 
    381 alias REGISTERWORD * PREGISTERWORD, LPREGISTERWORD; 
    382 alias IMEMENUITEMINFO * PIMEMENUITEMINFO, LPIMEMENUITEMINFO; 
     369    alias REGISTERWORDENUMPROCA REGISTERWORDENUMPROC; 
     370    alias REGISTERWORDA REGISTERWORD; 
     371    alias IMEMENUITEMINFOA IMEMENUITEMINFO; 
     372    alias STYLEBUFA STYLEBUF; 
     373} 
     374 
     375alias STYLEBUF* PSTYLEBUF, LPSTYLEBUF; 
     376alias REGISTERWORD* PREGISTERWORD, LPREGISTERWORD; 
     377alias IMEMENUITEMINFO* PIMEMENUITEMINFO, LPIMEMENUITEMINFO; 
    383378 
    384379 
    385380extern (Windows): 
    386 HKL ImmInstallIMEA(LPCSTR,LPCSTR); 
    387 HKL ImmInstallIMEW(LPCWSTR,LPCWSTR); 
     381HKL ImmInstallIMEA(LPCSTR, LPCSTR); 
     382HKL ImmInstallIMEW(LPCWSTR, LPCWSTR); 
    388383HWND ImmGetDefaultIMEWnd(HWND); 
    389 UINT ImmGetDescriptionA(HKL,LPSTR,UINT); 
    390 UINT ImmGetDescriptionW(HKL,LPWSTR,UINT); 
    391 UINT ImmGetIMEFileNameA(HKL,LPSTR,UINT); 
    392 UINT ImmGetIMEFileNameW(HKL,LPWSTR,UINT); 
    393 DWORD ImmGetProperty(HKL,DWORD); 
     384UINT ImmGetDescriptionA(HKL, LPSTR, UINT); 
     385UINT ImmGetDescriptionW(HKL, LPWSTR, UINT); 
     386UINT ImmGetIMEFileNameA(HKL, LPSTR, UINT); 
     387UINT ImmGetIMEFileNameW(HKL, LPWSTR, UINT); 
     388DWORD ImmGetProperty(HKL, DWORD); 
    394389BOOL ImmIsIME(HKL); 
    395 BOOL ImmSimulateHotKey(HWND,DWORD); 
     390BOOL ImmSimulateHotKey(HWND, DWORD); 
    396391HIMC ImmCreateContext(); 
    397392BOOL ImmDestroyContext(HIMC); 
    398393HIMC ImmGetContext(HWND); 
    399 BOOL ImmReleaseContext(HWND,HIMC); 
    400 HIMC ImmAssociateContext(HWND,HIMC); 
    401 LONG ImmGetCompositionStringA(HIMC,DWORD,PVOID,DWORD); 
    402 LONG ImmGetCompositionStringW(HIMC,DWORD,PVOID,DWORD); 
    403 BOOL ImmSetCompositionStringA(HIMC,DWORD,PCVOID,DWORD,PCVOID,DWORD); 
    404 BOOL ImmSetCompositionStringW(HIMC,DWORD,PCVOID,DWORD,PCVOID,DWORD); 
    405 DWORD ImmGetCandidateListCountA(HIMC,PDWORD); 
    406 DWORD ImmGetCandidateListCountW(HIMC,PDWORD); 
    407 DWORD ImmGetCandidateListA(HIMC,DWORD,PCANDIDATELIST,DWORD); 
    408 DWORD ImmGetCandidateListW(HIMC,DWORD,PCANDIDATELIST,DWORD); 
    409 DWORD ImmGetGuideLineA(HIMC,DWORD,LPSTR,DWORD); 
    410 DWORD ImmGetGuideLineW(HIMC,DWORD,LPWSTR,DWORD); 
    411 BOOL ImmGetConversionStatus(HIMC,LPDWORD,PDWORD); 
    412 BOOL ImmSetConversionStatus(HIMC,DWORD,DWORD); 
     394BOOL ImmReleaseContext(HWND, HIMC); 
     395HIMC ImmAssociateContext(HWND, HIMC); 
     396LONG ImmGetCompositionStringA(HIMC, DWORD, PVOID, DWORD); 
     397LONG ImmGetCompositionStringW(HIMC, DWORD, PVOID, DWORD); 
     398BOOL ImmSetCompositionStringA(HIMC, DWORD, PCVOID, DWORD, PCVOID, DWORD); 
     399BOOL ImmSetCompositionStringW(HIMC, DWORD, PCVOID, DWORD, PCVOID, DWORD); 
     400DWORD ImmGetCandidateListCountA(HIMC, PDWORD); 
     401DWORD ImmGetCandidateListCountW(HIMC, PDWORD); 
     402DWORD ImmGetCandidateListA(HIMC, DWORD, PCANDIDATELIST, DWORD); 
     403DWORD ImmGetCandidateListW(HIMC, DWORD, PCANDIDATELIST, DWORD); 
     404DWORD ImmGetGuideLineA(HIMC, DWORD, LPSTR, DWORD); 
     405DWORD ImmGetGuideLineW(HIMC, DWORD, LPWSTR, DWORD); 
     406BOOL ImmGetConversionStatus(HIMC, LPDWORD, PDWORD); 
     407BOOL ImmSetConversionStatus(HIMC, DWORD, DWORD); 
    413408BOOL ImmGetOpenStatus(HIMC); 
    414 BOOL ImmSetOpenStatus(HIMC,BOOL); 
    415  
    416 BOOL ImmGetCompositionFontA(HIMC,LPLOGFONTA); 
    417 BOOL ImmGetCompositionFontW(HIMC,LPLOGFONTW); 
    418 BOOL ImmSetCompositionFontA(HIMC,LPLOGFONTA); 
    419 BOOL ImmSetCompositionFontW(HIMC,LPLOGFONTW); 
    420  
    421 BOOL ImmConfigureIMEA(HKL,HWND,DWORD,PVOID); 
    422 BOOL ImmConfigureIMEW(HKL,HWND,DWORD,PVOID); 
    423 LRESULT ImmEscapeA(HKL,HIMC,UINT,PVOID); 
    424 LRESULT ImmEscapeW(HKL,HIMC,UINT,PVOID); 
    425 DWORD ImmGetConversionListA(HKL,HIMC,LPCSTR,PCANDIDATELIST,DWORD,UINT); 
    426 DWORD ImmGetConversionListW(HKL,HIMC,LPCWSTR,PCANDIDATELIST,DWORD,UINT); 
    427 BOOL ImmNotifyIME(HIMC,DWORD,DWORD,DWORD); 
    428 BOOL ImmGetStatusWindowPos(HIMC,LPPOINT); 
    429 BOOL ImmSetStatusWindowPos(HIMC,LPPOINT); 
    430 BOOL ImmGetCompositionWindow(HIMC,PCOMPOSITIONFORM); 
    431 BOOL ImmSetCompositionWindow(HIMC,PCOMPOSITIONFORM); 
    432 BOOL ImmGetCandidateWindow(HIMC,DWORD,PCANDIDATEFORM); 
    433 BOOL ImmSetCandidateWindow(HIMC,PCANDIDATEFORM); 
    434 BOOL ImmIsUIMessageA(HWND,UINT,WPARAM,LPARAM); 
    435 BOOL ImmIsUIMessageW(HWND,UINT,WPARAM,LPARAM); 
     409BOOL ImmSetOpenStatus(HIMC, BOOL); 
     410 
     411BOOL ImmGetCompositionFontA(HIMC, LPLOGFONTA); 
     412BOOL ImmGetCompositionFontW(HIMC, LPLOGFONTW); 
     413BOOL ImmSetCompositionFontA(HIMC, LPLOGFONTA); 
     414BOOL ImmSetCompositionFontW(HIMC, LPLOGFONTW); 
     415 
     416BOOL ImmConfigureIMEA(HKL, HWND, DWORD, PVOID); 
     417BOOL ImmConfigureIMEW(HKL, HWND, DWORD, PVOID); 
     418LRESULT ImmEscapeA(HKL, HIMC, UINT, PVOID); 
     419LRESULT ImmEscapeW(HKL, HIMC, UINT, PVOID); 
     420DWORD ImmGetConversionListA(HKL, HIMC, LPCSTR, PCANDIDATELIST, DWORD, UINT); 
     421DWORD ImmGetConversionListW(HKL, HIMC, LPCWSTR, PCANDIDATELIST, DWORD, UINT); 
     422BOOL ImmNotifyIME(HIMC, DWORD, DWORD, DWORD); 
     423BOOL ImmGetStatusWindowPos(HIMC, LPPOINT); 
     424BOOL ImmSetStatusWindowPos(HIMC, LPPOINT); 
     425BOOL ImmGetCompositionWindow(HIMC, PCOMPOSITIONFORM); 
     426BOOL ImmSetCompositionWindow(HIMC, PCOMPOSITIONFORM); 
     427BOOL ImmGetCandidateWindow(HIMC, DWORD, PCANDIDATEFORM); 
     428BOOL ImmSetCandidateWindow(HIMC, PCANDIDATEFORM); 
     429BOOL ImmIsUIMessageA(HWND, UINT, WPARAM, LPARAM); 
     430BOOL ImmIsUIMessageW(HWND, UINT, WPARAM, LPARAM); 
    436431UINT ImmGetVirtualKey(HWND); 
    437 BOOL ImmRegisterWordA(HKL,LPCSTR,DWORD,LPCSTR); 
    438 BOOL ImmRegisterWordW(HKL,LPCWSTR,DWORD,LPCWSTR); 
    439 BOOL ImmUnregisterWordA(HKL,LPCSTR,DWORD,LPCSTR); 
    440 BOOL ImmUnregisterWordW(HKL,LPCWSTR,DWORD,LPCWSTR); 
    441 UINT ImmGetRegisterWordStyleA(HKL,UINT,PSTYLEBUFA); 
    442 UINT ImmGetRegisterWordStyleW(HKL,UINT,PSTYLEBUFW); 
    443 UINT ImmEnumRegisterWordA(HKL,REGISTERWORDENUMPROCA,LPCSTR,DWORD,LPCSTR,PVOID); 
    444 UINT ImmEnumRegisterWordW(HKL,REGISTERWORDENUMPROCW,LPCWSTR,DWORD,LPCWSTR,PVOID); 
     432BOOL ImmRegisterWordA(HKL, LPCSTR, DWORD, LPCSTR); 
     433BOOL ImmRegisterWordW(HKL, LPCWSTR, DWORD, LPCWSTR); 
     434BOOL ImmUnregisterWordA(HKL, LPCSTR, DWORD, LPCSTR); 
     435BOOL ImmUnregisterWordW(HKL, LPCWSTR, DWORD, LPCWSTR); 
     436UINT ImmGetRegisterWordStyleA(HKL, UINT, PSTYLEBUFA); 
     437UINT ImmGetRegisterWordStyleW(HKL, UINT, PSTYLEBUFW); 
     438UINT ImmEnumRegisterWordA(HKL, REGISTERWORDENUMPROCA, LPCSTR, DWORD, LPCSTR, PVOID); 
     439UINT ImmEnumRegisterWordW(HKL, REGISTERWORDENUMPROCW, LPCWSTR, DWORD, LPCWSTR, PVOID); 
    445440BOOL EnableEUDC(BOOL); 
    446441BOOL ImmDisableIME(DWORD); 
    447 DWORD ImmGetImeMenuItemsA(HIMC,DWORD,DWORD,LPIMEMENUITEMINFOA,LPIMEMENUITEMINFOA,DWORD); 
    448 DWORD ImmGetImeMenuItemsW(HIMC,DWORD,DWORD,LPIMEMENUITEMINFOW,LPIMEMENUITEMINFOW,DWORD); 
     442DWORD ImmGetImeMenuItemsA(HIMC, DWORD, DWORD, LPIMEMENUITEMINFOA, LPIMEMENUITEMINFOA, DWORD); 
     443DWORD ImmGetImeMenuItemsW(HIMC, DWORD, DWORD, LPIMEMENUITEMINFOW, LPIMEMENUITEMINFOW, DWORD); 
    449444 
    450445version(Unicode) { 
    451  
    452 alias ImmEnumRegisterWordW ImmEnumRegisterWord; 
    453 alias ImmGetRegisterWordStyleW ImmGetRegisterWordStyle; 
    454 alias ImmUnregisterWordW ImmUnregisterWord; 
    455 alias ImmRegisterWordW ImmRegisterWord; 
    456 alias ImmInstallIMEW ImmInstallIME; 
    457 alias ImmIsUIMessageW ImmIsUIMessage; 
    458 alias ImmGetConversionListW ImmGetConversionList; 
    459 alias ImmEscapeW ImmEscape; 
    460 alias ImmConfigureIMEW ImmConfigureIME; 
    461 alias ImmSetCompositionFontW ImmSetCompositionFont; 
    462 alias ImmGetCompositionFontW ImmGetCompositionFont; 
    463 alias ImmGetGuideLineW ImmGetGuideLine; 
    464 alias ImmGetCandidateListW ImmGetCandidateList; 
    465 alias ImmGetCandidateListCountW ImmGetCandidateListCount; 
    466 alias ImmSetCompositionStringW ImmSetCompositionString; 
    467 alias ImmGetCompositionStringW ImmGetCompositionString; 
    468 alias ImmGetDescriptionW ImmGetDescription; 
    469 alias ImmGetIMEFileNameW ImmGetIMEFileName; 
    470 alias ImmGetImeMenuItemsW ImmGetImeMenuItems; 
    471  
     446    alias ImmEnumRegisterWordW ImmEnumRegisterWord; 
     447    alias ImmGetRegisterWordStyleW ImmGetRegisterWordStyle; 
     448    alias ImmUnregisterWordW ImmUnregisterWord; 
     449    alias ImmRegisterWordW ImmRegisterWord; 
     450    alias ImmInstallIMEW ImmInstallIME; 
     451    alias ImmIsUIMessageW ImmIsUIMessage; 
     452    alias ImmGetConversionListW ImmGetConversionList; 
     453    alias ImmEscapeW ImmEscape; 
     454    alias ImmConfigureIMEW ImmConfigureIME; 
     455    alias ImmSetCompositionFontW ImmSetCompositionFont; 
     456    alias ImmGetCompositionFontW ImmGetCompositionFont; 
     457    alias ImmGetGuideLineW ImmGetGuideLine; 
     458    alias ImmGetCandidateListW ImmGetCandidateList; 
     459    alias ImmGetCandidateListCountW ImmGetCandidateListCount; 
     460    alias ImmSetCompositionStringW ImmSetCompositionString; 
     461    alias ImmGetCompositionStringW ImmGetCompositionString; 
     462    alias ImmGetDescriptionW ImmGetDescription; 
     463    alias ImmGetIMEFileNameW ImmGetIMEFileName; 
     464    alias ImmGetImeMenuItemsW ImmGetImeMenuItems; 
    472465} else { 
    473  
    474 alias ImmEnumRegisterWordA ImmEnumRegisterWord; 
    475 alias ImmGetRegisterWordStyleA ImmGetRegisterWordStyle; 
    476 alias ImmUnregisterWordA ImmUnregisterWord; 
    477 alias ImmRegisterWordA ImmRegisterWord; 
    478 alias ImmInstallIMEA ImmInstallIME; 
    479 alias ImmIsUIMessageA ImmIsUIMessage; 
    480 alias ImmGetConversionListA ImmGetConversionList; 
    481 alias ImmEscapeA ImmEscape; 
    482 alias ImmConfigureIMEA ImmConfigureIME; 
    483 alias ImmSetCompositionFontA ImmSetCompositionFont; 
    484 alias ImmGetCompositionFontA ImmGetCompositionFont; 
    485 alias ImmGetGuideLineA ImmGetGuideLine; 
    486 alias ImmGetCandidateListA ImmGetCandidateList; 
    487 alias ImmGetCandidateListCountA ImmGetCandidateListCount; 
    488 alias ImmSetCompositionStringA ImmSetCompositionString; 
    489 alias ImmGetCompositionStringA ImmGetCompositionString; 
    490 alias ImmGetDescriptionA ImmGetDescription; 
    491 alias ImmGetIMEFileNameA ImmGetIMEFileName; 
    492 alias ImmGetImeMenuItemsW ImmGetImeMenuItems; 
    493 } 
     466    alias ImmEnumRegisterWordA ImmEnumRegisterWord; 
     467    alias ImmGetRegisterWordStyleA ImmGetRegisterWordStyle; 
     468    alias ImmUnregisterWordA ImmUnregisterWord; 
     469    alias ImmRegisterWordA ImmRegisterWord; 
     470    alias ImmInstallIMEA ImmInstallIME; 
     471    alias ImmIsUIMessageA ImmIsUIMessage; 
     472    alias ImmGetConversionListA ImmGetConversionList; 
     473    alias ImmEscapeA ImmEscape; 
     474    alias ImmConfigureIMEA ImmConfigureIME; 
     475    alias ImmSetCompositionFontA ImmSetCompositionFont; 
     476    alias ImmGetCompositionFontA ImmGetCompositionFont; 
     477    alias ImmGetGuideLineA ImmGetGuideLine; 
     478    alias ImmGetCandidateListA ImmGetCandidateList; 
     479    alias ImmGetCandidateListCountA ImmGetCandidateListCount; 
     480    alias ImmSetCompositionStringA ImmSetCompositionString; 
     481    alias ImmGetCompositionStringA ImmGetCompositionString; 
     482    alias ImmGetDescriptionA ImmGetDescription; 
     483    alias ImmGetIMEFileNameA ImmGetIMEFileName; 
     484    alias ImmGetImeMenuItemsW ImmGetImeMenuItems; 
     485} 

  • trunk/win32/mshtml.d

    r128 r141  
    2929 
    3030 
    31 extern (C) { 
    32 extern IID IID_IHTMLLinkElement; 
    33 extern IID IID_IHTMLImgElement; 
    34 extern IID IID_IHTMLElementCollection; 
    35 extern IID IID_IHTMLDocument; 
    36 extern IID IID_IHTMLDocument2; 
    37 extern IID IID_IHTMLSelectionObject; 
    38 extern IID IID_IHTMLTxtRange; 
    39 extern IID IID_IHTMLElement; 
    40 extern IID IID_IHTMLFramesCollection2; 
    41 extern IID IID_IHTMLWindow2; 
    42 extern IID IID_IHTMLFrameBase; 
    43 extern IID IID_IHTMLFrameBase2; 
    44 extern IID IID_IHTMLFrameBase3; 
    45 extern IID IID_IHTMLBodyElement; 
    46 extern IID IID_IHTMLBodyElement2; 
    47 } 
    48  
    49  
    50 interface IHTMLLinkElement : public IDispatch 
    51 { 
    52     HRESULT QueryInterface(REFIID,PVOID*); 
    53     ULONG AddRef(); 
    54     ULONG Release(); 
    55     HRESULT GetTypeInfoCount(UINT*); 
    56     HRESULT GetTypeInfo(UINT,LCID,LPTYPEINFO*); 
    57     HRESULT GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*); 
    58     HRESULT Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*); 
    59  
     31extern (C) extern const IID 
     32    IID_IHTMLLinkElement, 
     33    IID_IHTMLImgElement, 
     34    IID_IHTMLElementCollection, 
     35    IID_IHTMLDocument, 
     36    IID_IHTMLDocument2, 
     37    IID_IHTMLSelectionObject, 
     38    IID_IHTMLTxtRange, 
     39    IID_IHTMLElement, 
     40    IID_IHTMLFramesCollection2, 
     41    IID_IHTMLWindow2, 
     42    IID_IHTMLFrameBase, 
     43    IID_IHTMLFrameBase2, 
     44    IID_IHTMLFrameBase3, 
     45    IID_IHTMLBodyElement, 
     46    IID_IHTMLBodyElement2; 
     47 
     48interface IHTMLLinkElement : public IDispatch { 
    6049    HRESULT put_href(BSTR); 
    6150    HRESULT get_href(BSTR*); 
    …… 
    8069} 
    8170 
    82 interface IHTMLImgElement : public IDispatch 
    83 { 
    84     HRESULT QueryInterface(REFIID,PVOID*); 
    85     ULONG AddRef(); 
    86     ULONG Release(); 
    87     HRESULT GetTypeInfoCount(UINT*); 
    88     HRESULT GetTypeInfo(UINT,LCID,LPTYPEINFO*); 
    89     HRESULT GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*); 
    90     HRESULT Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*); 
    91  
     71interface IHTMLImgElement : public IDispatch { 
    9272    HRESULT put_isMap(VARIANT_BOOL); 
    9373    HRESULT get_isMap(VARIANT_BOOL*); 
    …… 
    140120} 
    141121 
    142 interface IHTMLElementCollection : public IDispatch 
    143 { 
    144     HRESULT QueryInterface(REFIID,PVOID*); 
    145     ULONG AddRef(); 
    146     ULONG Release(); 
    147     HRESULT GetTypeInfoCount(UINT*); 
    148     HRESULT GetTypeInfo(UINT,LCID,LPTYPEINFO*); 
    149     HRESULT GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*); 
    150     HRESULT Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*); 
    151  
     122interface IHTMLElementCollection : public IDispatch { 
    152123    HRESULT toString(BSTR*); 
    153124    HRESULT put_length(long); 
    …… 
    158129} 
    159130 
    160 interface IHTMLDocument : public IDispatch 
    161 { 
    162     HRESULT QueryInterface(REFIID,PVOID*); 
    163     ULONG AddRef(); 
    164     ULONG Release(); 
    165     HRESULT GetTypeInfoCount(UINT*); 
    166     HRESULT GetTypeInfo(UINT,LCID,LPTYPEINFO*); 
    167     HRESULT GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*); 
    168     HRESULT Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*); 
    169  
     131interface IHTMLDocument : public IDispatch { 
    170132    HRESULT get_Script(IDispatch**); 
    171133} 
    172134 
    173 interface IHTMLDocument2 : public IHTMLDocument 
    174 { 
    175     HRESULT QueryInterface(REFIID,PVOID*); 
    176     ULONG AddRef(); 
    177     ULONG Release(); 
    178     HRESULT GetTypeInfoCount(UINT*); 
    179     HRESULT GetTypeInfo(UINT,LCID,LPTYPEINFO*); 
    180     HRESULT GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*); 
    181     HRESULT Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*); 
    182  
    183     HRESULT get_Script(IDispatch**); 
    184  
     135interface IHTMLDocument2 : public IHTMLDocument { 
    185136    HRESULT get_all(LPHTMLELEMENTCOLLECTION*); 
    186137    HRESULT get_body(LPHTMLELEMENT*); 
    …… 
    293244} 
    294245 
    295 interface IHTMLSelectionObject : public IDispatch 
    296 { 
    297     HRESULT QueryInterface(REFIID,PVOID*); 
    298     ULONG AddRef(); 
    299     ULONG Release(); 
    300     HRESULT GetTypeInfoCount(UINT*); 
    301     HRESULT GetTypeInfo(UINT,LCID,LPTYPEINFO*); 
    302     HRESULT GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*); 
    303     HRESULT Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*); 
    304  
     246interface IHTMLSelectionObject : public IDispatch { 
    305247    HRESULT createRange(IDispatch**); 
    306248    HRESULT empty(); 
    …… 
    309251} 
    310252 
    311 interface IHTMLTxtRange : public IDispatch 
    312 { 
    313     HRESULT QueryInterface(REFIID,PVOID*); 
    314     ULONG AddRef(); 
    315     ULONG Release(); 
    316     HRESULT GetTypeInfoCount(UINT*); 
    317     HRESULT GetTypeInfo(UINT,LCID,LPTYPEINFO*); 
    318     HRESULT GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*); 
    319     HRESULT Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*); 
    320  
     253interface IHTMLTxtRange : public IDispatch { 
    321254    HRESULT get_htmlText(BSTR*); 
    322255    HRESULT put_text(BSTR); 
    …… 
    351284} 
    352285 
    353 interface IHTMLElement : public IDispatch 
    354 { 
    355     HRESULT QueryInterface(REFIID,PVOID*); 
    356     ULONG AddRef(); 
    357     ULONG Release(); 
    358     HRESULT GetTypeInfoCount(UINT*); 
    359     HRESULT GetTypeInfo(UINT,LCID,LPTYPEINFO*); 
    360     HRESULT GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*); 
    361     HRESULT Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*); 
    362  
     286interface IHTMLElement : public IDispatch { 
    363287    HRESULT setAttribute(BSTR,VARIANT,long); 
    364288    HRESULT getAttribute(BSTR,long,VARIANT*); 
    …… 
    450374} 
    451375 
    452 interface IHTMLFramesCollection2 : public IDispatch 
    453 { 
    454     HRESULT QueryInterface(REFIID,PVOID*); 
    455     ULONG AddRef(); 
    456     ULONG Release(); 
    457     HRESULT GetTypeInfoCount(UINT*); 
    458     HRESULT GetTypeInfo(UINT,LCID,LPTYPEINFO*); 
    459     HRESULT GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*); 
    460     HRESULT Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*); 
    461  
     376interface IHTMLFramesCollection2 : public IDispatch { 
    462377    HRESULT item(VARIANT*,VARIANT*); 
    463378    HRESULT get_length(long*); 
    464379} 
    465380 
    466 interface IHTMLWindow2 : public IHTMLFramesCollection2 
    467 { 
    468     HRESULT QueryInterface(REFIID,PVOID*); 
    469     ULONG AddRef(); 
    470     ULONG Release(); 
    471     HRESULT GetTypeInfoCount(UINT*); 
    472     HRESULT GetTypeInfo(UINT,LCID,LPTYPEINFO*); 
    473     HRESULT GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*); 
    474     HRESULT Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*); 
    475     HRESULT item(VARIANT*,VARIANT*); 
    476     HRESULT get_length(long*); 
    477  
     381interface IHTMLWindow2 : public IHTMLFramesCollection2 { 
    478382    HRESULT get_frames(IHTMLFramesCollection2**); 
    479383    HRESULT put_defaultStatus(BSTR); 
    …… 
    546450} 
    547451 
    548 interface IHTMLFrameBase : public IDispatch 
    549 { 
    550     HRESULT QueryInterface(REFIID,PVOID*); 
    551     ULONG AddRef(); 
    552     ULONG Release(); 
    553     HRESULT GetTypeInfoCount(UINT*); 
    554     HRESULT GetTypeInfo(UINT,LCID,LPTYPEINFO*); 
    555     HRESULT GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*); 
    556     HRESULT Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*); 
    557  
     452interface IHTMLFrameBase : public IDispatch { 
    558453    HRESULT put_src(BSTR); 
    559454    HRESULT get_src(BSTR*); 
    …… 
    576471} 
    577472 
    578 interface IHTMLFrameBase2 : public IDispatch 
    579 { 
    580     HRESULT QueryInterface(REFIID,PVOID*); 
    581     ULONG AddRef(); 
    582     ULONG Release(); 
    583     HRESULT GetTypeInfoCount(UINT*); 
    584     HRESULT GetTypeInfo(UINT,LCID,LPTYPEINFO*); 
    585     HRESULT GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*); 
    586     HRESULT Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*); 
    587  
     473interface IHTMLFrameBase2 : public IDispatch { 
    588474    HRESULT get_contentWindow(IHTMLWindow2 **); 
    589475    HRESULT put_onload(VARIANT); 
    …… 
    596482} 
    597483 
    598 interface IHTMLFrameBase3 : public IDispatch 
    599 { 
    600     HRESULT QueryInterface(REFIID,PVOID*); 
    601     ULONG AddRef(); 
    602     ULONG Release(); 
    603     HRESULT GetTypeInfoCount(UINT*); 
    604     HRESULT GetTypeInfo(UINT,LCID,LPTYPEINFO*); 
    605     HRESULT GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*); 
    606     HRESULT Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*); 
    607  
     484interface IHTMLFrameBase3 : public IDispatch { 
    608485    HRESULT put_longDesc(BSTR); 
    609486    HRESULT get_longDesc(BSTR*); 
    610487} 
    611488 
    612 interface IHTMLBodyElement : public IDispatch 
    613 { 
    614     HRESULT QueryInterface(REFIID,PVOID*); 
    615     ULONG AddRef(); 
    616     ULONG Release(); 
    617     HRESULT GetTypeInfoCount(UINT*); 
    618     HRESULT GetTypeInfo(UINT,LCID,LPTYPEINFO*); 
    619     HRESULT GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*); 
    620     HRESULT Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*); 
    621  
     489interface IHTMLBodyElement : public IDispatch { 
    622490    HRESULT put_background(BSTR); 
    623491    HRESULT get_background(BSTR*); 
    …… 
    657525} 
    658526 
    659 interface IHTMLBodyElement2 : public IDispatch 
    660 { 
    661     HRESULT QueryInterface(REFIID,PVOID*); 
    662     ULONG AddRef(); 
    663     ULONG Release(); 
    664     HRESULT GetTypeInfoCount(UINT*); 
    665     HRESULT GetTypeInfo(UINT,LCID,LPTYPEINFO*); 
    666     HRESULT GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*); 
    667     HRESULT Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*); 
    668  
     527interface IHTMLBodyElement2 : public IDispatch { 
    669528    HRESULT put_onbeforeprint(VARIANT); 
    670529    HRESULT get_onbeforeprint(VARIANT*); 

  • trunk/win32/ole2.d

    r127 r141  
    4141    LPOLESTREAMVTBL lpstbl; 
    4242} 
    43 alias OLESTREAM * LPOLESTREAM; 
     43alias OLESTREAM* LPOLESTREAM; 
    4444 
    4545extern (Windows) { 
    4646    struct OLESTREAMVTBL{ 
    47         DWORD function (LPOLESTREAM,void*,DWORD) Get; 
    48         DWORD function (LPOLESTREAM, void*,DWORD) Put; 
     47        DWORD function (LPOLESTREAM, void*, DWORD) Get; 
     48        DWORD function (LPOLESTREAM, void*, DWORD) Put; 
    4949    } 
    5050} 
    51 alias OLESTREAMVTBL * LPOLESTREAMVTBL; 
    52  
    53 align: 
     51alias OLESTREAMVTBL* LPOLESTREAMVTBL; 
    5452 
    5553extern (Windows) { 
    56 HRESULT CreateDataAdviseHolder(LPDATAADVISEHOLDER*); 
    57 DWORD OleBuildVersion(); 
    58 HRESULT ReadClassStg(LPSTORAGE,CLSID*); 
    59 HRESULT WriteClassStg(LPSTORAGE,REFCLSID); 
    60 HRESULT ReadClassStm(LPSTREAM,CLSID*); 
    61 HRESULT WriteClassStm(LPSTREAM,REFCLSID); 
    62 HRESULT WriteFmtUserTypeStg(LPSTORAGE,CLIPFORMAT,LPOLESTR); 
    63 HRESULT ReadFmtUserTypeStg(LPSTORAGE,CLIPFORMAT*,LPOLESTR*); 
    64 HRESULT OleInitialize(PVOID); 
    65 void OleUninitialize(); 
    66 HRESULT OleQueryLinkFromData(LPDATAOBJECT); 
    67 HRESULT OleQueryCreateFromData(LPDATAOBJECT); 
    68 HRESULT OleCreate(REFCLSID,REFIID,DWORD,LPFORMATETC,LPOLECLIENTSITE,LPSTORAGE,PVOID*); 
    69 HRESULT OleCreateFromData(LPDATAOBJECT,REFIID,DWORD,LPFORMATETC,LPOLECLIENTSITE,LPSTORAGE,PVOID*); 
    70 HRESULT OleCreateLinkFromData(LPDATAOBJECT,REFIID,DWORD,LPFORMATETC,LPOLECLIENTSITE,LPSTORAGE,PVOID*); 
    71 HRESULT OleCreateStaticFromData(LPDATAOBJECT,REFIID,DWORD,LPFORMATETC,LPOLECLIENTSITE,LPSTORAGE,PVOID*); 
    72 HRESULT OleCreateLink(LPMONIKER,REFIID,DWORD,LPFORMATETC,LPOLECLIENTSITE,LPSTORAGE,PVOID*); 
    73 HRESULT OleCreateLinkToFile(LPCOLESTR,REFIID,DWORD,LPFORMATETC,LPOLECLIENTSITE,LPSTORAGE,PVOID*); 
    74 HRESULT OleCreateFromFile(REFCLSID,LPCOLESTR,REFIID,DWORD,LPFORMATETC,LPOLECLIENTSITE,LPSTORAGE,PVOID*); 
    75 HRESULT OleLoad(LPSTORAGE,REFIID,LPOLECLIENTSITE,PVOID*); 
    76 HRESULT OleSave(LPPERSISTSTORAGE,LPSTORAGE,BOOL); 
    77 HRESULT OleLoadFromStream(LPSTREAM,REFIID,PVOID*); 
    78 HRESULT OleSaveToStream(LPPERSISTSTREAM,LPSTREAM); 
    79 HRESULT OleSetContainedObject(LPUNKNOWN,BOOL); 
    80 HRESULT OleNoteObjectVisible(LPUNKNOWN,BOOL); 
    81 HRESULT RegisterDragDrop(HWND,LPDROPTARGET); 
    82 HRESULT RevokeDragDrop(HWND); 
    83 HRESULT DoDragDrop(LPDATAOBJECT,LPDROPSOURCE,DWORD,PDWORD); 
    84 HRESULT OleSetClipboard(LPDATAOBJECT); 
    85 HRESULT OleGetClipboard(LPDATAOBJECT*); 
    86 HRESULT OleFlushClipboard(); 
    87 HRESULT OleIsCurrentClipboard(LPDATAOBJECT); 
    88 HOLEMENU OleCreateMenuDescriptor(HMENU,LPOLEMENUGROUPWIDTHS); 
    89 HRESULT OleSetMenuDescriptor(HOLEMENU,HWND,HWND,LPOLEINPLACEFRAME,LPOLEINPLACEACTIVEOBJECT); 
    90 HRESULT OleDestroyMenuDescriptor(HOLEMENU); 
    91 HRESULT OleTranslateAccelerator(LPOLEINPLACEFRAME,LPOLEINPLACEFRAMEINFO,LPMSG); 
    92 HANDLE OleDuplicateData(HANDLE,CLIPFORMAT,UINT); 
    93 HRESULT OleDraw(LPUNKNOWN,DWORD,HDC,LPCRECT); 
    94 HRESULT OleRun(LPUNKNOWN); 
    95 BOOL OleIsRunning(LPOLEOBJECT); 
    96 HRESULT OleLockRunning(LPUNKNOWN,BOOL,BOOL); 
    97 void ReleaseStgMedium(LPSTGMEDIUM); 
    98 HRESULT CreateOleAdviseHolder(LPOLEADVISEHOLDER*); 
    99 HRESULT OleCreateDefaultHandler(REFCLSID,LPUNKNOWN,REFIID,PVOID*); 
    100 HRESULT OleCreateEmbeddingHelper(REFCLSID,LPUNKNOWN,DWORD,LPCLASSFACTORY,REFIID,PVOID*); 
    101 BOOL IsAccelerator(HACCEL,int,LPMSG,WORD*); 
    102 HGLOBAL OleGetIconOfFile(LPOLESTR,BOOL); 
    103 HGLOBAL OleGetIconOfClass(REFCLSID,LPOLESTR,BOOL); 
    104 HGLOBAL OleMetafilePictFromIconAndLabel(HICON,LPOLESTR,LPOLESTR,UINT); 
    105 HRESULT OleRegGetUserType(REFCLSID,DWORD,LPOLESTR*); 
    106 HRESULT OleRegGetMiscStatus(REFCLSID,DWORD,DWORD*); 
    107 HRESULT OleRegEnumFormatEtc (REFCLSID,DWORD,LPENUMFORMATETC*); 
    108 HRESULT OleRegEnumVerbs (REFCLSID,LPENUMOLEVERB*); 
    109 HRESULT OleConvertOLESTREAMToIStorage(LPOLESTREAM,LPSTORAGE, DVTARGETDEVICE*); 
    110 HRESULT OleConvertIStorageToOLESTREAM(LPSTORAGE,LPOLESTREAM); 
    111 HRESULT GetHGlobalFromILockBytes(LPLOCKBYTES,HGLOBAL*); 
    112 HRESULT CreateILockBytesOnHGlobal(HGLOBAL,BOOL,LPLOCKBYTES*); 
    113 HRESULT GetHGlobalFromStream(LPSTREAM,HGLOBAL*); 
    114 HRESULT CreateStreamOnHGlobal(HGLOBAL,BOOL,LPSTREAM*); 
    115 HRESULT OleDoAutoConvert(LPSTORAGE,LPCLSID); 
    116 HRESULT OleGetAutoConvert(REFCLSID,LPCLSID); 
    117 HRESULT OleSetAutoConvert(REFCLSID,REFCLSID); 
    118 HRESULT GetConvertStg(LPSTORAGE); 
    119 HRESULT SetConvertStg(LPSTORAGE,BOOL); 
    120 HRESULT OleConvertIStorageToOLESTREAMEx(LPSTORAGE,CLIPFORMAT,LONG,LONG,DWORD,LPSTGMEDIUM,LPOLESTREAM); 
    121 HRESULT OleConvertOLESTREAMToIStorageEx(LPOLESTREAM,LPSTORAGE,CLIPFORMAT*,LONG*,LONG*,DWORD*,LPSTGMEDIUM); 
     54   HRESULT CreateDataAdviseHolder(LPDATAADVISEHOLDER*); 
     55   DWORD OleBuildVersion(); 
     56   HRESULT ReadClassStg(LPSTORAGE, CLSID*); 
     57   HRESULT WriteClassStg(LPSTORAGE, REFCLSID); 
     58   HRESULT ReadClassStm(LPSTREAM, CLSID*); 
     59   HRESULT WriteClassStm(LPSTREAM, REFCLSID); 
     60   HRESULT WriteFmtUserTypeStg(LPSTORAGE, CLIPFORMAT, LPOLESTR); 
     61   HRESULT ReadFmtUserTypeStg(LPSTORAGE, CLIPFORMAT*, LPOLESTR*); 
     62   HRESULT OleInitialize(PVOID); 
     63   void OleUninitialize(); 
     64   HRESULT OleQueryLinkFromData(LPDATAOBJECT); 
     65   HRESULT OleQueryCreateFromData(LPDATAOBJECT); 
     66   HRESULT OleCreate(REFCLSID, REFIID, DWORD, LPFORMATETC, LPOLECLIENTSITE, LPSTORAGE, PVOID*); 
     67   HRESULT OleCreateFromData(LPDATAOBJECT, REFIID, DWORD, LPFORMATETC, LPOLECLIENTSITE, LPSTORAGE, PVOID*); 
     68   HRESULT OleCreateLinkFromData(LPDATAOBJECT, REFIID, DWORD, LPFORMATETC, LPOLECLIENTSITE, LPSTORAGE, PVOID*); 
     69   HRESULT OleCreateStaticFromData(LPDATAOBJECT, REFIID, DWORD, LPFORMATETC, LPOLECLIENTSITE, LPSTORAGE, PVOID*); 
     70   HRESULT OleCreateLink(LPMONIKER, REFIID, DWORD, LPFORMATETC, LPOLECLIENTSITE, LPSTORAGE, PVOID*); 
     71   HRESULT OleCreateLinkToFile(LPCOLESTR, REFIID, DWORD, LPFORMATETC, LPOLECLIENTSITE, LPSTORAGE, PVOID*); 
     72   HRESULT OleCreateFromFile(REFCLSID, LPCOLESTR, REFIID, DWORD, LPFORMATETC, LPOLECLIENTSITE, LPSTORAGE, PVOID*); 
     73   HRESULT OleLoad(LPSTORAGE, REFIID, LPOLECLIENTSITE, PVOID*); 
     74   HRESULT OleSave(LPPERSISTSTORAGE, LPSTORAGE, BOOL); 
     75   HRESULT OleLoadFromStream(LPSTREAM, REFIID, PVOID*); 
     76   HRESULT OleSaveToStream(LPPERSISTSTREAM, LPSTREAM); 
     77   HRESULT OleSetContainedObject(LPUNKNOWN, BOOL); 
     78   HRESULT OleNoteObjectVisible(LPUNKNOWN, BOOL); 
     79   HRESULT RegisterDragDrop(HWND, LPDROPTARGET); 
     80   HRESULT RevokeDragDrop(HWND); 
     81   HRESULT DoDragDrop(LPDATAOBJECT, LPDROPSOURCE, DWORD, PDWORD); 
     82   HRESULT OleSetClipboard(LPDATAOBJECT); 
     83   HRESULT OleGetClipboard(LPDATAOBJECT*); 
     84   HRESULT OleFlushClipboard(); 
     85   HRESULT OleIsCurrentClipboard(LPDATAOBJECT); 
     86   HOLEMENU OleCreateMenuDescriptor(HMENU, LPOLEMENUGROUPWIDTHS); 
     87   HRESULT OleSetMenuDescriptor(HOLEMENU, HWND, HWND, LPOLEINPLACEFRAME, LPOLEINPLACEACTIVEOBJECT); 
     88   HRESULT OleDestroyMenuDescriptor(HOLEMENU); 
     89   HRESULT OleTranslateAccelerator(LPOLEINPLACEFRAME, LPOLEINPLACEFRAMEINFO, LPMSG); 
     90   HANDLE OleDuplicateData(HANDLE, CLIPFORMAT, UINT); 
     91   HRESULT OleDraw(LPUNKNOWN, DWORD, HDC, LPCRECT); 
     92   HRESULT OleRun(LPUNKNOWN); 
     93   BOOL OleIsRunning(LPOLEOBJECT); 
     94   HRESULT OleLockRunning(LPUNKNOWN, BOOL, BOOL); 
     95   void ReleaseStgMedium(LPSTGMEDIUM); 
     96   HRESULT CreateOleAdviseHolder(LPOLEADVISEHOLDER*); 
     97   HRESULT OleCreateDefaultHandler(REFCLSID, LPUNKNOWN, REFIID, PVOID*); 
     98   HRESULT OleCreateEmbeddingHelper(REFCLSID, LPUNKNOWN, DWORD, LPCLASSFACTORY, REFIID, PVOID*); 
     99   BOOL IsAccelerator(HACCEL, int, LPMSG, WORD*); 
     100   HGLOBAL OleGetIconOfFile(LPOLESTR, BOOL); 
     101   HGLOBAL OleGetIconOfClass(REFCLSID, LPOLESTR, BOOL); 
     102   HGLOBAL OleMetafilePictFromIconAndLabel(HICON, LPOLESTR, LPOLESTR, UINT); 
     103   HRESULT OleRegGetUserType(REFCLSID, DWORD, LPOLESTR*); 
     104   HRESULT OleRegGetMiscStatus(REFCLSID, DWORD, DWORD*); 
     105   HRESULT OleRegEnumFormatEtc (REFCLSID, DWORD, LPENUMFORMATETC*); 
     106   HRESULT OleRegEnumVerbs (REFCLSID, LPENUMOLEVERB*); 
     107   HRESULT OleConvertOLESTREAMToIStorage(LPOLESTREAM, LPSTORAGE, DVTARGETDEVICE*); 
     108   HRESULT OleConvertIStorageToOLESTREAM(LPSTORAGE, LPOLESTREAM); 
     109   HRESULT GetHGlobalFromILockBytes(LPLOCKBYTES, HGLOBAL*); 
     110   HRESULT CreateILockBytesOnHGlobal(HGLOBAL, BOOL, LPLOCKBYTES*); 
     111   HRESULT GetHGlobalFromStream(LPSTREAM, HGLOBAL*); 
     112   HRESULT CreateStreamOnHGlobal(HGLOBAL, BOOL, LPSTREAM*); 
     113   HRESULT OleDoAutoConvert(LPSTORAGE, LPCLSID); 
     114   HRESULT OleGetAutoConvert(REFCLSID, LPCLSID); 
     115   HRESULT OleSetAutoConvert(REFCLSID, REFCLSID); 
     116   HRESULT GetConvertStg(LPSTORAGE); 
     117   HRESULT SetConvertStg(LPSTORAGE, BOOL); 
     118   HRESULT OleConvertIStorageToOLESTREAMEx(LPSTORAGE, CLIPFORMAT, LONG, LONG, DWORD, LPSTGMEDIUM, LPOLESTREAM); 
     119   HRESULT OleConvertOLESTREAMToIStorageEx(LPOLESTREAM, LPSTORAGE, CLIPFORMAT*, LONG*, LONG*, DWORD*, LPSTGMEDIUM); 
    122120} 

  • trunk/win32/oleacc.d

    r135 r141  
    4444    NAVDIR_PREVIOUS, 
    4545    NAVDIR_FIRSTCHILD, 
    46     NAVDIR_LASTCHILD // =8 
     46    NAVDIR_LASTCHILD // = 8 
    4747} 
    4848 
    …… 
    154154} 
    155155 
    156 const SELFLAG_VALID=0x0000001F; 
     156const SELFLAG_VALID = 0x0000001F; 
    157157 
    158158extern (Windows) { 
    159  
    160 /* DEFINE_GUID(LIBID_Accessibility, 0x1ea4dbf0, 0x3c3b,0x11cf, 0x81, 0x0c, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); */ 
    161 /* DEFINE_GUID(IID_IAccessible,     0x618736e0, 0x3c3d,0x11cf, 0x81, 0x0c, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); */ 
    162 extern IID LIBID_Accessibility; 
    163 extern IID IID_IAccessible; 
    164  
    165 } 
    166  
    167 interface IAccessible : public IDispatch 
    168 { 
    169     HRESULT GetTypeInfoCount(UINT*); 
    170     HRESULT GetTypeInfo(UINT,LCID,LPTYPEINFO*); 
    171     HRESULT GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*); 
    172     HRESULT Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*); 
    173  
     159    /* DEFINE_GUID(LIBID_Accessibility, 0x1ea4dbf0, 0x3c3b, 0x11cf, 0x81, 0x0c, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); */ 
     160    /* DEFINE_GUID(IID_IAccessible,     0x618736e0, 0x3c3d, 0x11cf, 0x81, 0x0c, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); */ 
     161    extern IID LIBID_Accessibility; 
     162    extern IID IID_IAccessible; 
     163} 
     164 
     165interface IAccessible : public IDispatch { 
    174166    HRESULT get_accParent(IDispatch**); 
    175167    HRESULT get_accChildCount(int*); 
    …… 
    200192 
    201193extern (Windows) { 
    202  
    203 HRESULT AccessibleChildren(IAccessible*,LONG,LONG,VARIANT*,LONG*); 
    204 HRESULT AccessibleObjectFromEvent(HWND,DWORD,DWORD,IAccessible*,VARIANT*); 
    205 HRESULT AccessibleObjectFromPoint(POINT,IAccessible**,VARIANT*); 
    206 HRESULT AccessibleObjectFromWindow(HWND,DWORD,REFIID,void**); 
    207 HRESULT CreateStdAccessibleObject(HWND,LONG,REFIID,void**); 
    208 HRESULT CreateStdAccessibleProxyA(HWND,LPCSTR,LONG,REFIID,void**); 
    209 HRESULT CreateStdAccessibleProxyW(HWND,LPCWSTR,LONG,REFIID,void**); 
    210  
    211 void GetOleaccVersionInfo(DWORD*,DWORD*); 
    212 UINT GetRoleTextA(DWORD,LPSTR,UINT); 
    213 UINT GetRoleTextW(DWORD,LPWSTR,UINT); 
    214 UINT GetStateTextA(DWORD,LPSTR,UINT); 
    215 UINT GetStateTextW(DWORD,LPWSTR,UINT); 
    216 LRESULT LresultFromObject(REFIID,WPARAM,LPUNKNOWN); 
    217 HRESULT ObjectFromLresult(LRESULT,REFIID,WPARAM,void**); 
    218 HRESULT WindowFromAccessibleObject(IAccessible*,HWND*); 
     194    HRESULT AccessibleChildren(IAccessible*, LONG, LONG, VARIANT*, LONG*); 
     195    HRESULT AccessibleObjectFromEvent(HWND, DWORD, DWORD, IAccessible*, VARIANT*); 
     196    HRESULT AccessibleObjectFromPoint(POINT, IAccessible**, VARIANT*); 
     197    HRESULT AccessibleObjectFromWindow(HWND, DWORD, REFIID, void**); 
     198    HRESULT CreateStdAccessibleObject(HWND, LONG, REFIID, void**); 
     199    HRESULT CreateStdAccessibleProxyA(HWND, LPCSTR, LONG, REFIID, void**); 
     200    HRESULT CreateStdAccessibleProxyW(HWND, LPCWSTR, LONG, REFIID, void**); 
     201 
     202    void GetOleaccVersionInfo(DWORD*, DWORD*); 
     203    UINT GetRoleTextA(DWORD, LPSTR, UINT); 
     204    UINT GetRoleTextW(DWORD, LPWSTR, UINT); 
     205    UINT GetStateTextA(DWORD, LPSTR, UINT); 
     206    UINT GetStateTextW(DWORD, LPWSTR, UINT); 
     207    LRESULT LresultFromObject(REFIID, WPARAM, LPUNKNOWN); 
     208    HRESULT ObjectFromLresult(LRESULT, REFIID, WPARAM, void**); 
     209    HRESULT WindowFromAccessibleObject(IAccessible*, HWND*); 
    219210} 
    220211 

  • trunk/win32/oleauto.d

    r135 r141  
    4242const DISPATCH_PROPERTYPUTREF = 8; 
    4343 
    44 ULONG LHashValOfName(LCID l,OLECHAR * n) { return LHashValOfNameSys(SYSKIND.SYS_WIN32,l,n); } 
     44ULONG LHashValOfName(LCID l, OLECHAR* n) { return LHashValOfNameSys(SYSKIND.SYS_WIN32, l, n); } 
    4545 
    4646// DAC: These aren't in the 2003 SDK. 
    4747//MACRO #define WHashValOfLHashVal(h) ((unsigned short)(0x0000ffff&(h))) 
    48 //MACRO #define IsHashValCompatible(h1,h2) ((BOOL)((0x00ff0000&(h1))==(0x00ff0000&(h2)))) 
     48//MACRO #define IsHashValCompatible(h1, h2) ((BOOL)((0x00ff0000&(h1))==(0x00ff0000&(h2)))) 
    4949 
    5050enum { 
    …… 
    5454 
    5555// DAC: These seem to be irrelevant for D. 
    56 //#define V_UNION(X,Y) ((X)->Y) 
     56//#define V_UNION(X, Y) ((X)->Y) 
    5757//#define V_VT(X) ((X)->vt) 
    58 //#define V_BOOL(X) V_UNION(X,boolVal) 
     58//#define V_BOOL(X) V_UNION(X, boolVal) 
    5959//#define V_ISBYREF(X) (V_VT(X)&VT_BYREF) 
    6060//#define V_ISARRAY(X) (V_VT(X)&VT_ARRAY) 
    6161//#define V_ISVECTOR(X) (V_VT(X)&VT_VECTOR) 
    6262//#define V_NONE(X) V_I2(X) 
    63 //#define V_UI1(X) V_UNION(X,bVal) 
    64 //#define V_UI1REF(X) V_UNION(X,pbVal) 
    65 //#define V_I2(X) V_UNION(X,iVal) 
    66 //#define V_UI2(X) V_UNION(X,uiVal) 
    67 //#define V_I2REF(X) V_UNION(X,piVal) 
    68 //#define V_I4(X) V_UNION(X,lVal) 
    69 //#define V_UI4(X) V_UNION(X,ulVal) 
    70 //#define V_I4REF(X) V_UNION(X,plVal) 
    71 //#define V_UI4REF(X) V_UNION(X,pulVal) 
    72 //#define V_I8(X) V_UNION(X,llVal) 
    73 //#define V_UI8(X) V_UNION(X,ullVal) 
    74 //#define V_I8REF(X) V_UNION(X,pllVal) 
    75 //#define V_UI8REF(X) V_UNION(X,pullVal) 
    76 //#define V_R4(X) V_UNION(X,fltVal) 
    77 //#define V_R4REF(X) V_UNION(X,pfltVal) 
    78 //#define V_R8(X) V_UNION(X,dblVal) 
    79 //#define V_R8REF(X) V_UNION(X,pdblVal) 
    80 //#define V_CY(X) V_UNION(X,cyVal) 
    81 //#define V_CYREF(X) V_UNION(X,pcyVal) 
    82 //#define V_DATE(X) V_UNION(X,date) 
    83 //#define V_DATEREF(X) V_UNION(X,pdate) 
    84 //#define V_BSTR(X) V_UNION(X,bstrVal) 
    85 //#define V_BSTRREF(X) V_UNION(X,pbstrVal) 
    86 //#define V_DISPATCH(X) V_UNION(X,pdispVal) 
    87 //#define V_DISPATCHREF(X) V_UNION(X,ppdispVal) 
    88 //#define V_ERROR(X) V_UNION(X,scode) 
    89 //#define V_ERRORREF(X) V_UNION(X,pscode) 
    90 //#define V_BOOLREF(X) V_UNION(X,pboolVal) 
    91 //#define V_UNKNOWN(X) V_UNION(X,punkVal) 
    92 //#define V_UNKNOWNREF(X) V_UNION(X,ppunkVal) 
    93 //#define V_VARIANTREF(X) V_UNION(X,pvarVal) 
    94 //#define V_LPSTR(X) V_UNION(X,pszVal) 
    95 //#define V_LPSTRREF(X) V_UNION(X,ppszVal) 
    96 //#define V_LPWSTR(X) V_UNION(X,pwszVal) 
    97 //#define V_LPWSTRREF(X) V_UNION(X,ppwszVal) 
    98 //#define V_FILETIME(X) V_UNION(X,filetime) 
    99 //#define V_FILETIMEREF(X) V_UNION(X,pfiletime) 
    100 //#define V_BLOB(X) V_UNION(X,blob) 
    101 //#define V_UUID(X) V_UNION(X,puuid) 
    102 //#define V_CLSID(X) V_UNION(X,puuid) 
    103 //#define V_ARRAY(X) V_UNION(X,parray) 
    104 //#define V_ARRAYREF(X) V_UNION(X,pparray) 
    105 //#define V_BYREF(X) V_UNION(X,byref) 
     63//#define V_UI1(X) V_UNION(X, bVal) 
     64//#define V_UI1REF(X) V_UNION(X, pbVal) 
     65//#define V_I2(X) V_UNION(X, iVal) 
     66//#define V_UI2(X) V_UNION(X, uiVal) 
     67//#define V_I2REF(X) V_UNION(X, piVal) 
     68//#define V_I4(X) V_UNION(X, lVal) 
     69//#define V_UI4(X) V_UNION(X, ulVal) 
     70//#define V_I4REF(X) V_UNION(X, plVal) 
     71//#define V_UI4REF(X) V_UNION(X, pulVal) 
     72//#define V_I8(X) V_UNION(X, llVal) 
     73//#define V_UI8(X) V_UNION(X, ullVal) 
     74//#define V_I8REF(X) V_UNION(X, pllVal) 
     75//#define V_UI8REF(X) V_UNION(X, pullVal) 
     76//#define V_R4(X) V_UNION(X, fltVal) 
     77//#define V_R4REF(X) V_UNION(X, pfltVal) 
     78//#define V_R8(X) V_UNION(X, dblVal) 
     79//#define V_R8REF(X) V_UNION(X, pdblVal) 
     80//#define V_CY(X) V_UNION(X, cyVal) 
     81//#define V_CYREF(X) V_UNION(X, pcyVal) 
     82//#define V_DATE(X) V_UNION(X, date) 
     83//#define V_DATEREF(X) V_UNION(X, pdate) 
     84//#define V_BSTR(X) V_UNION(X, bstrVal) 
     85//#define V_BSTRREF(X) V_UNION(X, pbstrVal) 
     86//#define V_DISPATCH(X) V_UNION(X, pdispVal) 
     87//#define V_DISPATCHREF(X) V_UNION(X, ppdispVal) 
     88//#define V_ERROR(X) V_UNION(X, scode) 
     89//#define V_ERRORREF(X) V_UNION(X, pscode) 
     90//#define V_BOOLREF(X) V_UNION(X, pboolVal) 
     91//#define V_UNKNOWN(X) V_UNION(X, punkVal) 
     92//#define V_UNKNOWNREF(X) V_UNION(X, ppunkVal) 
     93//#define V_VARIANTREF(X) V_UNION(X, pvarVal) 
     94//#define V_LPSTR(X) V_UNION(X, pszVal) 
     95//#define V_LPSTRREF(X) V_UNION(X, ppszVal) 
     96//#define V_LPWSTR(X) V_UNION(X, pwszVal) 
     97//#define V_LPWSTRREF(X) V_UNION(X, ppwszVal) 
     98//#define V_FILETIME(X) V_UNION(X, filetime) 
     99//#define V_FILETIMEREF(X) V_UNION(X, pfiletime) 
     100//#define V_BLOB(X) V_UNION(X, blob) 
     101//#define V_UUID(X) V_UNION(X, puuid) 
     102//#define V_CLSID(X) V_UNION(X, puuid) 
     103//#define V_ARRAY(X) V_UNION(X, parray) 
     104//#define V_ARRAYREF(X) V_UNION(X, pparray) 
     105//#define V_BYREF(X) V_UNION(X, byref) 
    106106//#define V_DECIMAL(X) ((X)->decVal) 
    107 //#define V_DECIMALREF(X) V_UNION(X,pdecVal) 
    108 //#define V_I1(X) V_UNION(X,cVal) 
     107//#define V_DECIMALREF(X) V_UNION(X, pdecVal) 
     108//#define V_I1(X) V_UNION(X, cVal) 
    109109 
    110110//#ifdef _WIN64 
    …… 
    173173 
    174174struct PARAMDATA{ 
    175     OLECHAR *szName; 
     175    OLECHAR* szName; 
    176176    VARTYPE vt; 
    177177} 
    178 alias PARAMDATA * LPPARAMDATA; 
     178alias PARAMDATA* LPPARAMDATA; 
    179179 
    180180struct METHODDATA{ 
    181     OLECHAR *szName; 
    182     PARAMDATA *ppdata; 
     181    OLECHAR* szName; 
     182    PARAMDATA* ppdata; 
    183183    DISPID dispid; 
    184184    UINT iMeth; 
    …… 
    188188    VARTYPE vtReturn; 
    189189} 
    190 alias METHODDATA * LPMETHODDATA; 
     190alias METHODDATA* LPMETHODDATA; 
    191191 
    192192struct INTERFACEDATA{ 
    193     METHODDATA *pmethdata; 
     193    METHODDATA* pmethdata; 
    194194    UINT cMembers; 
    195195} 
    196 alias INTERFACEDATA * LPINTERFACEDATA; 
     196alias INTERFACEDATA* LPINTERFACEDATA; 
    197197 
    198198struct UDATE { 
    …… 
    218218 
    219219deprecated {  // not actually deprecated, but they aren't converted yet. 
    220 interface ICreateTypeInfo {}; 
    221 interface ICreateTypeInfo2 {}; 
    222 interface ICreateTypeLib {}; 
    223 interface ICreateTypeLib2 {}; 
    224 } 
    225  
    226 alias ICreateTypeInfo *LPCREATETYPEINFO; 
    227 alias ICreateTypeInfo2 *LPCREATETYPEINFO2; 
    228 alias ICreateTypeLib *LPCREATETYPELIB; 
    229 alias ICreateTypeLib2 *LPCREATETYPELIB2; 
     220   interface ICreateTypeInfo {}; 
     221   interface ICreateTypeInfo2 {}; 
     222   interface ICreateTypeLib {}; 
     223   interface ICreateTypeLib2 {}; 
     224} 
     225 
     226alias ICreateTypeInfo* LPCREATETYPEINFO; 
     227alias ICreateTypeInfo2* LPCREATETYPEINFO2; 
     228alias ICreateTypeLib* LPCREATETYPELIB; 
     229alias ICreateTypeLib2* LPCREATETYPELIB2; 
    230230 
    231231 
    232232extern (Windows) { 
    233  
    234 BSTR SysAllocString( OLECHAR*); 
    235 int SysReAllocString(BSTR*, OLECHAR*); 
    236 BSTR SysAllocStringLen( OLECHAR*,uint); 
    237 int SysReAllocStringLen(BSTR*, OLECHAR*,uint); 
    238 void SysFreeString(BSTR); 
    239 uint SysStringLen(BSTR); 
    240 uint SysStringByteLen(BSTR); 
    241 BSTR SysAllocStringByteLen( char*,uint); 
    242 int DosDateTimeToVariantTime(ushort,ushort,double*); 
    243 int VariantTimeToDosDateTime(double,ushort*,ushort*); 
    244 int VariantTimeToSystemTime(double,LPSYSTEMTIME); 
    245 int SystemTimeToVariantTime(LPSYSTEMTIME, double*); 
    246 HRESULT VarDateFromUdate(UDATE*,ULONG,DATE*); 
    247 HRESULT VarDateFromUdateEx(UDATE*,LCID,ULONG,DATE*); 
    248 HRESULT VarUdateFromDate(DATE,ULONG,UDATE*); 
    249 HRESULT SafeArrayAllocDescriptor(uint,SAFEARRAY**); 
    250 HRESULT SafeArrayAllocData(SAFEARRAY*); 
    251 SAFEARRAY * SafeArrayCreate(VARTYPE,uint,SAFEARRAYBOUND*); 
    252 HRESULT SafeArrayDestroyDescriptor(SAFEARRAY*); 
    253 HRESULT SafeArrayDestroyData(SAFEARRAY*); 
    254 HRESULT SafeArrayDestroy(SAFEARRAY*); 
    255 HRESULT SafeArrayRedim(SAFEARRAY*,SAFEARRAYBOUND*); 
    256 uint SafeArrayGetDim(SAFEARRAY*); 
    257 uint SafeArrayGetElemsize(SAFEARRAY*); 
    258 HRESULT SafeArrayGetUBound(SAFEARRAY*,uint,int*); 
    259 HRESULT SafeArrayGetLBound(SAFEARRAY*,uint,int*); 
    260 HRESULT SafeArrayLock(SAFEARRAY*); 
    261 HRESULT SafeArrayUnlock(SAFEARRAY*); 
    262 HRESULT SafeArrayAccessData(SAFEARRAY*,void**); 
    263 HRESULT SafeArrayUnaccessData(SAFEARRAY*); 
    264 HRESULT SafeArrayGetElement(SAFEARRAY*,int*,void*); 
    265 HRESULT SafeArrayPutElement(SAFEARRAY*,int*,void*); 
    266 HRESULT SafeArrayCopy(SAFEARRAY*,SAFEARRAY**); 
    267 HRESULT SafeArrayPtrOfIndex(SAFEARRAY*,int*,void**); 
    268 SAFEARRAY * SafeArrayCreateVector(VARTYPE,LONG,ULONG); 
    269 SAFEARRAY * SafeArrayCreateVectorEx(VARTYPE,LONG,ULONG,LPVOID); 
    270 HRESULT SafeArrayAllocDescriptorEx(VARTYPE,UINT,SAFEARRAY**); 
    271 HRESULT SafeArrayGetVartype(SAFEARRAY*,VARTYPE*); 
    272 HRESULT SafeArraySetRecordInfo(SAFEARRAY*,IRecordInfo*); 
    273 HRESULT SafeArrayGetRecordInfo(SAFEARRAY*,IRecordInfo**); 
    274 HRESULT SafeArraySetIID(SAFEARRAY*,REFGUID); 
    275 HRESULT SafeArrayGetIID(SAFEARRAY*,GUID*); 
    276 void VariantInit(VARIANTARG*); 
    277 HRESULT VariantClear(VARIANTARG*); 
    278 HRESULT VariantCopy(VARIANTARG*,VARIANTARG*); 
    279 HRESULT VariantCopyInd(VARIANT*,VARIANTARG*); 
    280 HRESULT VariantChangeType(VARIANTARG*,VARIANTARG*,ushort,VARTYPE); 
    281 HRESULT VariantChangeTypeEx(VARIANTARG*,VARIANTARG*,LCID,ushort,VARTYPE); 
    282 HRESULT VarUI1FromI2(short,ubyte*); 
    283 HRESULT VarUI1FromI4(int,ubyte*); 
    284 HRESULT VarUI1FromR4(float,ubyte*); 
    285 HRESULT VarUI1FromR8(double,ubyte*); 
    286 HRESULT VarUI1FromCy(CY,ubyte*); 
    287 HRESULT VarUI1FromDate(DATE,ubyte*); 
    288 HRESULT VarUI1FromStr(OLECHAR*,LCID,uint,ubyte*); 
    289 HRESULT VarUI1FromDisp(LPDISPATCH,LCID,ubyte*); 
    290 HRESULT VarUI1FromBool(VARIANT_BOOL,ubyte*); 
    291 HRESULT VarI2FromUI1(ubyte,short*); 
    292 HRESULT VarI2FromI4(int,short*); 
    293 HRESULT VarI2FromR4(float,short*); 
    294 HRESULT VarI2FromR8(double,short*); 
    295 HRESULT VarI2FromCy(CY cyIn,short*); 
    296 HRESULT VarI2FromDate(DATE,short*); 
    297 HRESULT VarI2FromStr(OLECHAR*,LCID,uint,short*); 
    298 HRESULT VarI2FromDisp(LPDISPATCH,LCID,short*); 
    299 HRESULT VarI2FromBool(VARIANT_BOOL,short*); 
    300 HRESULT VarI4FromUI1(ubyte,int*); 
    301 HRESULT VarI4FromI2(short,int*); 
    302 HRESULT VarI4FromR4(float,int*); 
    303 HRESULT VarI4FromR8(double,int*); 
    304 HRESULT VarI4FromCy(CY,int*); 
    305 HRESULT VarI4FromDate(DATE,int*); 
    306 HRESULT VarI4FromStr(OLECHAR*,LCID,uint,int*); 
    307 HRESULT VarI4FromDisp(LPDISPATCH,LCID,int*); 
    308 HRESULT VarI4FromBool(VARIANT_BOOL,int*); 
    309 HRESULT VarR4FromUI1(ubyte,float*); 
    310 HRESULT VarR4FromI2(short,float*); 
    311 HRESULT VarR4FromI4(int,float*); 
    312 HRESULT VarR4FromR8(double,float*); 
    313 HRESULT VarR4FromCy(CY,float*); 
    314 HRESULT VarR4FromDate(DATE,float*); 
    315 HRESULT VarR4FromStr(OLECHAR*,LCID,uint,float*); 
    316 HRESULT VarR4FromDisp(LPDISPATCH,LCID,float*); 
    317 HRESULT VarR4FromBool(VARIANT_BOOL,float*); 
    318 HRESULT VarR8FromUI1(ubyte,double*); 
    319 HRESULT VarR8FromI2(short,double*); 
    320 HRESULT VarR8FromI4(int,double*); 
    321 HRESULT VarR8FromR4(float,double*); 
    322 HRESULT VarR8FromCy(CY,double*); 
    323 HRESULT VarR8FromDate(DATE,double*); 
    324 HRESULT VarR8FromStr(OLECHAR*,LCID,uint,double*); 
    325 HRESULT VarR8FromDisp(LPDISPATCH,LCID,double*); 
    326 HRESULT VarR8FromBool(VARIANT_BOOL,double*); 
    327 HRESULT VarR8FromDec(DECIMAL*,double*); 
    328 HRESULT VarDateFromUI1(ubyte,DATE*); 
    329 HRESULT VarDateFromI2(short,DATE*); 
    330 HRESULT VarDateFromI4(int,DATE*); 
    331 HRESULT VarDateFromR4(float,DATE*); 
    332 HRESULT VarDateFromR8(double,DATE*); 
    333 HRESULT VarDateFromCy(CY,DATE*); 
    334 HRESULT VarDateFromStr(OLECHAR*,LCID,uint,DATE*); 
    335 HRESULT VarDateFromDisp(LPDISPATCH,LCID,DATE*); 
    336 HRESULT VarDateFromBool(VARIANT_BOOL,DATE*); 
    337 HRESULT VarCyFromUI1(ubyte,CY*); 
    338 HRESULT VarCyFromI2(short,CY*); 
    339 HRESULT VarCyFromI4(int,CY*); 
    340 HRESULT VarCyFromR4(float,CY*); 
    341 HRESULT VarCyFromR8(double,CY*); 
    342 HRESULT VarCyFromDate(DATE,CY*); 
    343 HRESULT VarCyFromStr(OLECHAR*,LCID,uint,CY*); 
    344 HRESULT VarCyFromDisp(LPDISPATCH,LCID,CY*); 
    345 HRESULT VarCyFromBool(VARIANT_BOOL,CY*); 
    346 HRESULT VarBstrFromUI1(ubyte,LCID,uint,BSTR*); 
    347 HRESULT VarBstrFromI2(short,LCID,uint,BSTR*); 
    348 HRESULT VarBstrFromI4(int,LCID,uint,BSTR*); 
    349 HRESULT VarBstrFromR4(float,LCID,uint,BSTR*); 
    350 HRESULT VarBstrFromR8(double,LCID,uint,BSTR*); 
    351 HRESULT VarBstrFromCy(CY,LCID,uint,BSTR*); 
    352 HRESULT VarBstrFromDate(DATE,LCID,uint,BSTR*); 
    353 HRESULT VarBstrFromDisp(LPDISPATCH,LCID,uint,BSTR*); 
    354 HRESULT VarBstrFromBool(VARIANT_BOOL,LCID,uint,BSTR*); 
    355 HRESULT VarBoolFromUI1(ubyte,VARIANT_BOOL*); 
    356 HRESULT VarBoolFromI2(short,VARIANT_BOOL*); 
    357 HRESULT VarBoolFromI4(int,VARIANT_BOOL*); 
    358 HRESULT VarBoolFromR4(float,VARIANT_BOOL*); 
    359 HRESULT VarBoolFromR8(double,VARIANT_BOOL*); 
    360 HRESULT VarBoolFromDate(DATE,VARIANT_BOOL*); 
    361 HRESULT VarBoolFromCy(CY,VARIANT_BOOL*); 
    362 HRESULT VarBoolFromStr(OLECHAR*,LCID,uint,VARIANT_BOOL*); 
    363 HRESULT VarBoolFromDisp(LPDISPATCH,LCID,VARIANT_BOOL*); 
    364 HRESULT VarDecFromR8(double,DECIMAL*); 
    365 ULONG LHashValOfNameSysA(SYSKIND,LCID, char*); 
    366 ULONG LHashValOfNameSys(SYSKIND,LCID, OLECHAR*); 
    367 HRESULT LoadTypeLib( OLECHAR*,LPTYPELIB*); 
    368 HRESULT LoadTypeLibEx(LPCOLESTR,REGKIND,LPTYPELIB*); 
    369 HRESULT LoadRegTypeLib(REFGUID,WORD,WORD,LCID,LPTYPELIB*); 
    370 HRESULT QueryPathOfRegTypeLib(REFGUID,ushort,ushort,LCID,LPBSTR); 
    371 HRESULT RegisterTypeLib(LPTYPELIB,OLECHAR*,OLECHAR*); 
    372 HRESULT UnRegisterTypeLib(REFGUID,WORD,WORD,LCID,SYSKIND); 
    373 HRESULT CreateTypeLib(SYSKIND, OLECHAR*,LPCREATETYPELIB*); 
    374 HRESULT DispGetParam(DISPPARAMS*,UINT,VARTYPE,VARIANT*,UINT*); 
    375 HRESULT DispGetIDsOfNames(LPTYPEINFO,OLECHAR**,UINT,DISPID*); 
    376 HRESULT DispInvoke(void*,LPTYPEINFO,DISPID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*); 
    377 HRESULT CreateDispTypeInfo(INTERFACEDATA*,LCID,LPTYPEINFO*); 
    378 HRESULT CreateStdDispatch(IUnknown*,void*,LPTYPEINFO,IUnknown**); 
    379 HRESULT RegisterActiveObject(IUnknown*,REFCLSID,DWORD,DWORD*); 
    380 HRESULT RevokeActiveObject(DWORD,void*); 
    381 HRESULT GetActiveObject(REFCLSID,void*,IUnknown**); 
    382 HRESULT SetErrorInfo(uint,LPERRORINFO); 
    383 HRESULT GetErrorInfo(uint,LPERRORINFO*); 
    384 HRESULT CreateErrorInfo(LPCREATEERRORINFO*); 
    385 uint OaBuildVersion(); 
    386 HRESULT VectorFromBstr (BSTR, SAFEARRAY **); 
    387 HRESULT BstrFromVector (SAFEARRAY *, BSTR *); 
    388 HRESULT VarParseNumFromStr(OLECHAR*,LCID,ULONG,NUMPARSE*,BYTE*); 
    389 HRESULT VarNumFromParseNum(NUMPARSE*,BYTE*,ULONG,VARIANT*); 
    390  
    391 HRESULT VarAdd(LPVARIANT, LPVARIANT, LPVARIANT); 
    392 HRESULT VarSub(LPVARIANT, LPVARIANT, LPVARIANT); 
    393 HRESULT VarMul(LPVARIANT, LPVARIANT, LPVARIANT); 
    394 HRESULT VarDiv(LPVARIANT, LPVARIANT, LPVARIANT); 
    395  
    396 HRESULT VarUI1FromI2(SHORT,BYTE*); 
    397 HRESULT VarUI1FromI4(LONG,BYTE*); 
    398 HRESULT VarUI1FromI8(LONG64,BYTE*); 
    399 HRESULT VarUI1FromR4(FLOAT,BYTE*); 
    400 HRESULT VarUI1FromR8(DOUBLE,BYTE*); 
    401 HRESULT VarUI1FromDate(DATE,BYTE*); 
    402 HRESULT VarUI1FromBool(VARIANT_BOOL,BYTE*); 
    403 HRESULT VarUI1FromI1(byte,BYTE*); 
    404 HRESULT VarUI1FromUI2(USHORT,BYTE*); 
    405 HRESULT VarUI1FromUI4(ULONG,BYTE*); 
    406 HRESULT VarUI1FromUI8(ULONG64,BYTE*); 
    407 HRESULT VarUI1FromStr(OLECHAR*,LCID,ULONG,BYTE*); 
    408 HRESULT VarUI1FromCy(CY,BYTE*); 
    409 HRESULT VarUI1FromDec(DECIMAL*,BYTE*); 
    410 HRESULT VarUI1FromDisp(IDispatch*,LCID,BYTE*); 
    411  
    412 HRESULT VarI2FromUI1(BYTE,SHORT*); 
    413 HRESULT VarI2FromI4(LONG,SHORT*); 
    414 HRESULT VarI2FromI8(LONG64,SHORT*); 
    415 HRESULT VarI2FromR4(FLOAT,SHORT*); 
    416 HRESULT VarI2FromR8(DOUBLE,SHORT*); 
    417 HRESULT VarI2FromDate(DATE,SHORT*); 
    418 HRESULT VarI2FromBool(VARIANT_BOOL,SHORT*); 
    419 HRESULT VarI2FromI1(byte,SHORT*); 
    420 HRESULT VarI2FromUI2(USHORT,SHORT*); 
    421 HRESULT VarI2FromUI4(ULONG,SHORT*); 
    422 HRESULT VarI2FromUI8(ULONG64,SHORT*); 
    423 HRESULT VarI2FromStr(OLECHAR*,LCID,ULONG,SHORT*); 
    424 HRESULT VarI2FromCy(CY,SHORT*); 
    425 HRESULT VarI2FromDec(DECIMAL*,SHORT*); 
    426 HRESULT VarI2FromDisp(IDispatch*,LCID,SHORT*); 
    427  
    428 HRESULT VarI4FromUI1(BYTE,LONG*); 
    429 HRESULT VarI4FromI2(SHORT,LONG*); 
    430 HRESULT VarI4FromI8(LONG64,LONG*); 
    431 HRESULT VarI4FromR4(FLOAT,LONG*); 
    432 HRESULT VarI4FromR8(DOUBLE,LONG*); 
    433 HRESULT VarI4FromDate(DATE,LONG*); 
    434 HRESULT VarI4FromBool(VARIANT_BOOL,LONG*); 
    435 HRESULT VarI4FromI1(byte,LONG*); 
    436 HRESULT VarI4FromUI2(USHORT,LONG*); 
    437 HRESULT VarI4FromUI4(ULONG,LONG*); 
    438 HRESULT VarI4FromUI8(ULONG64,LONG*); 
    439 HRESULT VarI4FromStr(OLECHAR*,LCID,ULONG,LONG*); 
    440 HRESULT VarI4FromCy(CY,LONG*); 
    441 HRESULT VarI4FromDec(DECIMAL*,LONG*); 
    442 HRESULT VarI4FromDisp(IDispatch*,LCID,LONG*); 
    443  
    444 HRESULT VarI8FromUI1(BYTE,LONG64*); 
    445 HRESULT VarI8FromI2(SHORT,LONG64*); 
    446 HRESULT VarI8FromI4(LONG,LONG64*); 
    447 HRESULT VarI8FromR4(FLOAT,LONG64*); 
    448 HRESULT VarI8FromR8(DOUBLE,LONG64*); 
    449 HRESULT VarI8FromDate(DATE,LONG64*); 
    450 HRESULT VarI8FromStr(OLECHAR*,LCID,ULONG,LONG64*); 
    451 HRESULT VarI8FromBool(VARIANT_BOOL,LONG64*); 
    452 HRESULT VarI8FromI1(byte,LONG64*); 
    453 HRESULT VarI8FromUI2(USHORT,LONG64*); 
    454 HRESULT VarI8FromUI4(ULONG,LONG64*); 
    455 HRESULT VarI8FromUI8(ULONG64,LONG64*); 
    456 HRESULT VarI8FromDec(DECIMAL *pdecIn,LONG64*); 
    457 HRESULT VarI8FromInt(INT intIn,LONG64*); 
    458 HRESULT VarI8FromCy(CY,LONG64*); 
    459 HRESULT VarI8FromDisp(IDispatch*,LCID,LONG64*); 
    460  
    461 HRESULT VarR4FromUI1(BYTE,FLOAT*); 
    462 HRESULT VarR4FromI2(SHORT,FLOAT*); 
    463 HRESULT VarR4FromI4(LONG,FLOAT*); 
    464 HRESULT VarR4FromI8(LONG64,FLOAT*); 
    465 HRESULT VarR4FromR8(DOUBLE,FLOAT*); 
    466 HRESULT VarR4FromDate(DATE,FLOAT*); 
    467 HRESULT VarR4FromBool(VARIANT_BOOL,FLOAT*); 
    468 HRESULT VarR4FromI1(byte,FLOAT*); 
    469 HRESULT VarR4FromUI2(USHORT,FLOAT*); 
    470 HRESULT VarR4FromUI4(ULONG,FLOAT*); 
    471 HRESULT VarR4FromUI8(ULONG64,FLOAT*); 
    472 HRESULT VarR4FromStr(OLECHAR*,LCID,ULONG,FLOAT*); 
    473 HRESULT VarR4FromCy(CY,FLOAT*); 
    474 HRESULT VarR4FromDec(DECIMAL*,FLOAT*); 
    475 HRESULT VarR4FromDisp(IDispatch*,LCID,FLOAT*); 
    476  
    477 HRESULT VarR8FromUI1(BYTE,double*); 
    478 HRESULT VarR8FromI2(SHORT,double*); 
    479 HRESULT VarR8FromI4(LONG,double*); 
    480 HRESULT VarR8FromI8(LONG64,double*); 
    481 HRESULT VarR8FromR4(FLOAT,double*); 
    482 HRESULT VarR8FromDate(DATE,double*); 
    483 HRESULT VarR8FromBool(VARIANT_BOOL,double*); 
    484 HRESULT VarR8FromI1(byte,double*); 
    485 HRESULT VarR8FromUI2(USHORT,double*); 
    486 HRESULT VarR8FromUI4(ULONG,double*); 
    487 HRESULT VarR8FromUI8(ULONG64,double*); 
    488 HRESULT VarR8FromStr(OLECHAR*,LCID,ULONG,double*); 
    489 HRESULT VarR8FromCy(CY,double*); 
    490 HRESULT VarR8FromDec(DECIMAL*,double*); 
    491 HRESULT VarR8FromDisp(IDispatch*,LCID,double*); 
    492  
    493 HRESULT VarDateFromUI1(BYTE,DATE*); 
    494 HRESULT VarDateFromI2(SHORT,DATE*); 
    495 HRESULT VarDateFromI4(LONG,DATE*); 
    496 HRESULT VarDateFromI8(LONG64,DATE*); 
    497 HRESULT VarDateFromR4(FLOAT,DATE*); 
    498 HRESULT VarDateFromR8(DOUBLE,DATE*); 
    499 HRESULT VarDateFromStr(OLECHAR*,LCID,ULONG,DATE*); 
    500 HRESULT VarDateFromI1(byte,DATE*); 
    501 HRESULT VarDateFromUI2(USHORT,DATE*); 
    502 HRESULT VarDateFromUI4(ULONG,DATE*); 
    503 HRESULT VarDateFromUI8(ULONG64,DATE*); 
    504 HRESULT VarDateFromBool(VARIANT_BOOL,DATE*); 
    505 HRESULT VarDateFromCy(CY,DATE*); 
    506 HRESULT VarDateFromDec(DECIMAL*,DATE*); 
    507 HRESULT VarDateFromDisp(IDispatch*,LCID,DATE*); 
    508  
    509 HRESULT VarCyFromUI1(BYTE,CY*); 
    510 HRESULT VarCyFromI2(SHORT sIn,CY*); 
    511 HRESULT VarCyFromI4(LONG,CY*); 
    512 HRESULT VarCyFromI8(LONG64,CY*); 
    513 HRESULT VarCyFromR4(FLOAT,CY*); 
    514 HRESULT VarCyFromR8(DOUBLE,CY*); 
    515 HRESULT VarCyFromDate(DATE,CY*); 
    516 HRESULT VarCyFromStr(OLECHAR*,LCID,ULONG,CY*); 
    517 HRESULT VarCyFromBool(VARIANT_BOOL,CY*); 
    518 HRESULT VarCyFromI1(byte,CY*); 
    519 HRESULT VarCyFromUI2(USHORT,CY*); 
    520 HRESULT VarCyFromUI4(ULONG,CY*); 
    521 HRESULT VarCyFromUI8(ULONG64,CY*); 
    522 HRESULT VarCyFromDec(DECIMAL*,CY*); 
    523 HRESULT VarCyFromStr(OLECHAR*,LCID,ULONG,CY*); 
    524 HRESULT VarCyFromDisp(IDispatch*,LCID,CY*); 
    525  
    526 HRESULT VarBstrFromUI1(BYTE,LCID,ULONG,BSTR*); 
    527 HRESULT VarBstrFromI2(SHORT,LCID,ULONG,BSTR*); 
    528 HRESULT VarBstrFromI4(LONG,LCID,ULONG,BSTR*); 
    529 HRESULT VarBstrFromI8(LONG64,LCID,ULONG,BSTR*); 
    530 HRESULT VarBstrFromR4(FLOAT,LCID,ULONG,BSTR*); 
    531 HRESULT VarBstrFromR8(DOUBLE,LCID,ULONG,BSTR*); 
    532 HRESULT VarBstrFromDate(DATE,LCID,ULONG,BSTR*); 
    533 HRESULT VarBstrFromBool(VARIANT_BOOL,LCID,ULONG,BSTR*); 
    534 HRESULT VarBstrFromI1(byte,LCID,ULONG,BSTR*); 
    535 HRESULT VarBstrFromUI2(USHORT,LCID,ULONG,BSTR*); 
    536 HRESULT VarBstrFromUI8(ULONG64,LCID,ULONG,BSTR*); 
    537 HRESULT VarBstrFromUI4(ULONG,LCID,ULONG,BSTR*); 
    538 HRESULT VarBstrFromCy(CY,LCID,ULONG,BSTR*); 
    539 HRESULT VarBstrFromDec(DECIMAL*,LCID,ULONG,BSTR*); 
    540 HRESULT VarBstrFromDisp(IDispatch*,LCID,ULONG,BSTR*); 
    541  
    542 HRESULT VarBoolFromUI1(BYTE,VARIANT_BOOL*); 
    543 HRESULT VarBoolFromI2(SHORT,VARIANT_BOOL*); 
    544 HRESULT VarBoolFromI4(LONG,VARIANT_BOOL*); 
    545 HRESULT VarBoolFromI8(LONG64,VARIANT_BOOL*); 
    546 HRESULT VarBoolFromR4(FLOAT,VARIANT_BOOL*); 
    547 HRESULT VarBoolFromR8(DOUBLE,VARIANT_BOOL*); 
    548 HRESULT VarBoolFromDate(DATE,VARIANT_BOOL*); 
    549 HRESULT VarBoolFromStr(OLECHAR*,LCID,ULONG,VARIANT_BOOL*); 
    550 HRESULT VarBoolFromI1(byte,VARIANT_BOOL*); 
    551 HRESULT VarBoolFromUI2(USHORT,VARIANT_BOOL*); 
    552 HRESULT VarBoolFromUI4(ULONG,VARIANT_BOOL*); 
    553 HRESULT VarBoolFromUI8(ULONG64,VARIANT_BOOL*); 
    554 HRESULT VarBoolFromCy(CY,VARIANT_BOOL*); 
    555 HRESULT VarBoolFromDec(DECIMAL*,VARIANT_BOOL*); 
    556 HRESULT VarBoolFromDisp(IDispatch*,LCID,VARIANT_BOOL*); 
    557  
    558 HRESULT VarI1FromUI1(BYTE,byte*); 
    559 HRESULT VarI1FromI2(SHORT,byte*); 
    560 HRESULT VarI1FromI4(LONG,byte*); 
    561 HRESULT VarI1FromI8(LONG64,byte*); 
    562 HRESULT VarI1FromR4(FLOAT,byte*); 
    563 HRESULT VarI1FromR8(DOUBLE,byte*); 
    564 HRESULT VarI1FromDate(DATE,byte*); 
    565 HRESULT VarI1FromStr(OLECHAR*,LCID,ULONG,byte*); 
    566 HRESULT VarI1FromBool(VARIANT_BOOL,byte*); 
    567 HRESULT VarI1FromUI2(USHORT,byte*); 
    568 HRESULT VarI1FromUI4(ULONG,byte*); 
    569 HRESULT VarI1FromUI8(ULONG64,byte*); 
    570 HRESULT VarI1FromCy(CY,byte*); 
    571 HRESULT VarI1FromDec(DECIMAL*,byte*); 
    572 HRESULT VarI1FromDisp(IDispatch*,LCID,byte*); 
    573  
    574 HRESULT VarUI2FromUI1(BYTE,USHORT*); 
    575 HRESULT VarUI2FromI2(SHORT,USHORT*); 
    576 HRESULT VarUI2FromI4(LONG,USHORT*); 
    577 HRESULT VarUI2FromI8(LONG64,USHORT*); 
    578 HRESULT VarUI2FromR4(FLOAT,USHORT*); 
    579 HRESULT VarUI2FromR8(DOUBLE,USHORT*); 
    580 HRESULT VarUI2FromDate(DATE,USHORT*); 
    581 HRESULT VarUI2FromStr(OLECHAR*,LCID,ULONG,USHORT*); 
    582 HRESULT VarUI2FromBool(VARIANT_BOOL,USHORT*); 
    583 HRESULT VarUI2FromI1(byte,USHORT*); 
    584 HRESULT VarUI2FromUI4(ULONG,USHORT*); 
    585 HRESULT VarUI2FromUI8(ULONG64,USHORT*); 
    586 HRESULT VarUI2FromCy(CY,USHORT*); 
    587 HRESULT VarUI2FromDec(DECIMAL*,USHORT*); 
    588 HRESULT VarUI2FromDisp(IDispatch*,LCID,USHORT*); 
    589  
    590 HRESULT VarUI4FromStr(OLECHAR*,LCID,ULONG,ULONG*); 
    591 HRESULT VarUI4FromUI1(BYTE,ULONG*); 
    592 HRESULT VarUI4FromI2(SHORT,ULONG*); 
    593 HRESULT VarUI4FromI4(LONG,ULONG*); 
    594 HRESULT VarUI4FromI8(LONG64,ULONG*); 
    595 HRESULT VarUI4FromR4(FLOAT,ULONG*); 
    596 HRESULT VarUI4FromR8(DOUBLE,ULONG*); 
    597 HRESULT VarUI4FromDate(DATE,ULONG*); 
    598 HRESULT VarUI4FromBool(VARIANT_BOOL,ULONG*); 
    599 HRESULT VarUI4FromI1(byte,ULONG*); 
    600 HRESULT VarUI4FromUI2(USHORT,ULONG*); 
    601 HRESULT VarUI4FromUI8(ULONG64,ULONG*); 
    602 HRESULT VarUI4FromCy(CY,ULONG*); 
    603 HRESULT VarUI4FromDec(DECIMAL*,ULONG*); 
    604 HRESULT VarUI4FromDisp(IDispatch*,LCID,ULONG*); 
    605  
    606 HRESULT VarUI8FromUI1(BYTE,ULONG64*); 
    607 HRESULT VarUI8FromI2(SHORT,ULONG64*); 
    608 HRESULT VarUI8FromI4(LONG,ULONG64*); 
    609 HRESULT VarUI8FromI8(LONG64,ULONG64*); 
    610 HRESULT VarUI8FromR4(FLOAT,ULONG64*); 
    611 HRESULT VarUI8FromR8(DOUBLE,ULONG64*); 
    612 HRESULT VarUI8FromDate(DATE,ULONG64*); 
    613 HRESULT VarUI8FromStr(OLECHAR*,LCID,ULONG,ULONG64*); 
    614 HRESULT VarUI8FromBool(VARIANT_BOOL,ULONG64*); 
    615 HRESULT VarUI8FromI1(byte,ULONG64*); 
    616 HRESULT VarUI8FromUI2(USHORT,ULONG64*); 
    617 HRESULT VarUI8FromUI4(ULONG,ULONG64*); 
    618 HRESULT VarUI8FromDec(DECIMAL*,ULONG64*); 
    619 HRESULT VarUI8FromInt(INT,ULONG64*); 
    620 HRESULT VarUI8FromCy(CY,ULONG64*); 
    621 HRESULT VarUI8FromDisp(IDispatch*,LCID,ULONG64*); 
    622  
    623 HRESULT VarDecFromUI1(BYTE,DECIMAL*); 
    624 HRESULT VarDecFromI2(SHORT,DECIMAL*); 
    625 HRESULT VarDecFromI4(LONG,DECIMAL*); 
    626 HRESULT VarDecFromI8(LONG64,DECIMAL*); 
    627 HRESULT VarDecFromR4(FLOAT,DECIMAL*); 
    628 HRESULT VarDecFromR8(DOUBLE,DECIMAL*); 
    629 HRESULT VarDecFromDate(DATE,DECIMAL*); 
    630 HRESULT VarDecFromStr(OLECHAR*,LCID,ULONG,DECIMAL*); 
    631 HRESULT VarDecFromBool(VARIANT_BOOL,DECIMAL*); 
    632 HRESULT VarDecFromI1(byte,DECIMAL*); 
    633 HRESULT VarDecFromUI2(USHORT,DECIMAL*); 
    634 HRESULT VarDecFromUI4(ULONG,DECIMAL*); 
    635 HRESULT VarDecFromUI8(ULONG64,DECIMAL*); 
    636 HRESULT VarDecFromCy(CY,DECIMAL*); 
    637 HRESULT VarDecFromDisp(IDispatch*,LCID,DECIMAL*); 
    638  
    639 HRESULT VarDecNeg( DECIMAL*,DECIMAL*); 
    640 HRESULT VarR4CmpR8(float,double); 
    641 HRESULT VarR8Pow(double,double,double*); 
    642 HRESULT VarR8Round(double,int,double*); 
    643 HRESULT VarDecAbs( DECIMAL*,DECIMAL*); 
    644 HRESULT VarDecAdd( DECIMAL*, DECIMAL*,DECIMAL*); 
    645 HRESULT VarDecCmp( DECIMAL*, DECIMAL*); 
    646 HRESULT VarDecCmpR8( DECIMAL*,DOUBLE); 
    647 HRESULT VarDecDiv( DECIMAL*, DECIMAL*,DECIMAL*); 
    648 HRESULT VarDecFix( DECIMAL*,DECIMAL*); 
    649 HRESULT VarDecInt( DECIMAL*,DECIMAL*); 
    650 HRESULT VarDecMul( DECIMAL*, DECIMAL*,DECIMAL*); 
    651 HRESULT VarDecRound( DECIMAL*,int,DECIMAL*); 
    652 HRESULT VarDecSub( DECIMAL*, DECIMAL*,DECIMAL*); 
    653 HRESULT VarCyAbs( CY,CY*); 
    654 HRESULT VarCyAdd( CY, CY,CY*); 
    655 HRESULT VarCyCmp( CY, CY); 
    656 HRESULT VarCyCmpR8( CY,DOUBLE); 
    657 HRESULT VarCyFix( CY,CY*); 
    658 HRESULT VarCyInt( CY,CY*); 
    659 HRESULT VarCyMul( CY,CY,CY*); 
    660 HRESULT VarCyMulI4( CY,LONG,CY*); 
    661 HRESULT VarCyMulI8( CY,LONG64,CY*); 
    662 HRESULT VarCyNeg( CY,CY*); 
    663 HRESULT VarCyRound( CY,INT,CY*); 
    664 HRESULT VarCySub( CY, CY,CY*); 
    665 HRESULT VarAdd(LPVARIANT,LPVARIANT,LPVARIANT); 
    666 HRESULT VarAnd(LPVARIANT,LPVARIANT,LPVARIANT); 
    667 HRESULT VarCat(LPVARIANT,LPVARIANT,LPVARIANT); 
    668 HRESULT VarDiv(LPVARIANT,LPVARIANT,LPVARIANT); 
    669 HRESULT VarEqv(LPVARIANT,LPVARIANT,LPVARIANT); 
    670 HRESULT VarIdiv(LPVARIANT,LPVARIANT,LPVARIANT); 
    671 HRESULT VarImp(LPVARIANT,LPVARIANT,LPVARIANT); 
    672 HRESULT VarMod(LPVARIANT,LPVARIANT,LPVARIANT); 
    673 HRESULT VarMul(LPVARIANT,LPVARIANT,LPVARIANT); 
    674 HRESULT VarOr(LPVARIANT,LPVARIANT,LPVARIANT); 
    675 HRESULT VarPow(LPVARIANT,LPVARIANT,LPVARIANT); 
    676 HRESULT VarSub(LPVARIANT,LPVARIANT,LPVARIANT); 
    677 HRESULT VarXor(LPVARIANT,LPVARIANT,LPVARIANT); 
    678 HRESULT VarAbs(LPVARIANT,LPVARIANT); 
    679 HRESULT VarFix(LPVARIANT,LPVARIANT); 
    680 HRESULT VarInt(LPVARIANT,LPVARIANT); 
    681 HRESULT VarNeg(LPVARIANT,LPVARIANT); 
    682 HRESULT VarNot(LPVARIANT,LPVARIANT); 
    683 HRESULT VarRound(LPVARIANT,int,LPVARIANT); 
    684 HRESULT VarCmp(LPVARIANT,LPVARIANT,LCID,ULONG); 
    685 HRESULT VarBstrCmp(BSTR,BSTR,LCID,ULONG); 
    686 HRESULT VarBstrCat(BSTR,BSTR,BSTR*); 
    687 } 
    688  
     233    BSTR SysAllocString(OLECHAR*); 
     234    int SysReAllocString(BSTR*, OLECHAR*); 
     235    BSTR SysAllocStringLen(OLECHAR*, uint); 
     236    int SysReAllocStringLen(BSTR*, OLECHAR*, uint); 
     237    void SysFreeString(BSTR); 
     238    uint SysStringLen(BSTR); 
     239    uint SysStringByteLen(BSTR); 
     240    BSTR SysAllocStringByteLen(char*, uint); 
     241    int DosDateTimeToVariantTime(ushort, ushort, double*); 
     242    int VariantTimeToDosDateTime(double, ushort*, ushort*); 
     243    int VariantTimeToSystemTime(double, LPSYSTEMTIME); 
     244    int SystemTimeToVariantTime(LPSYSTEMTIME, double*); 
     245    HRESULT VarDateFromUdate(UDATE*, ULONG, DATE*); 
     246    HRESULT VarDateFromUdateEx(UDATE*, LCID, ULONG, DATE*); 
     247    HRESULT VarUdateFromDate(DATE, ULONG, UDATE*); 
     248    HRESULT SafeArrayAllocDescriptor(uint, SAFEARRAY**); 
     249    HRESULT SafeArrayAllocData(SAFEARRAY*); 
     250    SAFEARRAY* SafeArrayCreate(VARTYPE, uint, SAFEARRAYBOUND*); 
     251    HRESULT SafeArrayDestroyDescriptor(SAFEARRAY*); 
     252    HRESULT SafeArrayDestroyData(SAFEARRAY*); 
     253    HRESULT SafeArrayDestroy(SAFEARRAY*); 
     254    HRESULT SafeArrayRedim(SAFEARRAY*, SAFEARRAYBOUND*); 
     255    uint SafeArrayGetDim(SAFEARRAY*); 
     256    uint SafeArrayGetElemsize(SAFEARRAY*); 
     257    HRESULT SafeArrayGetUBound(SAFEARRAY*, uint, int*); 
     258    HRESULT SafeArrayGetLBound(SAFEARRAY*, uint, int*); 
     259    HRESULT SafeArrayLock(SAFEARRAY*); 
     260    HRESULT SafeArrayUnlock(SAFEARRAY*); 
     261    HRESULT SafeArrayAccessData(SAFEARRAY*, void**); 
     262    HRESULT SafeArrayUnaccessData(SAFEARRAY*); 
     263    HRESULT SafeArrayGetElement(SAFEARRAY*, int*, void*); 
     264    HRESULT SafeArrayPutElement(SAFEARRAY*, int*, void*); 
     265    HRESULT SafeArrayCopy(SAFEARRAY*, SAFEARRAY**); 
     266    HRESULT SafeArrayPtrOfIndex(SAFEARRAY*, int*, void**); 
     267    SAFEARRAY* SafeArrayCreateVector(VARTYPE, LONG, ULONG); 
     268    SAFEARRAY* SafeArrayCreateVectorEx(VARTYPE, LONG, ULONG, LPVOID); 
     269    HRESULT SafeArrayAllocDescriptorEx(VARTYPE, UINT, SAFEARRAY**); 
     270    HRESULT SafeArrayGetVartype(SAFEARRAY*, VARTYPE*); 
     271    HRESULT SafeArraySetRecordInfo(SAFEARRAY*, IRecordInfo*); 
     272    HRESULT SafeArrayGetRecordInfo(SAFEARRAY*, IRecordInfo**); 
     273    HRESULT SafeArraySetIID(SAFEARRAY*, REFGUID); 
     274    HRESULT SafeArrayGetIID(SAFEARRAY*, GUID*); 
     275    void VariantInit(VARIANTARG*); 
     276    HRESULT VariantClear(VARIANTARG*); 
     277    HRESULT VariantCopy(VARIANTARG*, VARIANTARG*); 
     278    HRESULT VariantCopyInd(VARIANT*, VARIANTARG*); 
     279    HRESULT VariantChangeType(VARIANTARG*, VARIANTARG*, ushort, VARTYPE); 
     280    HRESULT VariantChangeTypeEx(VARIANTARG*, VARIANTARG*, LCID, ushort, VARTYPE); 
     281    HRESULT VarUI1FromI2(short, ubyte*); 
     282    HRESULT VarUI1FromI4(int, ubyte*); 
     283    HRESULT VarUI1FromR4(float, ubyte*); 
     284    HRESULT VarUI1FromR8(double, ubyte*); 
     285    HRESULT VarUI1FromCy(CY, ubyte*); 
     286    HRESULT VarUI1FromDate(DATE, ubyte*); 
     287    HRESULT VarUI1FromStr(OLECHAR*, LCID, uint, ubyte*); 
     288    HRESULT VarUI1FromDisp(LPDISPATCH, LCID, ubyte*); 
     289    HRESULT VarUI1FromBool(VARIANT_BOOL, ubyte*); 
     290    HRESULT VarI2FromUI1(ubyte, short*); 
     291    HRESULT VarI2FromI4(int, short*); 
     292    HRESULT VarI2FromR4(float, short*); 
     293    HRESULT VarI2FromR8(double, short*); 
     294    HRESULT VarI2FromCy(CY cyIn, short*); 
     295    HRESULT VarI2FromDate(DATE, short*); 
     296    HRESULT VarI2FromStr(OLECHAR*, LCID, uint, short*); 
     297    HRESULT VarI2FromDisp(LPDISPATCH, LCID, short*); 
     298    HRESULT VarI2FromBool(VARIANT_BOOL, short*); 
     299    HRESULT VarI4FromUI1(ubyte, int*); 
     300    HRESULT VarI4FromI2(short, int*); 
     301    HRESULT VarI4FromR4(float, int*); 
     302    HRESULT VarI4FromR8(double, int*); 
     303    HRESULT VarI4FromCy(CY, int*); 
     304    HRESULT VarI4FromDate(DATE, int*); 
     305    HRESULT VarI4FromStr(OLECHAR*, LCID, uint, int*); 
     306    HRESULT VarI4FromDisp(LPDISPATCH, LCID, int*); 
     307    HRESULT VarI4FromBool(VARIANT_BOOL, int*); 
     308    HRESULT VarR4FromUI1(ubyte, float*); 
     309    HRESULT VarR4FromI2(short, float*); 
     310    HRESULT VarR4FromI4(int, float*); 
     311    HRESULT VarR4FromR8(double, float*); 
     312    HRESULT VarR4FromCy(CY, float*); 
     313    HRESULT VarR4FromDate(DATE, float*); 
     314    HRESULT VarR4FromStr(OLECHAR*, LCID, uint, float*); 
     315    HRESULT VarR4FromDisp(LPDISPATCH, LCID, float*); 
     316    HRESULT VarR4FromBool(VARIANT_BOOL, float*); 
     317    HRESULT VarR8FromUI1(ubyte, double*); 
     318    HRESULT VarR8FromI2(short, double*); 
     319    HRESULT VarR8FromI4(int, double*); 
     320    HRESULT VarR8FromR4(float, double*); 
     321    HRESULT VarR8FromCy(CY, double*); 
     322    HRESULT VarR8FromDate(DATE, double*); 
     323    HRESULT VarR8FromStr(OLECHAR*, LCID, uint, double*); 
     324    HRESULT VarR8FromDisp(LPDISPATCH, LCID, double*); 
     325    HRESULT VarR8FromBool(VARIANT_BOOL, double*); 
     326    HRESULT VarR8FromDec(DECIMAL*, double*); 
     327    HRESULT VarDateFromUI1(ubyte, DATE*); 
     328    HRESULT VarDateFromI2(short, DATE*); 
     329    HRESULT VarDateFromI4(int, DATE*); 
     330    HRESULT VarDateFromR4(float, DATE*); 
     331    HRESULT VarDateFromR8(double, DATE*); 
     332    HRESULT VarDateFromCy(CY, DATE*); 
     333    HRESULT VarDateFromStr(OLECHAR*, LCID, uint, DATE*); 
     334    HRESULT VarDateFromDisp(LPDISPATCH, LCID, DATE*); 
     335    HRESULT VarDateFromBool(VARIANT_BOOL, DATE*); 
     336    HRESULT VarCyFromUI1(ubyte, CY*); 
     337    HRESULT VarCyFromI2(short, CY*); 
     338    HRESULT VarCyFromI4(int, CY*); 
     339    HRESULT VarCyFromR4(float, CY*); 
     340    HRESULT VarCyFromR8(double, CY*); 
     341    HRESULT VarCyFromDate(DATE, CY*); 
     342    HRESULT VarCyFromStr(OLECHAR*, LCID, uint, CY*); 
     343    HRESULT VarCyFromDisp(LPDISPATCH, LCID, CY*); 
     344    HRESULT VarCyFromBool(VARIANT_BOOL, CY*); 
     345    HRESULT VarBstrFromUI1(ubyte, LCID, uint, BSTR*); 
     346    HRESULT VarBstrFromI2(short, LCID, uint, BSTR*); 
     347    HRESULT VarBstrFromI4(int, LCID, uint, BSTR*); 
     348    HRESULT VarBstrFromR4(float, LCID, uint, BSTR*); 
     349    HRESULT VarBstrFromR8(double, LCID, uint, BSTR*); 
     350    HRESULT VarBstrFromCy(CY, LCID, uint, BSTR*); 
     351    HRESULT VarBstrFromDate(DATE, LCID, uint, BSTR*); 
     352    HRESULT VarBstrFromDisp(LPDISPATCH, LCID, uint, BSTR*); 
     353    HRESULT VarBstrFromBool(VARIANT_BOOL, LCID, uint, BSTR*); 
     354    HRESULT VarBoolFromUI1(ubyte, VARIANT_BOOL*); 
     355    HRESULT VarBoolFromI2(short, VARIANT_BOOL*); 
     356    HRESULT VarBoolFromI4(int, VARIANT_BOOL*); 
     357    HRESULT VarBoolFromR4(float, VARIANT_BOOL*); 
     358    HRESULT VarBoolFromR8(double, VARIANT_BOOL*); 
     359    HRESULT VarBoolFromDate(DATE, VARIANT_BOOL*); 
     360    HRESULT VarBoolFromCy(CY, VARIANT_BOOL*); 
     361    HRESULT VarBoolFromStr(OLECHAR*, LCID, uint, VARIANT_BOOL*); 
     362    HRESULT VarBoolFromDisp(LPDISPATCH, LCID, VARIANT_BOOL*); 
     363    HRESULT VarDecFromR8(double, DECIMAL*); 
     364    ULONG LHashValOfNameSysA(SYSKIND, LCID, char*); 
     365    ULONG LHashValOfNameSys(SYSKIND, LCID, OLECHAR*); 
     366    HRESULT LoadTypeLib(OLECHAR*, LPTYPELIB*); 
     367    HRESULT LoadTypeLibEx(LPCOLESTR, REGKIND, LPTYPELIB*); 
     368    HRESULT LoadRegTypeLib(REFGUID, WORD, WORD, LCID, LPTYPELIB*); 
     369    HRESULT QueryPathOfRegTypeLib(REFGUID, ushort, ushort, LCID, LPBSTR); 
     370    HRESULT RegisterTypeLib(LPTYPELIB, OLECHAR*, OLECHAR*); 
     371    HRESULT UnRegisterTypeLib(REFGUID, WORD, WORD, LCID, SYSKIND); 
     372    HRESULT CreateTypeLib(SYSKIND, OLECHAR*, LPCREATETYPELIB*); 
     373    HRESULT DispGetParam(DISPPARAMS*, UINT, VARTYPE, VARIANT*, UINT*); 
     374    HRESULT DispGetIDsOfNames(LPTYPEINFO, OLECHAR**, UINT, DISPID*); 
     375    HRESULT DispInvoke(void*, LPTYPEINFO, DISPID, WORD, DISPPARAMS*, VARIANT*, EXCEPINFO*, UINT*); 
     376    HRESULT CreateDispTypeInfo(INTERFACEDATA*, LCID, LPTYPEINFO*); 
     377    HRESULT CreateStdDispatch(IUnknown*, void*, LPTYPEINFO, IUnknown**); 
     378    HRESULT RegisterActiveObject(IUnknown*, REFCLSID, DWORD, DWORD*); 
     379    HRESULT RevokeActiveObject(DWORD, void*); 
     380    HRESULT GetActiveObject(REFCLSID, void*, IUnknown**); 
     381    HRESULT SetErrorInfo(uint, LPERRORINFO); 
     382    HRESULT GetErrorInfo(uint, LPERRORINFO*); 
     383    HRESULT CreateErrorInfo(LPCREATEERRORINFO*); 
     384    uint OaBuildVersion(); 
     385    HRESULT VectorFromBstr (BSTR, SAFEARRAY**); 
     386    HRESULT BstrFromVector (SAFEARRAY*, BSTR*); 
     387    HRESULT VarParseNumFromStr(OLECHAR*, LCID, ULONG, NUMPARSE*, BYTE*); 
     388    HRESULT VarNumFromParseNum(NUMPARSE*, BYTE*, ULONG, VARIANT*); 
     389 
     390    HRESULT VarAdd(LPVARIANT, LPVARIANT, LPVARIANT); 
     391    HRESULT VarSub(LPVARIANT, LPVARIANT, LPVARIANT); 
     392    HRESULT VarMul(LPVARIANT, LPVARIANT, LPVARIANT); 
     393    HRESULT VarDiv(LPVARIANT, LPVARIANT, LPVARIANT); 
     394 
     395    HRESULT VarUI1FromI2(SHORT, BYTE*); 
     396    HRESULT VarUI1FromI4(LONG, BYTE*); 
     397    HRESULT VarUI1FromI8(LONG64, BYTE*); 
     398    HRESULT VarUI1FromR4(FLOAT, BYTE*); 
     399    HRESULT VarUI1FromR8(DOUBLE, BYTE*); 
     400    HRESULT VarUI1FromDate(DATE, BYTE*); 
     401    HRESULT VarUI1FromBool(VARIANT_BOOL, BYTE*); 
     402    HRESULT VarUI1FromI1(byte, BYTE*); 
     403    HRESULT VarUI1FromUI2(USHORT, BYTE*); 
     404    HRESULT VarUI1FromUI4(ULONG, BYTE*); 
     405    HRESULT VarUI1FromUI8(ULONG64, BYTE*); 
     406    HRESULT VarUI1FromStr(OLECHAR*, LCID, ULONG, BYTE*); 
     407    HRESULT VarUI1FromCy(CY, BYTE*); 
     408    HRESULT VarUI1FromDec(DECIMAL*, BYTE*); 
     409    HRESULT VarUI1FromDisp(IDispatch*, LCID, BYTE*); 
     410 
     411    HRESULT VarI2FromUI1(BYTE, SHORT*); 
     412    HRESULT VarI2FromI4(LONG, SHORT*); 
     413    HRESULT VarI2FromI8(LONG64, SHORT*); 
     414    HRESULT VarI2FromR4(FLOAT, SHORT*); 
     415    HRESULT VarI2FromR8(DOUBLE, SHORT*); 
     416    HRESULT VarI2FromDate(DATE, SHORT*); 
     417    HRESULT VarI2FromBool(VARIANT_BOOL, SHORT*); 
     418    HRESULT VarI2FromI1(byte, SHORT*); 
     419    HRESULT VarI2FromUI2(USHORT, SHORT*); 
     420    HRESULT VarI2FromUI4(ULONG, SHORT*); 
     421    HRESULT VarI2FromUI8(ULONG64, SHORT*); 
     422    HRESULT VarI2FromStr(OLECHAR*, LCID, ULONG, SHORT*); 
     423    HRESULT VarI2FromCy(CY, SHORT*); 
     424    HRESULT VarI2FromDec(DECIMAL*, SHORT*); 
     425    HRESULT VarI2FromDisp(IDispatch*, LCID, SHORT*); 
     426 
     427    HRESULT VarI4FromUI1(BYTE, LONG*); 
     428    HRESULT VarI4FromI2(SHORT, LONG*); 
     429    HRESULT VarI4FromI8(LONG64, LONG*); 
     430    HRESULT VarI4FromR4(FLOAT, LONG*); 
     431    HRESULT VarI4FromR8(DOUBLE, LONG*); 
     432    HRESULT VarI4FromDate(DATE, LONG*); 
     433    HRESULT VarI4FromBool(VARIANT_BOOL, LONG*); 
     434    HRESULT VarI4FromI1(byte, LONG*); 
     435    HRESULT VarI4FromUI2(USHORT, LONG*); 
     436    HRESULT VarI4FromUI4(ULONG, LONG*); 
     437    HRESULT VarI4FromUI8(ULONG64, LONG*); 
     438    HRESULT VarI4FromStr(OLECHAR*, LCID, ULONG, LONG*); 
     439    HRESULT VarI4FromCy(CY, LONG*); 
     440    HRESULT VarI4FromDec(DECIMAL*, LONG*); 
     441    HRESULT VarI4FromDisp(IDispatch*, LCID, LONG*); 
     442 
     443    HRESULT VarI8FromUI1(BYTE, LONG64*); 
     444    HRESULT VarI8FromI2(SHORT, LONG64*); 
     445    HRESULT VarI8FromI4(LONG, LONG64*); 
     446    HRESULT VarI8FromR4(FLOAT, LONG64*); 
     447    HRESULT VarI8FromR8(DOUBLE, LONG64*); 
     448    HRESULT VarI8FromDate(DATE, LONG64*); 
     449    HRESULT VarI8FromStr(OLECHAR*, LCID, ULONG, LONG64*); 
     450    HRESULT VarI8FromBool(VARIANT_BOOL, LONG64*); 
     451    HRESULT VarI8FromI1(byte, LONG64*); 
     452    HRESULT VarI8FromUI2(USHORT, LONG64*); 
     453    HRESULT VarI8FromUI4(ULONG, LONG64*); 
     454    HRESULT VarI8FromUI8(ULONG64, LONG64*); 
     455    HRESULT VarI8FromDec(DECIMAL* pdecIn, LONG64*); 
     456    HRESULT VarI8FromInt(INT intIn, LONG64*); 
     457    HRESULT VarI8FromCy(CY, LONG64*); 
     458    HRESULT VarI8FromDisp(IDispatch*, LCID, LONG64*); 
     459 
     460    HRESULT VarR4FromUI1(BYTE, FLOAT*); 
     461    HRESULT VarR4FromI2(SHORT, FLOAT*); 
     462    HRESULT VarR4FromI4(LONG, FLOAT*); 
     463    HRESULT VarR4FromI8(LONG64, FLOAT*); 
     464    HRESULT VarR4FromR8(DOUBLE, FLOAT*); 
     465    HRESULT VarR4FromDate(DATE, FLOAT*); 
     466    HRESULT VarR4FromBool(VARIANT_BOOL, FLOAT*); 
     467    HRESULT VarR4FromI1(byte, FLOAT*); 
     468    HRESULT VarR4FromUI2(USHORT, FLOAT*); 
     469    HRESULT VarR4FromUI4(ULONG, FLOAT*); 
     470    HRESULT VarR4FromUI8(ULONG64, FLOAT*); 
     471    HRESULT VarR4FromStr(OLECHAR*, LCID, ULONG, FLOAT*); 
     472    HRESULT VarR4FromCy(CY, FLOAT*); 
     473    HRESULT VarR4FromDec(DECIMAL*, FLOAT*); 
     474    HRESULT VarR4FromDisp(IDispatch*, LCID, FLOAT*); 
     475 
     476    HRESULT VarR8FromUI1(BYTE, double*); 
     477    HRESULT VarR8FromI2(SHORT, double*); 
     478    HRESULT VarR8FromI4(LONG, double*); 
     479    HRESULT VarR8FromI8(LONG64, double*); 
     480    HRESULT VarR8FromR4(FLOAT, double*); 
     481    HRESULT VarR8FromDate(DATE, double*); 
     482    HRESULT VarR8FromBool(VARIANT_BOOL, double*); 
     483    HRESULT VarR8FromI1(byte, double*); 
     484    HRESULT VarR8FromUI2(USHORT, double*); 
     485    HRESULT VarR8FromUI4(ULONG, double*); 
     486    HRESULT VarR8FromUI8(ULONG64, double*); 
     487    HRESULT VarR8FromStr(OLECHAR*, LCID, ULONG, double*); 
     488    HRESULT VarR8FromCy(CY, double*); 
     489    HRESULT VarR8FromDec(DECIMAL*, double*); 
     490    HRESULT VarR8FromDisp(IDispatch*, LCID, double*); 
     491 
     492    HRESULT VarDateFromUI1(BYTE, DATE*); 
     493    HRESULT VarDateFromI2(SHORT, DATE*); 
     494    HRESULT VarDateFromI4(LONG, DATE*); 
     495    HRESULT VarDateFromI8(LONG64, DATE*); 
     496    HRESULT VarDateFromR4(FLOAT, DATE*); 
     497    HRESULT VarDateFromR8(DOUBLE, DATE*); 
     498    HRESULT VarDateFromStr(OLECHAR*, LCID, ULONG, DATE*); 
     499    HRESULT VarDateFromI1(byte, DATE*); 
     500    HRESULT VarDateFromUI2(USHORT, DATE*); 
     501    HRESULT VarDateFromUI4(ULONG, DATE*); 
     502    HRESULT VarDateFromUI8(ULONG64, DATE*); 
     503    HRESULT VarDateFromBool(VARIANT_BOOL, DATE*); 
     504    HRESULT VarDateFromCy(CY, DATE*); 
     505    HRESULT VarDateFromDec(DECIMAL*, DATE*); 
     506    HRESULT VarDateFromDisp(IDispatch*, LCID, DATE*); 
     507 
     508    HRESULT VarCyFromUI1(BYTE, CY*); 
     509    HRESULT VarCyFromI2(SHORT sIn, CY*); 
     510    HRESULT VarCyFromI4(LONG, CY*); 
     511    HRESULT VarCyFromI8(LONG64, CY*); 
     512    HRESULT VarCyFromR4(FLOAT, CY*); 
     513    HRESULT VarCyFromR8(DOUBLE, CY*); 
     514    HRESULT VarCyFromDate(DATE, CY*); 
     515    HRESULT VarCyFromStr(OLECHAR*, LCID, ULONG, CY*); 
     516    HRESULT VarCyFromBool(VARIANT_BOOL, CY*); 
     517    HRESULT VarCyFromI1(byte, CY*); 
     518    HRESULT VarCyFromUI2(USHORT, CY*); 
     519    HRESULT VarCyFromUI4(ULONG, CY*); 
     520    HRESULT VarCyFromUI8(ULONG64, CY*); 
     521    HRESULT VarCyFromDec(DECIMAL*, CY*); 
     522    HRESULT VarCyFromStr(OLECHAR*, LCID, ULONG, CY*); 
     523    HRESULT VarCyFromDisp(IDispatch*, LCID, CY*); 
     524 
     525    HRESULT VarBstrFromUI1(BYTE, LCID, ULONG, BSTR*); 
     526    HRESULT VarBstrFromI2(SHORT, LCID, ULONG, BSTR*); 
     527    HRESULT VarBstrFromI4(LONG, LCID, ULONG, BSTR*); 
     528    HRESULT VarBstrFromI8(LONG64, LCID, ULONG, BSTR*); 
     529    HRESULT VarBstrFromR4(FLOAT, LCID, ULONG, BSTR*); 
     530    HRESULT VarBstrFromR8(DOUBLE, LCID, ULONG, BSTR*); 
     531    HRESULT VarBstrFromDate(DATE, LCID, ULONG, BSTR*); 
     532    HRESULT VarBstrFromBool(VARIANT_BOOL, LCID, ULONG, BSTR*); 
     533    HRESULT VarBstrFromI1(byte, LCID, ULONG, BSTR*); 
     534    HRESULT VarBstrFromUI2(USHORT, LCID, ULONG, BSTR*); 
     535    HRESULT VarBstrFromUI8(ULONG64, LCID, ULONG, BSTR*); 
     536    HRESULT VarBstrFromUI4(ULONG, LCID, ULONG, BSTR*); 
     537    HRESULT VarBstrFromCy(CY, LCID, ULONG, BSTR*); 
     538    HRESULT VarBstrFromDec(DECIMAL*, LCID, ULONG, BSTR*); 
     539    HRESULT VarBstrFromDisp(IDispatch*, LCID, ULONG, BSTR*); 
     540 
     541    HRESULT VarBoolFromUI1(BYTE, VARIANT_BOOL*); 
     542    HRESULT VarBoolFromI2(SHORT, VARIANT_BOOL*); 
     543    HRESULT VarBoolFromI4(LONG, VARIANT_BOOL*); 
     544    HRESULT VarBoolFromI8(LONG64, VARIANT_BOOL*); 
     545    HRESULT VarBoolFromR4(FLOAT, VARIANT_BOOL*); 
     546    HRESULT VarBoolFromR8(DOUBLE, VARIANT_BOOL*); 
     547    HRESULT VarBoolFromDate(DATE, VARIANT_BOOL*); 
     548    HRESULT VarBoolFromStr(OLECHAR*, LCID, ULONG, VARIANT_BOOL*); 
     549    HRESULT VarBoolFromI1(byte, VARIANT_BOOL*); 
     550    HRESULT VarBoolFromUI2(USHORT, VARIANT_BOOL*); 
     551    HRESULT VarBoolFromUI4(ULONG, VARIANT_BOOL*); 
     552    HRESULT VarBoolFromUI8(ULONG64, VARIANT_BOOL*); 
     553    HRESULT VarBoolFromCy(CY, VARIANT_BOOL*); 
     554    HRESULT VarBoolFromDec(DECIMAL*, VARIANT_BOOL*); 
     555    HRESULT VarBoolFromDisp(IDispatch*, LCID, VARIANT_BOOL*); 
     556 
     557    HRESULT VarI1FromUI1(BYTE, byte*); 
     558    HRESULT VarI1FromI2(SHORT, byte*); 
     559    HRESULT VarI1FromI4(LONG, byte*); 
     560    HRESULT VarI1FromI8(LONG64, byte*); 
     561    HRESULT VarI1FromR4(FLOAT, byte*); 
     562    HRESULT VarI1FromR8(DOUBLE, byte*); 
     563    HRESULT VarI1FromDate(DATE, byte*); 
     564    HRESULT VarI1FromStr(OLECHAR*, LCID, ULONG, byte*); 
     565    HRESULT VarI1FromBool(VARIANT_BOOL, byte*); 
     566    HRESULT VarI1FromUI2(USHORT, byte*); 
     567    HRESULT VarI1FromUI4(ULONG, byte*); 
     568    HRESULT VarI1FromUI8(ULONG64, byte*); 
     569    HRESULT VarI1FromCy(CY, byte*); 
     570    HRESULT VarI1FromDec(DECIMAL*, byte*); 
     571    HRESULT VarI1FromDisp(IDispatch*, LCID, byte*); 
     572 
     573    HRESULT VarUI2FromUI1(BYTE, USHORT*); 
     574    HRESULT VarUI2FromI2(SHORT, USHORT*); 
     575    HRESULT VarUI2FromI4(LONG, USHORT*); 
     576    HRESULT VarUI2FromI8(LONG64, USHORT*); 
     577    HRESULT VarUI2FromR4(FLOAT, USHORT*); 
     578    HRESULT VarUI2FromR8(DOUBLE, USHORT*); 
     579    HRESULT VarUI2FromDate(DATE, USHORT*); 
     580    HRESULT VarUI2FromStr(OLECHAR*, LCID, ULONG, USHORT*); 
     581    HRESULT VarUI2FromBool(VARIANT_BOOL, USHORT*); 
     582    HRESULT VarUI2FromI1(byte, USHORT*); 
     583    HRESULT VarUI2FromUI4(ULONG, USHORT*); 
     584    HRESULT VarUI2FromUI8(ULONG64, USHORT*); 
     585    HRESULT VarUI2FromCy(CY, USHORT*); 
     586    HRESULT VarUI2FromDec(DECIMAL*, USHORT*); 
     587    HRESULT VarUI2FromDisp(IDispatch*, LCID, USHORT*); 
     588 
     589    HRESULT VarUI4FromStr(OLECHAR*, LCID, ULONG, ULONG*); 
     590    HRESULT VarUI4FromUI1(BYTE, ULONG*); 
     591    HRESULT VarUI4FromI2(SHORT, ULONG*); 
     592    HRESULT VarUI4FromI4(LONG, ULONG*); 
     593    HRESULT VarUI4FromI8(LONG64, ULONG*); 
     594    HRESULT VarUI4FromR4(FLOAT, ULONG*); 
     595    HRESULT VarUI4FromR8(DOUBLE, ULONG*); 
     596    HRESULT VarUI4FromDate(DATE, ULONG*); 
     597    HRESULT VarUI4FromBool(VARIANT_BOOL, ULONG*); 
     598    HRESULT VarUI4FromI1(byte, ULONG*); 
     599    HRESULT VarUI4FromUI2(USHORT, ULONG*); 
     600    HRESULT VarUI4FromUI8(ULONG64, ULONG*); 
     601    HRESULT VarUI4FromCy(CY, ULONG*); 
     602    HRESULT VarUI4FromDec(DECIMAL*, ULONG*); 
     603    HRESULT VarUI4FromDisp(IDispatch*, LCID, ULONG*); 
     604 
     605    HRESULT VarUI8FromUI1(BYTE, ULONG64*); 
     606    HRESULT VarUI8FromI2(SHORT, ULONG64*); 
     607    HRESULT VarUI8FromI4(LONG, ULONG64*); 
     608    HRESULT VarUI8FromI8(LONG64, ULONG64*); 
     609    HRESULT VarUI8FromR4(FLOAT, ULONG64*); 
     610    HRESULT VarUI8FromR8(DOUBLE, ULONG64*); 
     611    HRESULT VarUI8FromDate(DATE, ULONG64*); 
     612    HRESULT VarUI8FromStr(OLECHAR*, LCID, ULONG, ULONG64*); 
     613    HRESULT VarUI8FromBool(VARIANT_BOOL, ULONG64*); 
     614    HRESULT VarUI8FromI1(byte, ULONG64*); 
     615    HRESULT VarUI8FromUI2(USHORT, ULONG64*); 
     616    HRESULT VarUI8FromUI4(ULONG, ULONG64*); 
     617    HRESULT VarUI8FromDec(DECIMAL*, ULONG64*); 
     618    HRESULT VarUI8FromInt(INT, ULONG64*); 
     619    HRESULT VarUI8FromCy(CY, ULONG64*); 
     620    HRESULT VarUI8FromDisp(IDispatch*, LCID, ULONG64*); 
     621 
     622    HRESULT VarDecFromUI1(BYTE, DECIMAL*); 
     623    HRESULT VarDecFromI2(SHORT, DECIMAL*); 
     624    HRESULT VarDecFromI4(LONG, DECIMAL*); 
     625    HRESULT VarDecFromI8(LONG64, DECIMAL*); 
     626    HRESULT VarDecFromR4(FLOAT, DECIMAL*); 
     627    HRESULT VarDecFromR8(DOUBLE, DECIMAL*); 
     628    HRESULT VarDecFromDate(DATE, DECIMAL*); 
     629    HRESULT VarDecFromStr(OLECHAR*, LCID, ULONG, DECIMAL*); 
     630    HRESULT VarDecFromBool(VARIANT_BOOL, DECIMAL*); 
     631    HRESULT VarDecFromI1(byte, DECIMAL*); 
     632    HRESULT VarDecFromUI2(USHORT, DECIMAL*); 
     633    HRESULT VarDecFromUI4(ULONG, DECIMAL*); 
     634    HRESULT VarDecFromUI8(ULONG64, DECIMAL*); 
     635    HRESULT VarDecFromCy(CY, DECIMAL*); 
     636    HRESULT VarDecFromDisp(IDispatch*, LCID, DECIMAL*); 
     637 
     638    HRESULT VarDecNeg(DECIMAL*, DECIMAL*); 
     639    HRESULT VarR4CmpR8(float, double); 
     640    HRESULT VarR8Pow(double, double, double*); 
     641    HRESULT VarR8Round(double, int, double*); 
     642    HRESULT VarDecAbs(DECIMAL*, DECIMAL*); 
     643    HRESULT VarDecAdd(DECIMAL*, DECIMAL*, DECIMAL*); 
     644    HRESULT VarDecCmp(DECIMAL*, DECIMAL*); 
     645    HRESULT VarDecCmpR8(DECIMAL*, DOUBLE); 
     646    HRESULT VarDecDiv(DECIMAL*, DECIMAL*, DECIMAL*); 
     647    HRESULT VarDecFix(DECIMAL*, DECIMAL*); 
     648    HRESULT VarDecInt(DECIMAL*, DECIMAL*); 
     649    HRESULT VarDecMul(DECIMAL*, DECIMAL*, DECIMAL*); 
     650    HRESULT VarDecRound(DECIMAL*, int, DECIMAL*); 
     651    HRESULT VarDecSub(DECIMAL*, DECIMAL*, DECIMAL*); 
     652    HRESULT VarCyAbs(CY, CY*); 
     653    HRESULT VarCyAdd(CY, CY, CY*); 
     654    HRESULT VarCyCmp(CY, CY); 
     655    HRESULT VarCyCmpR8(CY, DOUBLE); 
     656    HRESULT VarCyFix(CY, CY*); 
     657    HRESULT VarCyInt(CY, CY*); 
     658    HRESULT VarCyMul(CY, CY, CY*); 
     659    HRESULT VarCyMulI4(CY, LONG, CY*); 
     660    HRESULT VarCyMulI8(CY, LONG64, CY*); 
     661    HRESULT VarCyNeg(CY, CY*); 
     662    HRESULT VarCyRound(CY, INT, CY*); 
     663    HRESULT VarCySub(CY, CY, CY*); 
     664    HRESULT VarAdd(LPVARIANT, LPVARIANT, LPVARIANT); 
     665    HRESULT VarAnd(LPVARIANT, LPVARIANT, LPVARIANT); 
     666    HRESULT VarCat(LPVARIANT, LPVARIANT, LPVARIANT); 
     667    HRESULT VarDiv(LPVARIANT, LPVARIANT, LPVARIANT); 
     668    HRESULT VarEqv(LPVARIANT, LPVARIANT, LPVARIANT); 
     669    HRESULT VarIdiv(LPVARIANT, LPVARIANT, LPVARIANT); 
     670    HRESULT VarImp(LPVARIANT, LPVARIANT, LPVARIANT); 
     671    HRESULT VarMod(LPVARIANT, LPVARIANT, LPVARIANT); 
     672    HRESULT VarMul(LPVARIANT, LPVARIANT, LPVARIANT); 
     673    HRESULT VarOr(LPVARIANT, LPVARIANT, LPVARIANT); 
     674    HRESULT VarPow(LPVARIANT, LPVARIANT, LPVARIANT); 
     675    HRESULT VarSub(LPVARIANT, LPVARIANT, LPVARIANT); 
     676    HRESULT VarXor(LPVARIANT, LPVARIANT, LPVARIANT); 
     677    HRESULT VarAbs(LPVARIANT, LPVARIANT); 
     678    HRESULT VarFix(LPVARIANT, LPVARIANT); 
     679    HRESULT VarInt(LPVARIANT, LPVARIANT); 
     680    HRESULT VarNeg(LPVARIANT, LPVARIANT); 
     681    HRESULT VarNot(LPVARIANT, LPVARIANT); 
     682    HRESULT VarRound(LPVARIANT, int, LPVARIANT); 
     683    HRESULT VarCmp(LPVARIANT, LPVARIANT, LCID, ULONG); 
     684    HRESULT VarBstrCmp(BSTR, BSTR, LCID, ULONG); 
     685    HRESULT VarBstrCat(BSTR, BSTR, BSTR*); 
     686} 

  • trunk/win32/olectl.d

    r135 r141  
    377377} 
    378378alias PICTDESC* LPPICTDESC; 
    379 align: 
    380379 
    381380extern(Windows) { 

  • trunk/win32/olectlid.d

    r99 r141  
    1111private import win32.basetyps; 
    1212 
    13 extern (Windows) { 
    14 extern GUID IID_IDispatch; 
    15 extern GUID IID_IPropertyNotifySink; 
    16 extern GUID IID_IClassFactory2; 
    17 extern GUID IID_IProvideClassInfo; 
    18 extern GUID IID_IProvideClassInfo2; 
    19 extern GUID IID_IConnectionPointContainer; 
    20 extern GUID IID_IEnumConnectionPoints; 
    21 extern GUID IID_IConnectionPoint; 
    22 extern GUID IID_IEnumConnections; 
    23 extern GUID IID_IOleControl; 
    24 extern GUID IID_IOleControlSite; 
    25 extern GUID IID_ISimpleFrameSite; 
    26 extern GUID IID_IPersistStreamInit; 
    27 extern GUID IID_IPersistMemory; 
    28 extern GUID IID_IPersistPropertyBag; 
    29 extern GUID IID_IPropertyBag; 
    30 extern GUID IID_IErrorLog; 
    31 extern GUID IID_IPropertyFrame; 
    32 extern GUID IID_ISpecifyPropertyPages; 
    33 extern GUID IID_IPerPropertyBrowsing; 
    34 extern GUID IID_IPropertyPageSite; 
    35 extern GUID IID_IPropertyPage; 
    36 extern GUID IID_IPropertyPage2; 
    37 extern GUID CLSID_CFontPropPage; 
    38 extern GUID CLSID_CColorPropPage; 
    39 extern GUID CLSID_CPicturePropPage; 
    40 extern GUID CLSID_PersistPropset; 
    41 extern GUID CLSID_ConvertVBX; 
    42 extern GUID CLSID_StdFont; 
    43 extern GUID CLSID_StdPicture; 
    44 extern GUID IID_IFont; 
    45 extern GUID IID_IFontDisp; 
    46 extern GUID IID_IPicture; 
    47 extern GUID IID_IPictureDisp; 
    48 extern GUID GUID_HIMETRIC; 
    49 extern GUID GUID_COLOR; 
    50 extern GUID GUID_XPOSPIXEL; 
    51 extern GUID GUID_YPOSPIXEL; 
    52 extern GUID GUID_XSIZEPIXEL; 
    53 extern GUID GUID_YSIZEPIXEL; 
    54 extern GUID GUID_XPOS; 
    55 extern GUID GUID_YPOS; 
    56 extern GUID GUID_XSIZE; 
    57 extern GUID GUID_YSIZE; 
    58 extern GUID GUID_TRISTATE; 
    59 extern GUID GUID_OPTIONVALUEEXCLUSIVE; 
    60 extern GUID GUID_CHECKVALUEEXCLUSIVE; 
    61 extern GUID GUID_FONTNAME; 
    62 extern GUID GUID_FONTSIZE; 
    63 extern GUID GUID_FONTBOLD; 
    64 extern GUID GUID_FONTITALIC; 
    65 extern GUID GUID_FONTUNDERSCORE; 
    66 extern GUID GUID_FONTSTRIKETHROUGH; 
    67 extern GUID GUID_HANDLE; 
    68 extern GUID IID_IEnumUnknown; 
    69 extern GUID IID_IEnumString; 
    70 extern GUID IID_IEnumMoniker; 
    71 extern GUID IID_IEnumFORMATETC; 
    72 extern GUID IID_IEnumOLEVERB; 
    73 extern GUID IID_IEnumSTATDATA; 
    74 extern GUID IID_IEnumSTATSTG; 
    75 extern GUID IID_IEnumGeneric; 
    76 extern GUID IID_IEnumHolder; 
    77 extern GUID IID_IEnumCallback; 
    78 extern GUID IID_IPersistStream; 
    79 extern GUID IID_IPersistStorage; 
    80 extern GUID IID_IPersistFile; 
    81 extern GUID IID_IPersist; 
    82 extern GUID IID_IViewObject; 
    83 extern GUID IID_IDataObject; 
    84 extern GUID IID_IAdviseSink; 
    85 extern GUID IID_IDataAdviseHolder; 
    86 extern GUID IID_IOleAdviseHolder; 
    87 extern GUID IID_IOleObject; 
    88 extern GUID IID_IOleInPlaceObject; 
    89 extern GUID IID_IOleWindow; 
    90 extern GUID IID_IOleInPlaceUIWindow; 
    91 extern GUID IID_IOleInPlaceFrame; 
    92 extern GUID IID_IOleInPlaceActiveObject; 
    93 extern GUID IID_IOleClientSite; 
    94 extern GUID IID_IOleInPlaceSite; 
    95 extern GUID IID_IParseDisplayName; 
    96 extern GUID IID_IOleContainer; 
    97 extern GUID IID_IOleItemContainer; 
    98 extern GUID IID_IOleLink; 
    99 extern GUID IID_IOleCache; 
    100 extern GUID IID_IOleManager; 
    101 extern GUID IID_IOlePresObj; 
    102 extern GUID IID_IDropSource; 
    103 extern GUID IID_IDropTarget; 
    104 extern GUID IID_IDebug; 
    105 extern GUID IID_IDebugStream; 
    106 extern GUID IID_IAdviseSink2; 
    107 extern GUID IID_IRunnableObject; 
    108 extern GUID IID_IViewObject2; 
    109 extern GUID IID_IOleCache2; 
    110 extern GUID IID_IOleCacheControl; 
    111 extern GUID CLSID_Picture_Metafile; 
    112 extern GUID CLSID_Picture_Dib; 
    113 } 
     13extern (Windows) extern const GUID 
     14    IID_IDispatch, 
     15    IID_IPropertyNotifySink, 
     16    IID_IClassFactory2, 
     17    IID_IProvideClassInfo, 
     18    IID_IProvideClassInfo2, 
     19    IID_IConnectionPointContainer, 
     20    IID_IEnumConnectionPoints, 
     21    IID_IConnectionPoint, 
     22    IID_IEnumConnections, 
     23    IID_IOleControl, 
     24    IID_IOleControlSite, 
     25    IID_ISimpleFrameSite, 
     26    IID_IPersistStreamInit, 
     27    IID_IPersistMemory, 
     28    IID_IPersistPropertyBag, 
     29    IID_IPropertyBag, 
     30    IID_IErrorLog, 
     31    IID_IPropertyFrame, 
     32    IID_ISpecifyPropertyPages, 
     33    IID_IPerPropertyBrowsing, 
     34    IID_IPropertyPageSite, 
     35    IID_IPropertyPage, 
     36    IID_IPropertyPage2, 
     37    CLSID_CFontPropPage, 
     38    CLSID_CColorPropPage, 
     39    CLSID_CPicturePropPage, 
     40    CLSID_PersistPropset, 
     41    CLSID_ConvertVBX, 
     42    CLSID_StdFont, 
     43    CLSID_StdPicture, 
     44    IID_IFont, 
     45    IID_IFontDisp, 
     46    IID_IPicture, 
     47    IID_IPictureDisp, 
     48    GUID_HIMETRIC, 
     49    GUID_COLOR, 
     50    GUID_XPOSPIXEL, 
     51    GUID_YPOSPIXEL, 
     52    GUID_XSIZEPIXEL, 
     53    GUID_YSIZEPIXEL, 
     54    GUID_XPOS, 
     55    GUID_YPOS, 
     56    GUID_XSIZE, 
     57    GUID_YSIZE, 
     58    GUID_TRISTATE, 
     59    GUID_OPTIONVALUEEXCLUSIVE, 
     60    GUID_CHECKVALUEEXCLUSIVE, 
     61    GUID_FONTNAME, 
     62    GUID_FONTSIZE, 
     63    GUID_FONTBOLD, 
     64    GUID_FONTITALIC, 
     65    GUID_FONTUNDERSCORE, 
     66    GUID_FONTSTRIKETHROUGH, 
     67    GUID_HANDLE, 
     68    IID_IEnumUnknown, 
     69    IID_IEnumString, 
     70    IID_IEnumMoniker, 
     71    IID_IEnumFORMATETC, 
     72    IID_IEnumOLEVERB, 
     73    IID_IEnumSTATDATA, 
     74    IID_IEnumSTATSTG, 
     75    IID_IEnumGeneric, 
     76    IID_IEnumHolder, 
     77    IID_IEnumCallback, 
     78    IID_IPersistStream, 
     79    IID_IPersistStorage, 
     80    IID_IPersistFile, 
     81    IID_IPersist, 
     82    IID_IViewObject, 
     83    IID_IDataObject, 
     84    IID_IAdviseSink, 
     85    IID_IDataAdviseHolder, 
     86    IID_IOleAdviseHolder, 
     87    IID_IOleObject, 
     88    IID_IOleInPlaceObject, 
     89    IID_IOleWindow, 
     90    IID_IOleInPlaceUIWindow, 
     91    IID_IOleInPlaceFrame, 
     92    IID_IOleInPlaceActiveObject, 
     93    IID_IOleClientSite, 
     94    IID_IOleInPlaceSite, 
     95    IID_IParseDisplayName, 
     96    IID_IOleContainer, 
     97    IID_IOleItemContainer, 
     98    IID_IOleLink, 
     99    IID_IOleCache, 
     100    IID_IOleManager, 
     101    IID_IOlePresObj, 
     102    IID_IDropSource, 
     103    IID_IDropTarget, 
     104    IID_IDebug, 
     105    IID_IDebugStream, 
     106    IID_IAdviseSink2, 
     107    IID_IRunnableObject, 
     108    IID_IViewObject2, 
     109    IID_IOleCache2, 
     110    IID_IOleCacheControl, 
     111    CLSID_Picture_Metafile, 
     112    CLSID_Picture_Dib; 

  • trunk/win32/oledlg.d

    r135 r141  
    477477interface IOleUILinkContainerW : public IUnknown 
    478478{ 
    479     HRESULT QueryInterface(REFIID,PVOID*); 
     479    HRESULT QueryInterface(REFIID, PVOID*); 
    480480    ULONG AddRef(); 
    481481    ULONG Release(); 
    482482    DWORD GetNextLink(DWORD dwLink); 
    483     HRESULT SetLinkUpdateOptions(DWORD,DWORD); 
    484     HRESULT GetLinkUpdateOptions(DWORD,PDWORD); 
    485     HRESULT SetLinkSource(DWORD, LPWSTR,ULONG,PULONG,BOOL); 
    486     HRESULT GetLinkSource(DWORD,LPWSTR*,PULONG,LPWSTR*,LPWSTR*,BOOL*,BOOL*); 
     483    HRESULT SetLinkUpdateOptions(DWORD, DWORD); 
     484    HRESULT GetLinkUpdateOptions(DWORD, PDWORD); 
     485    HRESULT SetLinkSource(DWORD, LPWSTR, ULONG, PULONG, BOOL); 
     486    HRESULT GetLinkSource(DWORD, LPWSTR*, PULONG, LPWSTR*, LPWSTR*, BOOL*, BOOL*); 
    487487    HRESULT OpenLinkSource(DWORD); 
    488     HRESULT UpdateLink(DWORD,BOOL,BOOL); 
     488    HRESULT UpdateLink(DWORD, BOOL, BOOL); 
    489489    HRESULT CancelLink(DWORD); 
    490490} 
    …… 
    493493interface IOleUILinkContainerA : public IUnknown 
    494494{ 
    495     HRESULT QueryInterface(REFIID,PVOID*); 
     495    HRESULT QueryInterface(REFIID, PVOID*); 
    496496    ULONG AddRef(); 
    497497    ULONG Release(); 
    498498    DWORD GetNextLink(DWORD); 
    499     HRESULT SetLinkUpdateOptions(DWORD,DWORD); 
    500     HRESULT GetLinkUpdateOptions(DWORD,PDWORD); 
    501     HRESULT SetLinkSource(DWORD, LPSTR,ULONG,PULONG,BOOL); 
    502     HRESULT GetLinkSource(DWORD,LPSTR*,PULONG,LPSTR*,LPSTR*,BOOL*,BOOL*); 
     499    HRESULT SetLinkUpdateOptions(DWORD, DWORD); 
     500    HRESULT GetLinkUpdateOptions(DWORD, PDWORD); 
     501    HRESULT SetLinkSource(DWORD, LPSTR, ULONG, PULONG, BOOL); 
     502    HRESULT GetLinkSource(DWORD, LPSTR*, PULONG, LPSTR*, LPSTR*, BOOL*, BOOL*); 
    503503    HRESULT OpenLinkSource(DWORD); 
    504     HRESULT UpdateLink(DWORD,BOOL,BOOL); 
     504    HRESULT UpdateLink(DWORD, BOOL, BOOL); 
    505505    HRESULT CancelLink(DWORD); 
    506506} 
    …… 
    695695interface IOleUIObjInfoW : public IUnknown 
    696696{ 
    697     HRESULT QueryInterface(REFIID,PVOID*); 
     697    HRESULT QueryInterface(REFIID, PVOID*); 
    698698    ULONG AddRef(); 
    699699    ULONG Release(); 
    700     HRESULT GetObjectInfo(DWORD,PDWORD,LPWSTR*,LPWSTR*,LPWSTR*,LPWSTR*); 
    701     HRESULT GetConvertInfo(DWORD,CLSID*,PWORD,CLSID*,LPCLSID*,UINT*); 
    702     HRESULT ConvertObject(DWORD,REFCLSID); 
    703     HRESULT GetViewInfo(DWORD,HGLOBAL*,PDWORD,int*); 
    704     HRESULT SetViewInfo(DWORD,HGLOBAL,DWORD,int,BOOL); 
     700    HRESULT GetObjectInfo(DWORD, PDWORD, LPWSTR*, LPWSTR*, LPWSTR*, LPWSTR*); 
     701    HRESULT GetConvertInfo(DWORD, CLSID*, PWORD, CLSID*, LPCLSID*, UINT*); 
     702    HRESULT ConvertObject(DWORD, REFCLSID); 
     703    HRESULT GetViewInfo(DWORD, HGLOBAL*, PDWORD, int*); 
     704    HRESULT SetViewInfo(DWORD, HGLOBAL, DWORD, int, BOOL); 
    705705} 
    706706alias IOleUIObjInfoW *LPOLEUIOBJINFOW; 
    …… 
    708708interface IOleUIObjInfoA : public IUnknown 
    709709{ 
    710     HRESULT QueryInterface(REFIID,PVOID*); 
     710    HRESULT QueryInterface(REFIID, PVOID*); 
    711711    ULONG AddRef(); 
    712712    ULONG Release(); 
    713     HRESULT GetObjectInfo(DWORD,PDWORD,LPSTR*,LPSTR*,LPSTR*,LPSTR*); 
    714     HRESULT GetConvertInfo(DWORD,CLSID*,PWORD,CLSID*,LPCLSID*,UINT*); 
    715     HRESULT ConvertObject(DWORD,REFCLSID); 
    716     HRESULT GetViewInfo(DWORD,HGLOBAL*,PDWORD,int*); 
    717     HRESULT SetViewInfo(DWORD,HGLOBAL,DWORD,int,BOOL); 
     713    HRESULT GetObjectInfo(DWORD, PDWORD, LPSTR*, LPSTR*, LPSTR*, LPSTR*); 
     714    HRESULT GetConvertInfo(DWORD, CLSID*, PWORD, CLSID*, LPCLSID*, UINT*); 
     715    HRESULT ConvertObject(DWORD, REFCLSID); 
     716    HRESULT GetViewInfo(DWORD, HGLOBAL*, PDWORD, int*); 
     717    HRESULT SetViewInfo(DWORD, HGLOBAL, DWORD, int, BOOL); 
    718718} 
    719719alias IOleUIObjInfoA *LPOLEUIOBJINFOA; 
    …… 
    721721interface IOleUILinkInfoW : public IOleUILinkContainerW 
    722722{ 
    723     HRESULT QueryInterface(REFIID,PVOID*); 
     723    HRESULT QueryInterface(REFIID, PVOID*); 
    724724    ULONG AddRef(); 
    725725    ULONG Release(); 
    726726    DWORD GetNextLink(DWORD); 
    727     HRESULT SetLinkUpdateOptions(DWORD,DWORD); 
    728     HRESULT GetLinkUpdateOptions(DWORD,DWORD*); 
    729     HRESULT SetLinkSource(DWORD,LPWSTR,ULONG,PULONG,BOOL); 
    730     HRESULT GetLinkSource(DWORD,LPWSTR*,PULONG,LPWSTR*,LPWSTR*,BOOL*,BOOL*); 
     727    HRESULT SetLinkUpdateOptions(DWORD, DWORD); 
     728    HRESULT GetLinkUpdateOptions(DWORD, DWORD*); 
     729    HRESULT SetLinkSource(DWORD, LPWSTR, ULONG, PULONG, BOOL); 
     730    HRESULT GetLinkSource(DWORD, LPWSTR*, PULONG, LPWSTR*, LPWSTR*, BOOL*, BOOL*); 
    731731    HRESULT OpenLinkSource(DWORD); 
    732     HRESULT UpdateLink(DWORD,BOOL,BOOL); 
     732    HRESULT UpdateLink(DWORD, BOOL, BOOL); 
    733733    HRESULT CancelLink(DWORD); 
    734     HRESULT GetLastUpdate(DWORD,FILETIME*); 
     734    HRESULT GetLastUpdate(DWORD, FILETIME*); 
    735735} 
    736736alias IOleUILinkInfoW *LPOLEUILINKINFOW; 
    …… 
    738738interface IOleUILinkInfoA : public IOleUILinkContainerA 
    739739{ 
    740     HRESULT QueryInterface(REFIID,PVOID*); 
     740    HRESULT QueryInterface(REFIID, PVOID*); 
    741741    ULONG AddRef(); 
    742742    ULONG Release(); 
    743743    DWORD GetNextLink(DWORD); 
    744     HRESULT SetLinkUpdateOptions(DWORD,DWORD); 
    745     HRESULT GetLinkUpdateOptions(DWORD,DWORD*); 
    746     HRESULT SetLinkSource(DWORD,LPSTR,ULONG,PULONG,BOOL); 
    747     HRESULT GetLinkSource(DWORD,LPSTR*,PULONG,LPSTR*,LPSTR*,BOOL*,BOOL*); 
     744    HRESULT SetLinkUpdateOptions(DWORD, DWORD); 
     745    HRESULT GetLinkUpdateOptions(DWORD, DWORD*); 
     746    HRESULT SetLinkSource(DWORD, LPSTR, ULONG, PULONG, BOOL); 
     747    HRESULT GetLinkSource(DWORD, LPSTR*, PULONG, LPSTR*, LPSTR*, BOOL*, BOOL*); 
    748748    HRESULT OpenLinkSource(DWORD); 
    749     HRESULT UpdateLink(DWORD,BOOL,BOOL); 
     749    HRESULT UpdateLink(DWORD, BOOL, BOOL); 
    750750    HRESULT CancelLink(DWORD); 
    751     HRESULT GetLastUpdate(DWORD,FILETIME*); 
     751    HRESULT GetLastUpdate(DWORD, FILETIME*); 
    752752} 
    753753alias IOleUILinkInfoA* LPOLEUILINKINFOA; 
    …… 
    851851alias OLEUIOBJECTPROPSA* POLEUIOBJECTPROPSA, LPOLEUIOBJECTPROPSA; 
    852852 
    853 align: 
    854  
    855853extern (Windows) { 
    856 BOOL OleUIAddVerbMenuW(LPOLEOBJECT,LPCWSTR,HMENU,UINT,UINT,UINT,BOOL,UINT,HMENU*); 
    857 BOOL OleUIAddVerbMenuA(LPOLEOBJECT,LPCSTR,HMENU,UINT,UINT,UINT,BOOL,UINT,HMENU*); 
    858 UINT OleUIBusyW(LPOLEUIBUSYW); 
    859 UINT OleUIBusyA(LPOLEUIBUSYA); 
    860 BOOL OleUICanConvertOrActivateAs(REFCLSID,BOOL,WORD); 
    861 UINT OleUIChangeIconW(LPOLEUICHANGEICONW); 
    862 UINT OleUIChangeIconA(LPOLEUICHANGEICONA); 
    863 UINT OleUIChangeSourceW(LPOLEUICHANGESOURCEW); 
    864 UINT OleUIChangeSourceA(LPOLEUICHANGESOURCEA); 
    865 UINT OleUIConvertW(LPOLEUICONVERTW); 
    866 UINT OleUIConvertA(LPOLEUICONVERTA); 
    867 UINT OleUIEditLinksW(LPOLEUIEDITLINKSW); 
    868 UINT OleUIEditLinksA(LPOLEUIEDITLINKSA); 
    869 UINT OleUIObjectPropertiesW(LPOLEUIOBJECTPROPSW); 
    870 UINT OleUIObjectPropertiesA(LPOLEUIOBJECTPROPSA); 
    871 UINT OleUIPasteSpecialW(LPOLEUIPASTESPECIALW); 
    872 UINT OleUIPasteSpecialA(LPOLEUIPASTESPECIALA); 
    873 BOOL OleUIUpdateLinksW(LPOLEUILINKCONTAINERW,HWND,LPWSTR,int); 
    874 BOOL OleUIUpdateLinksA(LPOLEUILINKCONTAINERA,HWND,LPSTR,int); 
     854   BOOL OleUIAddVerbMenuW(LPOLEOBJECT, LPCWSTR, HMENU, UINT, UINT, UINT, BOOL, UINT, HMENU*); 
     855   BOOL OleUIAddVerbMenuA(LPOLEOBJECT, LPCSTR, HMENU, UINT, UINT, UINT, BOOL, UINT, HMENU*); 
     856   UINT OleUIBusyW(LPOLEUIBUSYW); 
     857   UINT OleUIBusyA(LPOLEUIBUSYA); 
     858   BOOL OleUICanConvertOrActivateAs(REFCLSID, BOOL, WORD); 
     859   UINT OleUIChangeIconW(LPOLEUICHANGEICONW); 
     860   UINT OleUIChangeIconA(LPOLEUICHANGEICONA); 
     861   UINT OleUIChangeSourceW(LPOLEUICHANGESOURCEW); 
     862   UINT OleUIChangeSourceA(LPOLEUICHANGESOURCEA); 
     863   UINT OleUIConvertW(LPOLEUICONVERTW); 
     864   UINT OleUIConvertA(LPOLEUICONVERTA); 
     865   UINT OleUIEditLinksW(LPOLEUIEDITLINKSW); 
     866   UINT OleUIEditLinksA(LPOLEUIEDITLINKSA); 
     867   UINT OleUIObjectPropertiesW(LPOLEUIOBJECTPROPSW); 
     868   UINT OleUIObjectPropertiesA(LPOLEUIOBJECTPROPSA); 
     869   UINT OleUIPasteSpecialW(LPOLEUIPASTESPECIALW); 
     870   UINT OleUIPasteSpecialA(LPOLEUIPASTESPECIALA); 
     871   BOOL OleUIUpdateLinksW(LPOLEUILINKCONTAINERW, HWND, LPWSTR, int); 
     872   BOOL OleUIUpdateLinksA(LPOLEUILINKCONTAINERA, HWND, LPSTR, int); 
    875873} 
    876874 
    877875extern (C) { 
    878 int OleUIPromptUserW(int,HWND,...); 
    879 int OleUIPromptUserA(int,HWND,...); 
     876   int OleUIPromptUserW(int, HWND, ...); 
     877   int OleUIPromptUserA(int, HWND, ...); 
    880878} 
    881879 
    882880version(Unicode) { 
    883 alias IDD_SERVERNOTREGW IDD_SERVERNOTREG; 
    884 alias IDD_LINKTYPECHANGEDW IDD_LINKTYPECHANGED; 
    885 alias OleUIUpdateLinksW OleUIUpdateLinks; 
    886 alias OleUIAddVerbMenuW OleUIAddVerbMenu; 
    887 alias OLEUIOBJECTPROPSW OLEUIOBJECTPROPS; 
    888 alias POLEUIOBJECTPROPSW POLEUIOBJECTPROPS; 
    889 alias LPOLEUIOBJECTPROPSW LPOLEUIOBJECTPROPS; 
    890 alias OleUIObjectPropertiesW OleUIObjectProperties; 
    891 alias OLEUIINSERTOBJECTW OLEUIINSERTOBJECT; 
    892 alias POLEUIINSERTOBJECTW POLEUIINSERTOBJECT; 
    893 alias LPOLEUIINSERTOBJECTW LPOLEUIINSERTOBJECT; 
    894 alias OleUIInsertObjectW OleUIInsertObject; 
    895 alias OleUIPromptUserW OleUIPromptUser; 
    896 alias OLEUIPASTEENTRYW OLEUIPASTEENTRY; 
    897 alias POLEUIPASTEENTRYW POLEUIPASTEENTRY; 
    898 alias LPOLEUIPASTEENTRYW LPOLEUIPASTEENTRY; 
    899 alias OLEUIPASTESPECIALW OLEUIPASTESPECIAL; 
    900 alias POLEUIPASTESPECIALW POLEUIPASTESPECIAL; 
    901 alias LPOLEUIPASTESPECIALW LPOLEUIPASTESPECIAL; 
    902 alias OleUIPasteSpecialW OleUIPasteSpecial; 
    903 alias IOleUILinkContainerW IOleUILinkContainer; 
    904 alias LPOLEUILINKCONTAINERW LPOLEUILINKCONTAINER; 
    905 alias OLEUIEDITLINKSW OLEUIEDITLINKS; 
    906 alias POLEUIEDITLINKSW POLEUIEDITLINKS; 
    907 alias LPOLEUIEDITLINKSW LPOLEUIEDITLINKS; 
    908 alias OleUIEditLinksW OleUIEditLinks; 
    909 alias OLEUICHANGEICONW OLEUICHANGEICON; 
    910 alias POLEUICHANGEICONW POLEUICHANGEICON; 
    911 alias LPOLEUICHANGEICONW LPOLEUICHANGEICON; 
    912 alias OleUIChangeIconW OleUIChangeIcon; 
    913 alias OLEUICONVERTW OLEUICONVERT; 
    914 alias POLEUICONVERTW POLEUICONVERT; 
    915 alias LPOLEUICONVERTW LPOLEUICONVERT; 
    916 alias OleUIConvertW OleUIConvert; 
    917 alias OLEUIBUSYW OLEUIBUSY; 
    918 alias POLEUIBUSYW POLEUIBUSY; 
    919 alias LPOLEUIBUSYW LPOLEUIBUSY; 
    920 alias OleUIBusyW OleUIBusy; 
    921 alias OLEUICHANGESOURCEW OLEUICHANGESOURCE; 
    922 alias POLEUICHANGESOURCEW POLEUICHANGESOURCE; 
    923 alias LPOLEUICHANGESOURCEW LPOLEUICHANGESOURCE; 
    924 alias OleUIChangeSourceW OleUIChangeSource; 
    925 alias IOleUIObjInfoW IOleUIObjInfo; 
    926 alias LPOLEUIOBJINFOW LPOLEUIOBJINFO; 
    927 alias IOleUILinkInfoW IOleUILinkInfo; 
    928 //alias IOleUILinkInfoWVtbl IOleUILinkInfoVtbl; 
    929 alias LPOLEUILINKINFOW LPOLEUILINKINFO; 
    930 alias OLEUIGNRLPROPSW OLEUIGNRLPROPS; 
    931 alias POLEUIGNRLPROPSW POLEUIGNRLPROPS; 
    932 alias LPOLEUIGNRLPROPSW LPOLEUIGNRLPROPS; 
    933 alias OLEUIVIEWPROPSW OLEUIVIEWPROPS; 
    934 alias POLEUIVIEWPROPSW POLEUIVIEWPROPS; 
    935 alias LPOLEUIVIEWPROPSW LPOLEUIVIEWPROPS; 
    936 alias OLEUILINKPROPSW OLEUILINKPROPS; 
    937 alias POLEUILINKPROPSW POLEUILINKPROPS; 
    938 alias LPOLEUILINKPROPSW LPOLEUILINKPROPS; 
     881   alias IDD_SERVERNOTREGW IDD_SERVERNOTREG; 
     882   alias IDD_LINKTYPECHANGEDW IDD_LINKTYPECHANGED; 
     883   alias OleUIUpdateLinksW OleUIUpdateLinks; 
     884   alias OleUIAddVerbMenuW OleUIAddVerbMenu; 
     885   alias OLEUIOBJECTPROPSW OLEUIOBJECTPROPS; 
     886   alias POLEUIOBJECTPROPSW POLEUIOBJECTPROPS; 
     887   alias LPOLEUIOBJECTPROPSW LPOLEUIOBJECTPROPS; 
     888   alias OleUIObjectPropertiesW OleUIObjectProperties; 
     889   alias OLEUIINSERTOBJECTW OLEUIINSERTOBJECT; 
     890   alias POLEUIINSERTOBJECTW POLEUIINSERTOBJECT; 
     891   alias LPOLEUIINSERTOBJECTW LPOLEUIINSERTOBJECT; 
     892   alias OleUIInsertObjectW OleUIInsertObject; 
     893   alias OleUIPromptUserW OleUIPromptUser; 
     894   alias OLEUIPASTEENTRYW OLEUIPASTEENTRY; 
     895   alias POLEUIPASTEENTRYW POLEUIPASTEENTRY; 
     896   alias LPOLEUIPASTEENTRYW LPOLEUIPASTEENTRY; 
     897   alias OLEUIPASTESPECIALW OLEUIPASTESPECIAL; 
     898   alias POLEUIPASTESPECIALW POLEUIPASTESPECIAL; 
     899   alias LPOLEUIPASTESPECIALW LPOLEUIPASTESPECIAL; 
     900   alias OleUIPasteSpecialW OleUIPasteSpecial; 
     901   alias IOleUILinkContainerW IOleUILinkContainer; 
     902   alias LPOLEUILINKCONTAINERW LPOLEUILINKCONTAINER; 
     903   alias OLEUIEDITLINKSW OLEUIEDITLINKS; 
     904   alias POLEUIEDITLINKSW POLEUIEDITLINKS; 
     905   alias LPOLEUIEDITLINKSW LPOLEUIEDITLINKS; 
     906   alias OleUIEditLinksW OleUIEditLinks; 
     907   alias OLEUICHANGEICONW OLEUICHANGEICON; 
     908   alias POLEUICHANGEICONW POLEUICHANGEICON; 
     909   alias LPOLEUICHANGEICONW LPOLEUICHANGEICON; 
     910   alias OleUIChangeIconW OleUIChangeIcon; 
     911   alias OLEUICONVERTW OLEUICONVERT; 
     912   alias POLEUICONVERTW POLEUICONVERT; 
     913   alias LPOLEUICONVERTW LPOLEUICONVERT; 
     914   alias OleUIConvertW OleUIConvert; 
     915   alias OLEUIBUSYW OLEUIBUSY; 
     916   alias POLEUIBUSYW POLEUIBUSY; 
     917   alias LPOLEUIBUSYW LPOLEUIBUSY; 
     918   alias OleUIBusyW OleUIBusy; 
     919   alias OLEUICHANGESOURCEW OLEUICHANGESOURCE; 
     920   alias POLEUICHANGESOURCEW POLEUICHANGESOURCE; 
     921   alias LPOLEUICHANGESOURCEW LPOLEUICHANGESOURCE; 
     922   alias OleUIChangeSourceW OleUIChangeSource; 
     923   alias IOleUIObjInfoW IOleUIObjInfo; 
     924   alias LPOLEUIOBJINFOW LPOLEUIOBJINFO; 
     925   alias IOleUILinkInfoW IOleUILinkInfo; 
     926   //alias IOleUILinkInfoWVtbl IOleUILinkInfoVtbl; 
     927   alias LPOLEUILINKINFOW LPOLEUILINKINFO; 
     928   alias OLEUIGNRLPROPSW OLEUIGNRLPROPS; 
     929   alias POLEUIGNRLPROPSW POLEUIGNRLPROPS; 
     930   alias LPOLEUIGNRLPROPSW LPOLEUIGNRLPROPS; 
     931   alias OLEUIVIEWPROPSW OLEUIVIEWPROPS; 
     932   alias POLEUIVIEWPROPSW POLEUIVIEWPROPS; 
     933   alias LPOLEUIVIEWPROPSW LPOLEUIVIEWPROPS; 
     934   alias OLEUILINKPROPSW OLEUILINKPROPS; 
     935   alias POLEUILINKPROPSW POLEUILINKPROPS; 
     936   alias LPOLEUILINKPROPSW LPOLEUILINKPROPS; 
    939937} else { 
    940 alias IDD_SERVERNOTREGA IDD_SERVERNOTREG; 
    941 alias IDD_LINKTYPECHANGEDA IDD_LINKTYPECHANGED; 
    942 alias OleUIUpdateLinksA OleUIUpdateLinks; 
    943 alias OleUIAddVerbMenuA OleUIAddVerbMenu; 
    944 alias OLEUIOBJECTPROPSA OLEUIOBJECTPROPS; 
    945 alias POLEUIOBJECTPROPSA POLEUIOBJECTPROPS; 
    946 alias LPOLEUIOBJECTPROPSA LPOLEUIOBJECTPROPS; 
    947 alias OleUIObjectPropertiesA OleUIObjectProperties; 
    948 alias OLEUIINSERTOBJECTA OLEUIINSERTOBJECT; 
    949 alias POLEUIINSERTOBJECTA POLEUIINSERTOBJECT; 
    950 alias LPOLEUIINSERTOBJECTA LPOLEUIINSERTOBJECT; 
    951 alias OleUIInsertObjectA OleUIInsertObject; 
    952 alias OleUIPromptUserA OleUIPromptUser; 
    953 alias OLEUIPASTEENTRYA OLEUIPASTEENTRY; 
    954 alias POLEUIPASTEENTRYA POLEUIPASTEENTRY; 
    955 alias LPOLEUIPASTEENTRYA LPOLEUIPASTEENTRY; 
    956 alias OLEUIPASTESPECIALA OLEUIPASTESPECIAL; 
    957 alias POLEUIPASTESPECIALA POLEUIPASTESPECIAL; 
    958 alias LPOLEUIPASTESPECIALA LPOLEUIPASTESPECIAL; 
    959 alias OleUIPasteSpecialA OleUIPasteSpecial; 
    960 alias IOleUILinkContainerA IOleUILinkContainer; 
    961 alias LPOLEUILINKCONTAINERA LPOLEUILINKCONTAINER; 
    962 alias OLEUIEDITLINKSA OLEUIEDITLINKS; 
    963 alias POLEUIEDITLINKSA POLEUIEDITLINKS; 
    964 alias LPOLEUIEDITLINKSA LPOLEUIEDITLINKS; 
    965 alias OleUIEditLinksA OleUIEditLinks; 
    966 alias OLEUICHANGEICONA OLEUICHANGEICON; 
    967 alias POLEUICHANGEICONA POLEUICHANGEICON; 
    968 alias LPOLEUICHANGEICONA LPOLEUICHANGEICON; 
    969 alias OleUIChangeIconA OleUIChangeIcon; 
    970 alias OLEUICONVERTA OLEUICONVERT; 
    971 alias POLEUICONVERTA POLEUICONVERT; 
    972 alias LPOLEUICONVERTA LPOLEUICONVERT; 
    973 alias OleUIConvertA OleUIConvert; 
    974 alias OLEUIBUSYA OLEUIBUSY; 
    975 alias POLEUIBUSYA POLEUIBUSY; 
    976 alias LPOLEUIBUSYA LPOLEUIBUSY; 
    977 alias OleUIBusyA OleUIBusy; 
    978 alias OLEUICHANGESOURCEA OLEUICHANGESOURCE; 
    979 alias POLEUICHANGESOURCEA POLEUICHANGESOURCE; 
    980 alias LPOLEUICHANGESOURCEA LPOLEUICHANGESOURCE; 
    981 alias OleUIChangeSourceA OleUIChangeSource; 
    982 alias IOleUIObjInfoA IOleUIObjInfo; 
    983 alias LPOLEUIOBJINFOA LPOLEUIOBJINFO; 
    984 alias IOleUILinkInfoA IOleUILinkInfo; 
    985 //alias IOleUILinkInfoAVtbl IOleUILinkInfoVtbl; 
    986 alias LPOLEUILINKINFOA LPOLEUILINKINFO; 
    987 alias OLEUIGNRLPROPSA OLEUIGNRLPROPS; 
    988 alias POLEUIGNRLPROPSA POLEUIGNRLPROPS; 
    989 alias LPOLEUIGNRLPROPSA LPOLEUIGNRLPROPS; 
    990 alias OLEUIVIEWPROPSA OLEUIVIEWPROPS; 
    991 alias POLEUIVIEWPROPSA POLEUIVIEWPROPS; 
    992 alias LPOLEUIVIEWPROPSA LPOLEUIVIEWPROPS; 
    993 alias OLEUILINKPROPSA OLEUILINKPROPS; 
    994 alias POLEUILINKPROPSA POLEUILINKPROPS; 
    995 alias LPOLEUILINKPROPSA LPOLEUILINKPROPS; 
    996 } 
     938   alias IDD_SERVERNOTREGA IDD_SERVERNOTREG; 
     939   alias IDD_LINKTYPECHANGEDA IDD_LINKTYPECHANGED; 
     940   alias OleUIUpdateLinksA OleUIUpdateLinks; 
     941   alias OleUIAddVerbMenuA OleUIAddVerbMenu; 
     942   alias OLEUIOBJECTPROPSA OLEUIOBJECTPROPS; 
     943   alias POLEUIOBJECTPROPSA POLEUIOBJECTPROPS; 
     944   alias LPOLEUIOBJECTPROPSA LPOLEUIOBJECTPROPS; 
     945   alias OleUIObjectPropertiesA OleUIObjectProperties; 
     946   alias OLEUIINSERTOBJECTA OLEUIINSERTOBJECT; 
     947   alias POLEUIINSERTOBJECTA POLEUIINSERTOBJECT; 
     948   alias LPOLEUIINSERTOBJECTA LPOLEUIINSERTOBJECT; 
     949   alias OleUIInsertObjectA OleUIInsertObject; 
     950   alias OleUIPromptUserA OleUIPromptUser; 
     951   alias OLEUIPASTEENTRYA OLEUIPASTEENTRY; 
     952   alias POLEUIPASTEENTRYA POLEUIPASTEENTRY; 
     953   alias LPOLEUIPASTEENTRYA LPOLEUIPASTEENTRY; 
     954   alias OLEUIPASTESPECIALA OLEUIPASTESPECIAL; 
     955   alias POLEUIPASTESPECIALA POLEUIPASTESPECIAL; 
     956   alias LPOLEUIPASTESPECIALA LPOLEUIPASTESPECIAL; 
     957   alias OleUIPasteSpecialA OleUIPasteSpecial; 
     958   alias IOleUILinkContainerA IOleUILinkContainer; 
     959   alias LPOLEUILINKCONTAINERA LPOLEUILINKCONTAINER; 
     960   alias OLEUIEDITLINKSA OLEUIEDITLINKS; 
     961   alias POLEUIEDITLINKSA POLEUIEDITLINKS; 
     962   alias LPOLEUIEDITLINKSA LPOLEUIEDITLINKS; 
     963   alias OleUIEditLinksA OleUIEditLinks; 
     964   alias OLEUICHANGEICONA OLEUICHANGEICON; 
     965   alias POLEUICHANGEICONA POLEUICHANGEICON; 
     966   alias LPOLEUICHANGEICONA LPOLEUICHANGEICON; 
     967   alias OleUIChangeIconA OleUIChangeIcon; 
     968   alias OLEUICONVERTA OLEUICONVERT; 
     969   alias POLEUICONVERTA POLEUICONVERT; 
     970   alias LPOLEUICONVERTA LPOLEUICONVERT; 
     971   alias OleUIConvertA OleUIConvert; 
     972   alias OLEUIBUSYA OLEUIBUSY; 
     973   alias POLEUIBUSYA POLEUIBUSY; 
     974   alias LPOLEUIBUSYA LPOLEUIBUSY; 
     975   alias OleUIBusyA OleUIBusy; 
     976   alias OLEUICHANGESOURCEA OLEUICHANGESOURCE; 
     977   alias POLEUICHANGESOURCEA POLEUICHANGESOURCE; 
     978   alias LPOLEUICHANGESOURCEA LPOLEUICHANGESOURCE; 
     979   alias OleUIChangeSourceA OleUIChangeSource; 
     980   alias IOleUIObjInfoA IOleUIObjInfo; 
     981   alias LPOLEUIOBJINFOA LPOLEUIOBJINFO; 
     982   alias IOleUILinkInfoA IOleUILinkInfo; 
     983   //alias IOleUILinkInfoAVtbl IOleUILinkInfoVtbl; 
     984   alias LPOLEUILINKINFOA LPOLEUILINKINFO; 
     985   alias OLEUIGNRLPROPSA OLEUIGNRLPROPS; 
     986   alias POLEUIGNRLPROPSA POLEUIGNRLPROPS; 
     987   alias LPOLEUIGNRLPROPSA LPOLEUIGNRLPROPS; 
     988   alias OLEUIVIEWPROPSA OLEUIVIEWPROPS; 
     989   alias POLEUIVIEWPROPSA POLEUIVIEWPROPS; 
     990   alias LPOLEUIVIEWPROPSA LPOLEUIVIEWPROPS; 
     991   alias OLEUILINKPROPSA OLEUILINKPROPS; 
     992   alias POLEUILINKPROPSA POLEUILINKPROPS; 
     993   alias LPOLEUILINKPROPSA LPOLEUILINKPROPS; 
     994} 

  • trunk/win32/prsht.d

    r135 r141  
    321321} 
    322322alias PSHNOTIFY* LPPSHNOTIFY; 
    323  
    324 align: 
    325323 
    326324extern (Windows) { 

  • trunk/win32/ras.d

    r139 r141  
    132132    const RASLCPO_DES_56 = 0x00000008; 
    133133    const RASLCPO_3_DES  = 0x00000010; 
    134      
     134 
    135135    const RASCCPCA_MPPC = 0x00000006; 
    136136    const RASCCPCA_STAC = 0x00000005; 
    137      
     137 
    138138    const RASCCPO_Compression      = 0x00000001; 
    139139    const RASCCPO_HistoryLess      = 0x00000002; 
    …… 
    141141    const RASCCPO_Encryption40bit  = 0x00000020; 
    142142    const RASCCPO_Encryption128bit = 0x00000040; 
    143      
     143 
    144144    const RASEO_RequireEAP          = 0x00020000; 
    145145    const RASEO_RequirePAP          = 0x00040000; 
    146     const RASEO_RequireSPAP         = 0x00080000;   
     146    const RASEO_RequireSPAP         = 0x00080000; 
    147147    const RASEO_Custom              = 0x00100000; 
    148148    const RASEO_PreviewPhoneNumber  = 0x00200000; 
    …… 
    156156    const RASEO_RequireW95MSCHAP    = 0x40000000; 
    157157    const RASEO_CustomScript        = 0x80000000; 
    158      
     158 
    159159    const RASIPO_VJ = 0x00000001; 
    160160    const RCD_SingleUser = 0; 
    …… 
    202202    RASCS_RetryAuthentication, 
    203203    RASCS_CallbackSetByCaller, 
    204     RASCS_PasswordExpired,  
     204    RASCS_PasswordExpired, 
    205205//  static if (WINVER >= 0x0500) { 
    206206        RASCS_InvokeEapUI, 
    …… 
    637637    } 
    638638    alias RASADPARAMS* LPRASADPARAMS; 
    639      
     639 
    640640    struct RASSUBENTRYW{ 
    641641        DWORD dwSize; 
    …… 
    647647    } 
    648648    alias RASSUBENTRYW* LPRASSUBENTRYW; 
    649      
     649 
    650650    struct RASSUBENTRYA{ 
    651651        DWORD dwSize; 
    …… 
    657657    } 
    658658    alias RASSUBENTRYA* LPRASSUBENTRYA; 
    659      
     659 
    660660    struct RASCREDENTIALSW{ 
    661661        DWORD dwSize; 
    …… 
    666666    } 
    667667    alias RASCREDENTIALSW* LPRASCREDENTIALSW; 
    668      
     668 
    669669    struct RASCREDENTIALSA{ 
    670670        DWORD dwSize; 
    …… 
    675675    } 
    676676    alias RASCREDENTIALSA* LPRASCREDENTIALSA; 
    677      
     677 
    678678    struct RASAUTODIALENTRYW{ 
    679679        DWORD dwSize; 
    …… 
    683683    } 
    684684    alias RASAUTODIALENTRYW* LPRASAUTODIALENTRYW; 
    685      
     685 
    686686    struct RASAUTODIALENTRYA{ 
    687687        DWORD dwSize; 
    …… 
    703703    } 
    704704    alias RASPPPCCP* LPRASPPPCCP; 
    705      
     705 
    706706    struct RASEAPUSERIDENTITYW{ 
    707707        WCHAR szUserName[UNLEN + 1]; 
    …… 
    710710    } 
    711711    alias RASEAPUSERIDENTITYW* LPRASEAPUSERIDENTITYW; 
    712      
     712 
    713713    struct RASEAPUSERIDENTITYA{ 
    714714        CHAR szUserName[UNLEN + 1]; 
    …… 
    717717    } 
    718718    alias RASEAPUSERIDENTITYA* LPRASEAPUSERIDENTITYA; 
    719      
     719 
    720720    struct RAS_STATS{ 
    721721        DWORD dwSize; 
    …… 
    741741/* UNICODE typedefs for structures*/ 
    742742version (Unicode) { 
    743 alias RASCONNW RASCONN; 
    744 alias RASENTRYW RASENTRY; 
    745 alias RASCONNSTATUSW RASCONNSTATUS; 
    746 alias RASDIALPARAMSW RASDIALPARAMS; 
    747 alias RASAMBW RASAMB; 
    748 alias RASPPPNBFW RASPPPNBF; 
    749 alias RASPPPIPXW RASPPPIPX; 
    750 alias RASPPPIPW RASPPPIP; 
    751 alias RASPPPLCPW RASPPPLCP; 
    752 alias RASSLIPW RASSLIP; 
    753 alias RASDEVINFOW RASDEVINFO; 
    754 alias RASENTRYNAMEW RASENTRYNAME; 
    755  
    756 static if (WINVER >= 0x0401) { 
    757     alias RASSUBENTRYW RASSUBENTRY; 
    758     alias RASCREDENTIALSW RASCREDENTIALS; 
    759     alias RASAUTODIALENTRYW RASAUTODIALENTRY; 
    760 } 
    761  
    762 static if (WINVER >= 0x0500) { 
    763     alias RASEAPUSERIDENTITYW RASEAPUSERIDENTITY; 
    764 } 
     743   alias RASCONNW RASCONN; 
     744   alias RASENTRYW RASENTRY; 
     745   alias RASCONNSTATUSW RASCONNSTATUS; 
     746   alias RASDIALPARAMSW RASDIALPARAMS; 
     747   alias RASAMBW RASAMB; 
     748   alias RASPPPNBFW RASPPPNBF; 
     749   alias RASPPPIPXW RASPPPIPX; 
     750   alias RASPPPIPW RASPPPIP; 
     751   alias RASPPPLCPW RASPPPLCP; 
     752   alias RASSLIPW RASSLIP; 
     753   alias RASDEVINFOW RASDEVINFO; 
     754   alias RASENTRYNAMEW RASENTRYNAME; 
     755 
     756   static if (WINVER >= 0x0401) { 
     757       alias RASSUBENTRYW RASSUBENTRY; 
     758       alias RASCREDENTIALSW RASCREDENTIALS; 
     759       alias RASAUTODIALENTRYW RASAUTODIALENTRY; 
     760   } 
     761 
     762   static if (WINVER >= 0x0500) { 
     763       alias RASEAPUSERIDENTITYW RASEAPUSERIDENTITY; 
     764   } 
    765765 
    766766} else { // ! defined UNICODE 
    767767 
    768 alias RASCONNA RASCONN; 
    769 alias RASENTRYA  RASENTRY; 
    770 alias RASCONNSTATUSA RASCONNSTATUS; 
    771 alias RASDIALPARAMSA RASDIALPARAMS; 
    772 alias RASAMBA RASAMB; 
    773 alias RASPPPNBFA RASPPPNBF; 
    774 alias RASPPPIPXA RASPPPIPX; 
    775 alias RASPPPIPA RASPPPIP; 
    776 alias RASPPPLCPA RASPPPLCP; 
    777 alias RASSLIPA RASSLIP; 
    778 alias RASDEVINFOA  RASDEVINFO; 
    779 alias RASENTRYNAMEA RASENTRYNAME; 
    780  
    781 static if (WINVER >= 0x0401) { 
    782     alias RASSUBENTRYA RASSUBENTRY; 
    783     alias RASCREDENTIALSA RASCREDENTIALS; 
    784     alias RASAUTODIALENTRYA RASAUTODIALENTRY; 
    785 } 
    786 static if (WINVER >= 0x0500) { 
    787     alias RASEAPUSERIDENTITYA RASEAPUSERIDENTITY; 
    788 } 
     768   alias RASCONNA RASCONN; 
     769   alias RASENTRYA  RASENTRY; 
     770   alias RASCONNSTATUSA RASCONNSTATUS; 
     771   alias RASDIALPARAMSA RASDIALPARAMS; 
     772   alias RASAMBA RASAMB; 
     773   alias RASPPPNBFA RASPPPNBF; 
     774   alias RASPPPIPXA RASPPPIPX; 
     775   alias RASPPPIPA RASPPPIP; 
     776   alias RASPPPLCPA RASPPPLCP; 
     777   alias RASSLIPA RASSLIP; 
     778   alias RASDEVINFOA  RASDEVINFO; 
     779   alias RASENTRYNAMEA RASENTRYNAME; 
     780 
     781   static if (WINVER >= 0x0401) { 
     782       alias RASSUBENTRYA RASSUBENTRY; 
     783       alias RASCREDENTIALSA RASCREDENTIALS; 
     784       alias RASAUTODIALENTRYA RASAUTODIALENTRY; 
     785   } 
     786   static if (WINVER >= 0x0500) { 
     787       alias RASEAPUSERIDENTITYA RASEAPUSERIDENTITY; 
     788   } 
    789789}// ! UNICODE 
    790790 
    …… 
    814814/* Callback prototypes */ 
    815815deprecated { 
    816 alias BOOL function (HWND, LPSTR, DWORD, LPDWORD) ORASADFUNC; 
     816   alias BOOL function (HWND, LPSTR, DWORD, LPDWORD) ORASADFUNC; 
    817817} 
    818818 
    …… 
    872872 
    873873static if (WINVER >= 0x0401) { 
    874 alias BOOL function (LPSTR, LPSTR, LPRASADPARAMS, LPDWORD) RASADFUNCA; 
    875 alias BOOL function (LPWSTR, LPWSTR, LPRASADPARAMS, LPDWORD) RASADFUNCW; 
    876  
    877 DWORD RasGetSubEntryHandleA (HRASCONN, DWORD, LPHRASCONN); 
    878 DWORD RasGetSubEntryHandleW (HRASCONN, DWORD, LPHRASCONN); 
    879 DWORD RasGetCredentialsA (LPCSTR, LPCSTR, LPRASCREDENTIALSA); 
    880 DWORD RasGetCredentialsW (LPCWSTR, LPCWSTR, LPRASCREDENTIALSW); 
    881 DWORD RasSetCredentialsA (LPCSTR, LPCSTR, LPRASCREDENTIALSA, BOOL); 
    882 DWORD RasSetCredentialsW (LPCWSTR, LPCWSTR, LPRASCREDENTIALSW, BOOL); 
    883 DWORD RasConnectionNotificationA (HRASCONN, HANDLE, DWORD); 
    884 DWORD RasConnectionNotificationW (HRASCONN, HANDLE, DWORD); 
    885 DWORD RasGetSubEntryPropertiesA (LPCSTR, LPCSTR, DWORD, 
    886 LPRASSUBENTRYA, LPDWORD, LPBYTE, LPDWORD); 
    887 DWORD RasGetSubEntryPropertiesW (LPCWSTR, LPCWSTR, DWORD, 
    888 LPRASSUBENTRYW, LPDWORD, LPBYTE, LPDWORD); 
    889 DWORD RasSetSubEntryPropertiesA (LPCSTR, LPCSTR, DWORD, 
    890 LPRASSUBENTRYA, DWORD, LPBYTE, DWORD); 
    891 DWORD RasSetSubEntryPropertiesW (LPCWSTR, LPCWSTR, DWORD, 
    892 LPRASSUBENTRYW, DWORD, LPBYTE, DWORD); 
    893 DWORD RasGetAutodialAddressA (LPCSTR, LPDWORD, LPRASAUTODIALENTRYA, 
    894 LPDWORD, LPDWORD); 
    895 DWORD RasGetAutodialAddressW (LPCWSTR, LPDWORD, 
    896 LPRASAUTODIALENTRYW, LPDWORD, LPDWORD); 
    897 DWORD RasSetAutodialAddressA (LPCSTR, DWORD, LPRASAUTODIALENTRYA, 
    898 DWORD, DWORD); 
    899 DWORD RasSetAutodialAddressW (LPCWSTR, DWORD, LPRASAUTODIALENTRYW, 
    900 DWORD, DWORD); 
    901 DWORD RasEnumAutodialAddressesA (LPSTR *, LPDWORD, LPDWORD); 
    902 DWORD RasEnumAutodialAddressesW (LPWSTR *, LPDWORD, LPDWORD); 
    903 DWORD RasGetAutodialEnableA (DWORD, LPBOOL); 
    904 DWORD RasGetAutodialEnableW (DWORD, LPBOOL); 
    905 DWORD RasSetAutodialEnableA (DWORD, BOOL); 
    906 DWORD RasSetAutodialEnableW (DWORD, BOOL); 
    907 DWORD RasGetAutodialParamA (DWORD, LPVOID, LPDWORD); 
    908 DWORD RasGetAutodialParamW (DWORD, LPVOID, LPDWORD); 
    909 DWORD RasSetAutodialParamA (DWORD, LPVOID, DWORD); 
    910 DWORD RasSetAutodialParamW (DWORD, LPVOID, DWORD); 
     874   alias BOOL function (LPSTR, LPSTR, LPRASADPARAMS, LPDWORD) RASADFUNCA; 
     875   alias BOOL function (LPWSTR, LPWSTR, LPRASADPARAMS, LPDWORD) RASADFUNCW; 
     876 
     877   DWORD RasGetSubEntryHandleA (HRASCONN, DWORD, LPHRASCONN); 
     878   DWORD RasGetSubEntryHandleW (HRASCONN, DWORD, LPHRASCONN); 
     879   DWORD RasGetCredentialsA (LPCSTR, LPCSTR, LPRASCREDENTIALSA); 
     880   DWORD RasGetCredentialsW (LPCWSTR, LPCWSTR, LPRASCREDENTIALSW); 
     881   DWORD RasSetCredentialsA (LPCSTR, LPCSTR, LPRASCREDENTIALSA, BOOL); 
     882   DWORD RasSetCredentialsW (LPCWSTR, LPCWSTR, LPRASCREDENTIALSW, BOOL); 
     883   DWORD RasConnectionNotificationA (HRASCONN, HANDLE, DWORD); 
     884   DWORD RasConnectionNotificationW (HRASCONN, HANDLE, DWORD); 
     885   DWORD RasGetSubEntryPropertiesA (LPCSTR, LPCSTR, DWORD, 
     886   LPRASSUBENTRYA, LPDWORD, LPBYTE, LPDWORD); 
     887   DWORD RasGetSubEntryPropertiesW (LPCWSTR, LPCWSTR, DWORD, 
     888   LPRASSUBENTRYW, LPDWORD, LPBYTE, LPDWORD); 
     889   DWORD RasSetSubEntryPropertiesA (LPCSTR, LPCSTR, DWORD, 
     890   LPRASSUBENTRYA, DWORD, LPBYTE, DWORD); 
     891   DWORD RasSetSubEntryPropertiesW (LPCWSTR, LPCWSTR, DWORD, 
     892   LPRASSUBENTRYW, DWORD, LPBYTE, DWORD); 
     893   DWORD RasGetAutodialAddressA (LPCSTR, LPDWORD, LPRASAUTODIALENTRYA, 
     894   LPDWORD, LPDWORD); 
     895   DWORD RasGetAutodialAddressW (LPCWSTR, LPDWORD, 
     896   LPRASAUTODIALENTRYW, LPDWORD, LPDWORD); 
     897   DWORD RasSetAutodialAddressA (LPCSTR, DWORD, LPRASAUTODIALENTRYA, 
     898   DWORD, DWORD); 
     899   DWORD RasSetAutodialAddressW (LPCWSTR, DWORD, LPRASAUTODIALENTRYW, 
     900   DWORD, DWORD); 
     901   DWORD RasEnumAutodialAddressesA (LPSTR *, LPDWORD, LPDWORD); 
     902   DWORD RasEnumAutodialAddressesW (LPWSTR *, LPDWORD, LPDWORD); 
     903   DWORD RasGetAutodialEnableA (DWORD, LPBOOL); 
     904   DWORD RasGetAutodialEnableW (DWORD, LPBOOL); 
     905   DWORD RasSetAutodialEnableA (DWORD, BOOL); 
     906   DWORD RasSetAutodialEnableW (DWORD, BOOL); 
     907   DWORD RasGetAutodialParamA (DWORD, LPVOID, LPDWORD); 
     908   DWORD RasGetAutodialParamW (DWORD, LPVOID, LPDWORD); 
     909   DWORD RasSetAutodialParamA (DWORD, LPVOID, DWORD); 
     910   DWORD RasSetAutodialParamW (DWORD, LPVOID, DWORD); 
    911911} 
    912912 
    913913static if (WINVER >= 0x0500) { 
    914 alias DWORD function (HRASCONN) RasCustomHangUpFn; 
    915 alias DWORD function (LPCTSTR,    LPCTSTR, DWORD) RasCustomDeleteEntryNotifyFn; 
    916 alias DWORD function (HINSTANCE, LPRASDIALEXTENSIONS, 
    917 LPCTSTR, LPRASDIALPARAMS, DWORD, LPVOID, LPHRASCONN, DWORD) RasCustomDialFn; 
    918  
    919 DWORD RasInvokeEapUI (HRASCONN, DWORD, LPRASDIALEXTENSIONS, HWND); 
    920 DWORD RasGetLinkStatistics (HRASCONN, DWORD, RAS_STATS*); 
    921 DWORD RasGetConnectionStatistics (HRASCONN, RAS_STATS*); 
    922 DWORD RasClearLinkStatistics (HRASCONN, DWORD); 
    923 DWORD RasClearConnectionStatistics (HRASCONN); 
    924 DWORD RasGetEapUserDataA (HANDLE, LPCSTR, LPCSTR, BYTE*, DWORD*); 
    925 DWORD RasGetEapUserDataW (HANDLE, LPCWSTR, LPCWSTR, BYTE*, DWORD*); 
    926 DWORD RasSetEapUserDataA (HANDLE, LPCSTR, LPCSTR, BYTE*, DWORD); 
    927 DWORD RasSetEapUserDataW (HANDLE, LPCWSTR, LPCWSTR, BYTE*, DWORD); 
    928 DWORD RasGetCustomAuthDataA (LPCSTR,  LPCSTR, BYTE*,  DWORD*); 
    929 DWORD RasGetCustomAuthDataW (LPCWSTR, LPCWSTR, BYTE*, DWORD*); 
    930 DWORD RasSetCustomAuthDataA (LPCSTR,  LPCSTR, BYTE*,  DWORD); 
    931 DWORD RasSetCustomAuthDataW (LPCWSTR, LPCWSTR, BYTE*, DWORD); 
    932 DWORD RasGetEapUserIdentityW (LPCWSTR, LPCWSTR, DWORD, HWND, LPRASEAPUSERIDENTITYW*); 
    933 DWORD RasGetEapUserIdentityA (LPCSTR, LPCSTR, DWORD, HWND, LPRASEAPUSERIDENTITYA*); 
    934 void ARasFreeEapUserIdentityW (LPRASEAPUSERIDENTITYW); 
    935 void RasFreeEapUserIdentityA (LPRASEAPUSERIDENTITYA); 
     914   alias DWORD function (HRASCONN) RasCustomHangUpFn; 
     915   alias DWORD function (LPCTSTR, LPCTSTR, DWORD) RasCustomDeleteEntryNotifyFn; 
     916   alias DWORD function (HINSTANCE, LPRASDIALEXTENSIONS, 
     917   LPCTSTR, LPRASDIALPARAMS, DWORD, LPVOID, LPHRASCONN, DWORD) RasCustomDialFn; 
     918 
     919   DWORD RasInvokeEapUI (HRASCONN, DWORD, LPRASDIALEXTENSIONS, HWND); 
     920   DWORD RasGetLinkStatistics (HRASCONN, DWORD, RAS_STATS*); 
     921   DWORD RasGetConnectionStatistics (HRASCONN, RAS_STATS*); 
     922   DWORD RasClearLinkStatistics (HRASCONN, DWORD); 
     923   DWORD RasClearConnectionStatistics (HRASCONN); 
     924   DWORD RasGetEapUserDataA (HANDLE, LPCSTR, LPCSTR, BYTE*, DWORD*); 
     925   DWORD RasGetEapUserDataW (HANDLE, LPCWSTR, LPCWSTR, BYTE*, DWORD*); 
     926   DWORD RasSetEapUserDataA (HANDLE, LPCSTR, LPCSTR, BYTE*, DWORD); 
     927   DWORD RasSetEapUserDataW (HANDLE, LPCWSTR, LPCWSTR, BYTE*, DWORD); 
     928   DWORD RasGetCustomAuthDataA (LPCSTR,   LPCSTR, BYTE*,  DWORD*); 
     929   DWORD RasGetCustomAuthDataW (LPCWSTR, LPCWSTR, BYTE*, DWORD*); 
     930   DWORD RasSetCustomAuthDataA (LPCSTR,   LPCSTR, BYTE*,  DWORD); 
     931   DWORD RasSetCustomAuthDataW (LPCWSTR, LPCWSTR, BYTE*, DWORD); 
     932   DWORD RasGetEapUserIdentityW (LPCWSTR, LPCWSTR, DWORD, HWND, LPRASEAPUSERIDENTITYW*); 
     933   DWORD RasGetEapUserIdentityA (LPCSTR, LPCSTR, DWORD, HWND, LPRASEAPUSERIDENTITYA*); 
     934   void RasFreeEapUserIdentityW (LPRASEAPUSERIDENTITYW); 
     935   void RasFreeEapUserIdentityA (LPRASEAPUSERIDENTITYA); 
    936936} 
    937937 
    …… 
    939939/* UNICODE defines for functions */ 
    940940version(Unicode) { 
    941 alias RasDialW RasDial; 
    942 alias RasEnumConnectionsW RasEnumConnections; 
    943 alias RasEnumEntriesW RasEnumEntries; 
    944 alias RasGetConnectStatusW RasGetConnectStatus; 
    945 alias RasGetErrorStringW RasGetErrorString; 
    946 alias RasHangUpW RasHangUp; 
    947 alias RasGetProjectionInfoW RasGetProjectionInfo; 
    948 alias RasCreatePhonebookEntryW RasCreatePhonebookEntry; 
    949 alias RasEditPhonebookEntryW RasEditPhonebookEntry; 
    950 alias RasSetEntryDialParamsW RasSetEntryDialParams; 
    951 alias RasGetEntryDialParamsW RasGetEntryDialParams; 
    952 alias RasEnumDevicesW RasEnumDevices; 
    953 alias RasGetCountryInfoW RasGetCountryInfo; 
    954 alias RasGetEntryPropertiesW RasGetEntryProperties; 
    955 alias RasSetEntryPropertiesW RasSetEntryProperties; 
    956 alias RasRenameEntryW RasRenameEntry; 
    957 alias RasDeleteEntryW RasDeleteEntry; 
    958 alias RasValidateEntryNameW RasValidateEntryName; 
    959  
    960 static if (WINVER >= 0x0401) { 
    961     alias RASADFUNCW RASADFUNC; 
    962     alias RasGetSubEntryHandleW RasGetSubEntryHandle; 
    963     alias RasConnectionNotificationW RasConnectionNotification; 
    964     alias RasGetSubEntryPropertiesW RasGetSubEntryProperties; 
    965     alias RasSetSubEntryPropertiesW RasSetSubEntryProperties; 
    966     alias RasGetCredentialsW RasGetCredentials; 
    967     alias RasSetCredentialsW RasSetCredentials; 
    968     alias RasGetAutodialAddressW RasGetAutodialAddress; 
    969     alias RasSetAutodialAddressW RasSetAutodialAddress; 
    970     alias RasEnumAutodialAddressesW RasEnumAutodialAddresses; 
    971     alias RasGetAutodialEnableW RasGetAutodialEnable; 
    972     alias RasSetAutodialEnableW RasSetAutodialEnable; 
    973     alias RasGetAutodialParamW RasGetAutodialParam; 
    974     alias RasSetAutodialParamW RasSetAutodialParam; 
    975 } 
    976  
    977 static if (WINVER >= 0x0500) { 
    978     alias RasGetEapUserDataW RasGetEapUserData; 
    979     alias RasSetEapUserDataW RasSetEapUserData; 
    980     alias RasGetCustomAuthDataW RasGetCustomAuthData; 
    981     alias RasSetCustomAuthDataW RasSetCustomAuthData; 
    982     alias RasGetEapUserIdentityW RasGetEapUserIdentity; 
    983     alias RasFreeEapUserIdentityW RasFreeEapUserIdentity; 
    984 } 
     941   alias RasDialW RasDial; 
     942   alias RasEnumConnectionsW RasEnumConnections; 
     943   alias RasEnumEntriesW RasEnumEntries; 
     944   alias RasGetConnectStatusW RasGetConnectStatus; 
     945   alias RasGetErrorStringW RasGetErrorString; 
     946   alias RasHangUpW RasHangUp; 
     947   alias RasGetProjectionInfoW RasGetProjectionInfo; 
     948   alias RasCreatePhonebookEntryW RasCreatePhonebookEntry; 
     949   alias RasEditPhonebookEntryW RasEditPhonebookEntry; 
     950   alias RasSetEntryDialParamsW RasSetEntryDialParams; 
     951   alias RasGetEntryDialParamsW RasGetEntryDialParams; 
     952   alias RasEnumDevicesW RasEnumDevices; 
     953   alias RasGetCountryInfoW RasGetCountryInfo; 
     954   alias RasGetEntryPropertiesW RasGetEntryProperties; 
     955   alias RasSetEntryPropertiesW RasSetEntryProperties; 
     956   alias RasRenameEntryW RasRenameEntry; 
     957   alias RasDeleteEntryW RasDeleteEntry; 
     958   alias RasValidateEntryNameW RasValidateEntryName; 
     959 
     960   static if (WINVER >= 0x0401) { 
     961       alias RASADFUNCW RASADFUNC; 
     962       alias RasGetSubEntryHandleW RasGetSubEntryHandle; 
     963       alias RasConnectionNotificationW RasConnectionNotification; 
     964       alias RasGetSubEntryPropertiesW RasGetSubEntryProperties; 
     965       alias RasSetSubEntryPropertiesW RasSetSubEntryProperties; 
     966       alias RasGetCredentialsW RasGetCredentials; 
     967       alias RasSetCredentialsW RasSetCredentials; 
     968       alias RasGetAutodialAddressW RasGetAutodialAddress; 
     969       alias RasSetAutodialAddressW RasSetAutodialAddress; 
     970       alias RasEnumAutodialAddressesW RasEnumAutodialAddresses; 
     971       alias RasGetAutodialEnableW RasGetAutodialEnable; 
     972       alias RasSetAutodialEnableW RasSetAutodialEnable; 
     973       alias RasGetAutodialParamW RasGetAutodialParam; 
     974       alias RasSetAutodialParamW RasSetAutodialParam; 
     975   } 
     976 
     977   static if (WINVER >= 0x0500) { 
     978       alias RasGetEapUserDataW RasGetEapUserData; 
     979       alias RasSetEapUserDataW RasSetEapUserData; 
     980       alias RasGetCustomAuthDataW RasGetCustomAuthData; 
     981       alias RasSetCustomAuthDataW RasSetCustomAuthData; 
     982       alias RasGetEapUserIdentityW RasGetEapUserIdentity; 
     983       alias RasFreeEapUserIdentityW RasFreeEapUserIdentity; 
     984   } 
    985985 
    986986} else { // ! defined UNICODE 
    987 alias RasDialA RasDial; 
    988 alias RasEnumConnectionsA RasEnumConnections; 
    989 alias RasEnumEntriesA RasEnumEntries; 
    990 alias RasGetConnectStatusA RasGetConnectStatus; 
    991 alias RasGetErrorStringA RasGetErrorString; 
    992 alias RasHangUpA RasHangUp; 
    993 alias RasGetProjectionInfoA RasGetProjectionInfo; 
    994 alias RasCreatePhonebookEntryA RasCreatePhonebookEntry; 
    995 alias RasEditPhonebookEntryA RasEditPhonebookEntry; 
    996 alias RasSetEntryDialParamsA RasSetEntryDialParams; 
    997 alias RasGetEntryDialParamsA RasGetEntryDialParams; 
    998 alias RasEnumDevicesA RasEnumDevices; 
    999 alias RasGetCountryInfoA RasGetCountryInfo; 
    1000 alias RasGetEntryPropertiesA RasGetEntryProperties; 
    1001 alias RasSetEntryPropertiesA RasSetEntryProperties; 
    1002 alias RasRenameEntryA RasRenameEntry; 
    1003 alias RasDeleteEntryA RasDeleteEntry; 
    1004 alias RasValidateEntryNameA RasValidateEntryName; 
    1005  
    1006 static if (WINVER >= 0x0401) { 
    1007     alias RASADFUNCA RASADFUNC; 
    1008     alias RasGetSubEntryHandleA RasGetSubEntryHandle; 
    1009     alias RasConnectionNotificationA RasConnectionNotification; 
    1010     alias RasGetSubEntryPropertiesA RasGetSubEntryProperties; 
    1011     alias RasSetSubEntryPropertiesA RasSetSubEntryProperties; 
    1012     alias RasGetCredentialsA RasGetCredentials; 
    1013     alias RasSetCredentialsA RasSetCredentials; 
    1014     alias RasGetAutodialAddressA RasGetAutodialAddress; 
    1015     alias RasSetAutodialAddressA RasSetAutodialAddress; 
    1016     alias RasEnumAutodialAddressesA RasEnumAutodialAddresses; 
    1017     alias RasGetAutodialEnableA RasGetAutodialEnable; 
    1018     alias RasSetAutodialEnableA RasSetAutodialEnable; 
    1019     alias RasGetAutodialParamA RasGetAutodialParam; 
    1020     alias RasSetAutodialParamA RasSetAutodialParam; 
    1021 } 
    1022  
    1023 static if (WINVER >= 0x0500) { 
    1024     alias RasGetEapUserDataA RasGetEapUserData; 
    1025     alias RasSetEapUserDataA RasSetEapUserData; 
    1026     alias RasGetCustomAuthDataA RasGetCustomAuthData; 
    1027     alias RasSetCustomAuthDataA RasSetCustomAuthData; 
    1028     alias RasGetEapUserIdentityA RasGetEapUserIdentity; 
    1029     alias RasFreeEapUserIdentityA RasFreeEapUserIdentity; 
    1030 } 
    1031 }//#endif /* ! UNICODE */ 
    1032  
    1033 align: 
     987    alias RasDialA RasDial; 
     988    alias RasEnumConnectionsA RasEnumConnections; 
     989    alias RasEnumEntriesA RasEnumEntries; 
     990    alias RasGetConnectStatusA RasGetConnectStatus; 
     991    alias RasGetErrorStringA RasGetErrorString; 
     992    alias RasHangUpA RasHangUp; 
     993    alias RasGetProjectionInfoA RasGetProjectionInfo; 
     994    alias RasCreatePhonebookEntryA RasCreatePhonebookEntry; 
     995    alias RasEditPhonebookEntryA RasEditPhonebookEntry; 
     996    alias RasSetEntryDialParamsA RasSetEntryDialParams; 
     997    alias RasGetEntryDialParamsA RasGetEntryDialParams; 
     998    alias RasEnumDevicesA RasEnumDevices; 
     999    alias RasGetCountryInfoA RasGetCountryInfo; 
     1000    alias RasGetEntryPropertiesA RasGetEntryProperties; 
     1001    alias RasSetEntryPropertiesA RasSetEntryProperties; 
     1002    alias RasRenameEntryA RasRenameEntry; 
     1003    alias RasDeleteEntryA RasDeleteEntry; 
     1004    alias RasValidateEntryNameA RasValidateEntryName; 
     1005 
     1006    static if (WINVER >= 0x0401) { 
     1007        alias RASADFUNCA RASADFUNC; 
     1008        alias RasGetSubEntryHandleA RasGetSubEntryHandle; 
     1009        alias RasConnectionNotificationA RasConnectionNotification; 
     1010        alias RasGetSubEntryPropertiesA RasGetSubEntryProperties; 
     1011        alias RasSetSubEntryPropertiesA RasSetSubEntryProperties; 
     1012        alias RasGetCredentialsA RasGetCredentials; 
     1013        alias RasSetCredentialsA RasSetCredentials; 
     1014        alias RasGetAutodialAddressA RasGetAutodialAddress; 
     1015        alias RasSetAutodialAddressA RasSetAutodialAddress; 
     1016        alias RasEnumAutodialAddressesA RasEnumAutodialAddresses; 
     1017        alias RasGetAutodialEnableA RasGetAutodialEnable; 
     1018        alias RasSetAutodialEnableA RasSetAutodialEnable; 
     1019        alias RasGetAutodialParamA RasGetAutodialParam; 
     1020        alias RasSetAutodialParamA RasSetAutodialParam; 
     1021    } 
     1022 
     1023    static if (WINVER >= 0x0500) { 
     1024        alias RasGetEapUserDataA RasGetEapUserData; 
     1025        alias RasSetEapUserDataA RasSetEapUserData; 
     1026        alias RasGetCustomAuthDataA RasGetCustomAuthData; 
     1027        alias RasSetCustomAuthDataA RasSetCustomAuthData; 
     1028        alias RasGetEapUserIdentityA RasGetEapUserIdentity; 
     1029        alias RasFreeEapUserIdentityA RasFreeEapUserIdentity; 
     1030    } 
     1031} //#endif // ! UNICODE 

  • trunk/win32/richedit.d

    r135 r141  
    580580    alias TEXTRANGEA TEXTRANGE; 
    581581} 
    582 align: 

  • trunk/win32/richole.d

    r135 r141  
    5050} 
    5151 
    52 extern (C) { 
    53     extern GUID IID_IRichEditOle; 
    54     extern GUID IID_IRichEditOleCallback; 
    55 } 
     52extern (C) extern const GUID 
     53    IID_IRichEditOle, 
     54    IID_IRichEditOleCallback; 
    5655 
    5756struct REOBJECT { 

  • trunk/win32/secext.d

    r140 r141  
    55pragma(lib, "secur32.lib"); 
    66 
    7 static assert (_WIN32_WINNT >= 0x0500, "SecExt is only available on WindowsXP and later"); 
     7static assert (_WIN32_WINNT >= 0x0501, 
     8  "SecExt is only available on WindowsXP and later"); 
    89 
    910enum EXTENDED_NAME_FORMAT { 
    10   NameUnknown = 0,  
    11   NameFullyQualifiedDN = 1,  
    12   NameSamCompatible = 2,  
    13   NameDisplay = 3,  
    14   NameUniqueId = 6,  
    15   NameCanonical = 7,  
    16   NameUserPrincipal = 8,  
    17   NameCanonicalEx = 9,  
    18   NameServicePrincipal = 10,  
    19   NameDnsDomain = 12 
     11    NameUnknown, 
     12    NameFullyQualifiedDN, 
     13    NameSamCompatible, 
     14    NameDisplay,          // =  3 
     15    NameUniqueId             =  6, 
     16    NameCanonical, 
     17    NameUserPrincipal, 
     18    NameCanonicalEx, 
     19    NameServicePrincipal, // = 10 
     20   NameDnsDomain            = 12 
    2021} 
    2122alias EXTENDED_NAME_FORMAT* PEXTENDED_NAME_FORMAT; 
    2223 
    2324extern (Windows) { 
    24     BOOLEAN GetComputerObjectNameA(EXTENDED_NAME_FORMAT,LPSTR,PULONG); 
    25     BOOLEAN GetComputerObjectNameW(EXTENDED_NAME_FORMAT,LPWSTR,PULONG); 
    26     BOOLEAN GetUserNameExA(EXTENDED_NAME_FORMAT,LPSTR,PULONG); 
    27     BOOLEAN GetUserNameExW(EXTENDED_NAME_FORMAT,LPWSTR,PULONG); 
    28     BOOLEAN TranslateNameA(LPCSTR,EXTENDED_NAME_FORMAT,EXTENDED_NAME_FORMAT,LPSTR,PULONG); 
    29     BOOLEAN TranslateNameW(LPCWSTR,EXTENDED_NAME_FORMAT,EXTENDED_NAME_FORMAT,LPWSTR,PULONG); 
     25    BOOLEAN GetComputerObjectNameA(EXTENDED_NAME_FORMAT, LPSTR, PULONG); 
     26    BOOLEAN GetComputerObjectNameW(EXTENDED_NAME_FORMAT, LPWSTR, PULONG); 
     27    BOOLEAN GetUserNameExA(EXTENDED_NAME_FORMAT, LPSTR, PULONG); 
     28    BOOLEAN GetUserNameExW(EXTENDED_NAME_FORMAT, LPWSTR, PULONG); 
     29    BOOLEAN TranslateNameA(LPCSTR, EXTENDED_NAME_FORMAT, 
     30      EXTENDED_NAME_FORMAT, LPSTR, PULONG); 
     31    BOOLEAN TranslateNameW(LPCWSTR, EXTENDED_NAME_FORMAT, 
     32      EXTENDED_NAME_FORMAT, LPWSTR, PULONG); 
    3033} 
    3134 

  • trunk/win32/setupapi.d

    r127 r141  
    146146    DICD_INHERIT_CLASSDRVS = 0x00000002 
    147147} 
    148      
     148 
    149149enum : DWORD { 
    150150    DICS_ENABLE = 1, 
    …… 
    637637} 
    638638 
    639 enum : DWORD {  
     639enum : DWORD { 
    640640    SPDIT_NODRIVER, 
    641641    SPDIT_CLASSDRIVER, 
    …… 
    13651365} 
    13661366alias SP_BACKUP_QUEUE_PARAMS_W* PSP_BACKUP_QUEUE_PARAMS_W; 
    1367  
    1368 align: 
    13691367 
    13701368version (Unicode) { 

  • trunk/win32/shlguid.d

    r123 r141  
    1919 
    2020extern (C) { 
    21     extern GUID CLSID_ShellDesktop; 
    22     extern GUID CLSID_ShellLink; 
    23     extern GUID FMTID_Intshcut; 
    24     extern GUID FMTID_InternetSite; 
    25     extern GUID CGID_Explorer; 
    26     extern GUID CGID_ShellDocView; 
    27     extern GUID CGID_ShellServiceObject; 
    28     extern GUID IID_INewShortcutHookA; 
    29     extern GUID IID_IShellBrowser; 
    30     extern GUID IID_IShellView; 
    31     extern GUID IID_IContextMenu; 
    32     extern GUID IID_IColumnProvider; 
    33     extern GUID IID_IQueryInfo; 
    34     extern GUID IID_IShellIcon; 
    35     extern GUID IID_IShellIconOverlayIdentifier; 
    36     extern GUID IID_IShellFolder; 
    37     extern GUID IID_IShellExtInit; 
    38     extern GUID IID_IShellPropSheetExt; 
    39     extern GUID IID_IPersistFolder; 
    40     extern GUID IID_IExtractIconA; 
    41     extern GUID IID_IShellLinkA; 
    42     extern GUID IID_IShellCopyHookA; 
    43     extern GUID IID_IFileViewerA; 
    44     extern GUID IID_ICommDlgBrowser; 
    45     extern GUID IID_IEnumIDList; 
    46     extern GUID IID_IFileViewerSite; 
    47     extern GUID IID_IContextMenu2; 
    48     extern GUID IID_IShellExecuteHookA; 
    49     extern GUID IID_IPropSheetPage; 
    50     extern GUID IID_INewShortcutHookW; 
    51     extern GUID IID_IFileViewerW; 
    52     extern GUID IID_IShellLinkW; 
    53     extern GUID IID_IExtractIconW; 
    54     extern GUID IID_IShellExecuteHookW; 
    55     extern GUID IID_IShellCopyHookW; 
    56     extern GUID IID_IShellView2; 
    57     extern GUID LIBID_SHDocVw; 
    58     extern GUID IID_IShellExplorer; 
    59     extern GUID DIID_DShellExplorerEvents; 
    60     extern GUID CLSID_ShellExplorer; 
    61     extern GUID IID_ISHItemOC; 
    62     extern GUID DIID_DSHItemOCEvents; 
    63     extern GUID CLSID_SHItemOC; 
    64     extern GUID IID_DHyperLink; 
    65     extern GUID IID_DIExplorer; 
    66     extern GUID DIID_DExplorerEvents; 
    67     extern GUID CLSID_InternetExplorer; 
    68     extern GUID CLSID_StdHyperLink; 
    69     extern GUID CLSID_FileTypes; 
    70     extern GUID CLSID_InternetShortcut; 
    71     extern GUID IID_IUniformResourceLocator; 
    72     extern GUID CLSID_DragDropHelper; 
    73     extern GUID IID_IDropTargetHelper; 
    74     extern GUID IID_IDragSourceHelper; 
    75     extern GUID CLSID_AutoComplete; 
    76     extern GUID IID_IAutoComplete; 
    77     extern GUID IID_IAutoComplete2; 
    78     extern GUID CLSID_ACLMulti; 
    79     extern GUID IID_IObjMgr; 
    80     extern GUID CLSID_ACListISF; 
    81     extern GUID IID_IACList; 
     21    extern const GUID 
     22        CLSID_ShellDesktop, 
     23        CLSID_ShellLink, 
     24        FMTID_Intshcut, 
     25        FMTID_InternetSite, 
     26        CGID_Explorer, 
     27        CGID_ShellDocView, 
     28        CGID_ShellServiceObject, 
     29        IID_INewShortcutHookA, 
     30        IID_IShellBrowser, 
     31        IID_IShellView, 
     32        IID_IContextMenu, 
     33        IID_IColumnProvider, 
     34        IID_IQueryInfo, 
     35        IID_IShellIcon, 
     36        IID_IShellIconOverlayIdentifier, 
     37        IID_IShellFolder, 
     38        IID_IShellExtInit, 
     39        IID_IShellPropSheetExt, 
     40        IID_IPersistFolder, 
     41        IID_IExtractIconA, 
     42        IID_IShellLinkA, 
     43        IID_IShellCopyHookA, 
     44        IID_IFileViewerA, 
     45        IID_ICommDlgBrowser, 
     46        IID_IEnumIDList, 
     47        IID_IFileViewerSite, 
     48        IID_IContextMenu2, 
     49        IID_IShellExecuteHookA, 
     50        IID_IPropSheetPage, 
     51        IID_INewShortcutHookW, 
     52        IID_IFileViewerW, 
     53        IID_IShellLinkW, 
     54        IID_IExtractIconW, 
     55        IID_IShellExecuteHookW, 
     56        IID_IShellCopyHookW, 
     57        IID_IShellView2, 
     58        LIBID_SHDocVw, 
     59        IID_IShellExplorer, 
     60        DIID_DShellExplorerEvents, 
     61        CLSID_ShellExplorer, 
     62        IID_ISHItemOC, 
     63        DIID_DSHItemOCEvents, 
     64        CLSID_SHItemOC, 
     65        IID_DHyperLink, 
     66        IID_DIExplorer, 
     67        DIID_DExplorerEvents, 
     68        CLSID_InternetExplorer, 
     69        CLSID_StdHyperLink, 
     70        CLSID_FileTypes, 
     71        CLSID_InternetShortcut, 
     72        IID_IUniformResourceLocator, 
     73        CLSID_DragDropHelper, 
     74        IID_IDropTargetHelper, 
     75        IID_IDragSourceHelper, 
     76        CLSID_AutoComplete, 
     77        IID_IAutoComplete, 
     78        IID_IAutoComplete2, 
     79        CLSID_ACLMulti, 
     80        IID_IObjMgr, 
     81        CLSID_ACListISF, 
     82        IID_IACList; 
    8283 
    8384    static if (_WIN32_IE >= 0x400 || _WIN32_WINNT >= 0x500) { 
    84         extern GUID IID_IPersistFolder2; 
     85        extern const GUID IID_IPersistFolder2; 
    8586    } 
    8687 
    8788    static if (_WIN32_WINNT >= 0x0500) { 
    88         extern GUID IID_IPersistFolder3; 
    89         extern GUID IID_IShellFolder2; 
    90         extern GUID IID_IFileSystemBindData; 
     89        extern const GUID 
     90            IID_IPersistFolder3, 
     91            IID_IShellFolder2, 
     92            IID_IFileSystemBindData; 
    9193    } 
    9294} 

  • trunk/win32/shlwapi.d

    r128 r141  
    6363    ULONGLONG ullVersion; 
    6464} 
    65 align: 
    6665 
    6766enum ASSOCSTR { 
    …… 
    127126extern (Windows) 
    128127{ 
    129 alias HRESULT function (DLLVERSIONINFO *) DLLGETVERSIONPROC; 
     128   alias HRESULT function (DLLVERSIONINFO *) DLLGETVERSIONPROC; 
    130129} 
    131130 
    132131 
    133132BOOL IntlStrEqNA(LPCSTR pStr1, LPCSTR pStr2, int nChar) 
    134 {  
     133{ 
    135134    return IntlStrEqWorkerA(TRUE, pStr1, pStr2, nChar); 
    136135} 
    137136 
    138137BOOL IntlStrEqNW(LPCWSTR pStr1, LPCWSTR pStr2, int nChar) 
    139 {  
     138{ 
    140139    return IntlStrEqWorkerW(TRUE, pStr1, pStr2, nChar); 
    141140} 
    142141 
    143142BOOL IntlStrEqNIA(LPCSTR pStr1, LPCSTR pStr2, int nChar) 
    144 {  
     143{ 
    145144    return IntlStrEqWorkerA(FALSE, pStr1, pStr2, nChar); 
    146145} 
    147146 
    148147BOOL IntlStrEqNIW(LPCWSTR pStr1, LPCWSTR pStr2, int nChar) 
    149 {  
     148{ 
    150149    return IntlStrEqWorkerW(FALSE, pStr1, pStr2, nChar); 
    151150} 

  • trunk/win32/testcompile.bat

    r137 r141  
    2020@if errorlevel 1 goto abort 
    2121dmd -I.. -c -version=Win32_Winsock2 all.d 
     22@if errorlevel 1 goto abort 
     23@rem Do we really need to test version=Unicode under all combinations? 
     24dmd -I.. -c -version=Unicode all.d 
     25@if errorlevel 1 goto abort 
     26dmd -I.. -c -version=Unicode -version=Windows98 all.d 
     27@if errorlevel 1 goto abort 
     28dmd -I.. -c -version=Unicode -version=WindowsME all.d 
     29@if errorlevel 1 goto abort 
     30dmd -I.. -c -version=Unicode -version=WindowsNTonly all.d 
     31@if errorlevel 1 goto abort 
     32dmd -I.. -c -version=Unicode -version=Windows2000 all.d 
     33@if errorlevel 1 goto abort 
     34dmd -I.. -c -version=Unicode -version=Windows98 -version=Windows2000 all.d 
     35@if errorlevel 1 goto abort 
     36dmd -I.. -c -version=Unicode -version=WindowsME -version=Windows2000 all.d 
     37@if errorlevel 1 goto abort 
     38dmd -I.. -c -version=Unicode -version=WindowsNTonly -version=Windows2000 all.d 
     39@if errorlevel 1 goto abort 
     40dmd -I.. -c -version=Unicode -version=WindowsXP all.d 
     41@if errorlevel 1 goto abort 
     42dmd -I.. -c -version=Unicode -version=Windows2003 all.d 
     43@if errorlevel 1 goto abort 
     44dmd -I.. -c -version=Unicode -version=Win32_Winsock2 all.d 
    2245:abort 

  • trunk/win32/vfw.d

    r135 r141  
    12511251    alias MCIWNDM_OPENA MCIWNDM_OPEN; 
    12521252} 
    1253 align: 

  • trunk/win32/winnt.d

    r137 r141  
    123123 
    124124const ANYSIZE_ARRAY=1; 
    125      
     125 
    126126// Access Mask Format 
    127 const ACCESS_MASK  
     127const ACCESS_MASK 
    128128    DELETE                   = 0x00010000, 
    129129    READ_CONTROL             = 0x00020000, 
    …… 
    614614    SORT_CHINESE_UNICODE      = 1, 
    615615    SORT_CHINESE_PRC          = 2, 
    616     SORT_CHINESE_BOPOMOFO     = 3,  
     616    SORT_CHINESE_BOPOMOFO     = 3, 
    617617    SORT_KOREAN_KSC           = 0, 
    618618    SORT_KOREAN_UNICODE       = 1, 
    …… 
    32203220alias ADMINISTRATOR_POWER_POLICY* PADMINISTRATOR_POWER_POLICY; 
    32213221 
    3222 align: 
    3223  
    32243222//}//#endif /* WINVER >= 0x0500 */ 
    32253223 
    32263224static if (_WIN32_WINNT >= 0x0500) { 
    3227     alias void function (PVOID,BOOLEAN) WAITORTIMERCALLBACKFUNC; 
     3225    alias void function (PVOID, BOOLEAN) WAITORTIMERCALLBACKFUNC; 
    32283226} 
    32293227 

  • trunk/win32/winsock.d

    r129 r141  
    1919 
    2020// DRK: This module should not be included if -version=Win32_Winsock2 has 
    21 // been set.  If it has, assert.  I think it's better that way then letting 
     21// been set.  If it has, assert.  I think it's better that way than letting 
    2222// the user believe that it's worked. 
    2323version(Win32_Winsock2) { 

  • trunk/win32/winsock2.d

    r135 r141  
    2222 
    2323// DRK: This module should not be included if -version=Win32_Winsock2 has 
    24 // not been set.  If it has, assert.  I think it's better this way then 
     24// not been set.  If it has, assert.  I think it's better this way than 
    2525// letting the user believe that it's worked. 
    2626version(Win32_Winsock2) {}