| | auteurs : Geronimo, Ricky81 | Pour ajouter une entrée, il vous faut utiliser la fonction SHAddToRecentDocs (shlobj.h) et l'appeler comme suit :
AnsiString fichier = "C:\\monFichier.txt";
SHAddToRecentDocs(SHARD_PATH, fichier);
|
Si vous rencontrez un problème à l'inclusion de shlobj.h il vous faudra modifier les fichiers shobjidl.h et shlobj.h comme suit :
shobjidl :
- Commenter les lignes 2189 à 2193
- Commenter les lignes 8085 à 8095
shlobj.h :
- Modifier la ligne 1422 en } *LPFVSHOWINFO;
- Modifier la ligne 3457 en } *LPSHELLFLAGSTATE;
|
| | auteurs : Geronimo, Ricky81 | Sous Windows, le bureau est représenté par une fenêtre, qui a pour enfant toutes les autres fenêtres. Il faut donc récupérer le Handle de cette fenêtre, ce qui se fait avec la fonction FindWindow.
La fonction ShowWindow permet elle d'agir sur une fenêtre (cacher, afficher, réduire, agrandir, ...).
HWND Bureau = FindWindow("Progman", "Program Manager");
ShowWindow(Bureau, SW_HIDE);
|
Pour réactiver le bureau, il vous suffit de reproduire le code suivant :
HWND Bureau = FindWindow("Progman", "Program Manager");
ShowWindow(Bureau, SW_SHOW);
|
|
| | auteur : Ricky81 | Pour fermer une session Windows, il faut faire appel à la fonction ExitWindowsEx :
ExitWindowsEx(EWX_LOGOFF,0);
|
Remarque : pour forcer les applications à se terminer, il est possible d'utiliser le flag EWX_FORCE en complément de EWX_LOGOFF.
Par exemple :
ExitWindowsEx(EWX_LOGOFF | EWX_FORCE,0);
|
|
| | auteur : Ricky81 | Pour mettre l'ordinateur en veille, il faut faire appel à la fonction SetSystemPowerState :
SetSystemPowerState(False,True);
|
Le code précédent met l'ordinateur en veille en utilisant la technique d'hibernation et envoie le message de mise en veille aux applications sans attendre de réponse.
Cette fonction ne fonctionnera avec les systèmes NT que si l'application dispose du privilège SE_SHUTDOWN_NAME.
|
lien :  Comment donner un privilege à une application ?
|
| | auteur : Ricky81 | Pour redémarrer l'ordinateur, il faut faire appel à la fonction ExitWindowsEx :
ExitWindowsEx(EWX_REBOOT,0);
|
Remarque : pour forcer les applications à se terminer, il est possible d'utiliser le flag EWX_FORCE en complément de EWX_REBOOT.
Par exemple :
ExitWindowsEx(EWX_REBOOT | EWX_FORCE,0);
|
Cette fonction ne fonctionnera avec les systèmes NT que si l'application dispose du privilège SE_SHUTDOWN_NAME.
|
lien : Comment donner un privilege à une application ?
|
| | auteur : Geronimo | Pour éteindre l'ordinateur, il faut faire appel à la fonction ExitWindowsEx :
ExitWindowsEx(EWX_SHUTDOWN,0);
|
Le code précédent ferme Windows mais n'éteint pas nécessairement l'ordinateur.
Pour éteindre complètement l'ordinateur, il faut utiliser le flag EWX_POWEROFF à la place de EWX_SHUTDOWN.
Remarque : pour forcer les applications à se terminer, il est possible d'utiliser le flag EWX_FORCE en complément d'un des 2 précédemment cités.
Par exemple :
ExitWindowsEx(EWX_SHUTDOWN | EWX_FORCE,0);
|
Cette fonction ne fonctionnera avec les systèmes NT que si l'application dispose du privilège SE_SHUTDOWN_NAME.
|
lien : Comment donner un privilege à une application ?
|
| | auteurs : Greybird, Ricky81 |
Il existe un certain nombre de constantes et variables définies par SysUtils.hpp qui permettent d'obtenir les informations adéquates.
Notamment, Win32Platform renvoie le type de plateforme utilisée : VER_PLATFORM_WIN32s, VER_PLATFORM_WIN32_WINDOWS ou VER_PLATFORM_WIN32_NT.
Pour affiner, il est ensuite nécessaire de consulter les variables Win32MajorVersion et Win32MinorVersion, ainsi que Win32CSDVersion pour les Service Packs.
Pour obtenir la version de Windows installée sur le PC, C++ Builder fournit ainsi les variables Win32MajorVersion et Win32MinorVersion, entre autres.
On peut en déduire la version de Windows à l'aide du code suivant :
AnsiString __fastcall GetWindowsVersion()
{
AnsiString result;
switch(Win32MajorVersion)
{
case 3: result = "Windows NT 3.51";break;
case 4:
switch(Win32MinorVersion)
{
case 0:
switch (Win32Platform)
{
case 1:
{
switch (Win32CSDVersion[1])
{
case 'A': result = "Windows 95 SP 1";break;
case 'B': result = "Windows 95 SP 2";break;
}
break;
}
case 2: result = "Windows NT 4.0";break;
}
break;
case 10:
switch (Win32CSDVersion[1])
{
case 'A': result = "Windows 98 SP 1";break;
case 'B': result = "Windows 98 SP 2";break;
}
break;
case 90: result = "Windows ME";break;
}
break;
case 5:
switch (Win32MinorVersion)
{
case 0: result = "Windows 2000";break;
case 1: result = "Windows XP";break;
case 2: result = "Windows 2003";break;
}
break;
}
if (result.IsEmpty())
{
result = "Inconnue";
}
return result;
}
|
Cette méthode permet d'obtenir simplement le nom du système d'exploitation. Il est cependant possible d'obtenir des informations plus détaillées (numéro de construction, pro/perso, etc.) en utilisant les fonctions de l'API Windows. Cette méthode un peu plus longue est donnée dans le fichier zip ci-dessous.
|
lien :  MSDN - GetVersionEx
lien : MSDN : Getting the System Version
téléchargement : windowsversion.zip
|
| | auteur : ksly |
Le code suivant renvoie le nom de la machine :
AnsiString __fastcall GetMac()
{
AnsiString mac("");
DWORD t_computer(MAX_COMPUTERNAME_LENGTH + 1);
char *name_computer=new char[t_computer];
if( GetComputerName(name_computer, &t_computer) )
{
mac=AnsiString(name_computer);
}
delete[] name_computer;
return mac;
}
|
|
| | auteur : ksly |
Le code suivant retourne le nom de l'utilisateur connecté :
AnsiString __fastcall GetUser()
{
AnsiString user("");
DWORD t_user(256);
char *name_user=new char[t_user];
if( GetUserName(name_user, &t_user) )
{
user=AnsiString(name_user);
}
delete[] name_user;
return user;
}
|
|
| | auteur : Bandit Boy |
Voici une petite fonction qui permet de modifier le paramètre d'affichage de la barre des tâches en libérant l'espace (ce n'est pas un Hide()) :
_AppBarData TaskBar;
TaskBar.hWnd = FindWindow("Shell_TrayWnd", NULL);
TaskBar.cbSize = sizeof(TaskBar);
if((UINT) SHAppBarMessage(ABM_GETSTATE, &TaskBar) == ABS_ALWAYSONTOP)
{
TaskBar.lParam = ABS_AUTOHIDE ;
}
else
{
TaskBar.lParam = ABS_ALWAYSONTOP;
}
if( (UINT) SHAppBarMessage(ABM_SETSTATE, &TaskBar) == false )
{
Application->MessageBox("Erreur de changement de propriété", "Erreur", MB_OK);
}
|
Je déclare une structure TaskBar du même type que celle de la barre de tâches windows (type _AppBarData), ensuite je récupère le Handle de la barre de tâche pour lire ses paramètres.
Je m'intéresse tout particulièrement à TaskBar.lParam qui correspond à l'affichage de la barre. Ce paramètre peut prendre plusieurs valeurs dont voici la liste :
- ABM_ACTIVATE : Notifies the system that an appbar has been activated.
- ABM_GETAUTOHIDEBAR : Retrieves the handle to the autohide appbar associated with a particular edge of the screen.
- ABM_GETSTATE : Retrieves the autohide and always-on-top states of the Microsoft Windows taskbar.
- ABM_GETTASKBARPOS : Retrieves the bounding rectangle of the Windows taskbar.
- ABM_NEW : Registers a new appbar and specifies the message identifier that the system should use to send notification messages to the appbar.
- ABM_QUERYPOS : Requests a size and screen position for an appbar.
- ABM_REMOVE : Unregisters an appbar, removing the bar from the system's internal list.
- ABM_SETAUTOHIDEBAR : Registers or unregisters an autohide appbar for an edge of the screen.
- ABM_SETPOS : Sets the size and screen position of an appbar.
- ABM_SETSTATE : Sets the state of the appbar's autohide and always-on-top attributes.
- ABM_WINDOWPOSCHANGED : Notifies the system when an appbar's position has changed.
Une fois connue, soit je le modifie pour un affichage "Masqué automatiquement" ou "Toujours affiché".
On peut voir que cette fonction peut permettre de modifier d'autres paramètres de la barre ... Par ailleurs, la commande ABM_SETSTATE permet d'appliquer la modification.
|
lien : Lien vers l'API
|
| | auteurs : Bandit Boy, pottiez |
On pourrait utiliser la fonction IsUserAnAdmin() mais elle semble poser problème avec l'inclusion de " shlobj.h " (voir les erreurs générées) :
--------------------------------------------------------------------------------
[C++ Error] shobjidl.h(2193): E2238 Multiple declaration for 'FOLDERSETTINGS'
[C++ Error] shobjidl.h(8095): E2238 Multiple declaration for 'DESKBANDINFO'
[C++ Error] shlobj.h(1422): E2238 Multiple declaration for 'FVSHOWINFO'
--------------------------------------------------------------------------------
|
Cela semble bien être la faute à BCB :
http://bdn.borland.com/article/0,1410,26650,00.html
[C++ Error] shlobj.h(3457) : E2238 Multiple declaration for 'SHELLFLAGSTATE'
Pour déterminer si un utilisateur est administrateur ou non, on examine l'accès utilisateur à l'aide de la fonction GetTokenInformation(). Ces informations représentent les droits de l'utilisateur et le groupe auquel il appartient.
Quand l'utilisateur lance une application, ses droits d'accès y sont associés. Pour examiner ses droits, on utilise la fonction OpenProcessToken().
Ce code est proposé dans la rubrique d'aide de Windows (Win32.hlp).
BOOL IsAdmin(void)
{
HANDLE hProcess, hAccessToken;
UCHAR InfoBuffer[1024];
PTOKEN_GROUPS ptgGroups = (PTOKEN_GROUPS)InfoBuffer;
DWORD dwInfoBufferSize;
PSID psidAdministrators;
SID_IDENTIFIER_AUTHORITY siaNtAuthority = SECURITY_NT_AUTHORITY;
UINT x;
hProcess = GetCurrentProcess();
if(!OpenProcessToken(hProcess,TOKEN_READ,&hAccessToken))
return(FALSE);
if(!GetTokenInformation(hAccessToken,TokenGroups,InfoBuffer,
1024, &dwInfoBufferSize)) return(FALSE);
AllocateAndInitializeSid(&siaNtAuthority, 2,
SECURITY_BUILTIN_DOMAIN_RID,
DOMAIN_ALIAS_RID_ADMINS,
0, 0, 0, 0, 0, 0,
&psidAdministrators);
for(x=0;x<ptgGroups->GroupCount;x++)
{
if( EqualSid(psidAdministrators, ptgGroups->Groups[x].Sid) )
{
FreeSid(&psidAdministrators);
return( TRUE );
}
}
FreeSid(&psidAdministrators);
return(FALSE);
}
|
Attention :
Cette fonction déclenche une fenêtre CPU lors de l'éxécution de la ligne de libération de la structure de type SID, en mode debug. Ce problème n'intervient pas dans l'exécutable généré.
|
| | auteurs : Bandit Boy, pottiez |
Comment charger le papier peint du bureau dans un TImage ?
Cette opération s'effectue en utilisant l'API SystemParametersInfo avec la commande SPI_GETDESKWALLPAPER.
Cette API est décrite sur le site de msdn.
char path[200];
if(SystemParametersInfo( SPI_GETDESKWALLPAPER,
200,
path,
0) == TRUE)
{
AnsiString Chemin;
float i=0;
Image1->Picture->LoadFromFile(path);
i = (float)Screen->Height/(float)Screen->Width;
Image1->Height = i * Image1->Width;
}
|
Comment établir une image comme papier peint du bureau ?
On utilise la même API que pour la lecture, mais on utilise la commande SPI_SETDESKWALLPAPER. Ici l'image est chargée par un OpenDialog, puis modifiée et écrasée avant d'être établie comme papier peint.
if(OpenDialog1->Execute())
{
Image1->Picture->LoadFromFile(OpenDialog1->FileName);
Image1->Canvas->TextOutA(10,10,"modif de l'image par Builder");
Image1->Picture->SaveToFile(OpenDialog1->FileName);
if(SystemParametersInfo( SPI_SETDESKWALLPAPER,
OpenDialog1->FileName.Length(),
OpenDialog1->FileName.c_str(),
WM_SETTINGCHANGE) != TRUE)
{
Button2->Caption = "Erreur";
}
}
|
|
Consultez les autres F.A.Q.
 
|
|
