4. Reaktion auf Mausklick + instanzierung von Fenstern

Reaktion auf Mausklick + instanzierung von Fenstern

  • M

    ich möchte wenn ich auf das erstellte frame klicke ein 2tes Frame öffnen der gleichen instanz und dabei die ausgabe von werten innerhalb dieser frames trennen.

    #include <windows.h>
#include <stdio.h>

LRESULT WINAPI MainWndProc( HWND, UINT, WPARAM, LPARAM );

/*******************  Global Variables ********************/

int PASCAL WinMain( HINSTANCE hInstance,
    HINSTANCE hPrevInstance,
    LPSTR lpszCmdLine,
    int nCmdShow )
{
   WNDCLASS wc;
   MSG msg;
   HWND hWnd;

   if( !hPrevInstance )
   {
      wc.lpszClassName = "MiniAppClass";
      wc.lpfnWndProc = MainWndProc;
      wc.style = CS_OWNDC | CS_VREDRAW | CS_HREDRAW;
      wc.hInstance = hInstance;
      wc.hIcon = LoadIcon( NULL, IDI_APPLICATION );
      wc.hCursor = LoadCursor( NULL, IDC_ARROW );
      wc.hbrBackground = (HBRUSH)( COLOR_WINDOW+1 );

      wc.lpszMenuName = NULL;
      wc.cbClsExtra = 0;
      wc.cbWndExtra = 0;

      RegisterClass( &wc );
   }

   hWnd = CreateWindow( "MiniAppClass",
      "Mini Application",
      WS_OVERLAPPEDWINDOW|WS_HSCROLL|WS_VSCROLL,
      0,
      0,
      CW_USEDEFAULT,
      CW_USEDEFAULT,
      NULL,
      NULL,
      hInstance,
      NULL
   );

   ShowWindow( hWnd, nCmdShow );
   UpdateWindow(hWnd);
   while( GetMessage( &msg, NULL, 0, 0 ) ) {
      TranslateMessage( &msg );
      DispatchMessage( &msg );
   }
   return msg.wParam;
}

LRESULT CALLBACK MainWndProc( HWND hWnd, UINT msg, WPARAM wParam,
   LPARAM lParam )
{
   PAINTSTRUCT ps;
   HDC hDC;

   static char buffer[200];
   static int count=0;
   int y;

   switch( msg ) {

/**************************************************************\
*     WM_PAINT:                                                *
\**************************************************************/
   case WM_PAINT:{
					count++;

					y=sprintf(buffer,"Anzahl: %d\n",count);

					OutputDebugString("WM_PAINT\n");
					hDC = BeginPaint( hWnd, &ps );

					TextOut( hDC, 10, 10, buffer, y -1 );

					EndPaint( hWnd, &ps );
				 }
         break;

/**************************************************************\
*     WM_DESTROY: PostQuitMessage() is called                  *
\**************************************************************/
      case WM_DESTROY:
		  OutputDebugString("WM_DESTROY\n");
         PostQuitMessage( 0 );
         break;

/**************************************************************\
*     Let the default window proc handle all other messages    *
\**************************************************************/
      default:
         return( DefWindowProc( hWnd, msg, wParam, lParam ));
   }
   return 0;
}

    in WM_PAINT hab ich die ausgabe drinnen, es ist einfach nur ein Counter der incrementiert wird wenn man das fenster vergrößert oder verkleinert.

    Wenn ich nun aber mehrere Instanzen davon erzeuge wird doch der wert in alle instanzen übernommen oder nicht?

    wie bekomme ich die instanzierung hin so das jedes Fenster die gleichen variablen für sich hat?

    Bin über jeden Hinweis, der zur Problemlösung oder zur Richtungsweisung beiträgt dankbar.

    mfg
    Snoop

    0
  • R

    hallo

    nutze wc.cbWndExtra = ???; !!!

    - definiere eine struktur mit alle benötigten Variablen
    - setze wc.cbWndExtra = sizeof(ZeigerAufStruktur)
    - erzeuge zwei globale Instanzen dieser Struktur
    - übergebe einen Zeiger auf eine Struktur bei CreateWindow als letzten Parameter ( LPVOID lpParam // pointer to window-creation data )
    - sichere den Zeiger bei WM_CREATE:
    lpcs = (LPCREATESTRUCT) lParam;
    lpcs->lpCreateParams // das ist Dein Zeiger

    mit SetWindowLong(hWnd, GWL_USERDATA, (LONG) lpcs->lpCreateParams);

    - Verwende immer wenn Du auf die Daten zugreifen möchtest
    z = (MeinZeiger*) GetWindowLong(hWnd, GWL_USERDATA);

    Alternativ kannst Du auch Speicher bei WM_CREATE holen den Inhalt des Zeigers kopieren, und den neuen Zeiger mit SetClassLong sichern. So brauchts Du nur ein
    lokale Instanz der Struktur beim erstellen eines neuen Fensters.

    mfg

    0
  • M

    Uff,

    THX erstmal ich werde versuchen das umzusetzen, wenn noch fragen auftreten werden frag ich nochmal 🙂

    0
  • R

    hallo,

    beachte ich habe gerade den Beitrag editiert,

    NICHT SetClassLong SONDERN SetWindowLong ist die richtige Funktion.

    Die Ideed dahinter ist praktisch nur einen Zeiger an das Fenster[Handle] zu "binden". Der Platz (praktisch Zeigervariable) für den Zeiger wird von Windows bereitgestellt, wie viel Platz benötigt wird legt man bei füllen der wc
    fest.

    So hat jedes Fenster die Möglickkeit unabhängig von globalen Variablen und gleicher Fensterprozedur seine eigenen Daten zu halten.

    Eine andere Möglickeit ist wohl SetProp und GetProp zu verwenden.
    Schau Dir auch mal diese Funktionen an.

    mfg

    0
  • M

    RED-BARON schrieb:

    hallo

    nutze wc.cbWndExtra = ???; !!!
    - definiere eine struktur mit alle benötigten Variablen
    - setze wc.cbWndExtra = sizeof(ZeigerAufStruktur)

    wenn ich nur einen Wert speichern möchte reicht es doch aus wenn ich
    wc.cbWndExtra = sizeof(long); schreibe oder?

    RED-BARON schrieb:

    - erzeuge zwei globale Instanzen dieser Struktur

    warum 2 globale instanzen? werden dann nicht auch 2 fenster gezeichnet?

    0
  • R

    hallo

    nicht 2 Instanzen von WNDCALSS sondern 2 Instanzen Deiner eigenen Struktur.

    Wenn Du nur einen long-Wert Speichern willst brauchts Du natürlich keine
    Struktur dafür definieren
    wc.cbWndExtra = sizeof(long);
    ist in dem Fall schon richtig

    warum 2 globale instanzen? werden dann nicht auch 2 fenster gezeichnet?

    Ich bin davon ausgegangen, daß Du 2 Fenster erstellen willst oder nicht (?),
    hat aber nichts mit den Strukturen zu tun.
    Beide Fenster sollen jedoch die gleiche WndProc verwenden aber ihre eigenen Daten haben, so habe ich das aufgefaßt.

    mfg

    0
  • M

    RED-BARON schrieb:

    hallo
    Ich bin davon ausgegangen, daß Du 2 Fenster erstellen willst oder nicht (?),
    hat aber nichts mit den Strukturen zu tun.
    Beide Fenster sollen jedoch die gleiche WndProc verwenden aber ihre eigenen Daten haben, so habe ich das aufgefaßt.
    mfg

    doch 2 fenster sollen es schon werden, eigentlich soll immer ein neues fenster der gleich instanz erzeugt werden wenn man in das fenster klickt, aber halt der zähler der die ereignisse zählt soll halt nur die zu dem entsprechenden fenster zugehörigen veränderungen zählen.

    greetz

    0
  • R

    hallo,

    dann bist Du mit dem aufgezeigten Ansatz auf dem richtige Weg ...
    So werden ansich auch Controls erstellt, alle habe die geliche WndProc
    aber unterschiedliche eigene Daten. Bezeiht sich auf Ctrls gelichen Typs
    natürlich nur 😉

    mfg

    0
Anmelden zum Antworten