65 static constexpr bool w = false ;
66 using FIND_DATA_type = WIN32_FIND_DATAA ;
67 using WNDCLASS_type = WNDCLASSA ;
68 using PROPSHEETPAGE_type = PROPSHEETPAGEA ;
69 using PROPSHEETHEADER_type = PROPSHEETHEADERA ;
70 using NOTIFYICONDATA_type = NOTIFYICONDATAA ;
71 #if GCONFIG_HAVE_WINDOWS_STARTUP_INFO_EX
72 using STARTUPINFO_BASE_type = STARTUPINFOA ;
73 using STARTUPINFO_REAL_type = STARTUPINFOEXA ;
74 constexpr DWORD STARTUPINFO_flags = EXTENDED_STARTUPINFO_PRESENT ;
76 using STARTUPINFO_BASE_type = STARTUPINFOA ;
77 using STARTUPINFO_REAL_type = STARTUPINFOA ;
78 constexpr DWORD STARTUPINFO_flags = 0 ;
80 using IShellLink_type = IShellLinkA ;
81 using ADDRINFO_type = ADDRINFOW ;
83 static constexpr bool w = true ;
84 using FIND_DATA_type = WIN32_FIND_DATAW ;
85 using WNDCLASS_type = WNDCLASSW ;
86 using PROPSHEETPAGE_type = PROPSHEETPAGEW ;
87 using PROPSHEETHEADER_type = PROPSHEETHEADERW ;
88 using NOTIFYICONDATA_type = NOTIFYICONDATAW ;
89 #if GCONFIG_HAVE_WINDOWS_STARTUP_INFO_EX
90 using STARTUPINFO_BASE_type = STARTUPINFOW ;
91 using STARTUPINFO_REAL_type = STARTUPINFOEXW ;
92 constexpr DWORD STARTUPINFO_flags = EXTENDED_STARTUPINFO_PRESENT ;
94 using STARTUPINFO_BASE_type = STARTUPINFOW ;
95 using STARTUPINFO_REAL_type = STARTUPINFOW ;
96 constexpr DWORD STARTUPINFO_flags = 0 ;
98 using IShellLink_type = IShellLinkW ;
99 using ADDRINFO_type = ADDRINFOA ;
102 inline std::string getCommandLine()
107 return std::string( GetCommandLineA() ) ;
109 inline DWORD getFileAttributes(
const Path & path )
114 return GetFileAttributesA( path.cstr() ) ;
116 inline HANDLE findFirstFile(
const Path & path , WIN32_FIND_DATAW * find_data_p )
118 return FindFirstFileW(
Convert::widen(path.str()).c_str() , find_data_p ) ;
120 inline HANDLE findFirstFile(
const Path & path , WIN32_FIND_DATAA * find_data_p )
122 return FindFirstFileA( path.cstr() , find_data_p ) ;
124 inline BOOL findNextFile( HANDLE h , WIN32_FIND_DATAW * find_data_p )
126 return FindNextFileW( h , find_data_p ) ;
128 inline BOOL findNextFile( HANDLE h , WIN32_FIND_DATAA * find_data_p )
130 return FindNextFileA( h , find_data_p ) ;
132 inline std::string cFileName(
const WIN32_FIND_DATAW & find_data )
136 inline std::string cFileName(
const WIN32_FIND_DATAA & find_data )
138 return std::string( find_data.cFileName ) ;
140 template <
typename T>
141 void open( T & io ,
const Path & path , std::ios_base::openmode mode )
143 #if GCONFIG_HAVE_EXTENDED_OPEN
146 io.open(
Convert::widen(path.str()).c_str() , mode , _SH_DENYNO ) ;
148 io.open( path.str() , mode , _SH_DENYNO ) ;
154 io.open( path.str() , mode ) ;
157 inline int open(
const Path & path ,
int flags ,
int pmode ,
bool inherit =
false )
160 flags |= _O_NOINHERIT ;
165 #if GCONFIG_HAVE_WSOPEN_S
166 return 0 == _wsopen_s( &fd ,
Convert::widen(path.str()).c_str() , flags , _SH_DENYNO , pmode ) ? fd : -1 ;
168 return _wopen(
Convert::widen(path.str()).c_str() , flags , pmode ) ;
173 return 0 == _sopen_s( &fd , path.cstr() , flags , _SH_DENYNO , pmode ) ? fd : -1 ;
176 inline std::FILE * fopen(
const Path & path ,
const char * mode )
181 return _fsopen( path.cstr() , mode , _SH_DENYNO ) ;
183 inline bool rename(
const Path & from ,
const Path & to )
188 return 0 == std::rename( from.cstr() , to.cstr() ) ;
190 inline bool remove(
const Path & path )
195 return 0 == std::remove( path.cstr() ) ;
197 inline bool rmdir(
const Path & path )
202 return 0 == _rmdir( path.cstr() ) ;
204 inline int mkdir(
const Path & dir )
209 return _mkdir( dir.cstr() ) ;
211 typedef struct _stat64 statbuf_type ;
212 inline int stat(
const Path & path , statbuf_type * statbuf_p )
215 return _wstat64(
Convert::widen(path.str()).c_str() , statbuf_p ) ;
217 return _stat64( path.cstr() , statbuf_p ) ;
219 inline std::string getComputerNameEx( COMPUTER_NAME_FORMAT name_type = ComputerNameNetBIOS )
224 std::vector<wchar_t> buffer ;
225 if( !GetComputerNameExW( name_type , NULL , &size ) && GetLastError() == ERROR_MORE_DATA && size )
226 buffer.resize(
static_cast<std::size_t
>(size) ) ;
229 if( !GetComputerNameExW( name_type , buffer.data() , &size ) ||
230 (
static_cast<std::size_t
>(size)+1U) != buffer.size() )
237 std::vector<char> buffer ;
238 if( !GetComputerNameExA( name_type , NULL , &size ) && GetLastError() == ERROR_MORE_DATA && size )
239 buffer.resize(
static_cast<std::size_t
>(size) ) ;
242 if( !GetComputerNameExA( name_type , buffer.data() , &size ) ||
243 (
static_cast<std::size_t
>(size)+1U) != buffer.size() )
245 return std::string( buffer.data() , buffer.size()-1U ) ;
248 inline BOOL lookupAccountName(
const std::string & full_name ,
char * sid_buffer , DWORD * sidsize_p ,
249 bool with_domain , DWORD * domainsize_p , SID_NAME_USE * type_p )
253 std::vector<wchar_t> domainbuffer( std::max(DWORD(1),*domainsize_p) ) ;
254 return LookupAccountNameW( NULL ,
Convert::widen(full_name).c_str() , sid_buffer , sidsize_p ,
255 with_domain ? domainbuffer.data() :
nullptr , domainsize_p , type_p ) ;
259 std::vector<char> domainbuffer( std::max(DWORD(1),*domainsize_p) ) ;
260 return LookupAccountNameA( NULL , full_name.c_str() , sid_buffer , sidsize_p ,
261 with_domain ? domainbuffer.data() :
nullptr , domainsize_p , type_p ) ;
264 inline BOOL lookupAccountSid( PSID sid , std::string * name_out_p ,
265 bool with_name , DWORD * namesize_p ,
266 bool with_domain , DWORD * domainsize_p , SID_NAME_USE * type_p )
270 std::vector<wchar_t> namebuffer( std::max(DWORD(1),*namesize_p) ) ;
271 std::vector<wchar_t> domainbuffer( std::max(DWORD(1),*domainsize_p) ) ;
272 BOOL rc = LookupAccountSidW( NULL , sid ,
273 with_name ? namebuffer.data() :
nullptr , namesize_p ,
274 with_domain ? domainbuffer.data() :
nullptr , domainsize_p ,
276 if( with_name && name_out_p )
277 *name_out_p =
Convert::narrow( namebuffer.data() , namebuffer.size() ) ;
282 std::vector<char> namebuffer( std::max(DWORD(1),*namesize_p) ) ;
283 std::vector<char> domainbuffer( std::max(DWORD(1),*domainsize_p) ) ;
284 BOOL rc = LookupAccountSidA( NULL , sid ,
285 with_name ? namebuffer.data() :
nullptr , namesize_p ,
286 with_domain ? domainbuffer.data() :
nullptr , domainsize_p ,
288 if( with_name && name_out_p )
289 *name_out_p = std::string( namebuffer.data() , namebuffer.size() ) ;
293 inline std::string convertSidToStringSid( PSID sid_p )
297 wchar_t * str_p = nullptr ;
298 if( !ConvertSidToStringSidW( sid_p , &str_p ) || str_p ==
nullptr )
300 std::wstring s( str_p ) ;
306 char * str_p = nullptr ;
307 if( !ConvertSidToStringSidA( sid_p , &str_p ) || str_p ==
nullptr )
309 std::string s( str_p ) ;
314 inline unsigned int getTextMetricsHeight( HDC hdc )
noexcept
319 GetTextMetricsW( hdc , &tm ) ;
320 return static_cast<unsigned int>( tm.tmHeight + tm.tmExternalLeading ) ;
325 GetTextMetricsA( hdc , &tm ) ;
326 return static_cast<unsigned int>( tm.tmHeight + tm.tmExternalLeading ) ;
329 inline HPROPSHEETPAGE createPropertySheetPage( PROPSHEETPAGEW * page ,
const std::string & title ,
int dialog_id )
332 page->pszTitle = wtitle.c_str() ;
333 page->pszTemplate = dialog_id ? MAKEINTRESOURCEW(dialog_id) : 0 ;
334 return CreatePropertySheetPageW( page ) ;
336 inline HPROPSHEETPAGE createPropertySheetPage( PROPSHEETPAGEA * page ,
const std::string & title ,
int dialog_id )
noexcept
338 page->pszTitle = title.c_str() ;
339 page->pszTemplate = dialog_id ? MAKEINTRESOURCEA(dialog_id) : 0 ;
340 return CreatePropertySheetPageA( page ) ;
342 inline INT_PTR propertySheet( PROPSHEETHEADERW * header ,
const std::string & title ,
int icon_id )
345 header->pszIcon = icon_id ? MAKEINTRESOURCEW(icon_id) : 0 ;
346 header->pszCaption = wtitle.c_str() ;
347 return PropertySheetW( header ) ;
349 inline INT_PTR propertySheet( PROPSHEETHEADERA * header ,
const std::string & title ,
int icon_id )
noexcept
351 header->pszIcon = icon_id ? MAKEINTRESOURCEA(icon_id) : 0 ;
352 header->pszCaption = title.c_str() ;
353 return PropertySheetA( header ) ;
355 inline void reportEvent( HANDLE h , DWORD
id , WORD type ,
const char * message )
360 const wchar_t * p [] = { wmessage.c_str() ,
nullptr } ;
361 ReportEventW( h , type , 0 ,
id ,
nullptr , 1 , 0 , p ,
nullptr ) ;
365 const char * p [] = { message ,
nullptr } ;
366 ReportEventA( h , type , 0 ,
id ,
nullptr , 1 , 0 , p ,
nullptr ) ;
369 inline HANDLE registerEventSource(
const std::string & name )
372 return RegisterEventSourceW(
nullptr ,
Convert::widen(name).c_str() ) ;
374 return RegisterEventSourceA(
nullptr , name.c_str() ) ;
376 inline LSTATUS regCreateKey(
const Path & reg_path , HKEY * key_out_p ,
377 HKEY hkey_in = HKEY_LOCAL_MACHINE ,
bool * is_new_p =
nullptr )
380 DWORD disposition = 0 ;
382 result = RegCreateKeyExW( hkey_in ,
Convert::widen(reg_path.str()).c_str() ,
383 0 , NULL , 0 , KEY_ALL_ACCESS , NULL , key_out_p , &disposition ) ;
385 result = RegCreateKeyExA( hkey_in , reg_path.cstr() ,
386 0 , NULL , 0 , KEY_ALL_ACCESS , NULL , key_out_p , &disposition ) ;
388 *is_new_p = disposition == REG_CREATED_NEW_KEY ;
391 inline LSTATUS regOpenKey( HKEY key_in ,
const Path & sub , HKEY * key_out_p ,
bool read_only =
false )
393 REGSAM access = read_only ? (STANDARD_RIGHTS_READ|KEY_QUERY_VALUE) : KEY_ALL_ACCESS ;
395 return RegOpenKeyExW( key_in ,
Convert::widen(sub.str()).c_str() ,
396 0 , access , key_out_p ) ;
398 return RegOpenKeyExA( key_in , sub.cstr() ,
399 0 , access , key_out_p ) ;
401 inline LSTATUS regDeleteKey( HKEY key ,
const Path & sub )
406 return RegDeleteKeyA( key , sub.cstr() ) ;
408 inline LSTATUS regQueryValueType( HKEY key ,
const Path & sub , DWORD * type_out_p , DWORD * size_out_p )
411 return RegQueryValueExW( key ,
Convert::widen(sub.str()).c_str() ,
412 0 , type_out_p ,
nullptr , size_out_p ) ;
414 return RegQueryValueExA( key , sub.cstr() ,
415 0 , type_out_p ,
nullptr , size_out_p ) ;
417 inline LSTATUS regGetValueString( HKEY key ,
const Path & sub , std::string * value_out_p )
423 status = RegQueryValueExW( key ,
Convert::widen(sub.str()).c_str() , 0 , &type ,
nullptr , &size ) ;
425 status = RegQueryValueExA( key , sub.cstr() , 0 , &type ,
nullptr , &size ) ;
427 return ERROR_INVALID_DATA ;
428 if( status != ERROR_SUCCESS )
432 std::vector<wchar_t> buffer(
static_cast<std::size_t
>(size)+1U ,
'\0' ) ;
433 status = RegQueryValueExW( key ,
Convert::widen(sub.str()).c_str() , 0 , &type ,
434 reinterpret_cast<BYTE*
>(buffer.data()) , &size ) ;
435 if( status != ERROR_SUCCESS )
437 buffer[std::min(buffer.size()-1U,
static_cast<std::size_t
>(size))] = L
'\0' ;
442 std::vector<char> buffer(
static_cast<std::size_t
>(size)+1U ,
'\0' ) ;
443 status = RegQueryValueExA( key , sub.cstr() , 0 , &type ,
444 reinterpret_cast<BYTE*
>(buffer.data()) , &size ) ;
445 if( status != ERROR_SUCCESS )
447 buffer[std::min(buffer.size()-1U,
static_cast<std::size_t
>(size))] =
'\0' ;
448 *value_out_p = std::string( buffer.data() ) ;
452 inline LSTATUS regGetValueNumber( HKEY key ,
const Path & sub , DWORD * value_out_p )
458 status = RegQueryValueExW( key ,
Convert::widen(sub.str()).c_str() , 0 ,
459 &type ,
reinterpret_cast<BYTE*
>(value_out_p) , &size ) ;
461 status = RegQueryValueExA( key , sub.cstr() , 0 ,
462 &type ,
reinterpret_cast<BYTE*
>(value_out_p) , &size ) ;
463 if( type != REG_DWORD || size < 4U )
464 return ERROR_INVALID_DATA ;
465 if( status != ERROR_SUCCESS )
469 inline LSTATUS regSetValue( HKEY key ,
const Path & sub ,
const std::string & s )
474 const BYTE * p =
reinterpret_cast<const BYTE*
>(ws.c_str()) ;
475 DWORD n =
static_cast<DWORD
>( (s.size()*2U)+1U ) ;
476 return RegSetValueExW( key ,
Convert::widen(sub.str()).c_str() , 0 , REG_SZ , p , n ) ;
480 DWORD n =
static_cast<DWORD
>( s.size()+1U ) ;
481 const BYTE * p =
reinterpret_cast<const BYTE*
>(s.c_str()) ;
482 return RegSetValueExA( key , sub.cstr() , 0 , REG_SZ , p , n ) ;
485 inline LSTATUS regSetValue( HKEY key ,
const Path & sub , DWORD n )
488 return RegSetValueExW( key ,
Convert::widen(sub.str()).c_str() , 0 , REG_DWORD ,
489 reinterpret_cast<const BYTE*
>(&n) ,
sizeof(DWORD) ) ;
491 return RegSetValueExA( key , sub.cstr() , 0 , REG_DWORD ,
492 reinterpret_cast<const BYTE*
>(&n) ,
sizeof(DWORD) ) ;
494 inline BOOL createProcess( std::string_view exe , std::string_view command_line ,
495 const char * ,
const wchar_t * env_wchar_block_p ,
496 const Path * cd_path_p , DWORD startup_info_flags ,
497 STARTUPINFOW * startup_info , PROCESS_INFORMATION * info_ptr ,
bool inherit =
true )
499 return CreateProcessW( exe.empty() ?
nullptr :
Convert::widen(exe).c_str() ,
502 inherit , startup_info_flags|CREATE_UNICODE_ENVIRONMENT ,
503 const_cast<wchar_t*
>(env_wchar_block_p) ,
505 startup_info , info_ptr ) ;
507 inline BOOL createProcess(
const std::string & exe ,
const std::string & command_line ,
508 const char * env_char_block_p ,
const wchar_t * ,
509 const Path * cd_path_p , DWORD startup_info_flags ,
510 STARTUPINFOA * startup_info , PROCESS_INFORMATION * info_ptr ,
bool inherit =
true )
512 return CreateProcessA( exe.empty() ?
nullptr : exe.c_str() ,
513 const_cast<char*
>(command_line.c_str()) ,
515 inherit , startup_info_flags ,
516 const_cast<char*
>(env_char_block_p) ,
517 cd_path_p ? cd_path_p->cstr() :
nullptr ,
518 startup_info , info_ptr ) ;
520 inline std::string windowsPath()
524 std::vector<wchar_t> buffer( MAX_PATH+1 ) ;
526 unsigned int n = GetWindowsDirectoryW( buffer.data() , MAX_PATH ) ;
527 if( n == 0 || n > MAX_PATH )
529 return Convert::narrow( buffer.data() ,
static_cast<std::size_t
>(n) ) ;
533 std::vector<char> buffer( MAX_PATH+1 ) ;
535 unsigned int n = GetWindowsDirectoryA( buffer.data() , MAX_PATH ) ;
536 if( n == 0 || n > MAX_PATH )
538 return std::string( buffer.data() ,
static_cast<std::size_t
>(n) ) ;
541 inline std::string strerror(
int errno_ )
545 #if GCONFIG_HAVE_WCSERROR_S
546 std::vector<wchar_t> buffer( 80U ,
'\0' ) ;
547 if( _wcserror_s( buffer.data() , buffer.size()-1U , errno_ ) || buffer.at(0U) == L
'\0' )
548 return std::string(
"unknown error (").append(std::to_string(errno_)).append(1U,
')') ;
551 std::vector<char> buffer( 80U ,
'\0' ) ;
552 if( strerror_s( buffer.data() , buffer.size()-1U , errno_ ) || buffer.at(0U) ==
'\0' )
553 return std::string(
"unknown error (").append(std::to_string(errno_)).append(1U,
')') ;
559 std::vector<char> buffer( 80U ,
'\0' ) ;
560 if( strerror_s( buffer.data() , buffer.size()-1U , errno_ ) || buffer.at(0U) ==
'\0' )
561 return std::string(
"unknown error (").append(std::to_string(errno_)).append(1U,
')') ;
562 return {buffer.data()} ;
565 inline std::string formatMessage( DWORD e )
569 wchar_t * ptr = nullptr ;
570 FormatMessageW( FORMAT_MESSAGE_ALLOCATE_BUFFER |
571 FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS ,
572 NULL , e , MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT) ,
573 reinterpret_cast<wchar_t*
>(&ptr) , 1 , NULL ) ;
575 if( ptr ) LocalFree( ptr ) ;
580 char * ptr = nullptr ;
581 FormatMessageA( FORMAT_MESSAGE_ALLOCATE_BUFFER |
582 FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS ,
583 NULL , e , MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT) ,
584 reinterpret_cast<char*
>(&ptr) , 1 , NULL ) ;
585 std::string result = ptr ? std::string(ptr) :
std::string() ;
586 if( ptr ) LocalFree( ptr ) ;
594 std::vector<wchar_t> buffer ;
595 std::size_t sizes[] = { 80U , 1024U , 32768U , 0U } ;
596 for( std::size_t * size_p = sizes ; *size_p ; ++size_p )
598 buffer.resize( *size_p+1U ,
'\0' ) ;
599 DWORD buffer_size =
static_cast<DWORD
>( buffer.size() ) ;
600 DWORD rc = GetModuleFileNameW( HNULL , buffer.data() , buffer_size ) ;
601 if( rc == 0 ) break ;
602 if( rc < buffer_size )
603 return {
Convert::narrow( std::wstring(buffer.data(),
static_cast<std::size_t
>(rc)) )} ;
609 std::vector<char> buffer ;
610 std::size_t sizes[] = { 80U , 1024U , 32768U , 0U } ;
611 for( std::size_t * size_p = sizes ; *size_p ; ++size_p )
613 buffer.resize( *size_p+1U ,
'\0' ) ;
614 DWORD buffer_size =
static_cast<DWORD
>( buffer.size() ) ;
615 DWORD rc = GetModuleFileNameA( HNULL , buffer.data() , buffer_size ) ;
616 if( rc == 0 ) break ;
617 if( rc < buffer_size )
618 return {std::string_view( buffer.data() ,
static_cast<std::size_t
>(rc) )} ;
627 wchar_t * p = _wgetcwd(
nullptr , 2048 ) ;
636 char * p = _getcwd(
nullptr , 2048 ) ;
639 Path result( (std::string_view(p)) ) ;
644 inline std::string getenv(
const std::string & name ,
const std::string & default_ )
648 #if GCONFIG_HAVE_WGETENV_S
651 if( n == 0U )
return default_ ;
652 std::vector<wchar_t> buffer( n ) ;
653 auto rc = _wgetenv_s( &n , buffer.data() , buffer.size() ,
Convert::widen(name).c_str() ) ;
654 if( rc != 0 || n != buffer.size() )
return default_ ;
658 if( p ==
nullptr )
return default_ ;
664 #if GCONFIG_HAVE_GETENV_S
666 getenv_s( &n ,
nullptr , 0U , name.c_str() ) ;
667 if( n == 0U )
return default_ ;
668 std::vector<char> buffer( n ) ;
669 auto rc = getenv_s( &n , buffer.data() , buffer.size() , name.c_str() ) ;
670 if( rc != 0 || n != buffer.size() )
return default_ ;
671 return { buffer.data() , buffer.size()-1U } ;
673 const char * p = ::getenv( name.c_str() ) ;
674 if( p ==
nullptr )
return default_ ;
679 inline errno_t putenv(
const std::string & key ,
const std::string & value )
683 #if GCONFIG_HAVE_WPUTENV_S
687 GDEF_WARNING_DISABLE_START( 4996 )
688 _putenv( strdup(s.c_str()) ) ;
689 GDEF_WARNING_DISABLE_END
695 return _putenv_s( key.c_str() , value.c_str() ) ;
698 inline bool messageBox( HWND hparent ,
const std::string & message ,
const std::string & title , DWORD type )
703 return rc == IDOK || rc == IDYES ;
707 auto rc = MessageBoxA( hparent , message.c_str() , title.c_str() , type ) ;
708 return rc == IDOK || rc == IDYES ;
711 inline bool setWindowText( HWND hwnd ,
const std::string & text )
716 return SetWindowTextA( hwnd , text.c_str() ) ;
718 inline std::string getWindowText( HWND hwnd )
722 int length = GetWindowTextLengthW( hwnd ) ;
723 if( length <= 0 )
return {} ;
724 std::vector<wchar_t> buffer(
static_cast<std::size_t
>(length)+2U ) ;
725 GetWindowTextW( hwnd , buffer.data() , length+1 ) ;
726 buffer[buffer.size()-1U] = L
'\0' ;
731 int length = GetWindowTextLengthA( hwnd ) ;
732 if( length <= 0 )
return {} ;
733 std::vector<char> buffer(
static_cast<std::size_t
>(length)+2U ) ;
734 GetWindowTextA( hwnd , buffer.data() , length+1 ) ;
735 buffer[buffer.size()-1U] =
'\0' ;
736 return {buffer.data()} ;
739 inline int getWindowTextLength( HWND hwnd )
noexcept
742 return GetWindowTextLengthW( hwnd ) ;
744 return GetWindowTextLengthA( hwnd ) ;
746 inline HICON loadIcon( HINSTANCE hinstance ,
unsigned int icon_id )
noexcept
749 return LoadIconW( hinstance , MAKEINTRESOURCEW(icon_id) ) ;
751 return LoadIconA( hinstance , MAKEINTRESOURCEA(icon_id) ) ;
753 inline HICON loadIconApplication() noexcept
759 return LoadIcon( HNULL , IDI_APPLICATION ) ;
761 inline HCURSOR loadCursor( HINSTANCE hinstance ,
int resource_id )
noexcept
764 return LoadCursorW( hinstance , MAKEINTRESOURCEW(resource_id) ) ;
766 return LoadCursorA( hinstance , MAKEINTRESOURCEA(resource_id) ) ;
768 inline HCURSOR loadCursorArrow() noexcept
770 return LoadCursor( HNULL , IDC_ARROW ) ;
772 inline HCURSOR loadCursorWait() noexcept
774 return LoadCursor( HNULL , IDC_WAIT ) ;
776 inline int shellNotifyIcon( HINSTANCE hinstance , DWORD , NOTIFYICONDATAW * data ,
777 unsigned int icon_id , std::string_view tip )
780 data->hIcon = LoadIconW( hinstance , MAKEINTRESOURCEW(icon_id) ) ;
781 if( data->hIcon == HNULL )
return 2 ;
784 constexpr std::size_t n =
sizeof(data->szTip) /
sizeof(data->szTip[0]) ;
785 static_assert( n > 0U ,
"" ) ;
786 for( std::size_t i = 0U ; i < n ; i++ )
787 data->szTip[i] = ( i < wtip.size() ? wtip[i] : L
'\0' ) ;
788 data->szTip[n-1U] = L
'\0' ;
790 return Shell_NotifyIconW( NIM_ADD , data ) ? 0 : 1 ;
792 inline int shellNotifyIcon( HINSTANCE hinstance , DWORD , NOTIFYICONDATAA * data ,
793 unsigned int icon_id , std::string_view tip )
796 data->hIcon = LoadIconA( hinstance , MAKEINTRESOURCEA(icon_id) ) ;
797 if( data->hIcon == HNULL )
return 2 ;
799 constexpr std::size_t n =
sizeof(data->szTip) /
sizeof(data->szTip[0]) ;
800 static_assert( n > 0U ,
"" ) ;
801 for( std::size_t i = 0U ; i < n ; i++ )
802 data->szTip[i] = ( i < tip.size() ? tip[i] :
'\0' ) ;
803 data->szTip[n-1U] =
'\0' ;
805 return Shell_NotifyIconA( NIM_ADD , data ) ? 0 : 1 ;
807 inline bool shellNotifyIcon( DWORD message , NOTIFYICONDATAW * data , std::nothrow_t )
noexcept
809 return Shell_NotifyIconW( message , data ) ;
811 inline bool shellNotifyIcon( DWORD message , NOTIFYICONDATAA * data , std::nothrow_t )
noexcept
813 return Shell_NotifyIconA( message , data ) ;
815 inline unsigned int dragQueryFile( HDROP hdrop )
noexcept
818 return DragQueryFileW( hdrop , 0xFFFFFFFF ,
nullptr , 0 ) ;
820 return DragQueryFileA( hdrop , 0xFFFFFFFF ,
nullptr , 0 ) ;
822 inline std::string dragQueryFile( HDROP hdrop ,
unsigned int i )
826 unsigned int n = DragQueryFileW( hdrop , i ,
nullptr , 0U ) ;
827 std::vector<wchar_t> buffer( std::size_t(n)+1U , L
'\0' ) ;
828 n = DragQueryFileW( hdrop , i , buffer.data() , n+1U ) ;
829 return Convert::narrow( buffer.data() , std::min(std::size_t(n),buffer.size()) ) ;
833 unsigned int n = DragQueryFileA( hdrop , i ,
nullptr , 0U ) ;
834 std::vector<char> buffer( std::size_t(n)+1U ,
'\0' ) ;
835 n = DragQueryFileA( hdrop , i , buffer.data() , n+1U ) ;
836 return { buffer.data() , std::min(std::size_t(n),buffer.size()) } ;
839 inline INT_PTR dialogBoxParam( HINSTANCE hinstance ,
int resource_id , HWND parent , DLGPROC fn , LPARAM lparam )
842 return DialogBoxParamW( hinstance , MAKEINTRESOURCEW(resource_id) , parent , fn , lparam ) ;
844 return DialogBoxParamA( hinstance , MAKEINTRESOURCEA(resource_id) , parent , fn , lparam ) ;
846 inline INT_PTR dialogBoxParam( HINSTANCE hinstance ,
const std::string & resource , HWND parent , DLGPROC fn , LPARAM lparam )
849 return DialogBoxParamW( hinstance ,
Convert::widen(resource).c_str() , parent , fn , lparam ) ;
851 return DialogBoxParamA( hinstance , resource.c_str() , parent , fn , lparam ) ;
853 inline HWND createDialogParam( HINSTANCE hinstance ,
int resource_id , HWND parent , DLGPROC fn , LPARAM lparam )
856 return CreateDialogParamW( hinstance , MAKEINTRESOURCEW(resource_id) , parent , fn , lparam ) ;
858 return CreateDialogParamA( hinstance , MAKEINTRESOURCEA(resource_id) , parent , fn , lparam ) ;
860 inline HWND createDialogParam( HINSTANCE hinstance ,
const std::string & resource , HWND parent , DLGPROC fn , LPARAM lparam )
863 return CreateDialogParamW( hinstance ,
Convert::widen(resource).c_str() , parent , fn , lparam ) ;
865 return CreateDialogParamA( hinstance , resource.c_str() , parent , fn , lparam ) ;
867 inline void getClassInfo( HINSTANCE hinstance , std::string_view name , WNDCLASSW * info )
869 GetClassInfoW( hinstance ,
Convert::widen(name).c_str() , info ) ;
871 inline void getClassInfo( HINSTANCE hinstance ,
const std::string & name , WNDCLASSA * info )
873 GetClassInfoA( hinstance , name.c_str() , info ) ;
875 inline ATOM registerClass( WNDCLASSW info , std::string_view name ,
unsigned int menu_resource_id = 0U )
878 info.lpszClassName = wname.c_str() ;
879 if( menu_resource_id )
880 info.lpszMenuName = MAKEINTRESOURCEW(menu_resource_id) ;
881 return RegisterClassW( &info ) ;
883 inline ATOM registerClass( WNDCLASSA info ,
const std::string & name ,
unsigned int menu_resource_id = 0U )
885 info.lpszClassName = name.c_str() ;
886 if( menu_resource_id )
887 info.lpszMenuName = MAKEINTRESOURCEA(menu_resource_id) ;
888 return RegisterClassA( &info ) ;
890 inline std::string getClassName( HWND hwnd )
894 std::vector<wchar_t> buffer( 257U ) ;
896 GetClassNameW( hwnd , buffer.data() ,
static_cast<int>(buffer.size()-1U) ) ;
897 buffer[buffer.size()-1U] = L
'\0' ;
902 std::vector<char> buffer( 257U ) ;
904 GetClassNameA( hwnd , buffer.data() ,
static_cast<int>(buffer.size()-1U) ) ;
905 buffer[buffer.size()-1U] =
'\0' ;
906 return {buffer.data()} ;
909 inline HWND createWindowEx( DWORD extended_style ,
const std::string & class_name ,
910 const std::string & title , DWORD style ,
int x ,
int y ,
int dx ,
int dy ,
911 HWND parent , HMENU menu , HINSTANCE hinstance ,
void * vp )
914 return CreateWindowExW( extended_style ,
916 style , x , y , dx , dy , parent , menu , hinstance , vp ) ;
918 return CreateWindowExA( extended_style ,
919 class_name.c_str() , title.c_str() ,
920 style , x , y , dx , dy , parent , menu , hinstance , vp ) ;
922 inline void check_hwnd( HWND hwnd )
924 if( w != !!IsWindowUnicode(hwnd) )
925 throw std::runtime_error(
"unicode window mismatch" ) ;
927 inline LRESULT callWindowProc( LONG_PTR fn , HWND hwnd , UINT message , WPARAM wparam , LPARAM lparam )
931 return CallWindowProcW(
reinterpret_cast<WNDPROC
>(fn) , hwnd , message , wparam , lparam ) ;
933 return CallWindowProcA(
reinterpret_cast<WNDPROC
>(fn) , hwnd , message , wparam , lparam ) ;
936 inline LRESULT defWindowProc( HWND hwnd , UINT message , WPARAM wparam , LPARAM lparam )
940 return DefWindowProcW( hwnd , message , wparam , lparam ) ;
942 return DefWindowProcA( hwnd , message , wparam , lparam ) ;
944 inline LRESULT defDlgProc( HWND hwnd , UINT message , WPARAM wparam , LPARAM lparam )
948 return DefDlgProcW( hwnd , message , wparam , lparam ) ;
950 return DefDlgProcA( hwnd , message , wparam , lparam ) ;
952 inline bool isDialogMessage( HWND hdlg , MSG * msg )
noexcept
955 return IsDialogMessageW( hdlg , msg ) ;
957 return IsDialogMessageA( hdlg , msg ) ;
959 inline bool winHelp( HWND hwnd ,
const G::Path & path ,
unsigned int id )
964 return WinHelpA( hwnd , path.
cstr() ,
id , 0 ) ;
966 inline HMENU loadMenu( HINSTANCE hinstance ,
int id )
969 return LoadMenuW( hinstance , MAKEINTRESOURCEW(
id) ) ;
971 return LoadMenuA( hinstance , MAKEINTRESOURCEA(
id) ) ;
973 inline std::string getMenuString( HMENU hmenu , UINT
id , UINT flags )
977 int n = GetMenuStringW( hmenu ,
id ,
nullptr , 0 , flags ) ;
980 std::vector<wchar_t> buffer(
static_cast<std::size_t
>(n)+1U ) ;
981 n = GetMenuStringW( hmenu ,
id , buffer.data() ,
static_cast<int>(buffer.size()) , flags ) ;
982 if( n <= 0 ||
static_cast<std::size_t
>(n) != (buffer.size()-1U) )
988 int n = GetMenuStringA( hmenu ,
id ,
nullptr , 0 , flags ) ;
991 std::vector<char> buffer(
static_cast<std::size_t
>(n)+1U ) ;
992 n = GetMenuStringA( hmenu ,
id , buffer.data() ,
static_cast<int>(buffer.size()) , flags ) ;
993 if( n <= 0 ||
static_cast<std::size_t
>(n) != (buffer.size()-1U) )
995 return std::string( buffer.data() , buffer.size()-1U ) ;
998 inline void insertMenuItem( HMENU hmenu , UINT
id ,
const std::string & name )
1003 MENUITEMINFOW item {} ;
1004 item.cbSize =
sizeof( item ) ;
1005 item.fMask = MIIM_STRING | MIIM_ID ;
1006 item.fType = MFT_STRING ;
1008 item.dwTypeData =
const_cast<wchar_t*
>( wname.c_str() ) ;
1009 item.cch =
static_cast<UINT
>( wname.size() ) ;
1010 InsertMenuItemW( hmenu , 0 , TRUE , &item ) ;
1014 MENUITEMINFOA item {} ;
1015 item.cbSize =
sizeof( item ) ;
1016 item.fMask = MIIM_STRING | MIIM_ID ;
1017 item.fType = MFT_STRING ;
1019 item.dwTypeData =
const_cast<char*
>( name.c_str() ) ;
1020 item.cch =
static_cast<UINT
>( name.size() ) ;
1021 InsertMenuItemA( hmenu , 0 , TRUE , &item ) ;
1024 inline SC_HANDLE openSCManagerW( DWORD access )
noexcept
1026 return OpenSCManagerW(
nullptr ,
nullptr , access ) ;
1028 inline SC_HANDLE openSCManager( DWORD access )
noexcept
1031 return OpenSCManagerW(
nullptr ,
nullptr , access ) ;
1033 return OpenSCManagerA(
nullptr ,
nullptr , access ) ;
1035 inline BOOL startServiceW( SC_HANDLE hservice )
noexcept
1037 return StartServiceW( hservice , 0 ,
nullptr ) ;
1039 inline BOOL startService( SC_HANDLE hservice )
noexcept
1042 return StartServiceW( hservice , 0 ,
nullptr ) ;
1044 return StartServiceA( hservice , 0 ,
nullptr ) ;
1046 using ServiceMainWFn = void (WINAPI *)( DWORD ,
wchar_t ** ) ;
1047 using ServiceMainAFn = void (WINAPI *)( DWORD ,
char ** ) ;
1048 inline BOOL startServiceCtrlDispatcherW( ServiceMainWFn w_fn )
noexcept
1050 SERVICE_TABLE_ENTRYW table [2] = { {
const_cast<wchar_t*
>(L
"") , w_fn } , { nullptr ,
nullptr } } ;
1051 return StartServiceCtrlDispatcherW( table ) ;
1053 inline BOOL startServiceCtrlDispatcher( ServiceMainWFn w_fn , ServiceMainAFn a_fn )
noexcept
1057 SERVICE_TABLE_ENTRYW table [2] = { {
const_cast<wchar_t*
>(L
"") , w_fn } , { nullptr ,
nullptr } } ;
1058 return StartServiceCtrlDispatcherW( table ) ;
1062 SERVICE_TABLE_ENTRYA table [2] = { {
const_cast<char*
>(
"") , a_fn } , { nullptr ,
nullptr } } ;
1063 return StartServiceCtrlDispatcherA( table ) ;
1066 inline SC_HANDLE openServiceW( SC_HANDLE hmanager ,
const std::string & name , DWORD flags )
1068 return OpenServiceW( hmanager ,
Convert::widen(name).c_str() , flags ) ;
1070 inline SC_HANDLE openService( SC_HANDLE hmanager ,
const std::string & name , DWORD flags )
1073 return OpenServiceW( hmanager ,
Convert::widen(name).c_str() , flags ) ;
1075 return OpenServiceA( hmanager , name.c_str() , flags ) ;
1077 inline SC_HANDLE createServiceW( SC_HANDLE hmanager ,
const std::string & name ,
1078 const std::string & display_name , DWORD start_type ,
const std::string & commandline )
1080 return CreateServiceW( hmanager ,
1082 SERVICE_ALL_ACCESS , SERVICE_WIN32_OWN_PROCESS , start_type , SERVICE_ERROR_NORMAL ,
1084 nullptr ,
nullptr ,
nullptr ,
nullptr ,
nullptr ) ;
1086 inline SC_HANDLE createService( SC_HANDLE hmanager ,
const std::string & name ,
1087 const std::string & display_name , DWORD start_type ,
const std::string & commandline )
1090 return CreateServiceW( hmanager ,
1092 SERVICE_ALL_ACCESS , SERVICE_WIN32_OWN_PROCESS , start_type , SERVICE_ERROR_NORMAL ,
1094 nullptr ,
nullptr ,
nullptr ,
nullptr ,
nullptr ) ;
1096 return CreateServiceA( hmanager ,
1097 name.c_str() , display_name.c_str() ,
1098 SERVICE_ALL_ACCESS , SERVICE_WIN32_OWN_PROCESS , start_type , SERVICE_ERROR_NORMAL ,
1099 commandline.c_str() ,
1100 nullptr ,
nullptr ,
nullptr ,
nullptr ,
nullptr ) ;
1102 inline SERVICE_STATUS_HANDLE registerServiceCtrlHandlerW(
const std::string & service_name ,
void (WINAPI *handler_fn)(DWORD) )
1104 return RegisterServiceCtrlHandlerW(
Convert::widen(service_name).c_str() , handler_fn ) ;
1106 inline SERVICE_STATUS_HANDLE registerServiceCtrlHandler(
const std::string & service_name ,
void (WINAPI *handler_fn)(DWORD) )
1109 return RegisterServiceCtrlHandlerW(
Convert::widen(service_name).c_str() , handler_fn ) ;
1111 return RegisterServiceCtrlHandlerA( service_name.c_str() , handler_fn ) ;
1113 inline bool changeServiceConfigW( SC_HANDLE hmanager ,
const std::string & description )
1116 SERVICE_DESCRIPTIONW service_description {} ;
1117 service_description.lpDescription =
const_cast<wchar_t*
>( wdescription.c_str() ) ;
1118 return ChangeServiceConfig2W( hmanager , SERVICE_CONFIG_DESCRIPTION , &service_description ) ;
1120 inline bool changeServiceConfig( SC_HANDLE hmanager ,
const std::string & description )
1125 SERVICE_DESCRIPTIONW service_description {} ;
1126 service_description.lpDescription =
const_cast<wchar_t*
>( wdescription.c_str() ) ;
1127 return ChangeServiceConfig2W( hmanager , SERVICE_CONFIG_DESCRIPTION , &service_description ) ;
1131 SERVICE_DESCRIPTIONA service_description {} ;
1132 service_description.lpDescription =
const_cast<char*
>( description.c_str() ) ;
1133 return ChangeServiceConfig2A( hmanager , SERVICE_CONFIG_DESCRIPTION , &service_description ) ;
1136 inline LONG setWindowLong( HWND hwnd ,
int index , LONG value )
noexcept
1139 return SetWindowLongW( hwnd , index , value ) ;
1141 return SetWindowLongA( hwnd , index , value ) ;
1143 inline LONG_PTR setWindowLongPtr( HWND hwnd ,
int index , LONG_PTR value )
noexcept
1146 return SetWindowLongPtrW( hwnd , index , value ) ;
1148 return SetWindowLongPtrA( hwnd , index , value ) ;
1150 inline LONG getWindowLong( HWND hwnd ,
int index )
noexcept
1153 return GetWindowLongW( hwnd , index ) ;
1155 return GetWindowLongA( hwnd , index ) ;
1157 inline LONG_PTR getWindowLongPtr( HWND hwnd ,
int index )
noexcept
1160 return GetWindowLongPtrW( hwnd , index ) ;
1162 return GetWindowLongPtrA( hwnd , index ) ;
1164 inline LRESULT sendMessage( HWND hwnd , UINT msg , WPARAM wparam , LPARAM lparam )
noexcept
1167 return SendMessageW( hwnd , msg , wparam , lparam ) ;
1169 return SendMessageA( hwnd , msg , wparam , lparam ) ;
1171 inline LRESULT sendMessageString( HWND hwnd , UINT msg , WPARAM wparam ,
const std::string & s )
1173 check_hwnd( hwnd ) ;
1174 if( IsWindowUnicode(hwnd) )
1175 return SendMessageW( hwnd , msg , wparam ,
reinterpret_cast<LPARAM
>(
Convert::widen(s).c_str()) ) ;
1177 return SendMessageA( hwnd , msg , wparam ,
reinterpret_cast<LPARAM
>(s.c_str()) ) ;
1179 inline std::string sendMessageGetString( HWND hwnd , UINT msg , WPARAM wparam )
1181 check_hwnd( hwnd ) ;
1182 if( IsWindowUnicode(hwnd) )
1184 std::vector<wchar_t> buffer( 1024 , L
'\0' ) ;
1185 SendMessageW( hwnd , msg , wparam ,
reinterpret_cast<LPARAM
>(buffer.data()) ) ;
1190 std::vector<char> buffer( 1024 ,
'\0' ) ;
1191 SendMessageA( hwnd , msg , wparam ,
reinterpret_cast<LPARAM
>(buffer.data()) ) ;
1192 return {buffer.data()} ;
1195 inline LRESULT sendMessageInsertColumn( HWND hwnd ,
int sub_item ,
const std::string & text ,
int width )
1197 check_hwnd( hwnd ) ;
1198 if( IsWindowUnicode(hwnd) )
1202 column.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM ;
1203 column.iSubItem = sub_item ;
1204 column.pszText =
const_cast<wchar_t*
>( wtext.c_str() ) ;
1206 column.fmt = LVCFMT_LEFT ;
1207 return SendMessageW( hwnd , LVM_INSERTCOLUMNW ,
static_cast<WPARAM
>(sub_item) ,
reinterpret_cast<LPARAM
>(&column) ) ;
1212 column.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM ;
1213 column.iSubItem = sub_item ;
1214 column.pszText =
const_cast<char*
>( text.c_str() ) ;
1216 column.fmt = LVCFMT_LEFT ;
1217 return SendMessageA( hwnd , LVM_INSERTCOLUMNA ,
static_cast<WPARAM
>(sub_item) ,
reinterpret_cast<LPARAM
>(&column) ) ;
1220 inline void sendMessageInsertItem( HWND hwnd ,
int item ,
int sub_item ,
const std::string & text )
1222 check_hwnd( hwnd ) ;
1223 if( IsWindowUnicode(hwnd) )
1227 lvitem.mask = LVIF_TEXT ;
1228 lvitem.iItem = item ;
1229 lvitem.iSubItem = sub_item ;
1230 lvitem.pszText =
const_cast<wchar_t*
>( wtext.c_str() ) ;
1231 sendMessage( hwnd , sub_item == 0 ? LVM_INSERTITEMW : LVM_SETITEMW , 0 ,
reinterpret_cast<LPARAM
>(&lvitem) ) ;
1236 lvitem.mask = LVIF_TEXT ;
1237 lvitem.iItem = item ;
1238 lvitem.iSubItem = sub_item ;
1239 lvitem.pszText =
const_cast<char*
>( text.c_str() ) ;
1240 sendMessage( hwnd , sub_item == 0 ? LVM_INSERTITEMA : LVM_SETITEMA , 0 ,
reinterpret_cast<LPARAM
>(&lvitem) ) ;
1243 inline BOOL postMessage( HWND hwnd , UINT msg , WPARAM wparam , LPARAM lparam )
1246 return PostMessageW( hwnd , msg , wparam , lparam ) ;
1248 return PostMessageA( hwnd , msg , wparam , lparam ) ;
1250 inline BOOL getMessage( MSG * msg_p , HWND hwnd , UINT filter_min , UINT filter_max )
1253 return GetMessageW( msg_p , hwnd , filter_min , filter_max ) ;
1255 return GetMessageA( msg_p , hwnd , filter_min , filter_max ) ;
1257 inline BOOL peekMessage( MSG * msg_p , HWND hwnd , UINT filter_min , UINT filter_max , UINT remove_type )
1260 return PeekMessageW( msg_p , hwnd , filter_min , filter_max , remove_type ) ;
1262 return PeekMessageA( msg_p , hwnd , filter_min , filter_max , remove_type ) ;
1264 inline LRESULT dispatchMessage( MSG * msg_p )
1267 return DispatchMessageW( msg_p ) ;
1269 return DispatchMessageA( msg_p ) ;
1271 inline IID iidShellLink() noexcept
1274 return IID_IShellLinkW ;
1276 return IID_IShellLinkA ;
1278 inline HRESULT shellLinkSetPath( IShellLinkW * link_p ,
const Path & path )
1282 inline HRESULT shellLinkSetPath( IShellLinkA * link_p ,
const Path & path )
noexcept
1284 return link_p->SetPath( path.cstr() ) ;
1286 inline HRESULT shellLinkSetWorkingDirectory( IShellLinkW * link_p ,
const Path & dir )
1288 return link_p->SetWorkingDirectory(
Convert::widen(dir.str()).c_str() ) ;
1290 inline HRESULT shellLinkSetWorkingDirectory( IShellLinkA * link_p ,
const Path & dir )
noexcept
1292 return link_p->SetWorkingDirectory( dir.cstr() ) ;
1294 inline HRESULT shellLinkSetDescription( IShellLinkW * link_p , std::string_view s )
1298 inline HRESULT shellLinkSetDescription( IShellLinkA * link_p ,
const std::string & s )
noexcept
1300 return link_p->SetDescription( s.c_str() ) ;
1302 inline HRESULT shellLinkSetArguments( IShellLinkW * link_p , std::string_view s )
1306 inline HRESULT shellLinkSetArguments( IShellLinkA * link_p ,
const std::string & s )
noexcept
1308 return link_p->SetArguments( s.c_str() ) ;
1310 inline HRESULT shellLinkSetIconLocation( IShellLinkW * link_p ,
const Path & icon ,
unsigned int i )
1312 return link_p->SetIconLocation(
Convert::widen(icon.str()).c_str() , i ) ;
1314 inline HRESULT shellLinkSetIconLocation( IShellLinkA * link_p ,
const Path & icon ,
unsigned int i )
noexcept
1316 return link_p->SetIconLocation( icon.cstr() , i ) ;
1318 inline HRESULT shellLinkSetShowCmd( IShellLinkW * link_p ,
int show )
noexcept
1320 return link_p->SetShowCmd( show ) ;
1322 inline HRESULT shellLinkSetShowCmd( IShellLinkA * link_p ,
int show )
noexcept
1324 return link_p->SetShowCmd( show ) ;
1326 inline HRESULT persistFileSave( IPersistFile * persist_file_p ,
const G::Path & link_path , BOOL remember )
1328 return persist_file_p->Save(
Convert::widen(link_path.
str()).c_str() , remember ) ;
1330 inline Path shGetFolderPath( HWND hwnd ,
int csidl , HANDLE user_token , DWORD flags )
1334 std::vector<wchar_t> buffer( MAX_PATH+1U , L
'\0' ) ;
1335 if( S_OK != SHGetFolderPathW( hwnd , csidl , user_token , flags , buffer.data() ) )
1337 buffer[buffer.size()-1U] = L
'\0' ;
1342 std::vector<char> buffer( MAX_PATH+1U ,
'\0' ) ;
1343 if( S_OK != SHGetFolderPathA( hwnd , csidl , user_token , flags , buffer.data() ) )
1345 buffer[buffer.size()-1U] =
'\0' ;
1346 return Path( buffer.data() ) ;
1349 inline std::string loadString( HINSTANCE hinstance , UINT
id )
1353 std::vector<wchar_t> buffer( 1024U , L
'\0' ) ;
1354 int n = LoadStringW( hinstance ,
id , buffer.data() ,
static_cast<int>(buffer.size()-1U) ) ;
1355 if( n <= 0 )
return {} ;
1356 return Convert::narrow( buffer.data() ,
static_cast<std::size_t
>(n) ) ;
1360 std::vector<char> buffer( 1024U , L
'\0' ) ;
1361 int n = LoadStringA( hinstance ,
id , buffer.data() ,
static_cast<int>(buffer.size()-1U) ) ;
1362 if( n <= 0 )
return {} ;
1363 return {buffer.data(),
static_cast<std::size_t
>(n)} ;
1366 inline HANDLE createWaitableTimer( LPSECURITY_ATTRIBUTES attributes , BOOL manual_reset ,
const std::string & name )
1371 return CreateWaitableTimerW( attributes , manual_reset , wname.c_str() ) ;
1375 return CreateWaitableTimerA( attributes , manual_reset , name.c_str() ) ;
1378 inline INT getAddrInfo( std::string_view host , std::string_view service ,
const ADDRINFOW * hints , ADDRINFOW ** results )
1382 inline INT getAddrInfo(
const std::string & host ,
const std::string & service ,
const ADDRINFOA * hints , ADDRINFOA ** results )
1384 return GetAddrInfoA( host.c_str() , service.c_str() , hints , results ) ;
1386 inline std::string canonicalName(
const ADDRINFOW & ai )
1390 inline std::string canonicalName(
const ADDRINFOA & ai )
1392 return ai.ai_canonname ? std::string(ai.ai_canonname) :
std::string() ;
1394 inline void freeAddrInfo( ADDRINFOW * results )
1397 FreeAddrInfoW( results ) ;
1399 inline void freeAddrInfo( ADDRINFOA * results )
1402 FreeAddrInfoA( results ) ;
static std::wstring widen(std::string_view)
Widens from UTF-8 to UTF-16/UCS-4 wstring.
static std::string narrow(const std::wstring &)
Narrows from UTF-16/UCS-4 wstring to UTF-8.
A Path object represents a file system path.
const value_type * cstr() const noexcept
Returns the path's c-string.
std::string str() const
Returns the path string.
std::string fromCodePageAnsi(std::string_view)
Converts from the active OEM codepage (see GetACP(), 1252 on unix) to UTF-8.
std::string toCodePageAnsi(std::string_view)
Converts from UTF-8 to the active "ansi" codepage (see GetACP(), 1252 on unix).