Winapi in Borland

akari

Hallo

Da wir nicht wissen was du genau machst (sprich : es fehlt der relevante Code mitsamt genauer Fehlermeldung) können wir dir nicht helfen.
Der Kern der WinAPI ist jedenfalls schon durch den Include der vcl.h dabei. Weitere WinAPI-Header können jederzeit zusätzlich included werden.
Hast du ein reines Win32-"Konsolen"-programm, must du selber windows.h includen.

Allerdings verstehe ich nicht, warum du mit den WinAPI-Funktionen ein Fenster darstellen willst. Schließlich hast du mit dem Builder ja die VCL, die wesentlich komfortablere Möglichkeiten für GUIs anbietet. Die WinAPI ist dann nur noch für direkte, meistens nichtvisuelle Systeminteraktion notwendig.

bis bald
akari

Pronto451

Hallo

also ich will auf dem Desktop ein Fenster haben, das hinter allen Fenstern liegt.
Hier mal den WinAPI Code:

#include <Windows.h>
#include <tchar.h>

#define IDC_BUTTON 103

TCHAR szMainClassName[] = _T("APIDRAW");
TCHAR szWinTitle[] = _T("ApiDraw");

LRESULT CALLBACK MainWndProc( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam );

///////////////////////////////////////////////////////////////////////////////

int WINAPI WinMain(
  HINSTANCE hInstCurrent,  // handle to current instance
  HINSTANCE hInstPrevious,  // handle to previous instance
  LPSTR lpszCmdLine,      // pointer to command line
  int nCmdShow          // show state of window
)
{
	HWND hMainWnd;
	MSG msg;

  HBRUSH hBrush;			// eigenen Brush erstellen
	hBrush = CreateSolidBrush (RGB(100,100,100));

	//Definition einer Fensterklasse
	WNDCLASS wcl;
	wcl.style = 0L;					// Keine besonderen Styles
	wcl.lpfnWndProc = MainWndProc;	//Funktionsadresse der Hauptfensterfunktion
	wcl.cbClsExtra = 0;				//Anzahl der Extra-Bytes der Klasse
	wcl.cbWndExtra	= 0;			//Anzahl Extra-Bytes des Fensters
	wcl.hInstance = hInstCurrent;	//Aktuelles Instanzhandle der Anwendung
	wcl.hIcon = NULL;				//Kein besonderes Icon (Windows-Standard)
	wcl.hCursor = LoadCursor( NULL, IDC_ARROW );	//Keinen besonderen Cursor,(Standard-Pfeil-Cursor)
	wcl.hbrBackground = (HBRUSH) hBrush;	//Standard-Fensterhintergrundfarbe (wie in Systemsteuerung eingestellt)
	wcl.lpszMenuName = NULL;		//Kein Menü
	wcl.lpszClassName = szMainClassName;	//Name der Fensterklasse

	//Fensterklasse bei Windows anmelden
	if( !RegisterClass( &wcl ) )
	{
		MessageBox( NULL, _T("Fensterklasse konnte nicht registriert werden!"), szWinTitle, MB_OK | MB_ICONSTOP );
		return -1;
	}

	//Konkretes Fenster vom Typ der gerade angemeldtene Fensterklasse erstellen und anzeigen

	hMainWnd = CreateWindowEx(WS_EX_TOOLWINDOW,
								szMainClassName,		//Fensterklassenname
								szWinTitle,					//Titel des Fensters
								WS_CHILD,		
								0, 0,								//Position des Fensters wird von Windows festgelegt
								1280, 1024,					//Breite und Höhe des Fensters
								(HWND)GetDesktopWindow(),				//Kein Eltern-Fenster
								NULL,								//Kein Menü
								hInstCurrent,				//Aktuelles Instanzhandle
								NULL );							//zusätzliche Parameter

	if( !hMainWnd )
	{
		MessageBox( NULL, _T("Fenster konnte nicht erstellt werden!"), szWinTitle, MB_OK | MB_ICONSTOP );
		return -1;
	}

	ShowWindow( hMainWnd, nCmdShow );	//Fenster anzeigen (Standard-Elemente)
	UpdateWindow( hMainWnd );			//Innenbereich / Datenbereich aktualisieren
	// Taskleiste aktualisieren 
	ShowWindow(FindWindow("Shell_TrayWnd", NULL), SW_SHOW);

	//Nachrichtenverteilschleife (GetMessage() liefert 0 wenn eine WM_QUIT-Nachricht aus der Warteschlange geholt wurde 
	while( GetMessage( &msg, NULL, 0, 0 ) )	//Nachricht aus der Warteschlange der Anwendung holen
	{
		TranslateMessage( &msg );		//Falls nötig, Nachricht an Systemeinstellungen anpassen
		DispatchMessage( &msg );		//Nachricht verteilen, führt zum Aufruf der Hauptfensterfunktion
	}

	return (int)msg.wParam;		//Beedigungscode der Anwendung
}

///////////////////////////////////////////////////////////////////////////////

LRESULT CALLBACK MainWndProc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam )
{
	PAINTSTRUCT		ps;		// used in WM_PAINT
	HDC						hDC;	// handle to a device context

	static HWND hButton;
	const char  szText[] = "Management Center";
	// what is the message 
	switch(message)
	{	
		case WM_CREATE: 
  		// do initialization stuff here
      hButton = CreateWindow( "button",
															"Beenden",
                              WS_CHILD | WS_VISIBLE,
                              50, 50, 100, 32,
                              hwnd,
                              (HMENU)IDC_BUTTON,
                              ((LPCREATESTRUCT) lParam) -> hInstance,
                              NULL);		  
			break;
	  case WM_PAINT: 
		  // simply validate the window
		  hDC = BeginPaint(hwnd,&ps);
			{
        SetBkMode(hDC, TRANSPARENT);
				SetTextColor(hDC, RGB (255, 255, 255));
        TextOut(hDC, 10, 10, szText, sizeof(szText) - 1);
			}
		  EndPaint(hwnd,&ps);
   		break;
		case WM_COMMAND:
      if (lParam == (LPARAM)hButton)
      {
         if (HIWORD(wParam) == BN_CLICKED)
            SendMessage(hwnd, WM_CLOSE, 0, 0);
      }
      break;
		case WM_DESTROY:		//Fenster soll zerstört (geschlossen) werden
		  PostQuitMessage( 0 );	//Stellt eine WM_QUIT-Nachricht in die Warteschlange der Anwendung
		  break;
	  default:				//Für alle nicht selbst behandelten Nachrichten
							//Standard-Windows-Fensterfunktion aufrufen und Rückgabewert zurückliefern
		  return DefWindowProc( hwnd, message, wParam, lParam );
	}
	return 0;
}

Das funktionier auch schon ganz gut.

Wenn ich wüßte wie ich das auch mit dem Borland und der VCL hinbekomme ... prima, denn dann könnte ich alle meine eigenen Buttonkomponenten weiter verwenden und müsste sie nicht in WinAPI nochmal schreiben. Oder wie ich jetzt auf dieser Basis weiter mit der VCL arbeiten kann.

Pronto451

akari

Hallo

Wenn ich wüßte wie ich das auch mit dem Borland und der VCL hinbekomme ... prima, denn dann könnte ich alle meine eigenen Buttonkomponenten weiter verwenden und müsste sie nicht in WinAPI nochmal schreiben.

Das ist doch sehr einfach in der VCL umzusetzen.
Soweit ich das überblicken kann, gibt es ein Hauppt- und ein Unterfenster, das vom ersten mittels Button aufgerufen wird. Die Textausgabe per Cansas geht in der VCL so ähnlich, allerdings seh ich keinen Grund stattdesen nicht einfach TLabel zu verwenden.

bis bald
akari

Pronto451

Hallo

also ich wieß nicht wo du das zwei Fenster siehst ?!?!

Das ist ein Fenster mit etwas Test drauf und einem Button zum schließen. Nur das dieses Fenster den ganzen Desktop füllt, und hinter allen anderen Fenstern liegt.

Ich habs mit dem Borland schon mit diesem Code versucht:

void __fastcall TForm1::FormPaint(TObject *Sender)
{
  SetWindowPos(Application->Handle, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE);
}

und mit diesem:

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

  NewWindow = new TForm(GetDesktopWindow());

  // Größe und Position des Fensters setzen
  NewWindow->Left = 200;
  NewWindow->Top = 200;
  NewWindow->Width = 1024;
  NewWindow->Height = 768;

  NewButton = new TCLButton(NewWindow);
  NewButton->Parent = NewWindow;
  NewButton->Left = 200;
  NewButton->Top = 200;
  NewButton->Width = 100;
  NewButton->Height = 30;
  NewButton->Caption = "Hallo";
  NewButton->Visible = true;

  NewWindow->Visible = true;
}

Hat aber beides nicht richtig funktioniert.

Pronto451

Wenn das immer noch die gleiche Frage ist, wie vor ein paar Tagen:
Warum erstellst Du einen neuen Thread?
Und die Anwort ist immer noch dieselbe: Vermultich nur über Active Desktop zu lösen.

Pronto451

Hallo

ist noch das gleiche Projekt, aber jetzt halt eine andere Frage.

Wie arbeite ich mit WinAPI und Borland zusammen?

Pronto451

PS. Das ist kein neuer Thread, sondern ein ganz andere, weil es um WinAPI geht. Ich kann auch nix dafür, das ich immer noch an diesem Problem arbeite ...

Na ja, wenn ich mich richtig erinner, ging es Dir darum auf dem Desktop Daten auszugeben und nicht ein Fenster hinter allen anderen Fenstern zu haben: Active Desktop.

Pronto451

Hallo

also da errinerst du dich nicht richtig. Es ging darum ein Fenster hinter allen anderen zu haben und darauf Daten auszugeben. Ich habe gerade ein Programm gefunden das so etwas macht wie ich es auch machen will (http://www.sydatec.com/personaldesktop2/index.html), und das ist so weit ich es beurteilen kann nicht mit AktiveDesktop gemacht. Übrigens funktioniert das WinAPI Stückchen Code oben ja auch schon, nur wie krieg ich das jetzt mit der VCL unter einen Hut. Damit wir mal wieder zu der Frage zurück kommen.

Pronto451

Das Stückchen WinAPI-Code ist ein komplette Anwendung, nicht nur ein Fenster... Da fangen die Probleme an.
Keine Ahnung wie man das lösen könnte. Ich würde mal in der Projekt-CPP schauen, ob man dort die gewünschten Einstellungen für das Fenster machen kann.

Welcher Code-Teil in dem (unleserlichen ) WinAPI-Konstrukt ist denn für das 'im Hintergrund bleiben' zuständig?

EDIT: Wirf mal einen Blick auf TCreateParams in der BCB-Hilfe.

Pronto451

Hallo

also hier der Ausschnitt der für das Fensterverhalten wichtig ist:

hMainWnd = CreateWindowEx([b]WS_EX_TOOLWINDOW[/b],
                                szMainClassName,        //Fensterklassenname
                                szWinTitle,                    //Titel des Fensters
                                [b]WS_CHILD[/b],       
                                0, 0,                                //Position des Fensters wird von Windows festgelegt
                                1280, 1024,                    //Breite und Höhe des Fensters
                                (HWND)[b]GetDesktopWindow()[/b],                //Kein Eltern-Fenster
                                NULL,                                //Kein Menü
                                hInstCurrent,                //Aktuelles Instanzhandle
                                NULL );                            //zusätzliche Parameter

Wie bekomme ich so ein Fenster mit TForm hin ?

Ja, das schreit geradezu nach TCreateParams.

Pronto451

Hallo

und wenn du mir jetzt noch verraten könntest wie ich "TCreateParams" anwende !!!
In der Hilfe gibt es leiber kein Beispiel, wie ich das auf eine TForm anwende.

Pronto451

Hi,

RTFM (Read the fine MSDN) endlich darf ich das mal sagen

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winui/winui/windowsuserinterface/windowing/windows/windowreference/windowfunctions/setwindowpos.asp

Folgenden Code hab ich neulich eingebaut um ein
Programm immer im Vordergrund zu halten

if(SpeedButton3->Down==true)
  SetWindowPos(Handle, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE);
 else
  SetWindowPos(Handle, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE);

Ich glaub du brauchst anstatt HWND_TOPMOST das hier ---> HWND_BOTTOM
bei den Parametern hinten weis ich ehrlich gesagt nicht genau was die machen.
Kann man aber in der MSDN nachlesen (Link oben)

Grüsse

Morris Szyslak

füge z.B. folgendes in deine TForm ein:

virtual void __fastcall CreateParams(TCreateParams &Params)
  {
    TForm::CreateParams(Params);
    Params.ExStyle = WS_EX_TOOLWINDOW;
    Params.Style = WS_CHILD;
    Params.WndParent = (HWND)GetDesktopWindow();
  }

Nur der Vollständigkeit halber: Die Funktion muß natürlich ein Member der Form sein.

Pronto451

Hallo,

also das mit dem einfügen in die TForm hab ich noch nicht verstanden, wo einfügen ?!?!

Aus Howe's FAQ:

Q: Change the window class name of a form

Answer
Override the CreateParams method of your form, and copy your window class name into the WinClassName member of the TCreateParams structure.
//---------------------------------------------------------------
// header file
private:
    virtual void __fastcall CreateParams(TCreateParams & Params);
//---------------------------------------------------------------
// cpp file
void __fastcall TForm1::CreateParams(TCreateParams & Params)
{
    TForm::CreateParams(Params);
    strcpy(Params.WinClassName,"MotherPumpkin");
}
Note: The WinClassName member of the TCreateParams structure is an array of char. The array size is 64. You need to copy your window class name into this variable using strcpy. Do not attempt to assign the character string like this:

Note: The TCreateParams structure also contains a WindowClass member. This member is the WNDCLASS structure that you would normally see in an API program. The WNDCLASS structure contains a member called lpszClassName that would normally contain the class name in a standard API program. However, in the VCL, lpszClassName conflicts with the WinClassName character array. I tried to use lpszClassName to assign the class name, but it didn't have any effect. I recommend that you use WinClassName instead.

Hi,

mein Code kannst du überall verwenden.

Den anderen muss überschrieben werden.... so wie ich das sehe

in der unit.h

private:
 virtual void __fastcall CreateParams(TCreateParams &Params);

und in der unit.cpp

virtual void __fastcall TForm1::CreateParams(TCreateParams &Params)
{
.
.
.
.
}

Diese Funktion lässt du in der Form::Creat() aus aufrufen,
dann ist das fenster von Anfang an ganz hinten

Grüsse (zum Glück ist es mir heute nicht langweilig :-))

Pronto451

Hallo,

also irgend wie bin ich heute einfach zu blöd und verstehe nur noch Bahnhof.

Ich habe jetzt folgendes gemach:

//---------------------------------------------------------------------------
#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::CreateParams(TCreateParams &Params)
{
  TForm::CreateParams(Params);
  Params.ExStyle = WS_EX_TOOLWINDOW;
  Params.Style = WS_CHILD;
  Params.WndParent = (HWND)GetDesktopWindow();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormCreate(TObject *Sender)
{
  CreateParams();
}
//---------------------------------------------------------------------------

und in der H

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

#ifndef Unit1H
#define Unit1H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
//---------------------------------------------------------------------------
class TForm1 : public TForm
{
__published:	// Von der IDE verwaltete Komponenten
  void __fastcall FormCreate(TObject *Sender);
private:	// Anwender-Deklarationen
  virtual void __fastcall CreateParams(TCreateParams &Params);
public:		// Anwender-Deklarationen
  __fastcall TForm1(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif

Wie oder besser mit was muß ich den CreateParams aufrufen ?

akari

Hallo

Gar nicht. Die Methode wird automatisch von TForm aus aufgerufen. Deshalb ist die Methode virtual, damit sie in abgeleiteten Klassen (zum Beispiel deiner TForm1) überschrieben werden kann.

bis bald
akari