-junix

WinExec("Raetsel.exe", SW_SHOWNORMAL);

eine Pfadangabe hinbringe. Also ich wollte es so machen:

WinExec(".\\Rätselprogramm\\Raetsel.exe", SW_SHOWNORMAL);

Doch so macht er gar nichts.

Kevinus schrieb:

WinExec(".\\Rätselprogramm\\Raetsel.exe", SW_SHOWNORMAL);

Doch so macht er gar nichts.

WinExec ist doch uralt... (Obsolete sozusagen... siehe Hilfe)
Nimm lieber das hier :

AnsiString Pfad_der_EXE = "C:\\Rätselprogramm\\Raetsel.exe"; 
ShellExecute(Handle, 
             0, 
             ExtractFileName(Pfad_der_EXE).c_str(), 
             0, 
             ExtractFilePath(Pfad_der_EXE).c_str(), 
             SW_NORMAL);

Und nimm besser komplette Pfade, das bewahrt Dich vor unangenehmen Überraschungen.

Bis dann denn,

Nash

Muss ich AnsiString oder kann ich auch andere verwenden?

Ich benutze deshalb nicht den gesamten Pfadnamen, da das:
1. auh mit Punkt und dann restlicher Pfad geht.
2. ich mein Programm flexibel haben möchter, damit nicht jeder genau in den
Pfad installieren muss.

Was hat c.str() zu bedeuten, oder was machjt es?

Aber muss dann den NAmen nach nicht bei:
Extract File Name nur Raetsel.exe
und bei
Extract Path Name der AnsiString?

Muss ich AnsiString oder kann ich auch andere verwenden?

Hilfe benutzen...

Mist... das kommt davon, wenn man ohne zu überlegen kopiert...
So ist's richtig :

AnsiString Pfad_der_EXE = "C:\\Rätselprogramm\\Raetsel.exe"; 
ShellExecute(Handle, 
             0, 
             Pfad_der_EXE.c_str(), 
             0, 
             ExtractFilePath(Pfad_der_EXE).c_str(), 
             SW_NORMAL);

Ich benutze deshalb nicht den gesamten Pfadnamen, da das:
1. auh mit Punkt und dann restlicher Pfad geht.

Mach was immer Du auch willst... :p

2. ich mein Programm flexibel haben möchter, damit nicht jeder genau in den Pfad installieren muss.

Das kann man auch anders :
z.B. mit

ExtractFilePath(Application->ExeName)

und von hier weiter die Ordner ansprechen...

c_str()

Anklicken und dann F1 drücken.

Bis dann denn,

Nash

Das kommt wenn ich Shell Execute einfüge. Was kann ich tun.

ShellExecute ist ein Wort.

Bis dann denn,

Nash

...
String netsend="net send "+IP+" "+Text;
WinExec(netsend.c_str(),SW_SHOW);
...

Diese Funktion funktioniert einwandfrei(Ich habe den restlichen Programmcode weg gelassen). Aber die zweite Methode:

...
String netsend="net send "+IP+" "+Text;
ShellExecute(NULL,"open",netsend.c_str(),0,0,SW_SHOW);
...

funktioniert nicht, der Compiler gibt zwar keine Fehler aus, doch machen tut das Programm auch nichts, also wo liegt mein Fehler????

Kann man mit ShellExecute auch den Status des aufgerufenen Programmes abfragen und wenn ja dann ganz normal mit ner Int Variable?

ja, mit ShellExecuteEx(). Damit bekommst du ein Prozeßhandle, das du überwachen kannst. Das gehört dann aber ins WinAPI-Forum.

bis bald
akari

Windows-SDK schrieb:

HINSTANCE ShellExecute(
HWND hwnd, // handle to parent window
LPCTSTR lpOperation, // pointer to string that specifies operation to perform
LPCTSTR lpFile, // pointer to filename or folder name string
LPCTSTR lpParameters, // pointer to string that specifies executable-file parameters
LPCTSTR lpDirectory, // pointer to string that specifies default directory
INT nShowCmd // whether file is shown when opened
);

AnsiString NetStr      = "net";
AnsiString NetParamStr = "send 127.0.0.1 hallo dude";

ShellExecute(0, "open", NetStr.c_str(), NetParamStr.c_str(), 0, SW_SHOW);

net ist ein programm, der rest sind nur die parameter, also auch so benutzen!

Nagut dann kommt die nächste Frage auf, wie kann ich die Error Messages anzeigen bzw. auswerten lassen. Also es hat was mit handle zu tun nur wie sätze ich das ganze richtig ein, achja und der Beitrag in der msdn Libary hat mich nicht weitergebracht, also könntet ihr es mir bitte richtig erklären und nicht unbedingt so schwer verständlich wie in der msdn.

hier mal der code fuer eine unit error.cpp (inkl. header). hier wird eine funktion Error() und LastError()) definiert. Error() ermoeglicht die Erzeugung ein Fehler-Messagebox mit Angabe fuer Caption und Text. Die Ausgabe erfolgt ueber einen selbstdefinierten Error-Handler. LastError() liefert dir die formatierte Fehlermeldung von Windows-GetLastError(), d.h. aus dem Errorcode den WinAPI-Funktionen zurueckgeben, wird eine lesbare Fehlermeldung generiert.

// error.h

//---------------------------------------------------------------------------
#ifndef __RS_ERROR_H
#define __RS_ERROR_H
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
#include <stdio.h>          // für sprintf, vsprintf
#include <stdarg.h>         // für va_list
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
typedef	void (*ErrorHandler) (const char*, const char*, va_list);
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
// globale Funktionen und Variablen
//---------------------------------------------------------------------------
extern  "C"  void          Error(const char *Module, const char *Format, ...);
extern  "C"  void          LastError(const char *Module);
//---------------------------------------------------------------------------
extern  "C"  ErrorHandler  SetErrorHandler(ErrorHandler);
extern  "C"  ErrorHandler _ErrorHandler;
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
#endif
//---------------------------------------------------------------------------

// error.cpp

//---------------------------------------------------------------------------
#include <windows.hpp>   // für MessageBox
//---------------------------------------------------------------------------
#include "Error.h"
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
// Error-Handler für Programm
//---------------------------------------------------------------------------
void MyErrorHandler(const char *Module, const char *Format, va_list ArgPtr)
{
  char Caption[ 255];
  char Message[3072];

  if (!Module) sprintf(Caption, "%s", "Error");
  else         sprintf(Caption, "%s", Module);

  vsprintf(Message, Format, ArgPtr);

  MessageBox(GetFocus(),
             Message,
             Caption,
             MB_OK | MB_ICONERROR | MB_TOPMOST | MB_TASKMODAL);
}

//---------------------------------------------------------------------------
// Standard-Error-Handler festsetzen
//---------------------------------------------------------------------------
ErrorHandler _ErrorHandler = MyErrorHandler;
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
// Funktion setzt den Error-Handler
//---------------------------------------------------------------------------
ErrorHandler SetErrorHandler(ErrorHandler Handler)
{
  ErrorHandler Prev = _ErrorHandler;
  _ErrorHandler     = Handler;

  return Prev;
}

//---------------------------------------------------------------------------
// Funktion formatiert die Meldung und übergibt sie
// dem festgelegten Error-Handler
//---------------------------------------------------------------------------
void Error(const char *Module, const char *Format, ...)
{
  if (_ErrorHandler)
  {
    va_list ArgPtr;
    va_start(ArgPtr, Format);

    (*_ErrorHandler) (Module, Format, ArgPtr);

    va_end(ArgPtr);
  }
}

//---------------------------------------------------------------------------
// Funktion erzeugt eine Fehlermeldung von GetLastError und
// übergibt sie dem festgelegten Error-Handler
//---------------------------------------------------------------------------
void LastError(const char *Module)
{
  LPVOID lpMsgBuf;

  FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
                FORMAT_MESSAGE_FROM_SYSTEM,
                0,
                GetLastError(),
                MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                (LPTSTR) &lpMsgBuf,
                0,
                0);

  (*_ErrorHandler) (Module, (LPCTSTR) lpMsgBuf, 0);

  // Speicher freigeben
  LocalFree(lpMsgBuf);
}

Aufrufe ueber:

void FunktionBlahBlah()
{
  DWORD Result = ShellExecute(...);

  // Fehlermeldungen von ShellExecute ausgeben
  if (Result <= 32)
    LastError("FunktionBlahBlah");
}

ich hoffe ich habe nichts vergessen zu kopieren.

WORD ist ein 16-bit Wert, DWORD ein 32-bit Wert.
In dieser Form wird es in der WinAPI definiert. Deshalb wird es bei WinAPI-Zugriff gebraucht, meistens DWORD als typedef auf einen int.

bis bald
akari

http://www.marquardtnet.info/cecke/quickies.1/1_quicky_25.html

DWORD als typedef auf einen int.

nicht ganz.

korrekt ist das so definiert:

typedef  unsigned long   DWORD;
typedef  unsigned short  WORD;