Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » C / C++ (WinAPI, Konsole) » Keine Variablen ändern in LRESULT CALLBACK möglich?

Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: > 1 <
000
24.11.2007, 10:54 Uhr
~Popp
Gast


Hallo,

ich hab mir eine Klasse erstellt die unter anderen auch LRESULT CALLBACK enthält, die Funktion selbst ist in der Klasse als static deklariert. jedoch hab ich damit anscheinend ein problem.

die klasse sieht so aus:


C++:
class windowsampe
{
private:
int meinevariable;
public:
[...]
static LRESULT CALLBACK WndProc (HWND hWnd, UINT message,WPARAM wParam, LPARAM lParam);
[...]
windowsampe(int a)
{
meinevariable = a;
}
};



Die Klasse ist jetzt etwas abgespeckt da es mir nur um diesen teil geht. Und zwar möchte ich gerne die variable erhöhen wenn die taste VK_ADD gedrückt wird, doch irgendwie scheint das nicht zu gehen, schreibe ich in der funktion:


C++:
LRESULT CALLBACK windowsample::WndProc (HWND hWnd, UINT message,
                          WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
    case WM_CREATE:
        return 0;
    case WM_CLOSE:
        PostQuitMessage (0);
        return 0;

    case WM_DESTROY:
        return 0;

    case WM_KEYDOWN:
        switch (wParam)
        {
        case VK_ESCAPE:
            PostQuitMessage(0);
            return 0;
        case VK_ADD;
            meinevariable += 5;
            return 0;
        }
        return 0;

    default:
        return DefWindowProc (hWnd, message, wParam, lParam);
    }
}



Doch ich bekomme immer den fehler, das ich die variable falsch benutzt hätte: Zitat "Invalid use of member 'meinevariable" in static function.

Das ist komisch, kann mir mal jemand helfen wie ich die variable inkrementiere wenn die taste VK_ADD gedrückt wird?

Ich hoffe Ihr könnt mir helfen

Gruß

Popp
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
001
24.11.2007, 12:12 Uhr
Tommix



Hallo,
aus statischen Funktionen kannst Du nur auf statische Variablen zugreifen.
Gruß, Tommix
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
002
24.11.2007, 12:26 Uhr
~Popp
Gast


Gibt es dann noch eine weitere möglichkeit, die Variablen zu setzen? sprich kann ich das ganze auch noch anders machen? gibts noch ne alternative zu static bei der funktion?

gruß

popp
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
003
24.11.2007, 13:52 Uhr
xXx
Devil


hmm ne ... baer HWND kann nen this-Zeiger speichern (SetWindowLongPtr(hWnd, GWL_USERDATA, this)), den du dann in der statischen Methode wieder abrufen kannst und darüber hast du wieder normalen Zugriff auf die Variablen ^^
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
004
24.11.2007, 14:18 Uhr
~Popp
Gast


Hallo xXx,

könntest du mir das mal noch etwas genauer klären, wie ich das in den zeiger speichere?


C++:
(SetWindowLongPtr(hWnd, GWL_USERDATA, this))



kann ich das einfach eine Variable schreiben und dort wieder aufrufen? wäre dir sehr dankbar für deine hilfe.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
005
25.11.2007, 12:20 Uhr
~Popp
Gast


Hallo nochmal,

ich komme damit irgendwie nicht so klar, bitte xXx erklär mir das mal an meinem beispiel.

ach komm schon bitte mach das

gruß

popp
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
006
25.11.2007, 22:35 Uhr
xXx
Devil


Was gibt das denn hier für nen gejammer ^^
is mir auch zu stressig, deswegen mal der HEader der entsprechenden Lib von mir:

C++:
#if !defined(WINDOW_H__INCLUDED)
#define WINDOW_H__INCLUDED

#if (_MSC_VER >= 1300)
#pragma once
#endif // (_MSC_VER >= 1300)

namespace winapi
{
    //! HWND-structure wrapper class
    class WINAPIPP_API Window
    {
    public:
        Window();
        virtual ~Window();

    public:
        operator ::HWND() const        {    return m_hWnd;    }
#pragma warning(disable: 4312)
        static Window* FromHandle(const ::HWND& hWnd) { return reinterpret_cast<Window*>(GetWindowLongPtr(hWnd, GWL_USERDATA)); };
#pragma warning(default: 4312)
        typedef LRESULT (Window::*WindowProcHandler)(WPARAM, LPARAM);

    private:
        Window(const Window&){}
        Window& operator=(const Window&) { return *this; }

    protected:
        virtual void            create(unsigned long, unsigned long, unsigned long, unsigned long, const char_types::string&, unsigned long, unsigned long, const char_types::string&, const ::HINSTANCE&, const ::HMENU&, Window* pParentWnd = NULL);
        virtual void            create(const ::WNDCLASSEX&, unsigned long, unsigned long, unsigned long, unsigned long, unsigned long, unsigned long, const char_types::string&, const ::HMENU&, Window* pParentWnd = NULL);

    public:
        void                    register_handler(UINT message, WindowProcHandler handler)    { m_WindowProcHandlers[message] = handler;    }

    public:
        template<typename r>
        r                        send_message(UINT msg) const { return static_cast<r>(send_message(msg, 0, 0)); }
        LRESULT                    send_message(UINT msg, WPARAM wParam = 0u, LPARAM lParam = 0L) const { return ::SendMessage(m_hWnd, msg, wParam, lParam); }
    public:
        virtual LRESULT            _message_proc(::HWND, UINT, WPARAM, LPARAM);

    private:
        static LRESULT CALLBACK    __message_proc(::HWND, UINT, WPARAM, LPARAM);

    public:
        ::HWND const&            get_handle() const                        { if (m_hWnd == NULL || ::IsWindow(m_hWnd) == FALSE) throw std::invalid_argument("window handle does not exist"); return m_hWnd; }

    protected:
        ::HWND                    m_hWnd;
#pragma warning (disable: 4251)
        std::map<UINT, WindowProcHandler>    m_WindowProcHandlers;
#pragma warning (default: 4251)
        ::HINSTANCE                m_hInstance;
    };
}; // winapi

#endif // WINDOW_H__INCLUDED


C++:
void Window::create(const ::WNDCLASSEX& wc,unsigned long x, unsigned long y, unsigned long width, unsigned long height, unsigned long style, unsigned long exstyle, const char_types::string& caption, const ::HMENU& hMenu, Window* pParentWnd)
    {
        m_hWnd = ::CreateWindowEx(exstyle, wc.lpszClassName, caption.c_str(), style, x, y, width, height,
            (pParentWnd == NULL ? NULL : pParentWnd->get_handle()), hMenu, wc.hInstance, static_cast<LPVOID>(this));

        if (m_hWnd == NULL) throw std::runtime_error("window could not be created");
    }

    LRESULT CALLBACK Window::__message_proc(::HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
    {
        Window* pWindow = Window::FromHandle(hWnd);
#pragma warning(disable: 4311)
        if (message == WM_NCCREATE)
        {
            pWindow = reinterpret_cast<Window*>(reinterpret_cast<::LPCREATESTRUCT>(lParam)->lpCreateParams);
            SetWindowLongPtr(hWnd, GWL_USERDATA, reinterpret_cast<LONG>(pWindow));
        }
#pragma warning(default: 4311)
        return (pWindow != NULL ? pWindow->_message_proc(hWnd, message, wParam, lParam) : ::DefWindowProc(hWnd, message, wParam, lParam));
    }

    LRESULT    Window::_message_proc(::HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
    {
        std::map<UINT, WindowProcHandler>::iterator it    = m_WindowProcHandlers.find(message);
        return (it != m_WindowProcHandlers.end() ? (this->*(*it).second)(wParam, lParam) : ::DefWindowProc(hWnd, message, wParam, lParam));
    }
... das sollte jetzt aber reichen ...
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
007
25.11.2007, 22:37 Uhr
xXx
Devil


ehm der code ist etwas älter ... kann folglich noch etwas stärker optimiert werden ... aber mal so als erster Ansatz
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: > 1 <     [ C / C++ (WinAPI, Konsole) ]  


ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: