Ignore:
Timestamp:
Jun 12, 2000, 10:09:48 AM (25 years ago)
Author:
phaller
Message:

.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/shlwapi/ordinal.cpp

    r3684 r3687  
    1 /* $Id: ordinal.cpp,v 1.1 2000-06-11 08:44:53 phaller Exp $ */
     1/* $Id: ordinal.cpp,v 1.2 2000-06-12 08:09:37 phaller Exp $ */
    22
    33/*
    … …  
    5252#include "heap.h"
    5353
     54#include "win/wine/obj_base.h"
    5455#include "shellapi.h"
    5556#include "shlobj.h"
    … …  
    7172
    7273HANDLE WIN32API SHLWAPI_11(HANDLE, DWORD, DWORD, DWORD, DWORD);
    73 DWORD  WIN32API SHLWAPI_95(HWND, LPWSTR, int);
     74
     75
     76#define debugstr_guid(a) a
    7477
    7578
    … …  
    555558
    556559
     560/*****************************************************************************
     561 * Name      : ???
     562 * Purpose   : Unknown (used by explorer.exe)
     563 * Parameters: Unknown (wrong)
     564 * Variables :
     565 * Result    : Unknown
     566 * Remark    :
     567 * Status    : UNTESTED STUB
     568 *
     569 * Author    : Patrick Haller [Sun, 2000/06/09 04:47]
     570 *****************************************************************************/
     571
     572ODINFUNCTION2(DWORD,SHLWAPI_17,
     573              DWORD, arg0,
     574              DWORD, arg1)
     575{
     576  dprintf(("not implemented, explorer.exe will trap now"));
     577
     578  return 0;
     579}
     580
     581
     582/*****************************************************************************
     583 * Name      : ???
     584 * Purpose   : Unknown (used by explorer.exe)
     585 * Parameters: Unknown (wrong)
     586 * Variables :
     587 * Result    : Unknown
     588 * Remark    :
     589 * Status    : UNTESTED STUB
     590 *
     591 * Author    : Patrick Haller [Sun, 2000/06/09 04:47]
     592 *****************************************************************************/
     593
     594ODINFUNCTION2(DWORD,SHLWAPI_18,
     595              DWORD, arg0,
     596              DWORD, arg1)
     597{
     598  dprintf(("not implemented, explorer.exe will trap now"));
     599
     600  return 0;
     601}
     602
     603
     604/*****************************************************************************
     605 * Name      : SHLWAPI_19
     606 * Purpose   : Free memory
     607 * Parameters: LPVOID lpMem
     608 * Variables :
     609 * Result    :
     610 * Remark    : SHLWAPI.19
     611 * Status    : UNTESTED
     612 *
     613 * Author    : Patrick Haller [Sun, 2000/06/09 04:47]
     614 *****************************************************************************/
     615
     616ODINPROCEDURE1(SHLWAPI_19,
     617               HLOCAL, hMem)
     618{
     619  if (hMem != NULL)
     620    LocalFree(hMem);
     621}
     622
     623
     624/*****************************************************************************
     625 * Name      : ???
     626 * Purpose   : Unknown (used by explorer.exe)
     627 * Parameters: Unknown (wrong)
     628 * Variables :
     629 * Result    : Unknown
     630 * Remark    :
     631 * Status    : UNTESTED STUB
     632 *
     633 * Author    : Patrick Haller [Sun, 2000/06/09 04:47]
     634 *****************************************************************************/
     635
     636ODINFUNCTION2(DWORD,SHLWAPI_20,
     637              DWORD, arg0,
     638              DWORD, arg1)
     639{
     640  dprintf(("not implemented, explorer.exe will trap now"));
     641
     642  return 0;
     643}
     644
     645
     646/*****************************************************************************
     647 * Name      : ???
     648 * Purpose   : Unknown (used by explorer.exe)
     649 * Parameters: Unknown (wrong)
     650 * Variables :
     651 * Result    : Unknown
     652 * Remark    :
     653 * Status    : UNTESTED STUB
     654 *
     655 * Author    : Patrick Haller [Sun, 2000/06/09 04:47]
     656 *****************************************************************************/
     657
     658ODINFUNCTION2(DWORD,SHLWAPI_21,
     659              DWORD, arg0,
     660              DWORD, arg1)
     661{
     662  dprintf(("not implemented, explorer.exe will trap now"));
     663
     664  return 0;
     665}
     666
     667
     668/*****************************************************************************
     669 * Name      : ???
     670 * Purpose   : Unknown (used by explorer.exe)
     671 * Parameters: Unknown (wrong)
     672 * Variables :
     673 * Result    : Unknown
     674 * Remark    :
     675 * Status    : UNTESTED STUB
     676 *
     677 * Author    : Patrick Haller [Sun, 2000/06/09 04:47]
     678 *****************************************************************************/
     679
     680ODINFUNCTION2(DWORD,SHLWAPI_22,
     681              DWORD, arg0,
     682              DWORD, arg1)
     683{
     684  dprintf(("not implemented, explorer.exe will trap now"));
     685
     686  return 0;
     687}
     688
    557689
    558690/*****************************************************************************
    … …  
    561693 * Parameters:
    562694 * Variables :
    563  * Result    :
    564  * Remark    :
     695 * Result    : returns strlen(str)
     696 * Remark    : converts a guid to a string
    565697 * Status    : UNTESTED STUB
    566698 *
    … …  
    568700 *****************************************************************************/
    569701
    570 ODINFUNCTION3(DWORD,SHLWAPI_23,
    571               DWORD,arg0,
    572               DWORD,arg1,
    573               DWORD,arg2)
    574 {
    575   dprintf(("not yet implemented"));
    576 
    577   return 0;
     702ODINFUNCTION3(DWORD,  SHLWAPI_23,
     703              REFGUID,guid,  /* [in]  clsid */
     704              LPSTR,  str,     /* [out] buffer */
     705              INT,    cmax) /* [in]  size of buffer */
     706{
     707    char xguid[80];
     708   
     709    TRACE("(%s %p 0x%08x)stub\n", debugstr_guid(guid), str, cmax);
     710   
     711    if (WINE_StringFromCLSID(guid,xguid)) return 0;
     712    if (strlen(xguid)>=cmax) return 0;
     713    strcpy(str,xguid);
     714    return strlen(xguid) + 1;
     715}
     716
     717
     718/*************************************************************************
     719*      SHLWAPI_24  [SHLWAPI.24]
     720*
     721* NOTES
     722*   converts a guid to a string
     723*   returns strlen(str)
     724*/
     725ODINFUNCTION3(DWORD,   SHLWAPI_24,
     726              REFGUID, guid,   /* [in]  clsid */
     727              LPWSTR,  str,    /* [out] buffer */
     728              INT,     cmax)   /* [in]  size of buffer */
     729{
     730  TRACE("(%s %p 0x%08x)stub\n", debugstr_guid(guid), str, cmax);
     731  return StringFromGUID2(guid, str, cmax);
    578732}
    579733
    … …  
    601755
    602756/*****************************************************************************
    603  * Name      : LRESULT CallWindowProcAW
    604  * Purpose   :
     757 * Name      : SHLWAPI_30
     758 * Purpose   : Check for whitespace in ascii and unicode ?
    605759 * Parameters:
    606760 * Variables :
    607761 * Result    :
    608  * Remark    : SHLWAPI.37
     762 * Remark    :
    609763 * Status    : UNTESTED
    610764 *
    … …  
    612766 *****************************************************************************/
    613767
    614 ODINFUNCTION5(LRESULT,      CallWindowProcAW,
    615               WNDPROC,      lpPrevWndFunc,
    616               HWND,         hWnd,
    617               UINT,         Msg,
    618               WPARAM,       wParam,
    619               LPARAM,       lParam)
    620 {
    621   if (VERSION_OsIsUnicode())
    622     return CallWindowProcW(lpPrevWndFunc, hWnd, Msg, wParam, lParam);
     768ODINFUNCTION1(DWORD,SHLWAPI_30,
     769              WORD, ch)
     770{
     771  if ( (ch == 0x09)   || // tab
     772       (ch == 0x20)   || // space
     773       (ch == 0x3000) ||
     774       (ch == 0xFEFF) )
     775    return 1;
    623776  else
    624     return CallWindowProcA(lpPrevWndFunc, hWnd, Msg, wParam, lParam);
    625 }
    626 
    627 
    628 /*****************************************************************************
    629  * Name      : SHLWAPI_38
    630  * Purpose   :
    631  * Parameters:
    632  * Variables :
    633  * Result    :
    634  * Remark    :
    635  * Status    : UNTESTED STUB
     777    return 0;
     778}
     779
     780
     781
     782/*****************************************************************************
     783 * Name      : DWORD SHLWAPI_156
     784 * Purpose   : Case-sensitive wide string compare
     785 * Parameters: LPSTR lpStr1
     786 *             LPSTR lpStr2
     787 * Variables :
     788 * Result    : case-sensitive comparsion result between the two strings
     789 * Remark    : SHLWAPI.158
     790 * Status    : UNTESTED
    636791 *
    637792 * Author    : Patrick Haller [Sun, 2000/06/10 04:02]
    638793 *****************************************************************************/
    639794
    640 ODINFUNCTION1(DWORD,SHLWAPI_38,
    641               DWORD,arg0)
    642 {
    643   dprintf(("not yet implemented"));
    644 
    645   return 0;
    646 }
    647 
    648 
    649 /*****************************************************************************
    650  * Name      : SHLWAPI_40
    651  * Purpose   : looks like CharNextW
    652  * Parameters:
    653  * Variables :
    654  * Result    :
    655  * Remark    :
    656  * Status    : UNTESTED
    657  *
    658  * Author    : Patrick Haller [Sun, 2000/06/10 04:02]
    659  *****************************************************************************/
    660 
    661 ODINFUNCTION1(LPWSTR, SHLWAPI_40,
    662               LPWSTR, lpChar)
    663 {
    664    if (*lpChar == 0)
    665      return lpChar;
    666    else
    667      return lpChar++;
    668 }
    669 
    670 
    671 /*****************************************************************************
    672  * Name      : SHLWAPI_43
    673  * Purpose   :
    674  * Parameters:
    675  * Variables :
    676  * Result    :
    677  * Remark    :
    678  * Status    : UNTESTED STUB
    679  *
    680  * Author    : Patrick Haller [Sun, 2000/06/10 04:02]
    681  *****************************************************************************/
    682 
    683 ODINFUNCTION1(DWORD,SHLWAPI_43,
    684               DWORD,arg0)
    685 {
    686   dprintf(("not yet implemented"));
    687 
    688   return 0;
    689 }
    690 
    691 
    692 /*****************************************************************************
    693  * Name      : SHLWAPI_53
    694  * Purpose   : Character base independend CreateFontIndirect
    695  * Parameters:
    696  * Variables :
    697  * Result    :
    698  * Remark    :
    699  * Status    : UNTESTED
    700  *
    701  * Author    : Patrick Haller [Sun, 2000/06/10 04:02]
    702  *****************************************************************************/
    703 
    704 ODINFUNCTION1(DWORD,            SHLWAPI_53,
    705               CONST LOGFONTW *, lplf)
    706 {
    707   if (VERSION_OsIsUnicode())
    708     return CreateFontIndirectW(lplf);
    709   else
    710   {
    711     // Original:
    712     // convert lplf to LOGFONTA
    713     // call CreateFontIndirectA
    714     return CreateFontIndirectW(lplf);
    715   }
    716 }
    717 
    718 
    719 /*****************************************************************************
    720  * Name      : LRESULT sDefWindowProcAW
    721  * Purpose   :
    722  * Parameters:
    723  * Variables :
    724  * Result    :
    725  * Remark    : SHLWAPI.56 - this procedure has static unicode behaviour
    726  * Status    : UNTESTED
    727  *
    728  * Author    : Patrick Haller [Sun, 2000/06/10 04:02]
    729  *****************************************************************************/
    730 
    731 ODINFUNCTION4(LRESULT,      sDefWindowProcAW,
    732               HWND,         hWnd,
    733               UINT,         Msg,
    734               WPARAM,       wParam,
    735               LPARAM,       lParam)
    736 {
    737   if (VERSION_OsIsUnicode())
    738     return DefWindowProcW(hWnd, Msg, wParam, lParam);
    739   else
    740     return DefWindowProcA(hWnd, Msg, wParam, lParam);
    741 }
    742 
    743 
    744 /*****************************************************************************
    745  * Name      : SHLWAPI_59
    746  * Purpose   : DialogBoxParamAW
    747  * Parameters:
    748  * Variables :
    749  * Result    :
    750  * Remark    :
    751  * Status    : UNTESTED
    752  *
    753  * Author    : Patrick Haller [Sun, 2000/06/10 04:02]
    754  *****************************************************************************/
    755 
    756 ODINFUNCTION5(DWORD,     SHLWAPI_59,
    757               HINSTANCE, hInstance,
    758               LPCSTR,    lpTemplateName,
    759               HWND,      hWndParent,
    760               DLGPROC,   lpDialogFunc,
    761               LPARAM,    dwInitParam)
    762 {
    763   // PH Note: originally, here are some heavy hooks into Internet Explorer
    764   // and tons of language support stuff.
    765  
    766   if (VERSION_OsIsUnicode())
    767     return DialogBoxParamW(hInstance,
    768                            (LPCWSTR)lpTemplateName,
    769                            hWndParent,
    770                            lpDialogFunc,
    771                            dwInitParam);
    772   else
    773     return DialogBoxParamA(hInstance,
    774                            lpTemplateName,
    775                            hWndParent,
    776                            lpDialogFunc,
    777                            dwInitParam);
    778 }
    779 
    780 
    781 /*****************************************************************************
    782  * Name      : LONG DispatchMessage
    783  * Purpose   :
    784  * Parameters:
    785  * Variables :
    786  * Result    :
    787  * Remark    : SHLWAPI.60
    788  * Status    : UNTESTED
    789  *
    790  * Author    : Patrick Haller [Sun, 2000/06/10 04:02]
    791  *****************************************************************************/
    792 
    793 ODINFUNCTION1(LONG,       DispatchMessageAW,
    794               const MSG*, lpmsg)
    795 {
    796   if (VERSION_OsIsUnicode())
    797     return DispatchMessageW(lpmsg);
    798   else
    799     return DispatchMessageA(lpmsg);
    800 }
    801 
    802 
    803 /*****************************************************************************
    804  * Name      : SHLWAPI_74
    805  * Purpose   : Sort of GetDlgItemText
    806  * Parameters:
    807  * Variables :
    808  * Result    :
    809  * Remark    :
    810  * Status    : UNTESTED
    811  *
    812  * Author    : Patrick Haller [Sun, 2000/06/10 04:02]
    813  *****************************************************************************/
    814 
    815 ODINFUNCTION4(DWORD,     SHLWAPI_74,
    816               HWND,      hDlg,
    817               int,       nIDDlgItem,
    818               LPWSTR,    lpText,
    819               int,       nMaxCount)
    820 {
    821   HWND hwndItem = GetDlgItem(hDlg,
    822                              nIDDlgItem);
    823   if (hwndItem == NULL)
    824   {
    825     if (nMaxCount != 0)  // PH Note: bug in original windows code
    826       *lpText = 0;
    827    
    828     return NULL;
    829   }
    830  
    831   // else retrieve the text
    832   return SHLWAPI_95(hwndItem,
    833                     lpText,
    834                     nMaxCount);
    835 }
    836 
    837 
    838 /*****************************************************************************
    839  * Name      : HMODULE GetModuleHandleAW
    840  * Purpose   :
    841  * Parameters:
    842  * Variables :
    843  * Result    :
    844  * Remark    : SHLWAPI.83 - check back with original code, result may be wrong
    845  * Status    : UNTESTED
    846  *
    847  * Author    : Patrick Haller [Sun, 2000/06/10 04:02]
    848  *****************************************************************************/
    849 
    850 ODINFUNCTION1(HMODULE, GetModuleHandleAW,
    851               LPWSTR,  lpModuleName)
    852 {
    853   if (VERSION_OsIsUnicode())
    854     return GetModuleHandleW(lpModuleName);
    855   else
    856   {
    857     dprintf(("error: unicode to ascii conversion missing"));
    858     return GetModuleHandleA((LPSTR)lpModuleName);
    859   }
    860 }
    861 
    862 
    863 /*****************************************************************************
    864  * Name      : LONG GetWindowLongAW
    865  * Purpose   :
    866  * Parameters:
    867  * Variables :
    868  * Result    :
    869  * Remark    : SHLWAPI.94
    870  * Status    : UNTESTED
    871  *
    872  * Author    : Patrick Haller [Sun, 2000/06/10 04:02]
    873  *****************************************************************************/
    874 
    875 ODINFUNCTION2(LONG,    GetWindowLongAW,
    876               HWND,    hWnd,
    877               int,     nIndex)
    878 {
    879   if (VERSION_OsIsUnicode())
    880     return GetWindowLongW(hWnd, nIndex);
    881   else
    882     return GetWindowLongA(hWnd, nIndex);
    883 }
    884 
    885 
    886 /*****************************************************************************
    887  * Name      : SHLWAPI_95
    888  * Purpose   :
    889  * Parameters:
    890  * Variables :
    891  * Result    :
    892  * Remark    :
    893  * Status    : UNTESTED
    894  *
    895  * Author    : Patrick Haller [Sun, 2000/06/10 04:02]
    896  *****************************************************************************/
    897 
    898 ODINFUNCTION3(DWORD,     SHLWAPI_95,
    899               HWND,      hwndItem,
    900               LPWSTR,    lpText,
    901               int,       nMaxCount)
    902 {
    903   dprintf(("not properly implemented.\n"));
    904  
    905   // @@@PH too simple, original deals with some properties and stuff
    906   if (VERSION_OsIsUnicode())
    907     return GetWindowTextW(hwndItem,
    908                           lpText,
    909                           nMaxCount);
    910   else
    911   {
    912     // @@@PH unicode conversion is missing
    913     return GetWindowTextA(hwndItem,
    914                           (LPSTR)lpText,
    915                           nMaxCount);
    916   }
    917 }
    918 
    919 
    920 /*****************************************************************************
    921  * Name      : HCURSOR LoadCursorAW
    922  * Purpose   :
    923  * Parameters:
    924  * Variables :
    925  * Result    :
    926  * Remark    : SHLWAPI.102
    927  * Status    : UNTESTED
    928  *
    929  * Author    : Patrick Haller [Sun, 2000/06/10 04:02]
    930  *****************************************************************************/
    931 
    932 ODINFUNCTION2(HCURSOR,   LoadCursorAW,
    933               HINSTANCE, hInstance,
    934               LPCSTR,    lpCursorName)
    935 {
    936   if (VERSION_OsIsUnicode())
    937     return LoadCursorW(hInstance, (LPCWSTR)lpCursorName);
    938   else
    939     return LoadCursorA(hInstance, lpCursorName);
    940 }
    941 
    942 
    943 /*****************************************************************************
    944  * Name      : BOOL PeekMessageAW
    945  * Purpose   :
    946  * Parameters:
    947  * Variables :
    948  * Result    :
    949  * Remark    : SHLWAPI.116
    950  * Status    : UNTESTED
    951  *
    952  * Author    : Patrick Haller [Sun, 2000/06/10 04:02]
    953  *****************************************************************************/
    954 
    955 ODINFUNCTION5(BOOL,    PeekMessageAW,
    956               LPMSG,   lpMsg,
    957               HWND,    hWnd,
    958               UINT,    uMsgFilterMin,
    959               UINT,    uMsgFilterMax,
    960               UINT,    wRemoveMsg)
    961 {
    962   if (VERSION_OsIsUnicode())
    963     return PeekMessageW(lpMsg, hWnd, uMsgFilterMin, uMsgFilterMax, wRemoveMsg);
    964   else
    965     return PeekMessageA(lpMsg, hWnd, uMsgFilterMin, uMsgFilterMax, wRemoveMsg);
    966 }
    967 
    968 
    969 /*****************************************************************************
    970  * Name      : BOOL PostMessageAW
    971  * Purpose   :
    972  * Parameters:
    973  * Variables :
    974  * Result    :
    975  * Remark    : SHLWAPI.117
    976  * Status    : UNTESTED
    977  *
    978  * Author    : Patrick Haller [Sun, 2000/06/10 04:02]
    979  *****************************************************************************/
    980 
    981 ODINFUNCTION4(BOOL,    PostMessageAW,
    982               HWND,    hWnd,
    983               UINT,    Msg,
    984               WPARAM,  wParam,
    985               LPARAM,  lParam)
    986 {
    987   if (VERSION_OsIsUnicode())
    988     return PostMessageW(hWnd, Msg, wParam, lParam);
    989   else
    990     return PostMessageA(hWnd, Msg, wParam, lParam);
     795ODINFUNCTION2(DWORD,  SHLWAPI_156,
     796              LPWSTR, str1,   /* "shell32.dll" */
     797              LPWSTR, str2)   /* "shell32.dll" */
     798{
     799  return lstrcmpW(str1,str2);
    991800}
    992801
    … …  
    1035844  /* OK, strings compared til end of string1 */
    1036845  return 0;
     846}
     847
     848
     849/*****************************************************************************
     850 * Name      : DWORD SHLWAPI_160
     851 * Purpose   :
     852 * Parameters:
     853 * Variables :
     854 * Result    :
     855 * Remark    : SHLWAPI.160
     856 * Status    : UNTESTED STUB
     857 *
     858 * Author    : Patrick Haller [Sun, 2000/06/10 04:02]
     859 *****************************************************************************/
     860
     861ODINFUNCTION2(DWORD,  SHLWAPI_160,
     862              DWORD,  arg0,
     863              DWORD,  arg1)
     864{
     865  dprintf(("not implemented.\n"));
     866  return 0;
     867}
     868
     869
     870
     871/*************************************************************************
     872*      SHLWAPI_169 [SHLWAPI]
     873*/
     874ODINFUNCTION1(DWORD,       SHLWAPI_169,
     875              IUnknown **, lplpUnknown)
     876{
     877  IUnknown *lpUnknown;
     878 
     879  if (lplpUnknown == NULL)
     880    return 0;
     881 
     882  lpUnknown = *lplpUnknown;
     883  if (lpUnknown == NULL)
     884    return 0;
     885 
     886  *lplpUnknown = NULL; // kill object pointer
     887 
     888  // and still call the object's release method
     889  return IUnknown_Release(lpUnknown);
     890}
     891
     892
     893/*****************************************************************************
     894 * Name      : LPSTR SHLWAPI_170
     895 * Purpose   : verify if current string position is "//" or not
     896 *             skip "//" ...
     897 * Parameters: LPSTR lpStr
     898 * Variables :
     899 * Result    : lpStr + 2 or NULL
     900 * Remark    : SHLWAPI.170
     901 * Status    : UNTESTED
     902 *
     903 * Author    : Patrick Haller [Sun, 2000/06/10 04:02]
     904 *****************************************************************************/
     905
     906ODINFUNCTION1(LPSTR, SHLWAPI_170,
     907              LPSTR, lpStr)
     908{
     909  if ( (lpStr      != NULL) &&
     910       (*lpStr     == '/' ) &&
     911       (*(lpStr+1) == '/' ) )
     912    return lpStr+2;
     913  else
     914    return lpStr;
     915}
     916
     917
     918/*************************************************************************
     919*      SHLWAPI_193 [SHLWAPI]
     920* query current color depth
     921*/
     922ODINFUNCTION0(DWORD, SHLWAPI_193)
     923{
     924  HDC hdc;
     925  DWORD ret;
     926 
     927  hdc = GetDC(0);
     928  ret = GetDeviceCaps(hdc, BITSPIXEL) * GetDeviceCaps(hdc, PLANES);
     929  ReleaseDC(0, hdc);
     930  return ret;
    1037931}
    1038932
    … …  
    1073967
    1074968
     969/*************************************************************************
     970*      SHLWAPI_219 [SHLWAPI]
     971*/
     972ODINFUNCTION4(HRESULT, SHLWAPI_219,
     973              LPVOID,  w, /* returned by LocalAlloc */
     974              LPVOID,  x,
     975              LPVOID,  y,
     976              LPWSTR,  z) /* OUT: path */
     977{
     978  FIXME("(%p %p %p %p)stub\n",w,x,y,z);
     979  return 0xabba1252;
     980}
     981
     982
     983/*************************************************************************
     984*      SHLWAPI_222 [SHLWAPI]
     985*
     986* NOTES
     987*  securityattributes missing
     988*/
     989ODINFUNCTION1(HANDLE,  SHLWAPI_222,
     990              LPCLSID, guid)
     991{
     992  char lpstrName[80];
     993  strcpy( lpstrName,"shell.");
     994  WINE_StringFromCLSID(guid, lpstrName + strlen(lpstrName));
     995 
     996  FIXME("(%s) stub\n", lpstrName);
     997  return CreateSemaphoreA(NULL,0, 0x7fffffff, lpstrName);
     998}
     999
     1000
     1001/*************************************************************************
     1002*      SHLWAPI_223 [SHLWAPI]
     1003*
     1004* NOTES
     1005*  function guessed
     1006*/
     1007ODINFUNCTION1(DWORD,  SHLWAPI_223,
     1008              HANDLE, handle)
     1009{
     1010  LONG oldCount;
     1011 
     1012  FIXME("(0x%08x) stub\n",handle);
     1013 
     1014  ReleaseSemaphore( handle, 1, &oldCount);
     1015  WaitForSingleObject( handle, 0 );
     1016  return 0;
     1017}
     1018
     1019
     1020/*************************************************************************
     1021*      SHLWAPI_237 [SHLWAPI]
     1022* Purpose: verify a WNDCLASSW structure
     1023*/
     1024ODINFUNCTION1(DWORD,       SHLWAPI_237,
     1025              LPWNDCLASSW, lpWndClass)
     1026{
     1027  WNDCLASSW wndClass;
     1028 
     1029  if (GetClassInfoW(lpWndClass->hInstance,
     1030                    (LPWSTR)lpWndClass->lpszClassName,
     1031                    &wndClass) == TRUE)
     1032    return 1;
     1033  else
     1034    return 0;
     1035}
     1036
     1037
    10751038/*****************************************************************************
    10761039 * Name      : LRESULT DefWindowProcAW
    … …  
    10961059    return DefWindowProcA(hWnd, Msg, wParam, lParam);
    10971060}
     1061
     1062
     1063/*************************************************************************
     1064*      SHLWAPI_241 [SHLWAPI]
     1065*
     1066*/
     1067ODINFUNCTION0(DWORD, SHLWAPI_241)
     1068{
     1069  FIXME("()stub\n");
     1070  return 0xabba1243;
     1071}
     1072
     1073/*************************************************************************
     1074*      SHLWAPI_266 [SHLWAPI]
     1075*/
     1076ODINFUNCTION4(DWORD,  SHLWAPI_266,
     1077              LPVOID, w,
     1078              LPVOID, x,
     1079              LPVOID, y,
     1080              LPVOID, z)
     1081{
     1082  FIXME("(%p %p %p %p)stub\n",w,x,y,z);
     1083  return 0xabba1248;
     1084}
     1085
     1086/*************************************************************************
     1087*      SHLWAPI_267 [SHLWAPI]
     1088*/
     1089ODINFUNCTION4(HRESULT, SHLWAPI_267,
     1090              LPVOID,  w, /* same as 1th parameter of SHLWAPI_219 */
     1091              LPVOID,  x, /* same as 2nd parameter of SHLWAPI_219 */
     1092              LPVOID,  y,
     1093              LPVOID,  z)
     1094{
     1095  FIXME("(%p %p %p %p)stub\n",w,x,y,z);
     1096  *((LPDWORD)z) = 0xabba1200;
     1097  return 0xabba1254;
     1098}
     1099
     1100/*************************************************************************
     1101*      SHLWAPI_268 [SHLWAPI]
     1102*/
     1103ODINFUNCTION2(DWORD,  SHLWAPI_268,
     1104              LPVOID, w,
     1105              LPVOID, x)
     1106{
     1107  FIXME("(%p %p)\n",w,x);
     1108  return 0xabba1251; /* 0 = failure */
     1109}
     1110
     1111/*************************************************************************
     1112*      SHLWAPI_276 [SHLWAPI]
     1113* dynamically load SHELL32.DllGetVersion
     1114*
     1115*/
     1116ODINFUNCTION0(DWORD, SHLWAPI_276)
     1117{
     1118  FIXME("()stub\n");
     1119  return 0xabba1244;
     1120}
     1121
     1122
     1123/*************************************************************************
     1124*      SHLWAPI_309 [SHLWAPI]
     1125*
     1126*/
     1127ODINFUNCTION1(DWORD, SHLWAPI_309,
     1128              LPVOID, x)
     1129{
     1130  FIXME("(%p)stub\n",x);
     1131  return 0xabba1245;
     1132}
     1133
     1134/*************************************************************************
     1135*      SHLWAPI_342 [SHLWAPI]
     1136*
     1137*/
     1138ODINFUNCTION4(DWORD,  SHLWAPI_342,
     1139              LPVOID, w,
     1140              LPVOID, x,
     1141              LPVOID, y,
     1142              LPVOID, z)
     1143{
     1144  FIXME("(%p %p %p %p)stub\n",w,x,y,z);
     1145  return 0xabba1249;
     1146}
     1147
     1148/*************************************************************************
     1149*      SHLWAPI_346 [SHLWAPI]
     1150*/
     1151ODINFUNCTION3(DWORD,   SHLWAPI_346,
     1152              LPCWSTR, src,
     1153              LPWSTR,  dest,
     1154              int,     len)
     1155{
     1156  FIXME("(%s %p 0x%08x)stub\n",debugstr_w(src),dest,len);
     1157  lstrcpynW(dest, src, len);
     1158  return lstrlenW(dest)+1;
     1159}
     1160
     1161
     1162/*****************************************************************************
     1163 * Name      : SHLWAPI_364
     1164 * Purpose   : call lstrcpynA
     1165 * Parameters:
     1166 * Variables :
     1167 * Result    :
     1168 * Remark    : SHLWAPI.364
     1169 * Status    : UNTESTED
     1170 *
     1171 * Author    :
     1172 *****************************************************************************/
     1173
     1174ODINFUNCTION3(INT,   SHLWAPI_364,
     1175              LPSTR, lpStr1,
     1176              LPSTR, lpStr2,
     1177              INT,   nLength)
     1178{
     1179  // @@@PH is there some parameter twisting ?
     1180  lstrcpynA(lpStr2,
     1181            lpStr1,
     1182            nLength);
     1183 
     1184  return 1;
     1185}
     1186
     1187
     1188
     1189/*************************************************************************
     1190*      SHLWAPI_377 [SHLWAPI]
     1191*/
     1192ODINFUNCTION3(DWORD,  SHLWAPI_377,
     1193              LPVOID, x,
     1194              LPVOID, y,
     1195              LPVOID, z)
     1196{
     1197  FIXME("(%p %p %p)stub\n", x,y,z);
     1198  return 0xabba1246;
     1199}
     1200
     1201
     1202/*****************************************************************************
     1203 * Name      : DWORD SHLWAPI_437
     1204 * Purpose   : Determine product version and options
     1205 * Parameters:
     1206 * Variables :
     1207 * Result    :
     1208 * Remark    : SHLWAPI.437
     1209 * Status    : UNTESTED
     1210 *
     1211 * Author    : Patrick Haller [Sun, 2000/06/10 04:02]
     1212 *****************************************************************************/
     1213
     1214#define REG_PRODUCTOPTIONS "System\\CurrentControlSet\\Control\\ProductOptions"
     1215#define REG_OPTIONS_PRODUCTTYPE "ProductType"
     1216#define REG_OPTIONS_ENTERPRISE  "Enterprise"
     1217#define REG_OPTIONS_DATACENTER  "DataCenter"
     1218
     1219ODINFUNCTION1(DWORD,  SHLWAPI_437,
     1220              DWORD,  nFunction)
     1221{
     1222  static BOOL           flagProductOptionsInitialized = FALSE;
     1223  static BOOL           flagIsProductEnterprise       = FALSE;
     1224  static BOOL           flagIsProductDatacenter       = FALSE;
     1225  static OSVERSIONINFOA osVersionInfo;
     1226 
     1227  HKEY          hKeyOptions;
     1228  DWORD         dwKeyType;
     1229  char          szBuffer[260]; // MAX_PATH_LEN
     1230  DWORD         dwDataLength;
     1231 
     1232  dprintf(("not (properly) implemented.\n"));
     1233 
     1234  if (flagProductOptionsInitialized == FALSE)
     1235  {
     1236    // set to TRUE regardless of subsequent errors
     1237    flagProductOptionsInitialized = TRUE;
     1238   
     1239    // initialize required structures
     1240    osVersionInfo.dwOSVersionInfoSize = 0x9c;
     1241    if (GetVersionExA(&osVersionInfo) == FALSE)
     1242    {
     1243      osVersionInfo.dwOSVersionInfoSize = 0x94;
     1244      GetVersionExA(&osVersionInfo);
     1245    }
     1246   
     1247    LONG rc = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
     1248                           REG_PRODUCTOPTIONS,
     1249                           0,
     1250                           KEY_READ,
     1251                           &hKeyOptions);
     1252    if (rc == ERROR_SUCCESS)
     1253    {
     1254      dwDataLength = sizeof(szBuffer);
     1255      rc = RegQueryValueExA(hKeyOptions,
     1256                            REG_OPTIONS_PRODUCTTYPE,
     1257                            0,
     1258                            &dwKeyType,
     1259                            (LPBYTE)szBuffer,
     1260                            &dwDataLength);
     1261      if (StrStrIA(szBuffer, REG_OPTIONS_ENTERPRISE) != 0)
     1262        flagIsProductEnterprise = TRUE;
     1263      else
     1264      if (StrStrIA(szBuffer, REG_OPTIONS_DATACENTER) != 0)
     1265        flagIsProductDatacenter = TRUE;
     1266     
     1267      RegCloseKey(hKeyOptions);
     1268    }
     1269  }
     1270 
     1271  // OK, now to the usual work ...
     1272  switch (nFunction)
     1273  {
     1274    // is platform WINDOWS
     1275    case 0:
     1276      if (osVersionInfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS)
     1277        return 1;
     1278      else
     1279        return 0;
     1280   
     1281    // is platform NT
     1282    case 1:
     1283      if (osVersionInfo.dwPlatformId == VER_PLATFORM_WIN32_NT)
     1284        return 1;
     1285      else
     1286        return 0;
     1287   
     1288    // is  platform Windows 95/98/xx ?
     1289    case 2:
     1290      if (osVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_WINDOWS)
     1291        return 0;
     1292      if (osVersionInfo.dwMajorVersion >= 4)
     1293        return 1;
     1294      else
     1295        return 0;
     1296   
     1297    // is platform NT4 or better?
     1298    case 3:
     1299      if (osVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_NT)
     1300        return 0;
     1301      if (osVersionInfo.dwMajorVersion >= 4)
     1302        return 1;
     1303      else
     1304        return 0;
     1305   
     1306    // is platform Win2000 or better?
     1307    case 4:
     1308      if (osVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_NT)
     1309        return 0;
     1310      if (osVersionInfo.dwMajorVersion >= 5)
     1311        return 1;
     1312      else
     1313        return 0;
     1314   
     1315    // at least Windows 4.10 ?
     1316    case 5:
     1317      if (osVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_WINDOWS)
     1318        return 0;
     1319      if (osVersionInfo.dwMajorVersion > 4)
     1320        return 1;
     1321      else
     1322        if (osVersionInfo.dwMajorVersion == 4)
     1323          if (osVersionInfo.dwMinorVersion >= 10)
     1324            return 1;
     1325   
     1326      return 0;
     1327   
     1328    // is platform Windows98 GA ?
     1329    case 6:
     1330      if ( (osVersionInfo.dwPlatformId   == VER_PLATFORM_WIN32_WINDOWS) &&
     1331           (osVersionInfo.dwMajorVersion == 4) &&
     1332           (osVersionInfo.dwMinorVersion == 10) &&
     1333           (osVersionInfo.dwBuildNumber  == 1998) ) // 0x7ce
     1334        return 1;
     1335      else
     1336        return 0;
     1337   
     1338    // is platform some specific CSD ?
     1339    case 7:
     1340    case 8:
     1341      //@@@PH incorrect
     1342      if (osVersionInfo.dwMajorVersion >= 5)
     1343        return 1;
     1344      else
     1345        return 0;
     1346   
     1347    case 9:
     1348      //@@@PH incorrect
     1349      if (osVersionInfo.dwMajorVersion >= 5 ||
     1350          flagIsProductEnterprise ||
     1351          flagIsProductDatacenter)
     1352        return 1;
     1353      else
     1354        return 0;
     1355 
     1356    case 10:
     1357      //@@@PH incorrect
     1358      if (osVersionInfo.dwMajorVersion >= 5)
     1359        return flagIsProductEnterprise;
     1360      else
     1361        return 0;
     1362   
     1363    case 11:
     1364      //@@@PH incorrect
     1365      if (osVersionInfo.dwMajorVersion >= 5)
     1366        return flagIsProductDatacenter;
     1367      else
     1368        return 0;
     1369         
     1370    // @@@PH: Oops, wazzup there ?
     1371    case 12:
     1372      return GetSystemMetrics(4096);
     1373  }
     1374 
     1375  return 0;
     1376}
     1377
     1378
     1379/*****************************************************************************
     1380 * Name      : SHIsLowMemoryMachine
     1381 * Purpose   :
     1382 * Parameters: BOOL fRetest - TRUE if testing shall be repeated
     1383 *                          - FALSE if cached result is to be used
     1384 * Variables :
     1385 * Result    : 0 - machine is not memory-constrained
     1386 *             1 - machine is memory-constrained
     1387 * Remark    : SHLWAPI.584
     1388 * Status    : UNTESTED
     1389 *
     1390 * Author    : Patrick Haller [Mon, 2000/06/11 02:02]
     1391 *****************************************************************************/
     1392
     1393ODINFUNCTION1(int,     SHIsLowMemoryMachine,
     1394              BOOL,    fRetest)
     1395{
     1396         MEMORYSTATUS memBuffer;
     1397  static int          flagIsLowMemoryMachine = -1;
     1398         ULONG        ulMem;
     1399 
     1400  // use cached result?
     1401  if ( (fRetest == TRUE) ||
     1402       (flagIsLowMemoryMachine == -1) )
     1403  {
     1404    // determine and store result
     1405    GlobalMemoryStatus(&memBuffer);
     1406    if (VERSION_OsIsUnicode())
     1407      ulMem = 0x1000000; // unicode operation mode
     1408    else
     1409      ulMem = 0x0800000; // ascii operation mode
     1410   
     1411    // enough memory?
     1412    if (memBuffer.dwTotalPhys <= ulMem)
     1413      flagIsLowMemoryMachine = 1;
     1414    else
     1415      flagIsLowMemoryMachine = 0;
     1416  }
     1417 
     1418  return flagIsLowMemoryMachine;
     1419}
Note: See TracChangeset for help on using the changeset viewer.