Du bist nicht angemeldet.

Stilllegung des Forums
Das Forum wurde am 05.06.2023 nach über 20 Jahren stillgelegt (weitere Informationen und ein kleiner Rückblick).
Registrierungen, Anmeldungen und Postings sind nicht mehr möglich. Öffentliche Inhalte sind weiterhin zugänglich.
Das Team von spieleprogrammierer.de bedankt sich bei der Community für die vielen schönen Jahre.
Wenn du eine deutschsprachige Spieleentwickler-Community suchst, schau doch mal im Discord und auf ZFX vorbei!

Werbeanzeige

Mr. Schmidt

Frischling

  • »Mr. Schmidt« ist der Autor dieses Themas

Beiträge: 24

Wohnort: Nürnberg

  • Private Nachricht senden

1

26.09.2006, 16:21

Callback Parameter

Hallo alle zusammen,

ich komme bei einer "Aufgabe" im Buch nicht weiter.
Und zwar werden im letzten Programm im Kapitel 10 globale Variablen verwendet. Im Text steht der Hinweis, man sollte anschließend das Programm umschreiben, sodass es keine globalen Variablen mehr gibt.
Die einzige Idee die mir da gekommen ist, ist der CALLBACK Funktion alle dort benötigten Variablen zu übergeben. Allerdings meckert dann mein Compiler und verweigert seine Arbeit.
Wie löse ich das Problem und kann man der CALLBACK Funktion überhaupt zusätzliche Parameter übergeben?

Vielen Dank schonmal

2

26.09.2006, 16:39

Zeig uns einfach mal deinen Code.. kommt drauf an ... die Window Procedure wird ja immer mit SendMessage aufgerufen ... d.h. sie reagiert auf eine definierte Nachricht ... kannst auch ne eigene definieren ... auf die du in der func dann reagierst ... allerdings hast du auch dann nur lparam und wparam um nen paar parameter zu übergeben ... was aber dicke reicht ...

aber das wirst du für die Aufgabe eh nicht brauchen ... ist da niemals so gefragt ... also zeig uns deinen code ... ist warscheinlich nur mit gemeint das du die variablen nur local anlegst ...also in der funk selbst ...
Devil Entertainment :: Your education is our inspiration
Der Spieleprogrammierer :: Community Magazin
Merlin - A Legend awakes :: You are a dedicated C++ (DirectX) programmer and you have ability to work in a team? Contact us!
Siedler II.5 RttR :: The old settlers-style is comming back!

Also known as (D)Evil

Mr. Schmidt

Frischling

  • »Mr. Schmidt« ist der Autor dieses Themas

Beiträge: 24

Wohnort: Nürnberg

  • Private Nachricht senden

3

26.09.2006, 16:53

Das ist der Code von Listing 10_3:

C-/C++-Quelltext

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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
// C++ für Spieleprogrammierer

// Listing 10.3

// Eine kleine Anwendung

//


#include <windows.h>

// Prototypen

//

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

HWND ErstelleHauptfenster (HINSTANCE hInst);
void ErstelleSteuerelemente (HWND hWnd, HINSTANCE hInst);

// IDs der Child-Fenster

//

#define ID_STATICTEXT      4000
#define ID_EDITBOX         4001
#define ID_BTN_UEBERNEHMEN 4002
#define ID_BTN_BEENDEN     4003

// Globale Variablen

// Don't do this at home!

//

HWND hText;        // Handle für den statischen Text

HWND hEditBox;     // Handle für die Editbox

HWND hUebernehmen; // Handle für Button "Übernehmen"

HWND hBeenden;     // Handle für Button "Beenden"


// Hauptprogramm

//

int WINAPI WinMain (HINSTANCE hInst, HINSTANCE hPrevInst,
                    LPSTR lpcmdline, int ncmdshow)
{
  HWND hWnd;   // Fenster-Handle

  MSG message; // Nachricht


  // Hauptfenster erstellen

  hWnd = ErstelleHauptfenster (hInst);

  // Prüfen, ob alles glatt ging

  if (hWnd == NULL)
    return (0);

  // Alle Steuerelemente erstellen

  ErstelleSteuerelemente (hWnd, hInst);

  // Der "Herzschlag" des Programms

  // Hier werden alle Nachrichten abgeholt,

  // übersetzt und weitergeleitet

  //

  while (GetMessage (&message, NULL, 0, 0) )
  {
    TranslateMessage (&message);
    DispatchMessage  (&message);

  }

  // Programm beenden

  return (int)(message.wParam);

} // WinMain



// Erstelle Hauptfenster

//

// Hauptfenster erstellen und Handle zurückliefern

//

HWND ErstelleHauptfenster (HINSTANCE hInst)
{
  HWND        hWnd;        // Fenster-Handle

  WNDCLASSEX  windowclass; // Nachricht


  // Der Klassenname des Fensters ist frei wählbar

  const char szClassName[] = "Zweites Fenster";

  // Struktur mit gewünschten Eigenschaften füllen

  //


  // Größe der Struktur zwischenspeichern

  windowclass.cbSize = sizeof (WNDCLASSEX);

  // Fenster soll beim Verschieben neu gezeichnet werden

  windowclass.style = CS_HREDRAW | CS_VREDRAW;

  // Zeiger auf Callback-Funktion

  windowclass.lpfnWndProc = WindowProc;

  // Keine erweiterten Einstellungen

  windowclass.cbClsExtra = 0;
  windowclass.cbWndExtra = 0;

  // Instanz speichern

  windowclass.hInstance = hInst;

  // Icons und Cursor festlegen

  windowclass.hIcon   = LoadIcon (NULL, IDI_APPLICATION);
  windowclass.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
  windowclass.hCursor = LoadCursor (NULL, IDC_ARROW);

  // Hintergrundfarbe festlegen

  windowclass.hbrBackground = (HBRUSH)COLOR_BACKGROUND+1;

  // Ein Menü brauchen wir nicht

  windowclass.lpszMenuName = NULL;

  // Klassenname angeben

  windowclass.lpszClassName = szClassName;

  // Fensterklasse registrieren

  if (!RegisterClassEx (&windowclass) )
    return (NULL);

  // Das Fenster erzeugen

  hWnd = CreateWindowEx (NULL,
                         szClassName,
                         "Eine kleine Anwendung",
                         WS_OVERLAPPEDWINDOW | WS_VISIBLE,
                         CW_USEDEFAULT, CW_USEDEFAULT,
                         300, 135,
                         NULL,
                         NULL,
                         hInst,
                         NULL);

  // Fensterhandle zurückgeben

  return (hWnd);

} // ErstelleHauptfenster



// ErstelleSteuerelemente

//

// Alle Steuerelemente erstellen

//

void ErstelleSteuerelemente (HWND hWnd, HINSTANCE hInst)
{
  // Statischen Text als Child-Fenster erstellen

  //

  hText = CreateWindow ("STATIC",
                        "Eingegebener Text",
                        WS_VISIBLE | WS_CHILD | ES_CENTER,
                        0, 0,
                        300, 20,
                        hWnd,
                        (HMENU)ID_STATICTEXT,
                        hInst,
                        NULL);

  // Editbox als Child-Fenster erstellen

  //

  hEditBox = CreateWindow ("EDIT",
                           "Bitte Text eingeben",
                           WS_VISIBLE | WS_CHILD | WS_BORDER,
                           0, 20,
                           300, 20,
                           hWnd,
                           (HMENU)ID_EDITBOX,
                           hInst,
                           NULL);

  // "Übernehmen"-Button als Child-Fenster erstellen

  //

  hUebernehmen = CreateWindow ("BUTTON",
                           "Übernehmen",
                           BS_PUSHBUTTON | WS_VISIBLE | WS_CHILD,
                           20, 50,
                           95, 40,
                           hWnd,
                           (HMENU)ID_BTN_UEBERNEHMEN,
                           hInst,
                           NULL);

  // "Beenden"-Button als Child-Fenster erstellen

  //

  hBeenden = CreateWindow ("BUTTON",
                           "Beenden",
                           BS_PUSHBUTTON | WS_VISIBLE | WS_CHILD,
                           175, 50,
                           95, 40,
                           hWnd,
                           (HMENU)ID_BTN_BEENDEN,
                           hInst,
                           NULL);

} // ErstelleSteuerelemente



// Callback-Funktion zur Nachrichtenverarbeitung

//

LRESULT CALLBACK WindowProc (HWND hWnd, UINT message,
                             WPARAM wParam, LPARAM lParam)
{
  // Messages auswerten

  switch (message)
  {
    // Fenster schließen? (Auch Alt-F4)

    case WM_DESTROY:
    {
      // Nachricht zum Beenden schicken

      PostQuitMessage (0);
      return (0);

    }

    // Ab hier die Nachrichten unserer Child-Fenster bearbeiten

    case WM_COMMAND:
    {
      switch (wParam)
      {
        // Wurde "Übernehmen" angeklickt?

        case ID_BTN_UEBERNEHMEN:
        {
          char szText[256];

          // Text aus der Editbox holen

          GetWindowText (hEditBox, szText, 256);

          // Diesen Text in das Label schreiben und

          // den Text der Editbox löschen

          SetWindowText (hText, szText);
          SetWindowText (hEditBox, "");

          return (0);

        }

        // Wurde "Beenden" angeklickt?

        case ID_BTN_BEENDEN:
        {
          int Resultat; // Rückgabewert der Messagebox


          // Messagebox für Sicherheitsabfrage

          Resultat = MessageBox (hWnd, "Wirklich beenden?",
                                 "Programm beenden",
                                 MB_YESNO | MB_ICONQUESTION);

          // Wurde "Ja" angeklickt?

          if (Resultat == IDYES)
          {
            // Ja, also Programm beenden

            PostQuitMessage (0);
            return (0);

          }

          // Nein, also ganz normal weiter

          return (0);

        }
      } break;
    } break;
  }

  // Die Nachricht wurde nicht von uns verarbeitet, also

  // von Windows verarbeiten lassen

  return (DefWindowProc (hWnd, message, wParam, lParam) );

} // WindowProc


Es geht um die Handels des Textes und der Editbox. Die beiden werden in der seperaten Funktion "Erstelle_Steuerelemente" gefüllt.
In der CALLBACK Funktion werden ihre Werte ausgelesen und geändert.
Wenn man nun die Handels lokal z.B in der WinMain Funktion erstellt muss man sie ja an die CALLBACK Funktion übergeben, damit diese etwas ändern kann. Allerdings weiss ich nicht wie man das macht.

Nox

Supermoderator

Beiträge: 5 272

Beruf: Student

  • Private Nachricht senden

4

26.09.2006, 17:59

Hmm also du könntest in der CALLBACK statische Variablen erstellen und per WM_APP + 1 eine eigene Nachricht definieren und dem Fenster zuschicken, um die Zeiger zu setzen, oder du machst das Erstellen der Childs in dem WM_CREATE Aufruf.
Alternative, wenn dir das mit den statischen Zeigern nicht passt, kannst du dir die Elemente eines Fensters auch aufzählen lassen oder das Element an einer bestimmten Position holen (EnumChildWindows, ChildWindowFromPointEx).
Das sind jetzt nur einige Möglichkeiten, die mir spontan einfallen.
PRO Lernkurs "Wie benutze ich eine Doku richtig"!
CONTRA lasst mal die anderen machen!
networklibbenc - Netzwerklibs im Vergleich | syncsys - Netzwerk lib (MMO-ready) | Schleichfahrt Remake | Firegalaxy | Sammelsurium rund um FPGA&Co.

5

26.09.2006, 18:04

C-/C++-Quelltext

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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
#include <windows.h>

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

HWND CreateMainWnd(HINSTANCE);
void CreateControls(HWND, HINSTANCE, HWND* hWndControls);

#define ID_STATICTEXT      4000
#define ID_EDITBOX         4001
#define ID_BTN_UEBERNEHMEN 4002
#define ID_BTN_BEENDEN     4003

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpstCmdLine, int nCmdShow)
{
    HWND    hWnd;
    MSG     msg;

    if ((hWnd = CreateMainWnd(hInstance)) == NULL)
        return 0;

    while (GetMessage(&msg, NULL, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    return (int)(msg.wParam);
}

HWND CreateMainWnd(HINSTANCE hInstance)
{
    WNDCLASSEX  wcex;
    const TCHAR szClassName[] = _T("Zweites Fenster");

    wcex.cbSize         = sizeof(WNDCLASSEX);
    wcex.style          = CS_HREDRAW | CS_VREDRAW;
    wcex.lpfnWndProc    = WindowProc;
    wcex.cbClsExtra     = 0;
    wcex.cbWndExtra     = 0;
    wcex.hInstance      = hInstance;

    wcex.hIcon          = LoadIcon(NULL, IDI_APPLICATION);
    wcex.hIconSm        = LoadIcon(NULL, IDI_APPLICATION);
    wcex.hCursor        = LoadCursor(NULL, IDC_ARROW);
    wcex.hbrBackground  = (HBRUSH)COLOR_BACKGROUND + 1;
    wcex.lpszMenuName   = NULL;
    wcex.lpszClassName  = szClassName;

    if (!RegisterClassEx(&wcex))
        return NULL;

    return (CreateWindowEx(NULL, szClassName, _T("Eine kleine Anwendung"), WS_OVERLAPPEDWINDOW | WS_VISIBLE, CW_USEDEFAULT, CW_USEDEFAULT, 300, 135, NULL, NULL, hInstance, NULL));
}

bool CreateControls(HWND hWndParent, HINSTANCE hInstance, HWND* hWndControls)
{
    if (hWndParent == NULL || hInstance == NULL)
        return false;

    hWndControls[0] = CreateWindow(_T("STATIC"), _T("Eingegebener Text"), WS_VISIBLE | WS_CHILD | ES_CENTER, 0, 0, 300, 20, hWndParent, (HMENU)ID_STATICTEXT, hInstance, NULL);
    hWndControls[1] = CreateWindow(_T("EDIT"), _T("Bitte Text eingeben"), WS_VISIBLE | WS_CHILD | WS_BORDER, 0, 20, 300, 20, hWndParent, (HMENU)ID_EDITBOX, hInstance, NULL);
    hWndControls[2] = CreateWindow(_T("BUTTON"), _T("Übernehmen"), BS_PUSHBUTTON | WS_VISIBLE | WS_CHILD, 20, 50, 95, 40, hWndParent, (HMENU)ID_BTN_UEBERNEHMEN, hInstance, NULL);
    hWndControls[3] = CreateWindow(_T("BUTTON"), _T("Beenden"), BS_PUSHBUTTON | WS_VISIBLE | WS_CHILD, 175, 50, 95, 40, hWndParent, (HMENU)ID_BTN_BEENDEN, hInstance, NULL);

    if (hWndControls[0] == NULL || hWndControls[1] == NULL || hWndControls[2] == NULL || hWndControls[3] == NULL)
        return false;

    return true;
}

LRESULT CALLBACK WindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    static HWND hWndControls[4];

    switch (message)
    {
        case WM_CREATE:
        {
            if (CreateControls(hWnd, ((LPCREATESTRUCT)lParam)->hInstance, &hWndControls))
                return S_FALSE;
        } break;
        case WM_DESTROY:
        {
            PostQuitMessage (0);
        } break;
        case WM_COMMAND:
        {
            switch (wParam)
            {
                case ID_BTN_UEBERNEHMEN:
                {
                    TCHAR szText[256];
                    GetWindowText(hEditBox, szText, 256);
                    SetWindowText(hText, szText);
                    SetWindowText(hEditBox, _T(""));
                }break;
                case ID_BTN_BEENDEN:
                {
                    int nResult = MessageBox (hWnd, _T("Wirklich beenden?"), _T("Programm beenden"), MB_YESNO | MB_ICONQUESTION);
                    
                    if (nResult == IDYES)
                        PostQuitMessage(0);
                }break;
            }
        } break;
        default:
            return (DefWindowProc(hWnd, message, wParam, lParam));
    }

    return S_OK;
}

So in der Art in etwa ... hatte keine Zeit es zu testen ... bzw ist nur hier so reingetippt ... d.h. können auch tippfehler usw drin sein :(
Devil Entertainment :: Your education is our inspiration
Der Spieleprogrammierer :: Community Magazin
Merlin - A Legend awakes :: You are a dedicated C++ (DirectX) programmer and you have ability to work in a team? Contact us!
Siedler II.5 RttR :: The old settlers-style is comming back!

Also known as (D)Evil

Nox

Supermoderator

Beiträge: 5 272

Beruf: Student

  • Private Nachricht senden

6

26.09.2006, 23:35

Also ich sehe auf Anhieb 4 Stück, wobei 3 sich ganz ähnlich sind ;)
PRO Lernkurs "Wie benutze ich eine Doku richtig"!
CONTRA lasst mal die anderen machen!
networklibbenc - Netzwerklibs im Vergleich | syncsys - Netzwerk lib (MMO-ready) | Schleichfahrt Remake | Firegalaxy | Sammelsurium rund um FPGA&Co.

7

27.09.2006, 15:00

hmm jo kann sein :D einmal ne hIntance statt hInstance geschrieben ... den anderen seh ich jetzt gerade beim überfliegen nicht ... aber das kann ja Mr.Schmidt selbst machen ... bin hier nicht die Lösungsmaschiene ;)
Devil Entertainment :: Your education is our inspiration
Der Spieleprogrammierer :: Community Magazin
Merlin - A Legend awakes :: You are a dedicated C++ (DirectX) programmer and you have ability to work in a team? Contact us!
Siedler II.5 RttR :: The old settlers-style is comming back!

Also known as (D)Evil

Mr. Schmidt

Frischling

  • »Mr. Schmidt« ist der Autor dieses Themas

Beiträge: 24

Wohnort: Nürnberg

  • Private Nachricht senden

8

28.09.2006, 19:13

Vielen Dank für eure Hilfe. Die Lösung mit dem WM_CREATE funktioniert wunderbar.
Die Möglichkeit, das gleiche mit Hilfe von eigenen Messages zu machen versteh ich leider nicht. Auch in der Funktion EnumChildWindows blick ich nicht ganz durch. Laut der MSDN schickt die ja die Handels an eine spezielle EnumChildProc Funktion, aber nicht zur CALLBACK Funktion, daher weiss ich nicht wie ich das benutzen kann.

Vielen Dank noch mal.

Gruß Mr. Schmidt

Werbeanzeige