Ignore:
Timestamp:
Feb 6, 2002, 9:18:30 PM (24 years ago)
Author:
sandervl
Message:

Wine resync

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/shlwapi/ordinal_odin.cpp

    r6615 r7820  
    1 /* $Id: ordinal_odin.cpp,v 1.4 2001-08-31 19:56:34 phaller Exp $ */
     1/* $Id: ordinal_odin.cpp,v 1.5 2002-02-06 20:18:27 sandervl Exp $ */
    22
    33/*
    … …  
    6868
    6969
     70#if 0
    7071/*****************************************************************************
    7172 * Prototypes                                                                *
    … …  
    7475HANDLE WIN32API SHLWAPI_11(HANDLE, DWORD, DWORD, DWORD, DWORD);
    7576
    76 
    77 #define debugstr_guid(a) a
    7877
    7978
    … …  
    269268  return NO_ERROR;
    270269}
    271 
    272 
    273 /*****************************************************************************
    274  * Name      : ParseURLIntoProtocolAndURI_W
    275  * Purpose   :
    276  * Parameters:
    277  * Variables :
    278  * Result    :
    279  * Remark    :
    280  * Status    : UNTESTED
    281  *
    282  * Author    : Patrick Haller [2001-08-30]
    283  *****************************************************************************/
    284 
    285 ODINFUNCTION2(DWORD,              SHLWAPI_2,
    286               LPWSTR,             lpszURL,
    287               LPPROTOCOLHANDLERW, lpHandler)
    288 {
    289   dprintf(("not yet implemented"));
    290 
    291   // PH: do unicode conversion, call SHLWAPI_1
    292 
    293   return 0;
    294 }
     270#endif
     271
    295272
    296273
    … …  
    424401}
    425402
     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
     419ODINFUNCTION2(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
    426431/*****************************************************************************
    427432 * Name      : ???
    … …  
    436441 *****************************************************************************/
    437442
    438 ODINFUNCTION3(DWORD,SHLWAPI_7,
     443ODINFUNCTION2(DWORD,SHLWAPI_17,
    439444              DWORD, arg0,
    440               DWORD, arg1,
    441               DWORD, arg2)
    442 {
    443   HANDLE hMap;
    444   LPVOID lpMap;
    445   DWORD  dwResult;
    446 
    447   dprintf(("not implemented"));
    448 
    449   // create mapping
    450   hMap = CreateFileMappingA(-1,
    451                             NULL,
    452                             PAGE_READWRITE,
    453                             0,
    454                             arg1,
    455                             0);
    456   if (hMap == NULL)
    457     return FALSE;
    458 
    459   // now map the thing
    460   lpMap = MapViewOfFile(hMap,
    461                         FILE_MAP_READ | FILE_MAP_WRITE,
    462                         0,
    463                         0,
    464                         0);
    465   if (lpMap == NULL)
    466   {
    467     CloseHandle(hMap);
    468     return FALSE;
    469   }
    470 
    471   /*  @@@PH copy someting into the shared segment */
    472 
    473   UnmapViewOfFile(lpMap);
    474   dwResult = SHLWAPI_11(hMap,
    475                         GetCurrentProcessId(),
    476                         arg2,
    477                         FILE_MAP_ALL_ACCESS,
    478                         2);
    479   CloseHandle(hMap);
    480 
    481   return dwResult;
    482 }
     445              DWORD, arg1)
     446{
     447  dprintf(("not implemented, explorer.exe will trap now"));
     448
     449  return 0;
     450}
     451
     452
    483453
    484454
    … …  
    495465 *****************************************************************************/
    496466
    497 ODINFUNCTION2(DWORD,  SHLWAPI_8,
    498               HANDLE, hMap,
    499               DWORD,  arg1)
    500 {
    501   HANDLE hHandle;
    502   LPVOID lpBase;
    503 
    504   hHandle = SHLWAPI_11(hMap,
    505                        arg1,
    506                        GetCurrentProcessId(),
    507                        FILE_MAP_ALL_ACCESS,
    508                        0);
    509   lpBase = MapViewOfFile(hHandle,
    510                          FILE_MAP_READ | FILE_MAP_WRITE,
    511                          0,
    512                          0,
    513                          0);
    514   CloseHandle(hHandle);
    515 
    516   if (lpBase == NULL)
    517     return NULL;
    518   else
    519     return (DWORD)lpBase+4; // lea eax, [ebx + 4]
    520 }
    521 
    522 
    523 /*****************************************************************************
    524  * Name      :
    525  * Purpose   :
    526  * Parameters:
    527  * Variables :
    528  * Result    :
    529  * Remark    :
    530  * Status    : COMPLETELY IMPLEMENTED UNTESTED
    531  *
    532  * Author    : Patrick Haller [Sun, 2000/06/09 04:47]
    533  *****************************************************************************/
    534 
    535 ODINFUNCTION1(DWORD,  SHLWAPI_9,
    536               LPBYTE, lpBase)
    537 {
    538   return (UnmapViewOfFile( (LPVOID) ((DWORD)lpBase & 0xFFFFFFFC)) );
    539 }
    540 
    541 
    542 /*****************************************************************************
    543  * Name      : ???
    544  * Purpose   :
    545  * Parameters:
    546  * Variables :
    547  * Result    :
    548  * Remark    :
    549  * Status    : COMPLETELY IMPLEMENTED UNTESTED
    550  *
    551  * Author    : Patrick Haller [Sun, 2000/06/09 04:47]
    552  *****************************************************************************/
    553 
    554 ODINFUNCTION2(DWORD,  SHLWAPI_10,
    555               HANDLE, hMap,
    556               DWORD,  arg1)
    557 {
    558   HANDLE hHandle;
    559 
    560   hHandle = SHLWAPI_11(hMap,
    561                        arg1,
    562                        GetCurrentProcessId(),
    563                        FILE_MAP_ALL_ACCESS,
    564                        1);
    565   return CloseHandle(hHandle);
    566 }
    567 
    568 
    569 /*****************************************************************************
    570  * Name      :
    571  * Purpose   : Duplicate the handle to the shell shared segment
    572  * Parameters:
    573  * Variables :
    574  * Result    :
    575  * Remark    : SHLWAPI.11 - wrong implementation, check again
    576  * Status    : UNTESTED STUB
    577  *
    578  * Author    : Patrick Haller [Sun, 2000/06/09 04:47]
    579  *****************************************************************************/
    580 
    581 ODINFUNCTION5(HANDLE, SHLWAPI_11,
    582               HANDLE, hMap,
    583               DWORD,  dwProcessDest,
    584               DWORD,  dwCurrentPID,
    585               DWORD,  dwAccess,
    586               DWORD,  dwFlag)
    587 {
    588   dprintf(("not implemented, explorer.exe will trap now"));
    589 
    590   DWORD  dwMyPID = GetCurrentProcessId();
    591   HANDLE hProcess;
    592   HANDLE hTargetHandle;
    593   HANDLE hTargetProcessHandle = dwProcessDest;
    594   BOOL   fResult;
    595 
    596   // open desired process
    597   if (dwMyPID == dwProcessDest)
    598     hProcess == GetCurrentProcess();
    599   else
    600     hProcess == OpenProcess(PROCESS_DUP_HANDLE,
    601                             FALSE,
    602                             dwProcessDest);
    603 
    604   // verify result
    605   if (hProcess == NULL)
    606     return 0;
    607 
    608   // duplicate handle
    609   fResult = DuplicateHandle(hProcess,
    610                             hMap,
    611                             hTargetProcessHandle,
    612                             &hTargetHandle,
    613                             dwAccess,
    614                             0,
    615                             dwFlag | 0x02);
    616   //CloseHandle()
    617 
    618   return fResult;
    619 }
    620 
    621 
    622 /*****************************************************************************
    623  * Name      : ???
    624  * Purpose   : Looks like a strdup()
    625  * Parameters: Unknown (wrong)
    626  * Variables :
    627  * Result    : Unknown
    628  * Remark    :
    629  * Status    : UNTESTED STUB
    630  *
    631  * Author    : Patrick Haller [Sun, 2000/06/09 04:47]
    632  *****************************************************************************/
    633 
    634 ODINFUNCTION2(DWORD,SHLWAPI_12,
    635               DWORD,arg0,
    636               DWORD,arg1)
    637 {
    638   dprintf(("not implemented, explorer.exe will trap now"));
    639 
    640   return 0;
    641 }
    642 
    643 
    644 /*****************************************************************************
    645  * Name      : ???
    646  * Purpose   : Unknown (used by explorer.exe)
    647  * Parameters:
    648  * Variables :
    649  * Result    : Unknown
    650  * Remark    :
    651  * Status    : UNTESTED STUB
    652  *
    653  * Author    : Patrick Haller [Sun, 2000/06/09 04:47]
    654  *****************************************************************************/
    655 
    656 ODINFUNCTION2(DWORD,SHLWAPI_13,
    657               DWORD, arg0,
    658               DWORD, arg1)
    659 {
    660   dprintf(("not implemented, explorer.exe will trap now"));
    661 
    662   return 0;
    663 }
    664 
    665 
    666 /*****************************************************************************
    667  * Name      : ???
    668  * Purpose   : Unknown (used by explorer.exe)
    669  * Parameters: Unknown (wrong)
    670  * Variables :
    671  * Result    : Unknown
    672  * Remark    :
    673  * Status    : UNTESTED STUB
    674  *
    675  * Author    : Patrick Haller [Sun, 2000/06/09 04:47]
    676  *****************************************************************************/
    677 
    678 ODINFUNCTION2(DWORD,SHLWAPI_14,
    679               DWORD, arg0,
    680               DWORD, arg1)
    681 {
    682   dprintf(("not implemented, explorer.exe will trap now"));
    683 
    684   return 0;
    685 }
    686 
    687 
    688 /*****************************************************************************
    689  * Name      : ???
    690  * Purpose   : Unknown (used by explorer.exe)
    691  * Parameters: Unknown (wrong)
    692  * Variables :
    693  * Result    : Unknown
    694  * Remark    :
    695  * Status    : UNTESTED STUB
    696  *
    697  * Author    : Patrick Haller [Sun, 2000/06/09 04:47]
    698  *****************************************************************************/
    699 
    700 ODINFUNCTION2(DWORD,SHLWAPI_15,
    701               DWORD, arg0,
    702               DWORD, arg1)
    703 {
    704   dprintf(("not implemented, explorer.exe will trap now"));
    705 
    706   return 0;
    707 }
    708 
    709 
    710 /*****************************************************************************
    711  * Name      : ???
    712  * Purpose   : Unknown (used by explorer.exe)
    713  * Parameters: Unknown (wrong)
    714  * Variables :
    715  * Result    : Unknown
    716  * Remark    : SHLWAPI.16
    717  * Status    : UNTESTED STUB
    718  *
    719  * Author    : Patrick Haller [Sun, 2000/06/09 04:47]
    720  *****************************************************************************/
    721 
    722 ODINFUNCTION4(HANDLE,SHCreateThread,
    723               DWORD, arg0,
    724               DWORD, arg1,
    725               DWORD, arg2,
    726               DWORD, arg3)
    727 {
    728   dprintf(("not implemented, explorer.exe will trap now"));
    729 
    730   return 0;
    731 }
    732 
    733 
    734 /*****************************************************************************
    735  * Name      : ???
    736  * Purpose   : Unknown (used by explorer.exe)
    737  * Parameters: Unknown (wrong)
    738  * Variables :
    739  * Result    : Unknown
    740  * Remark    :
    741  * Status    : UNTESTED STUB
    742  *
    743  * Author    : Patrick Haller [Sun, 2000/06/09 04:47]
    744  *****************************************************************************/
    745 
    746 ODINFUNCTION2(DWORD,SHLWAPI_17,
    747               DWORD, arg0,
    748               DWORD, arg1)
    749 {
    750   dprintf(("not implemented, explorer.exe will trap now"));
    751 
    752   return 0;
    753 }
    754 
    755 
    756 /*****************************************************************************
    757  * Name      : ???
    758  * Purpose   : Unknown (used by explorer.exe)
    759  * Parameters: Unknown (wrong)
    760  * Variables :
    761  * Result    : Unknown
    762  * Remark    :
    763  * Status    : UNTESTED STUB
    764  *
    765  * Author    : Patrick Haller [Sun, 2000/06/09 04:47]
    766  *****************************************************************************/
    767 
    768 ODINFUNCTION2(DWORD,SHLWAPI_18,
    769               DWORD, arg0,
    770               DWORD, arg1)
    771 {
    772   dprintf(("not implemented, explorer.exe will trap now"));
    773 
    774   return 0;
    775 }
    776 
    777 
    778 /*****************************************************************************
    779  * Name      : SHLWAPI_19
    780  * Purpose   : Free memory
    781  * Parameters: LPVOID lpMem
    782  * Variables :
    783  * Result    :
    784  * Remark    : SHLWAPI.19
    785  * Status    : COMPLETELY IMPLEMENTED ? UNTESTED
    786  *
    787  * Author    : Patrick Haller [Sun, 2000/06/09 04:47]
    788  *****************************************************************************/
    789 
    790 ODINPROCEDURE1(SHLWAPI_19,
    791                HLOCAL, hMem)
    792 {
    793   if (hMem != NULL)
    794     LocalFree(hMem);
    795 }
    796 
    797 
    798 /*****************************************************************************
    799  * Name      : ???
    800  * Purpose   : Unknown (used by explorer.exe)
    801  * Parameters: Unknown (wrong)
    802  * Variables :
    803  * Result    : Unknown
    804  * Remark    :
    805  * Status    : UNTESTED STUB
    806  *
    807  * Author    : Patrick Haller [Sun, 2000/06/09 04:47]
    808  *****************************************************************************/
    809 
    810467ODINFUNCTION2(DWORD,SHLWAPI_20,
    811468              DWORD, arg0,
    … …  
    818475
    819476
    820 /*****************************************************************************
    821  * Name      : ???
    822  * Purpose   : Unknown (used by explorer.exe)
    823  * Parameters: Unknown (wrong)
    824  * Variables :
    825  * Result    : Unknown
    826  * Remark    :
    827  * Status    : UNTESTED STUB
    828  *
    829  * Author    : Patrick Haller [Sun, 2000/06/09 04:47]
    830  *****************************************************************************/
    831 
    832 ODINFUNCTION2(DWORD,SHLWAPI_21,
    833               DWORD, arg0,
    834               DWORD, arg1)
    835 {
    836   dprintf(("not implemented, explorer.exe will trap now"));
    837 
    838   return 0;
    839 }
    840 
    841 
    842 /*****************************************************************************
    843  * Name      : ???
    844  * Purpose   : Unknown (used by explorer.exe)
    845  * Parameters: Unknown (wrong)
    846  * Variables :
    847  * Result    : Unknown
    848  * Remark    :
    849  * Status    : UNTESTED STUB
    850  *
    851  * Author    : Patrick Haller [Sun, 2000/06/09 04:47]
    852  *****************************************************************************/
    853 
    854 ODINFUNCTION2(DWORD,SHLWAPI_22,
    855               DWORD, arg0,
    856               DWORD, arg1)
    857 {
    858   dprintf(("not implemented, explorer.exe will trap now"));
    859 
    860   return 0;
    861 }
    862 
    863 
    864 
    865 
    866 /*****************************************************************************
    867  * Name      : SHLWAPI_28
    868  * Purpose   :
    869  * Parameters:
    870  * Variables :
    871  * Result    :
    872  * Remark    :
    873  * Status    : UNTESTED STUB
    874  *
    875  * Author    : Patrick Haller [Sun, 2000/06/10 04:02]
    876  *****************************************************************************/
    877 
    878 ODINFUNCTION1(DWORD,SHLWAPI_28,
    879               DWORD,arg0)
    880 {
    881   dprintf(("not yet implemented"));
    882 
    883   return 0;
    884 }
    885 
    886 
    887 
    888 
    889 
    890 
    891 /*****************************************************************************
    892  * Name      : DWORD SHLWAPI_158
    893  * Purpose   : Case-ignoring wide string compare
    894  * Parameters: LPSTR lpStr1
    895  *             LPSTR lpStr2
    896  * Variables :
    897  * Result    : case-insensitive comparsion result between the two strings
    898  * Remark    : SHLWAPI.158
    899  * Status    : COMPLETELY IMPLEMENTED UNTESTED
    900  *
    901  * Author    : Patrick Haller [Sun, 2000/06/10 04:02]
    902  *****************************************************************************/
    903 
    904 ODINFUNCTION2(int,     SHLWAPI_158,
    905               LPWSTR,  lpStr1,
    906               LPWSTR,  lpStr2)
    907 {
    908   WCHAR ch1;
    909   WCHAR ch2;
    910   int   res;
    911 
    912   for (;
    913 
    914        *lpStr1 != 0;
    915 
    916        lpStr1++,
    917        lpStr2++)
    918   {
    919     ch1 = *lpStr1;
    920     ch2 = *lpStr2;
    921 
    922     /* ignore case of characters */
    923     if ( (ch1 >= 'A') && (ch1 <= 'Z')) ch1 += 0x20;
    924     if ( (ch2 >= 'A') && (ch2 <= 'Z')) ch1 += 0x20;
    925 
    926     /* compare characters */
    927     res = ch1 - ch2;
    928     if (res)
    929       return res;
    930   }
    931 
    932   /* OK, strings compared til end of string1 */
    933   return 0;
    934 }
     477
     478
     479
     480
    935481
    936482
    … …  
    1121667
    1122668
    1123 /*************************************************************************
    1124 *      SHLWAPI_219 [SHLWAPI]
    1125 */
    1126 ODINFUNCTION4(HRESULT, SHLWAPI_219,
    1127               LPVOID,  w, /* returned by LocalAlloc */
    1128               LPVOID,  x,
    1129               LPVOID,  y,
    1130               LPWSTR,  z) /* OUT: path */
    1131 {
    1132   FIXME("(%p %p %p %p)stub\n",w,x,y,z);
    1133   return 0xabba1252;
    1134 }
    1135 
    1136 
    1137 
    1138 
    1139 
    1140 /*************************************************************************
    1141 *      SHLWAPI_241 [SHLWAPI]
    1142 *
    1143 */
    1144 ODINFUNCTION0(DWORD, SHLWAPI_241)
    1145 {
    1146   FIXME("()stub\n");
    1147   return 0xabba1243;
    1148 }
    1149 
    1150669
    1151670/*****************************************************************************
    … …  
    1171690  return 0;
    1172691}
    1173 
    1174 
    1175 /*************************************************************************
    1176 *      SHLWAPI_266 [SHLWAPI]
    1177 */
    1178 ODINFUNCTION4(DWORD,  SHLWAPI_266,
    1179               LPVOID, w,
    1180               LPVOID, x,
    1181               LPVOID, y,
    1182               LPVOID, z)
    1183 {
    1184   FIXME("(%p %p %p %p)stub\n",w,x,y,z);
    1185   return 0xabba1248;
    1186 }
    1187 
    1188 /*************************************************************************
    1189 *      SHLWAPI_267 [SHLWAPI]
    1190 */
    1191 ODINFUNCTION4(HRESULT, SHLWAPI_267,
    1192               LPVOID,  w, /* same as 1th parameter of SHLWAPI_219 */
    1193               LPVOID,  x, /* same as 2nd parameter of SHLWAPI_219 */
    1194               LPVOID,  y,
    1195               LPVOID,  z)
    1196 {
    1197   FIXME("(%p %p %p %p)stub\n",w,x,y,z);
    1198   *((LPDWORD)z) = 0xabba1200;
    1199   return 0xabba1254;
    1200 }
    1201 
    1202 /*************************************************************************
    1203 *      SHLWAPI_268 [SHLWAPI]
    1204 */
    1205 ODINFUNCTION2(DWORD,  SHLWAPI_268,
    1206               LPVOID, w,
    1207               LPVOID, x)
    1208 {
    1209   FIXME("(%p %p)\n",w,x);
    1210   return 0xabba1251; /* 0 = failure */
    1211 }
    1212 
    1213 /*************************************************************************
    1214 *      SHLWAPI_276 [SHLWAPI]
    1215 
    1216 * dynamically load SHELL32.DllGetVersion
    1217 *
    1218 */
    1219 ODINFUNCTION0(DWORD, SHLWAPI_276)
    1220 {
    1221   FIXME("()stub\n");
    1222   return 0xabba1244;
    1223 }
    1224 
    1225 /*****************************************************************************
    1226  * Name      : DWORD SHLWAPI_376
    1227  * Purpose   : Try to determine user interface language
    1228  * Parameters:
    1229  * Variables :
    1230  * Result    :
    1231  * Remark    : SHLWAPI.366
    1232  * Status    : PARTIALLY IMPLEMENTED UNTESTED
    1233  *
    1234  * Author    : Patrick Haller [Sun, 2000/06/10 04:02]
    1235  *****************************************************************************/
    1236 
    1237 ODINFUNCTION0(DWORD, SHLWAPI_376)
    1238 {
    1239   /* Microsoft does a hell of a job here: looks for
    1240    * - Internet Explorer
    1241    * - Office
    1242    * - Lpk ?
    1243    * - Resource Locales
    1244    * - etc.
    1245    */
    1246 
    1247   return 0x0409; // @@@PH maybe this is 'nuf for now.
    1248 }
    1249 
    1250 
    1251 
    1252 /*************************************************************************
    1253 *      SHLWAPI_377 [SHLWAPI]
    1254 */
    1255 ODINFUNCTION3(DWORD,   SHLWAPI_377,
    1256               LPSTR,   lpstrModule,
    1257               HMODULE, hModule,
    1258               LPVOID,  z)
    1259 {
    1260   static BOOL flagSHLWAPI_377Initialized       = FALSE;
    1261   static BOOL flagInternetExplorerCheckVersion = FALSE;
    1262 
    1263   dprintf(("not (properly) implemented.\n"));
    1264 
    1265   char szModuleName[260]; // MAXPATHLEN
    1266   HMODULE hModLanguage;
    1267 
    1268   // initialize this subsystem
    1269   if (flagSHLWAPI_377Initialized == FALSE)
    1270   {
    1271     flagSHLWAPI_377Initialized = TRUE;
    1272 
    1273     flagInternetExplorerCheckVersion =
    1274     SHRegGetBoolUSValueA("Software\\Microsoft\\Internet Explorer\\International",
    1275                          "CheckVersion",
    1276                          1,
    1277                          1);
    1278   }
    1279 
    1280   if (lpstrModule == NULL) // Garbage in - garbage out
    1281     return 0;
    1282 
    1283   if (0 == GetModuleFileNameA(hModule,
    1284                               szModuleName,
    1285                               sizeof(szModuleName)))
    1286   {
    1287     // treat error
    1288   }
    1289   else
    1290   {
    1291     PathRemoveFileSpecA(szModuleName);
    1292     PathAppendA(szModuleName,
    1293                 lpstrModule);
    1294     // @@@PH twiddle around with the current IE codepage
    1295     hModLanguage = LoadLibraryA(szModuleName);
    1296   }
    1297 
    1298 
    1299   return hModLanguage;
    1300 }
    1301 
    1302692
    1303693/*****************************************************************************
Note: See TracChangeset for help on using the changeset viewer.