ich habe folgendes Problem.
Ich möchte das Funktionieren meiner Anwendung_B vom Aktivsein der
Anwendung_A abhängig machen.
Frage: Wie frage ich ab, ob meine *.exe von Anwendung_A aktiv ist (läuft)??

mfg
Traugott

Hab schon im Forum (FAQ) gestöbert. Hier finde ich nur Code zum Abschalten einer *.exe.(Pfad vorgegeben)
Ich aber möchte nur Prüfen ob die von mir benannte *.exe aktiv ist oder nicht.
Deshalb wäre es für mich sehr hilfreich, wenn vieleicht ein Codeschnipsel dabei wäre.(oder Link)

mfg
Traugott

// Bei Programmstart
HANDLE kdg_mutex = OpenMutex(MUTEX_ALL_ACCESS, 0, "irgend_eine_ID");

// Bei Programmende...
ReleaseMutex(kdg_mutex);

Im Programm, dass prüft, ob das andere gerade aktiv ist:

HANDLE kdg_mutex = OpenMutex(MUTEX_ALL_ACCESS, 0, "irgend_eine_ID")

//Wenn Mutex-Handle 1 ist, ist gerade eine Programminstanz aktiv...
if(kdg_mutex)   {
    // Hier was passieren soll, wenn das Programm läuft...
}

Ist jetzt aber aus'm Kopf, könnten Fehler drin sein

mfg
Traugott

dazu gibt es bereits in den Builder-Examples ein Control dazu :
<BCB_Path>\Examples\Controls\SingleInst

bis bald
akari

DWORD GetPidByName(PSTR ProcessName) {
	DWORD PIDs[1024], BytesNeeded, ProcessCount;

	//SetDebugPrivilege();

	if (!EnumProcesses(PIDs,sizeof(PIDs),&BytesNeeded)) {
		return 0;
	}

	ProcessCount = BytesNeeded / sizeof(DWORD);
	BytesNeeded = 0;

	for (UINT i = 0;i<ProcessCount;i++) {
		HANDLE hProcess = OpenProcess(PROCESS_QUERY_INFORMATION,false,PIDs[i]);

		if (hProcess != NULL) {
			HMODULE hModule;

			char CurProcessName[MAX_PATH];

			if (EnumProcessModules(hProcess,&hModule,sizeof(hModule),&BytesNeeded) ) {
				if (GetModuleBaseName(hProcess,hModule,CurProcessName, sizeof(CurProcessName) )) {
					if (strcmpi(CurProcessName,ProcessName)==0) {
						CloseHandle (hProcess);
						return PIDs[i];
					}
				}
			}
		}

		CloseHandle(hProcess);
	}
	return 0;
}

Deklarationen in der psapi.h -> psapi.lib einbinden

Das Programm, dass laufen muss:

// Bei Programmstart
HANDLE kdg_mutex = OpenMutex(MUTEX_ALL_ACCESS, 0, "irgend_eine_ID");

// Bei Programmende...
ReleaseMutex(kdg_mutex);

Ist jetzt aber aus'm Kopf, könnten Fehler drin sein

Wenn ich das so benutze, kommen bei mir folgende Fehler:

[C++ Warnung] Unit1.cpp(21): W8004 'kdg_mutex' wurde ein Wert zugewiesen, der nie verwendet wird
  [C++ Fehler] Unit1.cpp(25): E2451 Undefiniertes Symbol 'kdg_mutex'

Ich bin damit nicht so vertraut. Muss ich da noch etwas machen?
Danke im Voraus

die Fehelrmeldung ist doch klar. Du deklarierst zwar kdg_mutex, aber dort wo den Release aufrufst, ist kdg_mutex nicht bekannt. Vermutlich hast du kdg_mutex lokal in eienr Methode deklariert, aber wei ldu den Release in einer anderen aufrufst, must du kdg_mutex stattdesen als Member der Klasse deklarieren.

Ist das nicht der Fall und du findest den Fehler selber nicht, dann poste nochmal genau, in welchem Zusammenhang die beiden Codezeilen stehen.

bis bald
akari

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
HANDLE kdg_mutex = OpenMutex(MUTEX_ALL_ACCESS, 0, "123");
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------

void __fastcall TForm1::FormClose(TObject *Sender, TCloseAction &Action)
{
ReleaseMutex(kdg_mutex);
}
//---------------------------------------------------------------------------

Programm das überprüft werden soll.

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
HANDLE kdg_mutex = OpenMutex(MUTEX_ALL_ACCESS, 0, "123");
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender)
{

//Wenn Mutex-Handle 1 ist, ist gerade eine Programminstanz aktiv...
if(kdg_mutex)
  {
  ShowMessage("Opened");
  }
}
//---------------------------------------------------------------------------

Programm das überprüft.

Das überprüfende Programm gibt nie die Meldung aus (ShowMessage), egal ob das erste Programm geöffnet ist oder nicht.

Aber da wird erklärt wie man verhindert das ein Programm 2x geöffnet wird.

Damit wird auch doch irgendwie geklärt, ob ein Programm schon läuft. Ob du dann nun einen weiteren Start verhinderst oder sonstewas machst......

Programm1 (Ausgeführtes)
Programm2 (Überprüfendes)

1. Erst mache ich Programm1 an, dann Programm2. Programm2 meldet das Programm1 bereits läuft. OK soweit. Wenn ich jetzt Programm1 schließe und Programm2 nochmal überprüfen lasse, wird immer noch gemeldet das Programm1 läuft.

2. Erst starte ich Programm2 und lasse überprüfen, keine Fehlermeldung. Dann starte ich Programm1 und lasse wieder überprüfen, das Programm meldet dass Programm1 läuft. Wenn ich Programm1 schließe wieder der selbe Fehler von Punkt1.

Programm1:

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
HANDLE hMutex=OpenMutex(MUTEX_ALL_ACCESS,0,"MeinProgramm");
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------

void __fastcall TForm1::FormClose(TObject *Sender, TCloseAction &Action)
{
ReleaseMutex(hMutex);
}
//---------------------------------------------------------------------------

void __fastcall TForm1::FormCreate(TObject *Sender)
{
if(!hMutex)
  {
  hMutex=CreateMutex(0,0,"MeinProgramm");
  }
else
  {
  ShowMessage("Das Programm läuft bereits");	
  }
}
//---------------------------------------------------------------------------

Programm2:

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender)
{
HANDLE hMutex=OpenMutex(MUTEX_ALL_ACCESS,0,"MeinProgramm");
if(!hMutex)
  {
  ReleaseMutex(hMutex);
  }
else
  {
  ShowMessage("Das Programm läuft bereits");
  ReleaseMutex(hMutex);	
  }
}
//---------------------------------------------------------------------------

ich kann deinen Quellcode jetzt nicht testen, weil ich keinen Builder habe.
Aber CreateMutex und ReleaseMutex sollten besser in dem Konstruktor bzw. dem Destruktor des Forms stehen, und HANDLE hMutex sollte ein Member des Forms sein (also im Header des Forms nach private deklarieren).

bis bald
akari

__fastcall TForm1::TForm1(TComponent* Owner) 
        : TForm(Owner) 
{ 
} 
//---------------------------------------------------------------------------

besser ist aber das TForm Event OnCreat.

Destruktor:
ist ist das TForm Event OnDestroy
kannst du im Objektinspektor für TForm doppelt klicken.
Ok stimmt nicht ganz da der Destruktor danach kommt.
Den Destruktor würde ich nicht überschreiben!

besser ist aber das TForm Event OnCreat.

Falsch. Genausowenig wie OnDestroy besser als der Destruktor sein soll. Das gegenteil ist der Fall, die Begründung hatten wir schon ein paar mal in verschiedenen Threads dieses Forums.

Danke akari, kannst du (oder jemand anderes) mir noch sagen was Konstruktor und Destruktor bedeutet? Oder wo ich das finde?

Lies gleich ein ganzes Tutorial zum Thema OOP, denn du wirst es noch brauchen.

bis bald
akari

http://www.c-plusplus.net/forum/viewtopic-var-t-is-160149-and-highlight-is-%2Aoncreat%2A.html

Link von Braustein führt zu einem englischen Forum.
Die Aussage dort ist mir neu:

Ok, so let's summarize the most important reason why OnCreate is
dangerous: because it could execute before your constructor executes
and before any member objects have been initialized. In C++, it is
generally mandated that a base class constructor should not be able to
call the member functions of a derived class. OnCreate violates
this. OnDestroy does too, but during destruction.

Meine Frage ist jetzt, wie ich den Destruktor der Form einbaue?
etwa so:

Beispiel:

unit1.h

private:
__fastcall TForm1::TForm1(TComponent* Owner): TForm(Owner);
 ~Form1();
 TGraphics::TBitmap *hallo;

unit.cpp

__fastcall TForm1::TForm1(TComponent* Owner) 
        : TForm(Owner) 
{ 
 hallo=new TGraphics::TBitmap();
} 
//--------------------------------------------------------------------------- 
~Form1()
{
 delete hallo;
}

wäre das so richtig?

dlonra schrieb:

Meine Frage ist jetzt, wie ich den Destruktor der Form einbaue?
etwa so:

ja, Syntax und Anwendung von Destruktor und Konstruktor sind in Ordnung.
Wenn du aber schon mal dabei bist, dann mach es gleich richtig und benutzt die Initialisierungsliste

__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner), hallo(new TGraphics::TBitmap())
{
}

Aber nun back to Topic.

Feyo-Su schrieb:

Geht sowas auch indem man prüft, ob z.B. ABC.EXE in den ausgeführten Prozessen steht? Wenn ja, wie prüft man dies?

Ja das geht auch, mit der WinAPI-Funktion FindWindow.
Allerdings ist das etwas unsauberer, mit den Mutexten geht das sicherer.

bis bald
akari

hier hab ich ein Beispiel für FindWindow gefunden. So wie es aussieht muss dieser Code in die Projekt.cpp rein.

http://www.bcb-box.de/Informationen/Laeuftschon/laeuftschon.html

auch interessante Schnippsel
http://www.bcb-box.de/Informationen/informationen.html
Grüsse