Ignore:
Timestamp:
Jun 7, 2002, 10:02:20 AM (23 years ago)
Author:
sandervl
Message:

resynced with latest Wine

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/shlwapi/ordinal_odin.cpp

    r7820 r8584  
    1 /* $Id: ordinal_odin.cpp,v 1.5 2002-02-06 20:18:27 sandervl Exp $ */
     1/* $Id: ordinal_odin.cpp,v 1.6 2002-06-07 08:02:17 sandervl Exp $ */
    22
    33/*
    … …  
    5555#include "shellapi.h"
    5656#include "shlobj.h"
    57 #include "wine/undocshell.h"
    5857
    5958#include "shlwapi.h"
    … …  
    6564 *****************************************************************************/
    6665
    67 ODINDEBUGCHANNEL(SHLWAPI-ORDINAL)
    68 
    69 
    70 #if 0
    71 /*****************************************************************************
    72  * Prototypes                                                                *
    73  *****************************************************************************/
    74 
    75 HANDLE WIN32API SHLWAPI_11(HANDLE, DWORD, DWORD, DWORD, DWORD);
     66
     67
     68
     69
     70
     71/*****************************************************************************
     72 * Name      : ???
     73 * Purpose   : Looks like a strdup()
     74 * Parameters: Unknown (wrong)
     75 * Variables :
     76 * Result    : Unknown
     77 * Remark    :
     78 * Status    : UNTESTED STUB
     79 *
     80 * Author    : Patrick Haller [Sun, 2000/06/09 04:47]
     81 *****************************************************************************/
     82
     83DWORD WIN32API SHLWAPI_12(DWORD arg0, DWORD arg1)
     84{
     85  dprintf(("not implemented, explorer.exe will trap now"));
     86
     87  return 0;
     88}
     89
    7690
    7791
    … …  
    86100 * Status    : UNTESTED STUB
    87101 *
    88  * Author    : Christoph Bratschi [Wed, 2000/03/29 19:47]
    89  *****************************************************************************/
    90 
    91 // return characters in protocol part
    92 static INT extractProtocolFromURL(LPSTR  pszURL,
    93                                   LPSTR* ppszColon)
    94 {
    95   int i = 0;  // number of characters scanned
    96   LPSTR s = pszURL;
    97 
    98   *ppszColon = NULL;
    99 
    100   if (*pszURL == 0)
    101     return 0;
    102 
    103 
    104   // scan through the string for the 1st colon
    105   while(*s)
    106   {
    107     // filter non-printable characters
    108     if (*s < ' ')
    109       return 0;
    110     else
    111       if (*s > 0x80)
    112         return 0;     
    113 
    114     // Note: actually, the original code has a table with
    115     // "forbidden" characters, we don't reproduce this here yet.
    116 
    117     if (*s == ':')
    118     {
    119        // yes, first colon found!
    120        if ( (pszURL[0] == 'U' || pszURL[0] == 'u') &&
    121             (pszURL[1] == 'R' || pszURL[1] == 'r') &&
    122             (pszURL[2] == 'L' || pszURL[2] == 'l') )
    123        {
    124          // restart scan!
    125          pszURL = s+1;
    126          i = 0;
    127        }
    128        else
    129        {
    130          // OK, protocol extracted
    131          *ppszColon = s;
    132          return i;
    133        }
    134     }
    135 
    136     // skip to next character
    137     i++;
    138     s++;
    139   } 
     102 * Author    : Patrick Haller [Sun, 2000/06/09 04:47]
     103 *****************************************************************************/
     104
     105DWORD WIN32API SHLWAPI_17(DWORD arg0, DWORD arg1)
     106{
     107  dprintf(("not implemented, explorer.exe will trap now"));
    140108
    141109  return 0;
    142110}
    143111
    144 typedef struct tabProtocolTableEntry
    145 {
    146   LPSTR  pszName; // Note: original is unicode
    147   DWORD  ID;
    148   DWORD  dwNameLength;
    149   DWORD  dwCharacteristic;
    150 } PROTOCOLTABLEENTRY, *LPPROTOCOLTABLEENTRY;
    151 
    152 
    153 #define PROTOCOL_HTTP 2
    154 #define PROTOCOL_FILE 9
    155 
    156 static PROTOCOLTABLEENTRY tabProtocolTable[] =
    157 {
    158   { "http",        PROTOCOL_HTTP,  4, 0x0a },
    159   { "file",        PROTOCOL_FILE,  4, 0x08 },
    160   { "ftp",         1,  3, 0x0a },
    161   { "https",      11,  5, 0x0a },
    162   { "news",        5,  4, 0x0a },
    163   { "mailto",      0,  6, 0x01 },
    164   { "gopher",      3,  6, 0x0a },
    165   { "nntp",        6,  4, 0x0a },
    166   { "telnet",      7,  6, 0x0a },
    167   { "wais",        8,  4, 0x00 },
    168   { "mk",         10,  2, 0x04 },
    169   { "shell",      12,  5, 0x01 },
    170   { "local",      14,  5, 0x00 },
    171   { "javascript", 15, 10, 0x05 },
    172   { "vbscript",   16,  8, 0x05 },
    173   { "snews",      13,  5, 0x0a },
    174   { "about",      17,  5, 0x05 },
    175   { "res",        18,  3, 0x04 }
    176 };
    177 #define END_OF_PROTOCOLTABLE (tabProtocolTable + (sizeof(tabProtocolTable) / sizeof(PROTOCOLTABLEENTRY)) )
    178 
    179 
    180 
    181 static DWORD getProtocolTableEntry(LPSTR pszProtocol, DWORD dwNameLength)
    182 {
    183   LPPROTOCOLTABLEENTRY lpEntry = tabProtocolTable;
    184 
    185   for(;;)
    186   {
    187     if (lpEntry->dwNameLength == dwNameLength)
    188       if (lstrncmpiA( lpEntry->pszName, pszProtocol, dwNameLength) == 0)
    189       {
    190         return lpEntry->ID;
    191       }
    192 
    193     lpEntry++;
    194 
    195     // if scanning beyond end of the table,
    196     // abort and return null
    197     if (lpEntry > END_OF_PROTOCOLTABLE)
    198       return 0;
    199   }
    200 }
    201 
    202 typedef struct tagProtocolHandlerA
    203 {
    204   DWORD  dwSize;
    205   DWORD  dwProtocolNameLength;
    206   LPSTR  lpszProtocolName;
    207   LPSTR  lpszURL;
    208   DWORD  dwURLNameLength;
    209   DWORD  ProtocolID;
    210 } PROTOCOLHANDLERA, *LPPROTOCOLHANDLERA;
    211 
    212 typedef struct tagProtocolHandlerW
    213 {
    214   DWORD  dwSize;
    215   DWORD  dwProtocolNameLength;
    216   LPWSTR lpszProtocolName;
    217   LPWSTR lpszURL;
    218   DWORD  dwURLNameLength;
    219   DWORD  ProtocolID;
    220 } PROTOCOLHANDLERW, *LPPROTOCOLHANDLERW;
    221 
    222 
    223 ODINFUNCTION2(DWORD,   SHLWAPI_1,
    224               LPSTR,   lpszURL,
    225               LPPROTOCOLHANDLERA, lpHandler)
    226 {
    227   dprintf(("not implemented"));
    228 
    229   if (NULL == lpszURL)
    230     return E_INVALIDARG;
    231 
    232   if (NULL == lpHandler)
    233     return E_INVALIDARG;
    234 
    235   if (lpHandler->dwSize != sizeof( PROTOCOLHANDLERA) )
    236     return E_INVALIDARG;
    237 
    238   dprintf(("SHLWAPI-SHLWAPI1: URL=%s",
    239     lpszURL));
    240  
    241   LPSTR lpszColon;
    242   INT iProtocolLength = extractProtocolFromURL(lpszURL,
    243                                                &lpszColon);
    244   lpHandler->dwProtocolNameLength = iProtocolLength;
    245   if (0 == iProtocolLength)
    246     return 0x80041001; // unknown error constant
    247 
    248   lpHandler->lpszProtocolName = lpszURL;
    249 
    250   DWORD ID = getProtocolTableEntry(lpszURL,
    251                                    iProtocolLength);
    252   lpHandler->ProtocolID = ID;
    253   lpHandler->lpszURL    = (LPSTR)(lpszURL + iProtocolLength + 1);
    254  
    255   if (ID == PROTOCOL_FILE)
    256   {
    257     // cut off leading slashes as required
    258     if (lpHandler->lpszURL[0] == '/' &&
    259         lpHandler->lpszURL[1] == '/')
    260       lpHandler->lpszURL = lpHandler->lpszURL + 2;
    261 
    262     if (lpHandler->lpszURL[0] == '/')
    263       lpHandler->lpszURL = lpHandler->lpszURL + 1;
    264   }
    265 
    266   lpHandler->dwURLNameLength = lstrlenA(lpHandler->lpszURL);
    267 
    268   return NO_ERROR;
    269 }
    270 #endif
    271 
    272 
    273 
    274 /*****************************************************************************
    275  * Name      : SHLWAPI_3
    276  * Purpose   :
    277  * Parameters:
    278  * Variables :
    279  * Result    :
    280  * Remark    :
    281  * Status    : STUB UNTESTED
    282  *
    283  * Author    : Patrick Haller [Sun, 2000/06/10 04:02]
    284  *****************************************************************************/
    285 
    286 ODINFUNCTION2(BOOL,  SHLWAPI_3,
    287               LPSTR, lpPath,
    288               LPSTR, lpFile)
    289 {
    290   dprintf(("not properly implemented"));
    291 
    292   return TRUE;
    293 
    294 #if 0
    295   if (lpPath == NULL)                return FALSE;
    296   if (PathIsUNCServerA(lpPath))      return FALSE;
    297   if (PathIsUNCServerShareA(lpPath)) return FALSE;
    298 
    299   if (lpFile == NULL)
    300     return PathFileExistsA(lpPath);
    301   else
    302   {
    303     // PathFindExtensionA
    304     // lstrlenA
    305     // lstrcpyA
    306     // PathFileExistsA
    307     return FALSE;
    308   }
    309 
    310   return FALSE;
    311 #endif
    312 }
    313 
    314 
    315 /*****************************************************************************
    316  * Name      : SHLWAPI_4
    317  * Purpose   :
    318  * Parameters:
    319  * Variables :
    320  * Result    :
    321  * Remark    :
    322  * Status    : STUB UNTESTED
    323  *
    324  * Author    : Patrick Haller [Sun, 2000/06/10 04:02]
    325  *****************************************************************************/
    326 
    327 ODINFUNCTION2(BOOL,   SHLWAPI_4,
    328               LPWSTR, lpPath,
    329               LPWSTR, lpFile)
    330 {
    331   dprintf(("not properly implemented"));
    332 
    333   return TRUE;
    334 
    335 #if 0
    336   if (lpPath == NULL)                return FALSE;
    337   if (PathIsUNCServerW(lpPath))      return FALSE;
    338   if (PathIsUNCServerShareW(lpPath)) return FALSE;
    339 
    340   if (lpFile == NULL)
    341     return PathFileExtensionW(lpPath);
    342   else
    343   {
    344     // PathFindExtensionW
    345     // lstrlenW
    346     // lstrcpyW
    347     // PathFileExistsW
    348     return FALSE;
    349   }
    350 
    351   return FALSE;
    352 #endif
    353 }
     112
    354113
    355114
    356115/*****************************************************************************
    357116 * Name      : ???
    358  * Purpose   : extended version of PathFindOnPathA
     117 * Purpose   : Unknown (used by explorer.exe)
    359118 * Parameters: Unknown (wrong)
    360119 * Variables :
    … …  
    366125 *****************************************************************************/
    367126
    368 ODINFUNCTION3(DWORD, SHLWAPI_5,
    369               LPSTR, lpFile,
    370               LPSTR, lpDirectories,
    371               DWORD, dwUnknown)
    372 
    373 {
    374   dprintf(("not implemented"));
    375 
    376   return 0;
    377 }
    378 
    379 
    380 /*****************************************************************************
    381  * Name      : ???
    382  * Purpose   : extended version of PathFindOnPathA
    383  * Parameters: Unknown (wrong)
    384  * Variables :
    385  * Result    : Unknown
    386  * Remark    :
    387  * Status    : UNTESTED STUB
    388  *
    389  * Author    : Patrick Haller [Sun, 2000/06/09 04:47]
    390  *****************************************************************************/
    391 
    392 ODINFUNCTION3(DWORD, SHLWAPI_6,
    393               DWORD, arg0,
    394               DWORD, arg1,
    395               DWORD, arg2)
    396 
    397 {
    398   dprintf(("not implemented"));
    399 
    400   return 0;
    401 }
    402 
    403 
    404 
    405 
    406 
    407 /*****************************************************************************
    408  * Name      : ???
    409  * Purpose   : Looks like a strdup()
    410  * Parameters: Unknown (wrong)
    411  * Variables :
    412  * Result    : Unknown
    413  * Remark    :
    414  * Status    : UNTESTED STUB
    415  *
    416  * Author    : Patrick Haller [Sun, 2000/06/09 04:47]
    417  *****************************************************************************/
    418 
    419 ODINFUNCTION2(DWORD,SHLWAPI_12,
    420               DWORD,arg0,
    421               DWORD,arg1)
    422 {
    423   dprintf(("not implemented, explorer.exe will trap now"));
    424 
    425   return 0;
    426 }
    427 
    428 
    429 
    430 
    431 /*****************************************************************************
    432  * Name      : ???
    433  * Purpose   : Unknown (used by explorer.exe)
    434  * Parameters: Unknown (wrong)
    435  * Variables :
    436  * Result    : Unknown
    437  * Remark    :
    438  * Status    : UNTESTED STUB
    439  *
    440  * Author    : Patrick Haller [Sun, 2000/06/09 04:47]
    441  *****************************************************************************/
    442 
    443 ODINFUNCTION2(DWORD,SHLWAPI_17,
    444               DWORD, arg0,
    445               DWORD, arg1)
    446 {
    447   dprintf(("not implemented, explorer.exe will trap now"));
    448 
    449   return 0;
    450 }
    451 
    452 
    453 
    454 
    455 /*****************************************************************************
    456  * Name      : ???
    457  * Purpose   : Unknown (used by explorer.exe)
    458  * Parameters: Unknown (wrong)
    459  * Variables :
    460  * Result    : Unknown
    461  * Remark    :
    462  * Status    : UNTESTED STUB
    463  *
    464  * Author    : Patrick Haller [Sun, 2000/06/09 04:47]
    465  *****************************************************************************/
    466 
    467 ODINFUNCTION2(DWORD,SHLWAPI_20,
    468               DWORD, arg0,
    469               DWORD, arg1)
     127DWORD WIN32API SHLWAPI_20(DWORD arg0, DWORD arg1)
    470128{
    471129  dprintf(("not implemented, explorer.exe will trap now"));
    … …  
    493151 *****************************************************************************/
    494152
    495 ODINFUNCTION2(DWORD,  SHLWAPI_160,
    496               DWORD,  arg0,
    497               DWORD,  arg1)
     153DWORD WIN32API SHLWAPI_160(DWORD arg0, DWORD arg1)
    498154{
    499155  dprintf(("not implemented.\n"));
    … …  
    517173 *****************************************************************************/
    518174
    519 ODINFUNCTION6(DWORD,   SHLWAPI_185,
    520               DWORD, arg0,
    521               LPSTR, lpStr1,
    522               LPSTR, lpStr2,
    523               DWORD, arg3,
    524               DWORD, dwDefault,
    525               LPSTR, lpstrValueName)
     175DWORD WIN32API SHLWAPI_185(DWORD arg0, LPSTR lpStr1, LPSTR lpStr2,
     176                           DWORD arg3, DWORD dwDefault, LPSTR lpstrValueName)
    526177{
    527178  BOOL  fDontShow;
    … …  
    587238 *****************************************************************************/
    588239
    589 ODINFUNCTION6(DWORD,  SHLWAPI_191,
    590               HWND,   hwndParent,
    591               DWORD,  arg1,
    592               DWORD,  arg2,
    593               DWORD,  arg3,
    594               DWORD,  dwDefault,
    595               LPWSTR, lpstrDialog)
     240DWORD WIN32API SHLWAPI_191(HWND hwndParent, DWORD arg1, DWORD arg2,
     241                           DWORD arg3, DWORD dwDefault, LPWSTR lpstrDialog)
    596242{
    597243  BOOL rc = SHRegGetBoolUSValueW((LPCWSTR)L"Software\\Microsoft\\Windows\\CurrentVersion"
    … …  
    644290 *****************************************************************************/
    645291
    646 ODINFUNCTION3(BOOL,         SHLWAPI_197,
    647               HDC,          hdc,
    648               CONST RECT*,  lprc,
    649               COLORREF,     crColor)
     292BOOL WIN32API SHLWAPI_197(HDC hdc, CONST RECT*lprc, COLORREF crColor)
    650293{
    651294  COLORREF crOld;
    … …  
    680323 *****************************************************************************/
    681324
    682 ODINFUNCTION5(DWORD, SHLWAPI_243,
    683               DWORD, arg0,
    684               DWORD, arg1,
    685               DWORD, arg2,
    686               DWORD, arg3,
    687               DWORD, arg4)
     325DWORD WIN32API SHLWAPI_243(DWORD arg0, DWORD arg1, DWORD arg2, DWORD arg3,
     326                           DWORD arg4)
    688327{
    689328  dprintf(("not implementes.\n"));
    … …  
    708347#define REG_OPTIONS_DATACENTER  "DataCenter"
    709348
    710 ODINFUNCTION1(DWORD,  SHLWAPI_437,
    711               DWORD,  nFunction)
     349DWORD WIN32API SHLWAPI_437(DWORD  nFunction)
    712350{
    713351  static BOOL           flagProductOptionsInitialized = FALSE;
    … …  
    868506
    869507
    870 /*****************************************************************************
    871  * Name      : SHIsLowMemoryMachine
    872  * Purpose   :
    873  * Parameters: BOOL fRetest - TRUE if testing shall be repeated
    874  *                          - FALSE if cached result is to be used
    875  * Variables :
    876  * Result    : 0 - machine is not memory-constrained
    877  *             1 - machine is memory-constrained
    878  * Remark    : SHLWAPI.584
    879  * Status    : COMPLETELY IMPLEMENTED ? UNTESTED
    880  *
    881  * Author    : Patrick Haller [Mon, 2000/06/11 02:02]
    882  *****************************************************************************/
    883 
    884 ODINFUNCTION1(int,     SHIsLowMemoryMachine,
    885               BOOL,    fRetest)
    886 {
    887          MEMORYSTATUS memBuffer;
    888   static int          flagIsLowMemoryMachine = -1;
    889          ULONG        ulMem;
    890 
    891   // use cached result?
    892   if ( (fRetest == TRUE) ||
    893        (flagIsLowMemoryMachine == -1) )
    894   {
    895     // determine and store result
    896     GlobalMemoryStatus(&memBuffer);
    897     if (VERSION_OsIsUnicode())
    898       ulMem = 0x1000000; // unicode operation mode
    899     else
    900       ulMem = 0x0800000; // ascii operation mode
    901 
    902     // enough memory?
    903     if (memBuffer.dwTotalPhys <= ulMem)
    904       flagIsLowMemoryMachine = 1;
    905     else
    906       flagIsLowMemoryMachine = 0;
    907   }
    908 
    909   return flagIsLowMemoryMachine;
    910 }
    911 
Note: See TracChangeset for help on using the changeset viewer.