Discussion :

[Invité]

Bonjour,

je voudrais disposer d'un équivalent de EnModeTest() de Windev autrement dit savoir si le projet a été lancé de l'éditeur (IDE) ou de manière autonome. Je pourrais éventuellement utiliser le mode Debug en test et le mode Release pour la construction de l'exécutable autonome... Mais une erreur (humaine) est si vite arrivée !

Bref, à mon avis, je jouerais cela avec une variable de compilation... si c'est jouable en Delphi. Je ne sais pas.

Quel est l'intérêt ? Pour atteindre mes bases de test j'utilise mon IP interne (mon réseau local). Évidemment, un utilisateur utilisera l'IP publique (l'adresse fournie par mon Provider). Je pourrais éventuellement créer un ini mais je suis un adepte du all-in-one. Je pourrais également utiliser un Nat Hairpinning (chez moi un "Livebox Orange Nat Loopback") mais ma LiveBox semble ne pas le supporter. je pourrais aussi utiliser un code genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
With UniConnection1 do
  begin
    if Connected then
      Connected := False;
    Server := 'mon IP publique';  //L'adresse publique du serveur
    try
      Connected := true;
    except
      Server := '192.168.0.200';  //L'adresse locale du serveur
    end;
    if not Connected then
      try
        Connected := true;
      except
        sMess := 'Serveur indisposnible.';
      end;
  [...]

Mais c'est lent.

Bref, en C++, j'utilise une variable de pré-compilation. Une approche Delphi ?

MErci. Cordialement. Gilles
e

[Charly910]

Bonjour,

pour savoir si l'exécution se fait depuis l'IDE ou en dehors, j'utilise ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
  If DelphiLoaded then
     Begin
//  Lancement depuyis l'IDE
     End
  Else
     Begin
// Lancement depuis l'exe
     End ;
 
 { =========================================================================== }
function DelphiLoaded: Boolean;
begin
  DelphiLoaded := False;
  if (FindWindow('TPropertyInspector', nil) > 0) then
      if (FindWindow('TAppBuilder', nil) > 0) then
        if (FindWindow('TApplication', nil) > 0) then
          if (FindWindow('TAlignPalette', nil) > 0) then
            DelphiLoaded := True;
end;
 { =========================================================================== }

je pense que cela fonctionne depuis D7 jusqu'à D10.3 (à vérifier )

Cela me permet de gérer des répertoires de travail différents en exe normal et en cours de dev

A+
Charly

[ShaiLeTroll]

Tester si l'application est exécutée depuis l'EDI

VariableGlobale System.DebugHook pour un débug via Delphi

Sinon pour un mode debug général, tu as la fonction Windows.IsDebuggerPresent

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
//------------------------------------------------------------------------------
// Voir IsDebuggerPresent (API Windows SDK)                                    -
//                                                                             -
// L'aide API SDK Windows semble indiquer que cette function IsDebuggerPresent -
// n'est disponible qu'avec NT, à vérifier sur Win9x                           -
//                                                                             -
// IsRunInDebugger remplace la déclaration simple de Library sous Delphi       -
//                                                                             -
// interface                                                                   -
//    function IsDebuggerPresent(): BOOL; stdcall;                             -
//    {$EXTERNALSYM IsDebuggerPresent}                                         -
//                                                                             -
// implementation                                                              -
//    function IsDebuggerPresent; external kernel32 name 'IsDebuggerPresent';  -
//                                                                             -
//----------------------------------------------------------------------------*)
 
var
   _FKernelDLL: THandle = 0;
   _FVersionWindows: DWord = 0;
   _FFlagDebug: Boolean = False;
   _FFlagDebugChecked: Boolean = False;
   _IsDebuggerPresent: function: BOOL; stdcall;
 
function IsRunInDebugger(): Boolean;
var
   OSInfo: OSVERSIONINFO;
begin
   Result := _FFlagDebug;
 
   // Est-ce que le Flag a été Lu, si oui on Sort
   if _FFlagDebugChecked then
      Exit;
 
   // To know if a Application is running under de Delphi IDE or when it's running stand-alone
   if System.DebugHook <> 0 then
   begin
      _FFlagDebug := True;
      _FFlagDebugChecked := True;
   end;
 
   // Récupération de la Version de Windows
   if _FVersionWindows = 0 then
   begin
      OSInfo.dwOSVersionInfoSize := SizeOf(OSVERSIONINFO);
      if GetVersionEx(OSInfo) then
      begin
         _FVersionWindows := OSInfo.dwPlatformId;
      end;
   end;
 
   // Si la Versin de Window est inférieur à NT ou 9x, le Résultat est Faux
   if _FVersionWindows >= VER_PLATFORM_WIN32_WINDOWS then
   begin
      // Chargement de la DLL et de la Procedure
      if @_IsDebuggerPresent = nil then
      begin
         if _FKernelDLL = 0 then
         begin
            _FKernelDLL := LoadLibrary(PChar(Kernel32));
         end;
 
         if _FKernelDLL > 0 then
         begin
            @_IsDebuggerPresent := GetProcAddress(_FKernelDLL, 'IsDebuggerPresent');
         end;
      end;
 
      // Utilisation de la Procédure Chargée
      if Assigned(@_IsDebuggerPresent) then
      begin
        _FFlagDebug := _IsDebuggerPresent();
      end else
      begin
         _FFlagDebug := False;
      end;
      // Peu Importe si la Procédure Existe, on considère que l'on a testé la valeur
      _FFlagDebugChecked := True;
 
   end else
   begin
      // Windows antérieur à WinNT, Détection du Mode Débogage impossible !
      _FFlagDebug := False;
      _FFlagDebugChecked := True;
   end;
 
   Result := _FFlagDebug;
end;
 
initialization
  _FKernelDLL := 0;
 
finalization
  if _FKernelDLL > 0 then
     FreeLibrary(_FKernelDLL);
 
end.

[Invité]

Rebonjour,

Merci.... mais le problème est que ce n'est pas portable.

Je crois avoir trouvé une solution simple. En Delphi cela s'appelle "Directive" de compilation et pas "variable de pré-compilation". Voila pourquoi je ne trouvais pas sur le net.

1. Je crée une sous-configuration dans release :



2. Et j'ajoute dans cette configuration une directive :


3. Dans le programme :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
{$IFDEF DEPLOY}
showmessage('Deploiement');
{$ENDIF}

Encore merci pour votre aide. Cordialement. Gilles