C++ EventCallback类代码示例

int tools::messageArrivedCallback(void *context,
                                  char *topicName, int,
                                  MQTTAsync_message *message)
{
    if(context != nullptr) {
        EventCallback *callback = static_cast<EventCallback*>(context);
        QString topic;
        if(topicName != nullptr) {
            topic = topicName;
        } else {
            topic = "unknown";
        }
        QByteArray payload;
        if(message != nullptr) {
            // using this overload of "append" because the payload can contain more then one \0
            payload.append(static_cast<char*>(message->payload), message->payloadlen);
        }
        qDebug() << payload.length();
        callback->onMessageArrived(topic, payload);
    } else {
        qDebug() << "context was empty.";
    }
    MQTTAsync_free(topicName);
    MQTTAsync_freeMessage(&message);
    return true;
}

void tools::deliveryCompleteCallback(void *context, MQTTAsync_token token)
{
    if(context != nullptr) {
        EventCallback *callback = static_cast<EventCallback*>(context);
        callback->onDeliveryComplete(token);
    } else {
        qDebug() << "context was empty.";
    }

}

//---------------------------------------------------------------------------------------
std::list<EventCallback*>::iterator Observer::find_handler(int eventType)
{
    std::list<EventCallback*>::iterator it;
    for (it = m_handlers.begin(); it != m_handlers.end(); ++it)
    {
        EventCallback* pCB = *it;
        if (pCB->get_event_type() == eventType)
            break;
    }
    return it;
}

void tools::connectionLostCallback(void *context, char *cause)
{
    if(context != nullptr) {
        EventCallback *callback = static_cast<EventCallback*>(context);
        QString causeMsg;
        if(cause != nullptr) {
            causeMsg = cause;
        } else {
            causeMsg = "unknown";
        }
        callback->onConnectionLost(causeMsg);
    } else {
        qDebug() << "context was empty.";
    }
}

/**
**  Called each frame to handle keyboard timeouts.
**
**  @param callbacks  Callback structure for events.
**  @param ticks      Denotes time-stamp of video-system
*/
void InputKeyTimeout(const EventCallback &callbacks, unsigned ticks)
{
	if (LastIKey && ticks > LastKeyTicks + HoldKeyDelay) {
		LastKeyTicks = ticks - (HoldKeyDelay - HoldKeyAdditionalDelay);
		callbacks.KeyRepeated(LastIKey, LastIKeyChar);
	}
}

/**
**  Called if the mouse is moved
**
**  @param callbacks  Callback structure for events.
**  @param ticks      Denotes time-stamp of video-system
**  @param x          X movement
**  @param y          Y movement
*/
void InputMouseMove(const EventCallback &callbacks,
					unsigned ticks, int x, int y)
{
	// Don't reset the mouse state unless we really moved
#ifdef USE_TOUCHSCREEN
	const int buff = 32;
	if (((x - buff) <= MouseX && MouseX <= (x + buff)) == 0
		|| ((y - buff) <= MouseY && MouseY <= (y + buff)) == 0) {
		MouseState = InitialMouseState;
		LastMouseTicks = ticks;
	}
	if (MouseX != x || MouseY != y) {
		MouseX = x;
		MouseY = y;
	}
#else
	if (MouseX != x || MouseY != y) {
		MouseState = InitialMouseState;
		LastMouseTicks = ticks;
		MouseX = x;
		MouseY = y;
	}
#endif
	const PixelPos pos(x, y);
	callbacks.MouseMoved(pos);
}

/**
**  Called if any mouse button is released up
**
**  @param callbacks  Callback structure for events.
**  @param ticks      Denotes time-stamp of video-system
**  @param button     Mouse button released.
*/
void InputMouseButtonRelease(const EventCallback &callbacks,
							 unsigned ticks, unsigned button)
{
	//  Same button before pressed.
	if (button == LastMouseButton && MouseState == InitialMouseState) {
		MouseState = ClickedMouseState;
	} else {
		LastMouseButton = 0;
		MouseState = InitialMouseState;
	}
	LastMouseTicks = ticks;

	unsigned mask = 0;
	if (MouseButtons & ((1 << button) << MouseDoubleShift)) {
		mask |= button << MouseDoubleShift;
	}
	if (MouseButtons & ((1 << button) << MouseDragShift)) {
		mask |= button << MouseDragShift;
	}
	if (MouseButtons & ((1 << button) << MouseHoldShift)) {
		mask |= button << MouseHoldShift;
	}
	MouseButtons &= ~(0x01010101 << button);

	callbacks.ButtonReleased(button | mask);
}

/**
**  Called if the mouse is moved
**
**  @param callbacks  Callback structure for events.
**  @param ticks      Denotes time-stamp of video-system
**  @param x          X movement
**  @param y          Y movement
*/
void InputMouseMove(const EventCallback &callbacks,
					unsigned ticks, int x, int y)
{
	PixelPos mousePos(x, y);
	// Don't reset the mouse state unless we really moved
#ifdef USE_TOUCHSCREEN
	const int buff = 32;
	const PixelDiff diff = LastMousePos - mousePos;

	if (abs(diff.x) > buff || abs(diff.y) > buff) {
		MouseState = InitialMouseState;
		LastMouseTicks = ticks;
		// Reset rectangle select cursor state if we moved by a lot
		// - rectangle select should be a drag, not a tap
		if (CursorState == CursorStateRectangle
			&& (abs(diff.x) > 2 * buff || abs(diff.y) > 2 * buff)) {
			CursorState = CursorStatePoint;
		}
	}
	LastMousePos = mousePos;
#else
	if (LastMousePos != mousePos) {
		MouseState = InitialMouseState;
		LastMouseTicks = ticks;
		LastMousePos = mousePos;
	}
#endif
	callbacks.MouseMoved(mousePos);
}

/**
**  Handle keyboard key release.
**
**  @param callbacks  Callback structure for events.
**  @param ticks      Denotes time-stamp of video-system
**  @param ikey       Key scancode.
**  @param ikeychar   Character code.
*/
void InputKeyButtonRelease(const EventCallback &callbacks,
						   unsigned ticks, unsigned ikey, unsigned ikeychar)
{
	if (ikey == LastIKey) {
		LastIKey = 0;
	}
	LastKeyTicks = ticks;
	callbacks.KeyReleased(ikey, ikeychar);
}

void EventCallbackGen::unregisterEventCallback(EventCallback& cb)
{
	DEB_MEMBER_FUNCT();

	if (m_cb != &cb)
		THROW_HW_ERROR(InvalidValue) << 
			"Specified EventCallback is not registered";

	m_cb = NULL;
	cb.setEventCallbackGen(NULL);
}

/**
**  Handle keyboard key press.
**
**  @param callbacks  Callback structure for events.
**  @param ticks      Denotes time-stamp of video-system
**  @param ikey       Key scancode.
**  @param ikeychar   Character code.
*/
void InputKeyButtonPress(const EventCallback &callbacks,
						 unsigned ticks, unsigned ikey, unsigned ikeychar)
{
	if (!LastIKey && DoubleKey == ikey && ticks < LastKeyTicks + DoubleClickDelay) {
		KeyModifiers |= ModifierDoublePress;
	}
	DoubleKey = ikey;
	LastIKey = ikey;
	LastIKeyChar = ikeychar;
	LastKeyTicks = ticks;
	callbacks.KeyPressed(ikey, ikeychar);
	KeyModifiers &= ~ModifierDoublePress;
}

/**
**  Called each frame to handle mouse timeouts.
**
**  @param callbacks  Callback structure for events.
**  @param ticks      Denotes time-stamp of video-system
*/
void InputMouseTimeout(const EventCallback &callbacks, unsigned ticks)
{
	if (MouseButtons & (1 << LastMouseButton)) {
		if (ticks > StartMouseTicks + DoubleClickDelay) {
			MouseState = InitialMouseState;
		}
		if (ticks > LastMouseTicks + HoldClickDelay) {
			LastMouseTicks = ticks;
			MouseButtons |= (1 << LastMouseButton) << MouseHoldShift;
			callbacks.ButtonPressed(LastMouseButton | (LastMouseButton << MouseHoldShift));
		}
	}
}

/**
**  Called if any mouse button is pressed down
**
**  Handles event conversion to double click, dragging, hold.
**
**  FIXME: dragging is not supported.
**
**  @param callbacks  Callback structure for events.
**  @param ticks      Denotes time-stamp of video-system
**  @param button     Mouse button pressed.
*/
void InputMouseButtonPress(const EventCallback &callbacks,
						   unsigned ticks, unsigned button)
{
	//  Button new pressed.
	if (!(MouseButtons & (1 << button))) {
		MouseButtons |= (1 << button);
		//  Detect double click
		if (MouseState == ClickedMouseState && button == LastMouseButton
			&& ticks < StartMouseTicks + DoubleClickDelay) {
			MouseButtons |= (1 << button) << MouseDoubleShift;
			button |= button << MouseDoubleShift;
		} else {
			MouseState = InitialMouseState;
			StartMouseTicks = ticks;
			LastMouseButton = button;
		}
	}
	LastMouseTicks = ticks;

	callbacks.ButtonPressed(button);
}

/**
**  Called if the mouse exits the game window (when supported by videomode)
**
**  @param callbacks  Callback structure for events.
**  @param ticks      Denotes time-stamp of video-system
**
*/
void InputMouseExit(const EventCallback &callbacks, unsigned /* ticks */)
{
	// FIXME: should we do anything here with ticks? don't know, but conform others
	// JOHNS: called by callback HandleMouseExit();
	callbacks.MouseExit();
}

/**
* Entry point routine.
*
* There's no argument needed for registration but to uninstall, specify the
* "-uninstall" parameter.
* 
* This routine connects to the Google Desktop event publisher and establishes
* an event subscription.  The subscription can by filtered to only deliver
* events that belong to a certain schema. To specify a schema, use the
* "-s" flag, immediately followed by the schema name.
* Example:
*   console_events -sEmail
*
* Repeating the -s flag is supported.
*/
int _tmain(int argc, TCHAR* argv[]) {
  ArgumentCheck args;
  if (!args.Check(argc, argv)) {
    args.PrintUsage();
    return -1;
  }

  long cookie = 0;
  HRESULT hr;

  if (args.IsUninstall()) {
    hr = UnregisterFromGDEventFramework();
    if (SUCCEEDED(hr))
      return 0;
  } else {
    hr = EnsureRegistered(&cookie);
  }

  if (FAILED(hr)) {
    _tprintf(_T("Unable to %s with the Google Desktop event framework - 0x%08X\n%s\n"),
      args.IsUninstall() ? _T("unregister") : _T("register"), hr, GDErrorToString(hr));
    return hr;
  }

  ATLASSERT(cookie != 0);

  //
  // Create an instance of the Google Desktop Event Publisher
  // and set up a subscription
  //
  CComPtr<IGoogleDesktopEventPublisher> publisher;
  hr = publisher.CoCreateInstance(L"GoogleDesktop.EventPublisher.1");

  // Our callback object that will receive notifications
  EventCallback callback;

  // Our subscription that controls how events are delivered to us
  CComPtr<IGoogleDesktopEventSubscription> subscription;

  if (SUCCEEDED(hr)) {
    CComPtr<IUnknown> callback_identity;
    // Use ATL's special QI method to get the identity IUnknown pointer
    // of our callback object.
    hr = callback._LocDEQueryInterface(IID_IUnknown,
                                       reinterpret_cast<void**>(&callback_identity));
    ATLASSERT(SUCCEEDED(hr) && "_LocDEQueryInterface");

    //
    // Now connect our callback object to the GD Event Framework
    // by subscribing to events, then configure the subscription
    // and eventually, turn on the event stream.
    // 
    hr = publisher->Subscribe(cookie, callback_identity, &subscription);

    if (SUCCEEDED(hr)) {
      if (argc > 1) {
        hr = args.SetUserSpecifiedSchemaFilters(subscription);
      }

      if (SUCCEEDED(hr)) {
        // This turns on the event stream
        hr = subscription->put_active(VARIANT_TRUE);
      }
    }
  }

  if (FAILED(hr)) {
    _tprintf(_T("An error occured while connecting to the Google Desktop event framework - 0x%08X\n%s\n"),
      hr, GDErrorToString(hr));
    return hr;
  }

  _tprintf(_T("Event information will show up here.  Press Ctrl+C to stop.\n"));
  hr = ReceiveEvents();

  // Now turn off the subscription and unsubscribe
  ATLVERIFY(SUCCEEDED(subscription->put_active(VARIANT_FALSE)));
  ATLVERIFY(SUCCEEDED(publisher->Unsubscribe(subscription)));

  // Print out some information on our exit status
  if (FAILED(hr)) {
    _tprintf(_T("An error occured during processing of events - 0x%08X\n%s\n"),
      hr, GDErrorToString(hr));
  } else {
    _tprintf(_T("Have a nice day!\n"));
//.........这里部分代码省略.........