Nota
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare ad accedere o modificare le directory.
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare a modificare le directory.
[Queste funzioni sono disponibili tramite Windows XP Service Pack 2 (SP2) e Windows Server 2003. Potrebbero essere modificate o non disponibili nelle versioni successive di Windows.]
Le tabelle di questo documento elencano le funzioni wrapper di Shlwapi.dll che forniscono funzionalità Unicode limitate a Windows 95, Windows 98 e Windows Millennium Edition (Windows Me).
Windows 95, Windows 98 e Windows Millennium Edition (Windows Me) sono definiti "piattaforme ANSI native". Nelle piattaforme ANSI native, queste funzioni wrapper convertono i parametri della stringa di input Unicode in ANSI e chiamano le versioni ANSI delle funzioni nella colonna Forwards To . Ad esempio, AppendMenuWrapWrapW chiama AppendMenuA, ovvero la versione ANSI di AppendMenu. Le altre funzioni seguono lo stesso modello. Le stringhe restituite dalla funzione ANSI vengono convertite in Unicode e restituite all'applicazione chiamante. A parte le eccezioni indicate nella colonna Osservazioni , la funzione wrapper ha la stessa sintassi e fornisce la stessa funzionalità della funzione nella colonna Forwards To . Per informazioni dettagliate sull'utilizzo, fare riferimento a tale pagina di riferimento.
Avviso di sicurezza: Più stringhe Unicode possono essere convertite nella stessa stringa ANSI. Le collisioni impreviste dopo la conversione potrebbero causare un comportamento imprevisto. Ad esempio, se createEventWrapW viene usato per creare due eventi denominati in modo diverso i cui nomi corrispondono dopo la conversione da Unicode a ANSI, la seconda chiamata restituirà un handle allo stesso evento della prima chiamata, anche se le stringhe Unicode originali erano diverse.
Microsoft Windows NT, Windows 2000, Windows XP, Windows Server 2003 e sistemi operativi successivi sono definiti "piattaforme Unicode native". Nella maggior parte dei casi, nelle piattaforme Unicode native, queste funzioni wrapper inoltrano semplicemente i parametri della stringa di input alla versione Unicode della funzione nella colonna Inoltra a . Ad esempio, AppendMenuWrapW inoltra a AppendMenuW, ovvero la versione Unicode di AppendMenu. Le altre funzioni seguono lo stesso modello. Tutte le stringhe restituite dalla funzione Unicode vengono restituite all'applicazione chiamante. A parte le eccezioni indicate nella colonna Osservazioni , la funzione wrapper ha la stessa sintassi e fornisce la stessa funzionalità della funzione nella colonna Forwards To . Per informazioni dettagliate sull'utilizzo, fare riferimento a tale pagina di riferimento.
Avviso di sicurezza: I problemi di sicurezza annotati per le funzioni nella colonna Inoltra a si applicano anche alle funzioni wrapper corrispondenti. Per informazioni dettagliate, vedere la documentazione di riferimento per la funzione nella colonna Inoltra a .
Le funzioni wrapper in questa tabella sono tutte contenute in Shlwapi.dll. Per chiamarli, è necessario usare il numero ordinale elencato nella tabella.
Nota
Queste funzioni wrapper sono disponibili in Windows XP, ma non forniscono alcuna funzionalità wrapper in Windows XP Service Pack 2 (SP2) e versioni successive. Inoltre, non forniscono funzionalità wrapper in Windows Server 2003. È invece consigliabile usare le funzioni elencate nella colonna Inoltra a .
| Funzione | Ordinale | Inoltra a | DLL | Commenti |
|---|---|---|---|---|
| AppendMenuWrapW | 36 | AppendMenu | USER32 | (a), (f), (Menu) |
| ChiamaWindowProcWrapW | 37 | ChiamaWindowProc | USER32 | (i) |
| CharLowerWrapW | 38 | CharLower | KERNEL32 | (e) |
| CharUpperBufWrapW | 44 | CharUpperBuff | KERNEL32 | (e) |
| CharUpperWrapW | 43 | CharUpper | KERNEL32 | (e) |
| CompareStringWrapW | 45 | CompareString | KERNEL32 | (CompareString) |
| CopyFileWrapW | 112 | CopyFile | KERNEL32 | (a), (c) |
| CreateEventWrapW | 51 | CreateEvent | KERNEL32 | (a) |
| CreateFileWrapW | 52 | CreateFile | KERNEL32 | (a), (c) |
| CreateWindowExWrapW | 55 | CreateWindowEx | USER32 | (a) |
| DefWindowProcWrapW | 56 | DefWindowProc | USER32 | (i) |
| DeleteFileWrapW | 57 | DeleteFile | KERNEL32 | (a), (c) |
| DialogBoxParamWrapW | 59 | DialogBoxParam | USER32 | (f), (i), (DialogBoxParam) |
| DispatchMessageWrapW | 60 | DispatchMessage | USER32 | (i) |
| DragQueryFileWrapW | 318 | DragQueryFile | SHELL32 | (b), (c), (g), (DragQueryFile) |
| DrawTextExWrapW | 301 | DrawTextEx | USER32 | (a), (d) |
| DrawTextWrapW | 61 | Drawtext | USER32 | (a) |
| ExtTextOutWrapW | 299 | Exttextout | GDI32 | (d), (f), (ExtTextOut) |
| FormatMessageWrapW | 68 | FormatMessage | KERNEL32 | (a), (g), (FormatMessage) |
| GetClassInfoWrapW | 69 | GetClassInfo | USER32 | (GetClassInfo) |
| GetDateFormatWrapW | 311 | GetDateFormat | KERNEL32 | (a), (g), (DateTime) |
| GetDlgItemTextWrapW | 74 | GetDlgItemText | USER32 | (g) |
| GetFileAttributesWrapW | 75 | GetFileAttributes | KERNEL32 | (a), (c) |
| GetLocaleInfoWrapW | 77 | GetLocaleInfo | KERNEL32 | (g) |
| GetMenuItemInfoWrapW | 302 | GetMenuItemInfo | USER32 | (f), (g), (MenuItemInfo) |
| GetModuleFileNameWrapW | 80 | GetModuleFileName | KERNEL32 | (c), (g) |
| GetModuleHandleWrapW | 83 | GetModuleHandle | KERNEL32 | (c), (g) |
| GetObjectWrapW | 84 | Getobject | GDI32 | (g) |
| GetOpenFileNameWrapW | 403 | Getopenfilename | COMDLG32 | (a), (b), (g), (OpenFileName) |
| GetSaveFileNameWrapW | 389 | GetSaveFileName | COMDLG32 | (a), (b), (g), (OpenFileName) |
| GetSystemDirectoryWrapW | 81 | GetSystemDirectory | KERNEL32 | (c), (g) |
| GetTimeFormatWrapW | 310 | GetTimeFormat | KERNEL32 | (a), (g), (DateTime) |
| GetWindowLongWrapW | 94 | GetWindowLong | USER32 | (WindowLong) |
| GetWindowsDirectoryWrapW | 97 | GetWindowsDirectory | KERNEL32 | (c), (g) |
| GetWindowTextLengthWrapW | 96 | GetWindowTextLength | USER32 | (j) |
| GetWindowTextWrapW | 95 | GetWindowText | USER32 | (f), (g) |
| InsertMenuItemWrapW | 98 | InsertMenuItem | USER32 | (a), (f), (Menu), (MenuItemInfo) |
| IsCharAlphaWrapW | 25 | IsCharAlpha | USER32 | (e) |
| IsCharAlphaNumericWrapW | 28 | IsCharAlphaNumeric | KERNEL32 | (e) |
| IsCharUpperWrapW | 26 | IsCharUpper | USER32 | (e) |
| LoadLibraryWrapW | 105 | LoadLibrary | KERNEL32 | (a), (c) |
| LoadStringWrapW | 107 | LoadString | KERNEL32 | (e) |
| MessageBoxWrapW | 340 | MessageBox | USER32 | (a) |
| MoveFileWrapW | 113 | MoveFile | KERNEL32 | (a), (c) |
| OutputDebugStringWrapW | 115 | Outputdebugstring | KERNEL32 | (a) |
| PeekMessageWrapW | 116 | PeekMessage | USER32 | (PeekMessage e PostMessage) |
| PostMessageWrapW | 117 | PostMessage | USER32 | (PeekMessage e PostMessage) |
| RegCreateKeyExWrapW | 120 | RegCreateKeyEx | ADVAPI32 | (a) |
| RegisterClassWrapW | 131 | Registerclass | USER32 | (a), (RegisterClass) |
| RegOpenKeyExWrapW | 125 | Regopenkeyex | ADVAPI32 | (a) |
| RegQueryValueExWrapW | 128 | Regqueryvalueex | ADVAPI32 | (a), (g), (ValueEx), (RegQueryValueExW) |
| RegQueryValueWrapW | 127 | RegQueryValue | ADVAPI32 | (a), (g) |
| RegSetValueExWrapW | 130 | Regsetvalueex | ADVAPI32 | (a), (ValueEx) |
| SendMessageWrapW | 136 | SendMessage | USER32 | (SendMessage) |
| SetDlgItemTextWrapW | 138 | SetDlgItemText | USER32 | (a) |
| SetWindowLongWrapW | 141 | Setwindowlong | USER32 | (WindowLong) |
| SetWindowTextWrapW | 143 | SetWindowText | USER32 | (a) |
| ShellExecuteExWrapW | 35 | ShellExecuteEx | SHELL32 | (a), (b), (ShellExecuteEx) |
| ShellMessageBoxWrapW | 388 | ShellMessageBox | SHLWAPI | (a), (FormatMessage) |
| SHGetFileInfoWrapW | 313 | SHGetFileInfo | SHELL32 | (a), (b), (g) |
| SHGetPathFromIDListWrapW | 334 | SHGetPathFromIDList | USER32 | (g) |
| TranslateAcceleratorWrapW | 146 | TranslateAccelerator | USER32 | (i) |
| UnregisterClassWrapW | 147 | Annulla registrazioneClass | USER32 | (a) |
Le funzioni wrapper nella tabella seguente non eseguono alcuna conversione di set di caratteri. Forniscono invece un supporto limitato per le funzionalità del sistema operativo non disponibili nelle piattaforme precedenti.
| Funzione | Ordinale | Inoltra a | DLL | Commenti |
|---|---|---|---|---|
| MLGetUILanguage | 376 | GetUserDefaultUILanguage | KERNEL32 | (h) |
| SHCancelTimerQueueTimerTimer | 265 | DeleteTimerQueueTimer | KERNEL32 | (h) |
| SHDeleteTimerQueue | 262 | DeleteTimerQueue | KERNEL32 | (h) |
| SHInterlockedCompareExchange | 342 | InterlockedCompareExchangePointer | KERNEL32 | (CompareExchange) |
| SHQueueUserWorkItem | 260 | Queueuserworkitem | KERNEL32 | (QueueUserWorkItem), (h) |
| SHSetTimerQueueTimer | 263 | CreateTimerQueueTimer | KERNEL32 | (SetTimerQueueTimer), (h) |
Commenti
(a)
Se è necessaria la conversione di stringhe, tutte le stringhe vengono convertite tramite la tabella codici CP_ACP.
Queste funzioni usano caratteri più adatti e non eseguono il controllo predefinito durante la conversione da Unicode a ANSI. Inoltre, se la stringa non può essere convertita da Unicode a ANSI, la funzione wrapper passa una stringa NULL alla funzione ANSI sottostante. Ciò può verificarsi, ad esempio, quando la memoria non è sufficiente. Il passaggio di una stringa NULL può causare l'esito negativo di alcune funzioni con un errore di parametro non valido, ma altre funzioni accettano la stringa NULL e la considerano come parametro previsto. Ad esempio, si verifica un errore quando la funzione CreateWindowExWrapW tenta di convertire il parametro lpWindowName in ANSI e CreateWindowEx crea una finestra con un didascalia vuoto. Il wrapper non notifica quando si sono verificati questi problemi.
Il livello Microsoft per Unicode (MSLU) verifica la presenza di errori durante la conversione da Unicode a ANSI e restituisce i valori di errore appropriati. Ad esempio, la funzione wrapper AppendMenu in MSLU restituisce 0 se l'elemento non è stato aggiunto correttamente.
(b)
Queste funzioni usano un collegamento con caricamento ritardato alla funzione appropriata. Ciò significa che la DLL che contiene la funzione nella colonna "Inoltra a" non viene caricata dal Shlwapi.dll finché non viene chiamata una funzione in tale DLL. Il linker Microsoft Visual C++ supporta in genere questa funzionalità tramite l'opzione /DELAYLOAD.
(c)
Questa funzione modifica i nomi file. Come indicato in (a), le funzioni converteno tutte le stringhe nella tabella codici CP_ACP. Non controllano se le funzioni di I/O del file sono state impostate sulla modalità ANSI. Se le funzioni di I/O del file sono in modalità OEM, le stringhe verranno convertite in e dal set di caratteri errato. Un'applicazione può impostare le funzioni di I/O del file sulla modalità OEM in modo esplicito chiamando la funzione SetFileApisToOEM .
**Avviso di sicurezza: ** L'uso di queste funzioni wrapper per i nomi di file può compromettere la sicurezza dell'applicazione. Poiché non viene eseguito alcun controllo predefinito e vengono utilizzati caratteri di adattamento ottimale, i caratteri del nome file possono essere convertiti in modi imprevisti. Ciò potrebbe causare attacchi di spoofing del file system. Inoltre, la perdita di dati invisibile all'utente può verificarsi durante la conversione da Unicode a ANSI.
MSLU non presenta queste limitazioni.
(d)
Se la stringa da disegnare richiede un set di caratteri non disponibile nel tipo di carattere selezionato nel contesto del dispositivo, queste funzioni wrapper usano la funzionalità Collegamento caratteri della libreria MLang per eseguire il rendering di ogni carattere in un tipo di carattere appropriato. A differenza della maggior parte delle altre funzioni wrapper, queste funzioni sono funzionali in Microsoft Windows NT 4.0 oltre alle piattaforme ANSI native.
(e)
Le implementazioni Unicode complete di queste funzioni sono disponibili nelle piattaforme ANSI native. Queste funzioni non chiamano la funzione ANSI correlata.
(f)
Se il linguaggio dell'interfaccia utente predefinito per l'utente usa un set di caratteri diverso rispetto alla lingua dell'interfaccia utente predefinita del sistema, il sistema tenta di riscrivere i modelli di dialogo e i controlli della sottoclasse e convertire le voci di menu nel disegno proprietario, in modo che le stringhe nella lingua dell'interfaccia utente predefinita continuino a essere visualizzate correttamente. Gli unici controlli supportati dalle regole di riscrittura del modello di dialogo sono controlli statici, pulsante, casella di riepilogo e casella combinata. Questi controlli sono sottoclassati in modo che la funzione SendMessageWrapW possa ottenere la stringa Unicode originale senza essere tradotta tramite il set di caratteri ANSI. A differenza della maggior parte delle altre funzioni wrapper, queste funzioni sono funzionali in Microsoft Windows NT 4.0 e nelle piattaforme ANSI native. Vedere le osservazioni nella documentazione della funzione MLLoadLibrary per altre informazioni su come vengono determinati il linguaggio dell'interfaccia utente predefinito per l'utente e la lingua dell'interfaccia utente predefinita del sistema.
(g)
Se è necessaria la conversione di stringhe, tutte le stringhe vengono convertite tramite la tabella codici CP_ACP.
Quando si esegue la conversione da ANSI a Unicode per l'output, se la stringa restituita non rientra nel buffer fornito, le funzioni wrapper troncano la stringa. Le funzioni che restituiscono il numero di caratteri copiati nel buffer o il numero di caratteri necessari per evitare il troncamento non restituiscono il numero di caratteri Unicode copiati nel buffer fornito o richiesto dal chiamante della funzione wrapper. Restituiscono il numero di caratteri ANSI copiati nel buffer o richiesti dalla funzione ANSI sottostante. MSLU non presenta queste limitazioni.
(h)
Nei sistemi precedenti a Windows XP, queste funzioni implementano un pool di thread semplificato e una coda timer. In Windows XP e versioni successive, queste funzioni usano il pool di thread di sistema e la coda timer di sistema. Per le funzioni della coda timer, il parametro hQueue deve essere impostato su NULL per indicare che l'operazione deve essere eseguita nella coda timer predefinita.
(i)
Nelle piattaforme Unicode, queste funzioni convertono il messaggio da Unicode a ANSI se la finestra di destinazione è ANSI. Queste funzioni non eseguono la traduzione dei messaggi nelle piattaforme ANSI native. Pertanto, la chiamata di applicazioni che chiamano questa funzione deve garantire che il messaggio sia in formato Unicode nelle piattaforme Unicode e in formato ANSI nelle piattaforme ANSI. Ad esempio, nella chiamata di funzione seguente , wParam deve essere un punto di codice Unicode se il programma è in esecuzione su una piattaforma Unicode e deve essere un carattere ANSI se il programma è in esecuzione in una piattaforma ANSI.
CallWindowProcWrapW(prevWndProc, hwnd, WM_CHAR, wParam, lParam);
MSLU tiene traccia del set di caratteri della routine della finestra di destinazione e converte il messaggio in base alle esigenze.
(j)
Nelle piattaforme ANSI queste funzioni restituiscono la lunghezza della stringa ANSI sottostante, non la lunghezza della stringa Unicode tradotta. MSLU non presenta queste limitazioni.
(CompareExchange)
La sintassi per SHInterlockedCompareExchange è leggermente diversa da quella di InterlockedCompareExchangePointer, ma funziona in modo identico.
void* SHInterlockedCompareExchange(void **ppDest, void *pExch, void *pComp);
(CompareString)
Tenere presente che nelle piattaforme ANSI native, entrambe le stringhe vengono convertite in ANSI e confrontate come stringhe ANSI. Se le stringhe Unicode contengono caratteri che non possono essere rappresentati in ANSI, i risultati potrebbero essere imprevisti. Ad esempio, se la tabella codici ANSI predefinita non supporta i caratteri CJK, le stringhe L"\x66F0" e L"\x6708" verranno confrontate come uguali nelle piattaforme ANSI native perché eseguono entrambi il mapping alla stringa ANSI "?".
(DateTime)
In Shlwapi.dll versione 5.0, fornita con Windows 2000, la tabella codici dell'identificatore delle impostazioni locali passata come primo parametro di GetDateFormatWrapW e GetTimeFormatWrapW deve corrispondere alla tabella codici ANSI corrente. In caso contrario, la stringa restituita potrebbe essere convertita in modo non corretto. Questa limitazione non si applica a Shlwapi.dll versioni 5.5 o successive. Ciò significa che i sistemi Windows XP e versioni successive non sono soggetti a questa limitazione. MSLU non ha questa limitazione.
(DialogBoxParam)
Il parametro lpTemplateName per la funzione DialogBoxParamWrapW non può essere una stringa. Deve essere un ordinale creato dalla macro MAKEINTRESOURCE . La procedura di dialogo specificata dal parametro lpDialogFunc riceve messaggi ANSI su piattaforme ANSI native e messaggi Unicode su piattaforme Unicode native. La procedura di dialogo deve essere preparata per gestire entrambi i casi. MSLU non presenta queste limitazioni.
(ExtTextOut)
Le piattaforme ANSI native implementano la funzione ExtTextOutW e le piattaforme Unicode native. Lo scopo di ExtTextOutWrapW è eseguire il collegamento dei tipi di carattere, come descritto in una nota separata.
(DragQueryFile)
La funzione DragQueryFileWrapW non consente di eseguire query per la lunghezza di un file nell'handle di rilascio passando NULL come parametro lpszFile . MSLU non presenta queste limitazioni.
(FormatMessage)
Nelle piattaforme ANSI native i formati nella stringa non vengono convertiti da Unicode a ANSI. Ad esempio, l'esempio di codice seguente è in errore.
WCHAR szBuffer[MAX_PATH];
DWORD_PTR Arguments[2] = { L"String1", L"String2" };
FormatMessageWrapW(FORMAT_MESSAGE_FROM_STRING,
L"%1!s! %2",
0, 0,
szBuffer,
MAX_PATH,
(va_list*)Arguments);
In questo esempio di codice viene utilizzato il formato "!s!". Nelle piattaforme ANSI native questa stringa viene passata alla versione ANSI della funzione FormatMessage . Di conseguenza, è prevista una stringa ANSI anziché una stringa Unicode. Analogamente, il formato "%2" implica un argomento stringa. Quando viene passata alla funzione ANSI FormatMessage , viene interpretata come stringa ANSI anziché come stringa Unicode. La stringa di formato corretta è L"%1!ws! %2!ws!". Le stringhe vengono stampate correttamente nelle piattaforme ANSI e Unicode.
La funzione non supporta la stringa di formato speciale "%0".
MSLU non presenta queste limitazioni.
(GetClassInfo)
Nelle piattaforme ANSI native i membri lpszMenuName e lpszClassName della struttura WNDCLASS non vengono convertiti in Unicode e vengono sempre impostati su NULL. Inoltre, la routine finestra restituita nel membro lpfnWndProc della struttura WNDCLASS non viene convertita in Unicode e fa riferimento a una routine finestra ANSI. MSLU non presenta queste limitazioni.
(Menu)
In Shlwapi.dll versione 5.0, fornita con Windows 2000, le stringhe delle voci di menu che contengono caratteri di tabulazioni (\t) potrebbero non essere visualizzate correttamente. Questa limitazione non si applica a Shlwapi.dll versioni 5.5 o successive. Ciò significa che i sistemi Windows XP e versioni successive non sono soggetti a questa limitazione. MSLU non ha questa limitazione.
(MenuItemInfo)
Questa funzione supporta solo la versione di Microsoft Windows NT 4.0 della struttura MENUITEMINFOW . Questa struttura non dispone di un membro hbmpItem . Inoltre, la funzione non supporta il flag MIIM_BITMAP. MSLU non presenta queste limitazioni.
(OpenFileName)
Il membro cbSize della struttura OPENFILENAMEW deve essere impostato su sizeof(OPENFILENAME_NT4W).
Il membro lpstrCustomFilter della struttura OPENFILENAMEW deve essere impostato su NULL.
I valori dei membri nMaxFile e nMaxFileTitle della struttura OPENFILENAMEW non devono superare MAX_PATH.
Se il membro lpfnHook della struttura OPENFILENAMEW non è NULL, deve fare riferimento a una procedura di hook ANSI nelle piattaforme ANSI native e a una procedura di hook Unicode su piattaforme Unicode native.
MSLU non presenta queste limitazioni.
(PeekMessage e PostMessage)
Nelle piattaforme ANSI native non viene eseguita alcuna traduzione nel messaggio trasmesso o recuperato. Il messaggio trasmesso/recuperato è ANSI su piattaforme ANSI native e Unicode su piattaforme Unicode native. L'applicazione chiamante deve essere preparata per gestire entrambi i casi. Ad esempio, se il messaggio recuperato è WM_CHAR, wParam è un codice carattere ANSI nelle piattaforme ANSI native, ma si tratta di un punto di codice Unicode nelle piattaforme Unicode native. MSLU non presenta queste limitazioni.
(QueueUserWorkItem)
La funzione SHQueueUserWorkItem è leggermente diversa dalla funzione QueueUserWorkItem corrispondente. La sintassi per SHQueueUserWorkItem è illustrata qui.
BOOL SHQueueUserWorkItem(LPTHREAD_START_ROUTINE pfnCallback,
LPVOID pContext,
LONG lPriority,
DWORD_PTR dwTag,
DWORD_PTR * pdwId,
LPCSTR pszModule,
DWORD dwFlags);
I parametri devono essere impostati come segue:
I parametri pfnCallback e pContext hanno gli stessi significati dei parametri Function e Context , rispettivamente, di QueueUserWorkItem.
Il parametro dwTag è inutilizzato e deve essere impostato su 0.
Il parametro pdwld non è usato e deve essere impostato su NULL.
Il parametro pszModule punta a una stringa ANSI con terminazione Null facoltativa che specifica il nome di una libreria da caricare prima che l'elemento di lavoro inizi e venga scaricato dopo il completamento dell'elemento di lavoro. Questo parametro può essere NULL.
Il parametro dwFlags supporta solo un subset dei valori supportati da QueueUserWorkItem. Vengono riconosciuti i flag seguenti.
Nome Valore Significato TPS_EXECUTEIO 0x00000001 Uguale a WT_EXECUTEINIOTHREAD. TPS_LONGEXECTIME 0x00000008 Uguale a WT_EXECUTELONGFUNCTION. Nota
Il flag TPS_LONGEXECTIME non ha lo stesso valore numerico del flag WT_EXECUTELONGFUNCTION. Quando si usa SHQueueUserWorkItem, il parametro dwFlags deve essere una combinazione di valori TPS_*, non WT_* valori.
SHQueueUserWorkItem restituisce un valore diverso da zero se l'elemento di lavoro è stato accodato correttamente e 0 in caso contrario. Se la funzione ha esito negativo, è possibile usare GetLastError per ottenere informazioni aggiuntive.
(RegisterClass)
Nelle piattaforme ANSI native non viene eseguita alcuna conversione sul membro lpfnWndProc della struttura WNDCLASSW . La finestra riceverà messaggi della finestra ANSI sulle piattaforme ANSI native e i messaggi della finestra Unicode nelle piattaforme Unicode native. La procedura della finestra deve essere preparata per gestire entrambi i casi. MSLU non presenta queste limitazioni.
(RegQueryValueExW)
RegQueryValueExWrapW è stato chiamato anche sotto il nome RegQueryValueExW. Come per qualsiasi funzione senza nome esportata rigorosamente in base all'ordinale, è possibile scegliere il nome noto dalla funzione nel codice.
(SendMessage)
Nelle piattaforme Unicode native, la funzione SendMessageWrapW inoltra alla funzione SendMessageW . Nelle piattaforme ANSI native SendMessageWrapW offre un supporto limitato per la conversione di messaggi Unicode in ANSI. L'elenco dei messaggi supportati è riportato nella tabella seguente. La funzione non tradurrà altri messaggi.
MSLU non presenta queste limitazioni.
| Message | Descrizione |
|---|---|
| CB_ADDSTRING | (b) (f) (c) |
| CB_FINDSTRING | (b) (f) (c) |
| CB_FINDSTRINGEXACT | (a) (f) (c) |
| CB_GETLBTEXT | (b) (f) (c) (o) Il buffer passato nel parametro lParam deve avere spazio per almeno 256 caratteri. |
| CB_GETLBTEXTLEN | (a) |
| CB_INSERTSTRING | (b) (f) (c) |
| CB_SELECTSTRING | (b) (f) (c) |
| EM_CHARFROMPOS | |
| EM_GETLINE | (e) Il valore restituito è il numero di caratteri ANSI copiati. |
| EM_GETSEL | |
| EM_REPLACESEL | (b) (f) |
| EM_SETPASSWORDCHAR | (a) |
| EM_SETSEL | |
| EM_SETWORDBREAKPROC | Questo messaggio non ha alcun effetto. La procedura di interruzione di parola non è impostata. |
| LB_ADDSTRING | (b) (f) (d) |
| LB_FINDSTRING | (b) (f) (d) |
| LB_FINDSTRINGEXACT | (b) (f) (lbs) |
| LB_GETTEXT | (b) (f) (lbs) (o) Il buffer passato nel parametro lParam deve avere spazio per almeno 256 caratteri. |
| LB_GETTEXTLEN | (a) |
| LB_INSERTSTRING | (b) (f) (d) |
| LB_SELECTSTRING | (b) (f) (d) |
| WM_GETTEXT | (b) (f) |
| WM_GETTEXTLENGTH | (a) |
| WM_SETTEXT | (b) (f) |
| WM_SETTINGCHANGE | (a) Il messaggio viene inviato con un timeout di tre secondi. |
(a) La stringa ANSI misurata o recuperata deve soddisfare la condizione seguente: la lunghezza della versione Unicode corrispondente della stringa non può superare la lunghezza della versione ANSI della stringa. Se questa condizione non viene soddisfatta, la lunghezza restituita sarà breve. Se la memoria non è sufficiente per determinare la lunghezza della stringa Unicode, la funzione restituisce zero, non LB_ERR o CB_ERR come potrebbe essere previsto.
(b) Se è necessaria la conversione di stringhe, tutte le stringhe vengono convertite tramite la tabella codici CP_ACP.
Questa funzione usa i caratteri più adatti e non esegue il controllo predefinito durante la conversione da Unicode a ANSI. Inoltre, se la stringa non può essere convertita da Unicode a ANSI, la funzione passa una stringa Null alla funzione ANSI sottostante. Ciò può verificarsi, ad esempio, quando la memoria non è sufficiente. Il passaggio di una stringa Null può causare errori di alcune funzioni con un errore di parametro non valido, ma altre funzioni accettano la stringa Null e la considerano come parametro previsto. Ad esempio, se si verifica un errore quando il wrapper WM_SETTEXT tenta di convertire il titolo della finestra in ANSI, la finestra avrà un didascalia vuoto. La funzione non notifica quando si verificano questi problemi. MSLU non presenta queste limitazioni.
(c) L'handle di finestra specificato deve essere l'handle di un controllo ComboBox o ComboBoxEx. Se l'handle si trova in un controllo combobox di cui è stato creato il proprietario e non è stato creato con lo stile Stili casella di riepilogo , la traduzione di questo messaggio avrà esito negativo e potrebbe anche verificarsi un arresto anomalo.
(d) L'handle di finestra specificato deve essere l'handle di un controllo listbox. Se la casella di riepilogo è disegnare dal proprietario e non è stata creata con lo stile Stili casella di riepilogo, la traduzione di questo messaggio avrà esito negativo e potrebbe anche verificarsi un arresto anomalo.
(e) Se è necessaria la conversione di stringhe, tutte le stringhe vengono convertite tramite la tabella codici CP_ACP.
Quando si esegue la conversione da ANSI a Unicode per l'output, le funzioni wrapper troncano la stringa restituita se non rientra nel buffer specificato. Il valore restituito per le funzioni che restituiscono il numero di caratteri copiati nel buffer o il numero di caratteri necessari per evitare il troncamento fa riferimento al numero di caratteri ANSI copiati nel buffer o richiesti dalla funzione ANSI sottostante, non il numero di caratteri Unicode copiati nel buffer fornito da o richiesto dall'applicazione chiamante che ha chiamato la funzione wrapper. MSLU non ha questa limitazione. Per altri dettagli, vedere Microsoft Layer for Unicode in Windows 95/98/Me Systems.
(SetTimerQueueTimer)
La funzione SHSetTimerQueueTimer è leggermente diversa dalla funzione CreateTimerQueueTimer corrispondente. La sintassi è la seguente:
HANDLE SHSetTimerQueueTimer(HANDLE hQueue,
WAITORTIMERCALLBACK pfnCallback,
LPVOID pContext,
DWORD dwDueTime,
DWORD dwPeriod,
LPCSTR lpszLibrary,
DWORD dwFlags);
I parametri devono essere impostati come segue:
Il parametro hQueue deve essere impostato su NULL, specificando la coda timer predefinita.
I parametri pfnCallback, pContext, dwDueTime e dwPeriod hanno gli stessi significati dei parametri Callback, Parameter, DueTime e Period rispettivamente di CreateTimerQueueTimer.
Il parametro lpszLibrary non è usato e deve essere impostato su NULL.
Il parametro Flags supporta solo un subset dei valori supportati da CreateTimerQueueTimer.
Nome Valore Significato TPS_EXECUTEIO 0x00000001 Uguale a WT_EXECUTEINIOTHREAD TPS_LONGEXECTIME 0x00000008 Uguale a WT_EXECUTELONGFUNCTION Nota
Il flag TPS_LONGEXECTIME non ha lo stesso valore numerico del flag WT_EXECUTELONGFUNCTION. Quando si usa SHSetTimerQueueTimer, il parametro dwFlags deve essere una combinazione di valori TPS_*, non WT_* valori.
SHSetTimerQueueTimer restituisce l'handle del timer creato in caso di esito positivo e NULL in caso contrario.
(ShellExecuteEx)
Il membro lpFile della struttura SHELLEXECUTEINFO passato nel solo parametro di questa funzione può non superare i caratteri INTERNET_MAX_URL_LENGTH. Se il flag SEE_MASK_CLASSNAME viene omesso, il membro lpClass deve essere inizializzato su NULL.
(ValueEx)
Sono supportati solo i tipi di dati del Registro di sistema seguenti: REG_SZ, REG_EXPAND_SZ, REG_BINARY e REG_DWORD. A differenza di queste funzioni wrapper, MSLU supporta anche REG_MULTI_EXPAND_SZ.
(WindowLong)
Nelle piattaforme ANSI native, la funzione non esegue alcuna conversione in nessuna delle piattaforme ANSI native. Ad esempio, se si passa GWLP_WNDPROC, la funzione restituisce la routine della finestra ANSI, non un threadk. MSLU non presenta queste limitazioni.