// Generated by gmmproc 2.55.1 -- DO NOT MODIFY!


#include <glibmm.h>

#include <gdkmm/events.h>
#include <gdkmm/private/events_p.h>

#include <gdk/gdk.h>

/* Copyright (C) 2017 The gtkmm Development Team
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library. If not, see <http://www.gnu.org/licenses/>.
 */

#include <gdkmm/device.h>

namespace Gdk
{
int EventKey::get_scancode() const
{
  return gdk_event_get_scancode(const_cast<GdkEvent*>(Event::gobj()));
}

guint EventButton::get_click_count() const
{
  guint click_count = 0;
  gdk_event_get_click_count(Event::gobj(), &click_count);
  return click_count;
}

bool EventButton::shall_trigger_context_menu() const
{
  return gdk_event_triggers_context_menu(Event::gobj());
}

bool EventButton::get_axis(Gdk::AxisUse axis_use, double& value) const
{
  return gdk_event_get_axis(Event::gobj(), static_cast<GdkAxisUse>(axis_use), &value);
}

bool EventMotion::get_axis(Gdk::AxisUse axis_use, double& value) const
{
  return gdk_event_get_axis(Event::gobj(), static_cast<GdkAxisUse>(axis_use), &value);
}

bool EventTouch::get_axis(Gdk::AxisUse axis_use, double& value) const
{
  return gdk_event_get_axis(Event::gobj(), static_cast<GdkAxisUse>(axis_use), &value);
}

bool EventScroll::is_scroll_stop_event() const
{
  return gobj()->is_stop;
}

Gdk::Rectangle EventConfigure::get_rect() const
{
  return Gdk::Rectangle(gobj()->x, gobj()->y, gobj()->width, gobj()->height);
}

bool EventSelection::has_requestor() const
{
  return gobj()->requestor != nullptr;
}

bool EventOwnerChange::has_owner() const
{
  return gobj()->owner != nullptr;
}

bool EventGrabBroken::is_keyboard() const
{
  return gobj()->keyboard;
}

bool EventGrabBroken::is_implicit() const
{
  return gobj()->implicit;
}

bool EventGrabBroken::has_grab_window() const
{
  return gobj()->grab_window != nullptr;
}

} //namespace Gdk

namespace
{
} // anonymous namespace


namespace Glib
{

Gdk::EventKey wrap(GdkEventKey* object, bool take_copy)
{
  return Gdk::EventKey(object, take_copy);
}

} // namespace Glib

namespace Gdk
{


EventKey::EventKey()
:
  Event()
{
}

EventKey::EventKey(GdkEventKey* gobject, bool make_a_copy)
:
  Event(reinterpret_cast<GdkEvent*>(gobject), make_a_copy)
{}


void EventKey::swap(EventKey& other) noexcept
{
  Event::swap(other);
}

GdkEventKey* EventKey::gobj_copy() const
{
  return reinterpret_cast<GdkEventKey*>(Event::gobj_copy());
}

// The reinterpret_cast works because EventKey is a standard-layout class
// whose only data member is a GdkEvent pointer.
const EventKey& wrap_event(const GdkEventKey*& event)
{
  return reinterpret_cast<const EventKey&>(event);
}

EventKey& wrap_event(GdkEventKey*& event)
{
  return reinterpret_cast<EventKey&>(event);
}


guint32 EventKey::get_time() const
{
  return gobj()->time;
}

ModifierType EventKey::get_state() const
{
  return static_cast<ModifierType>(gobj()->state);
}

guint EventKey::get_keyval() const
{
  return gobj()->keyval;
}

guint16 EventKey::get_hardware_keycode() const
{
  return gobj()->hardware_keycode;
}

guint8 EventKey::get_group() const
{
  return gobj()->group;
}

bool EventKey::get_is_modifier() const
{
  return gobj()->is_modifier;
}


} // namespace Gdk


namespace Glib
{

Gdk::EventButton wrap(GdkEventButton* object, bool take_copy)
{
  return Gdk::EventButton(object, take_copy);
}

} // namespace Glib

namespace Gdk
{


EventButton::EventButton()
:
  Event()
{
}

EventButton::EventButton(GdkEventButton* gobject, bool make_a_copy)
:
  Event(reinterpret_cast<GdkEvent*>(gobject), make_a_copy)
{}


void EventButton::swap(EventButton& other) noexcept
{
  Event::swap(other);
}

GdkEventButton* EventButton::gobj_copy() const
{
  return reinterpret_cast<GdkEventButton*>(Event::gobj_copy());
}

// The reinterpret_cast works because EventButton is a standard-layout class
// whose only data member is a GdkEvent pointer.
const EventButton& wrap_event(const GdkEventButton*& event)
{
  return reinterpret_cast<const EventButton&>(event);
}

EventButton& wrap_event(GdkEventButton*& event)
{
  return reinterpret_cast<EventButton&>(event);
}

guint32 EventButton::get_time() const
{
  return gobj()->time;
}

ModifierType EventButton::get_state() const
{
  return static_cast<ModifierType>(gobj()->state);
}

double EventButton::get_x() const
{
  return gobj()->x;
}

double EventButton::get_y() const
{
  return gobj()->y;
}

double EventButton::get_root_x() const
{
  return gobj()->x_root;
}

double EventButton::get_root_y() const
{
  return gobj()->y_root;
}

guint EventButton::get_button() const
{
  return gobj()->button;
}

Glib::RefPtr<Gdk::Device> EventButton::get_device()
{
  Glib::RefPtr<Gdk::Device> ref_ptr(Glib::wrap(gobj()->device));

  if(ref_ptr)
    ref_ptr->reference();

  return ref_ptr;
}

Glib::RefPtr<const Gdk::Device> EventButton::get_device() const
{
  Glib::RefPtr<const Gdk::Device> ref_ptr(Glib::wrap(gobj()->device));

  if(ref_ptr)
    ref_ptr->reference();

  return ref_ptr;
}


} // namespace Gdk


namespace Glib
{

Gdk::EventScroll wrap(GdkEventScroll* object, bool take_copy)
{
  return Gdk::EventScroll(object, take_copy);
}

} // namespace Glib

namespace Gdk
{


EventScroll::EventScroll()
:
  Event()
{
}

EventScroll::EventScroll(GdkEventScroll* gobject, bool make_a_copy)
:
  Event(reinterpret_cast<GdkEvent*>(gobject), make_a_copy)
{}


void EventScroll::swap(EventScroll& other) noexcept
{
  Event::swap(other);
}

GdkEventScroll* EventScroll::gobj_copy() const
{
  return reinterpret_cast<GdkEventScroll*>(Event::gobj_copy());
}

// The reinterpret_cast works because EventScroll is a standard-layout class
// whose only data member is a GdkEvent pointer.
const EventScroll& wrap_event(const GdkEventScroll*& event)
{
  return reinterpret_cast<const EventScroll&>(event);
}

EventScroll& wrap_event(GdkEventScroll*& event)
{
  return reinterpret_cast<EventScroll&>(event);
}

guint32 EventScroll::get_time() const
{
  return gobj()->time;
}

ModifierType EventScroll::get_state() const
{
  return static_cast<ModifierType>(gobj()->state);
}

double EventScroll::get_x() const
{
  return gobj()->x;
}

double EventScroll::get_y() const
{
  return gobj()->y;
}

double EventScroll::get_root_x() const
{
  return gobj()->x_root;
}

double EventScroll::get_root_y() const
{
  return gobj()->y_root;
}

double EventScroll::get_delta_x() const
{
  return gobj()->delta_x;
}

double EventScroll::get_delta_y() const
{
  return gobj()->delta_y;
}

ScrollDirection EventScroll::get_direction() const
{
  return static_cast<ScrollDirection>(gobj()->direction);
}

Glib::RefPtr<Gdk::Device> EventScroll::get_device()
{
  Glib::RefPtr<Gdk::Device> ref_ptr(Glib::wrap(gobj()->device));

  if(ref_ptr)
    ref_ptr->reference();

  return ref_ptr;
}

Glib::RefPtr<const Gdk::Device> EventScroll::get_device() const
{
  Glib::RefPtr<const Gdk::Device> ref_ptr(Glib::wrap(gobj()->device));

  if(ref_ptr)
    ref_ptr->reference();

  return ref_ptr;
}


} // namespace Gdk


namespace Glib
{

Gdk::EventMotion wrap(GdkEventMotion* object, bool take_copy)
{
  return Gdk::EventMotion(object, take_copy);
}

} // namespace Glib

namespace Gdk
{


EventMotion::EventMotion()
:
  Event()
{
}

EventMotion::EventMotion(GdkEventMotion* gobject, bool make_a_copy)
:
  Event(reinterpret_cast<GdkEvent*>(gobject), make_a_copy)
{}


void EventMotion::swap(EventMotion& other) noexcept
{
  Event::swap(other);
}

GdkEventMotion* EventMotion::gobj_copy() const
{
  return reinterpret_cast<GdkEventMotion*>(Event::gobj_copy());
}

// The reinterpret_cast works because EventMotion is a standard-layout class
// whose only data member is a GdkEvent pointer.
const EventMotion& wrap_event(const GdkEventMotion*& event)
{
  return reinterpret_cast<const EventMotion&>(event);
}

EventMotion& wrap_event(GdkEventMotion*& event)
{
  return reinterpret_cast<EventMotion&>(event);
}

guint32 EventMotion::get_time() const
{
  return gobj()->time;
}

ModifierType EventMotion::get_state() const
{
  return static_cast<ModifierType>(gobj()->state);
}

double EventMotion::get_x() const
{
  return gobj()->x;
}

double EventMotion::get_y() const
{
  return gobj()->y;
}

double EventMotion::get_root_x() const
{
  return gobj()->x_root;
}

double EventMotion::get_root_y() const
{
  return gobj()->y_root;
}

bool EventMotion::get_is_hint() const
{
  return gobj()->is_hint;
}

void EventMotion::request_motions()
{
  gdk_event_request_motions(gobj());
}

Glib::RefPtr<Gdk::Device> EventMotion::get_device()
{
  Glib::RefPtr<Gdk::Device> ref_ptr(Glib::wrap(gobj()->device));

  if(ref_ptr)
    ref_ptr->reference();

  return ref_ptr;
}

Glib::RefPtr<const Gdk::Device> EventMotion::get_device() const
{
  Glib::RefPtr<const Gdk::Device> ref_ptr(Glib::wrap(gobj()->device));

  if(ref_ptr)
    ref_ptr->reference();

  return ref_ptr;
}


} // namespace Gdk


namespace Glib
{

Gdk::EventTouch wrap(GdkEventTouch* object, bool take_copy)
{
  return Gdk::EventTouch(object, take_copy);
}

} // namespace Glib

namespace Gdk
{


EventTouch::EventTouch()
:
  Event()
{
}

EventTouch::EventTouch(GdkEventTouch* gobject, bool make_a_copy)
:
  Event(reinterpret_cast<GdkEvent*>(gobject), make_a_copy)
{}


void EventTouch::swap(EventTouch& other) noexcept
{
  Event::swap(other);
}

GdkEventTouch* EventTouch::gobj_copy() const
{
  return reinterpret_cast<GdkEventTouch*>(Event::gobj_copy());
}

// The reinterpret_cast works because EventTouch is a standard-layout class
// whose only data member is a GdkEvent pointer.
const EventTouch& wrap_event(const GdkEventTouch*& event)
{
  return reinterpret_cast<const EventTouch&>(event);
}

EventTouch& wrap_event(GdkEventTouch*& event)
{
  return reinterpret_cast<EventTouch&>(event);
}

guint32 EventTouch::get_time() const
{
  return gobj()->time;
}

ModifierType EventTouch::get_state() const
{
  return static_cast<ModifierType>(gobj()->state);
}

double EventTouch::get_x() const
{
  return gobj()->x;
}

double EventTouch::get_y() const
{
  return gobj()->y;
}

double EventTouch::get_root_x() const
{
  return gobj()->x_root;
}

double EventTouch::get_root_y() const
{
  return gobj()->y_root;
}

const Gdk::EventSequence* EventTouch::get_event_sequence() const
{
  return reinterpret_cast<const Gdk::EventSequence*>(gobj()->sequence);
}

bool EventTouch::get_is_emulating_pointer() const
{
  return gobj()->emulating_pointer;
}

Glib::RefPtr<Gdk::Device> EventTouch::get_device()
{
  Glib::RefPtr<Gdk::Device> ref_ptr(Glib::wrap(gobj()->device));

  if(ref_ptr)
    ref_ptr->reference();

  return ref_ptr;
}

Glib::RefPtr<const Gdk::Device> EventTouch::get_device() const
{
  Glib::RefPtr<const Gdk::Device> ref_ptr(Glib::wrap(gobj()->device));

  if(ref_ptr)
    ref_ptr->reference();

  return ref_ptr;
}


} // namespace Gdk


namespace Glib
{

Gdk::EventCrossing wrap(GdkEventCrossing* object, bool take_copy)
{
  return Gdk::EventCrossing(object, take_copy);
}

} // namespace Glib

namespace Gdk
{


EventCrossing::EventCrossing()
:
  Event()
{
}

EventCrossing::EventCrossing(GdkEventCrossing* gobject, bool make_a_copy)
:
  Event(reinterpret_cast<GdkEvent*>(gobject), make_a_copy)
{}


void EventCrossing::swap(EventCrossing& other) noexcept
{
  Event::swap(other);
}

GdkEventCrossing* EventCrossing::gobj_copy() const
{
  return reinterpret_cast<GdkEventCrossing*>(Event::gobj_copy());
}

// The reinterpret_cast works because EventCrossing is a standard-layout class
// whose only data member is a GdkEvent pointer.
const EventCrossing& wrap_event(const GdkEventCrossing*& event)
{
  return reinterpret_cast<const EventCrossing&>(event);
}

EventCrossing& wrap_event(GdkEventCrossing*& event)
{
  return reinterpret_cast<EventCrossing&>(event);
}

guint32 EventCrossing::get_time() const
{
  return gobj()->time;
}

Glib::RefPtr<Gdk::Window> EventCrossing::get_subwindow()
{
  Glib::RefPtr<Gdk::Window> ref_ptr(Glib::wrap(gobj()->subwindow));

  if(ref_ptr)
    ref_ptr->reference();

  return ref_ptr;
}

Glib::RefPtr<const Gdk::Window> EventCrossing::get_subwindow() const
{
  Glib::RefPtr<const Gdk::Window> ref_ptr(Glib::wrap(gobj()->subwindow));

  if(ref_ptr)
    ref_ptr->reference();

  return ref_ptr;
}

ModifierType EventCrossing::get_state() const
{
  return static_cast<ModifierType>(gobj()->state);
}

double EventCrossing::get_x() const
{
  return gobj()->x;
}

double EventCrossing::get_y() const
{
  return gobj()->y;
}

double EventCrossing::get_root_x() const
{
  return gobj()->x_root;
}

double EventCrossing::get_root_y() const
{
  return gobj()->y_root;
}

Gdk::CrossingMode EventCrossing::get_mode() const
{
  return static_cast<Gdk::CrossingMode>(gobj()->mode);
}

Gdk::NotifyType EventCrossing::get_detail() const
{
  return static_cast<Gdk::NotifyType>(gobj()->detail);
}

bool EventCrossing::get_focus() const
{
  return gobj()->focus;
}


} // namespace Gdk


namespace Glib
{

Gdk::EventExpose wrap(GdkEventExpose* object, bool take_copy)
{
  return Gdk::EventExpose(object, take_copy);
}

} // namespace Glib

namespace Gdk
{


EventExpose::EventExpose()
:
  Event()
{
}

EventExpose::EventExpose(GdkEventExpose* gobject, bool make_a_copy)
:
  Event(reinterpret_cast<GdkEvent*>(gobject), make_a_copy)
{}


void EventExpose::swap(EventExpose& other) noexcept
{
  Event::swap(other);
}

GdkEventExpose* EventExpose::gobj_copy() const
{
  return reinterpret_cast<GdkEventExpose*>(Event::gobj_copy());
}

// The reinterpret_cast works because EventExpose is a standard-layout class
// whose only data member is a GdkEvent pointer.
const EventExpose& wrap_event(const GdkEventExpose*& event)
{
  return reinterpret_cast<const EventExpose&>(event);
}

EventExpose& wrap_event(GdkEventExpose*& event)
{
  return reinterpret_cast<EventExpose&>(event);
}

const Gdk::Rectangle& EventExpose::get_area() const
{
  return Glib::wrap(&gobj()->area);
}

::Cairo::RefPtr<const ::Cairo::Region> EventExpose::get_region() const
{
  return ::Cairo::RefPtr<::Cairo::Region>(new ::Cairo::Region(gobj()->region, false /* take ref */));
}

int EventExpose::get_count() const
{
  return gobj()->count;
}


} // namespace Gdk


namespace Glib
{

Gdk::EventFocus wrap(GdkEventFocus* object, bool take_copy)
{
  return Gdk::EventFocus(object, take_copy);
}

} // namespace Glib

namespace Gdk
{


EventFocus::EventFocus()
:
  Event()
{
}

EventFocus::EventFocus(GdkEventFocus* gobject, bool make_a_copy)
:
  Event(reinterpret_cast<GdkEvent*>(gobject), make_a_copy)
{}


void EventFocus::swap(EventFocus& other) noexcept
{
  Event::swap(other);
}

GdkEventFocus* EventFocus::gobj_copy() const
{
  return reinterpret_cast<GdkEventFocus*>(Event::gobj_copy());
}

// The reinterpret_cast works because EventFocus is a standard-layout class
// whose only data member is a GdkEvent pointer.
const EventFocus& wrap_event(const GdkEventFocus*& event)
{
  return reinterpret_cast<const EventFocus&>(event);
}

EventFocus& wrap_event(GdkEventFocus*& event)
{
  return reinterpret_cast<EventFocus&>(event);
}

bool EventFocus::get_focus() const
{
  return gobj()->in;
}


} // namespace Gdk


namespace Glib
{

Gdk::EventConfigure wrap(GdkEventConfigure* object, bool take_copy)
{
  return Gdk::EventConfigure(object, take_copy);
}

} // namespace Glib

namespace Gdk
{


EventConfigure::EventConfigure()
:
  Event()
{
}

EventConfigure::EventConfigure(GdkEventConfigure* gobject, bool make_a_copy)
:
  Event(reinterpret_cast<GdkEvent*>(gobject), make_a_copy)
{}


void EventConfigure::swap(EventConfigure& other) noexcept
{
  Event::swap(other);
}

GdkEventConfigure* EventConfigure::gobj_copy() const
{
  return reinterpret_cast<GdkEventConfigure*>(Event::gobj_copy());
}

// The reinterpret_cast works because EventConfigure is a standard-layout class
// whose only data member is a GdkEvent pointer.
const EventConfigure& wrap_event(const GdkEventConfigure*& event)
{
  return reinterpret_cast<const EventConfigure&>(event);
}

EventConfigure& wrap_event(GdkEventConfigure*& event)
{
  return reinterpret_cast<EventConfigure&>(event);
}

int EventConfigure::get_x() const
{
  return gobj()->x;
}

int EventConfigure::get_y() const
{
  return gobj()->y;
}

int EventConfigure::get_width() const
{
  return gobj()->width;
}

int EventConfigure::get_height() const
{
  return gobj()->height;
}


} // namespace Gdk


namespace Glib
{

Gdk::EventProperty wrap(GdkEventProperty* object, bool take_copy)
{
  return Gdk::EventProperty(object, take_copy);
}

} // namespace Glib

namespace Gdk
{


EventProperty::EventProperty()
:
  Event()
{
}

EventProperty::EventProperty(GdkEventProperty* gobject, bool make_a_copy)
:
  Event(reinterpret_cast<GdkEvent*>(gobject), make_a_copy)
{}


void EventProperty::swap(EventProperty& other) noexcept
{
  Event::swap(other);
}

GdkEventProperty* EventProperty::gobj_copy() const
{
  return reinterpret_cast<GdkEventProperty*>(Event::gobj_copy());
}

// The reinterpret_cast works because EventProperty is a standard-layout class
// whose only data member is a GdkEvent pointer.
const EventProperty& wrap_event(const GdkEventProperty*& event)
{
  return reinterpret_cast<const EventProperty&>(event);
}

EventProperty& wrap_event(GdkEventProperty*& event)
{
  return reinterpret_cast<EventProperty&>(event);
}

guint32 EventProperty::get_time() const
{
  return gobj()->time;
}

GdkAtom EventProperty::get_atom() const
{
  return gobj()->atom;
}

Gdk::PropertyState EventProperty::get_state() const
{
  return static_cast<Gdk::PropertyState>(gobj()->state);
}


} // namespace Gdk


namespace Glib
{

Gdk::EventSelection wrap(GdkEventSelection* object, bool take_copy)
{
  return Gdk::EventSelection(object, take_copy);
}

} // namespace Glib

namespace Gdk
{


EventSelection::EventSelection()
:
  Event()
{
}

EventSelection::EventSelection(GdkEventSelection* gobject, bool make_a_copy)
:
  Event(reinterpret_cast<GdkEvent*>(gobject), make_a_copy)
{}


void EventSelection::swap(EventSelection& other) noexcept
{
  Event::swap(other);
}

GdkEventSelection* EventSelection::gobj_copy() const
{
  return reinterpret_cast<GdkEventSelection*>(Event::gobj_copy());
}

// The reinterpret_cast works because EventSelection is a standard-layout class
// whose only data member is a GdkEvent pointer.
const EventSelection& wrap_event(const GdkEventSelection*& event)
{
  return reinterpret_cast<const EventSelection&>(event);
}

EventSelection& wrap_event(GdkEventSelection*& event)
{
  return reinterpret_cast<EventSelection&>(event);
}

guint32 EventSelection::get_time() const
{
  return gobj()->time;
}

GdkAtom EventSelection::get_selection() const
{
  return gobj()->selection;
}

GdkAtom EventSelection::get_target() const
{
  return gobj()->target;
}

GdkAtom EventSelection::get_property() const
{
  return gobj()->property;
}

Glib::RefPtr<Gdk::Window> EventSelection::get_requestor()
{
  Glib::RefPtr<Gdk::Window> ref_ptr(Glib::wrap(gobj()->requestor));

  if(ref_ptr)
    ref_ptr->reference();

  return ref_ptr;
}

Glib::RefPtr<const Gdk::Window> EventSelection::get_requestor() const
{
  Glib::RefPtr<const Gdk::Window> ref_ptr(Glib::wrap(gobj()->requestor));

  if(ref_ptr)
    ref_ptr->reference();

  return ref_ptr;
}


} // namespace Gdk


namespace Glib
{

Gdk::EventOwnerChange wrap(GdkEventOwnerChange* object, bool take_copy)
{
  return Gdk::EventOwnerChange(object, take_copy);
}

} // namespace Glib

namespace Gdk
{


EventOwnerChange::EventOwnerChange()
:
  Event()
{
}

EventOwnerChange::EventOwnerChange(GdkEventOwnerChange* gobject, bool make_a_copy)
:
  Event(reinterpret_cast<GdkEvent*>(gobject), make_a_copy)
{}


void EventOwnerChange::swap(EventOwnerChange& other) noexcept
{
  Event::swap(other);
}

GdkEventOwnerChange* EventOwnerChange::gobj_copy() const
{
  return reinterpret_cast<GdkEventOwnerChange*>(Event::gobj_copy());
}

// The reinterpret_cast works because EventOwnerChange is a standard-layout class
// whose only data member is a GdkEvent pointer.
const EventOwnerChange& wrap_event(const GdkEventOwnerChange*& event)
{
  return reinterpret_cast<const EventOwnerChange&>(event);
}

EventOwnerChange& wrap_event(GdkEventOwnerChange*& event)
{
  return reinterpret_cast<EventOwnerChange&>(event);
}

guint32 EventOwnerChange::get_time() const
{
  return gobj()->time;
}

guint32 EventOwnerChange::get_selection_time() const
{
  return gobj()->selection_time;
}

GdkAtom EventOwnerChange::get_selection() const
{
  return gobj()->selection;
}

Gdk::OwnerChange EventOwnerChange::get_reason() const
{
  return static_cast<Gdk::OwnerChange>(gobj()->reason);
}

Glib::RefPtr<Gdk::Window> EventOwnerChange::get_owner()
{
  Glib::RefPtr<Gdk::Window> ref_ptr(Glib::wrap(gobj()->owner));

  if(ref_ptr)
    ref_ptr->reference();

  return ref_ptr;
}

Glib::RefPtr<const Gdk::Window> EventOwnerChange::get_owner() const
{
  Glib::RefPtr<const Gdk::Window> ref_ptr(Glib::wrap(gobj()->owner));

  if(ref_ptr)
    ref_ptr->reference();

  return ref_ptr;
}


} // namespace Gdk


namespace Glib
{

Gdk::EventDND wrap(GdkEventDND* object, bool take_copy)
{
  return Gdk::EventDND(object, take_copy);
}

} // namespace Glib

namespace Gdk
{


EventDND::EventDND()
:
  Event()
{
}

EventDND::EventDND(GdkEventDND* gobject, bool make_a_copy)
:
  Event(reinterpret_cast<GdkEvent*>(gobject), make_a_copy)
{}


void EventDND::swap(EventDND& other) noexcept
{
  Event::swap(other);
}

GdkEventDND* EventDND::gobj_copy() const
{
  return reinterpret_cast<GdkEventDND*>(Event::gobj_copy());
}

// The reinterpret_cast works because EventDND is a standard-layout class
// whose only data member is a GdkEvent pointer.
const EventDND& wrap_event(const GdkEventDND*& event)
{
  return reinterpret_cast<const EventDND&>(event);
}

EventDND& wrap_event(GdkEventDND*& event)
{
  return reinterpret_cast<EventDND&>(event);
}

guint32 EventDND::get_time() const
{
  return gobj()->time;
}

double EventDND::get_root_x() const
{
  return gobj()->x_root;
}

double EventDND::get_root_y() const
{
  return gobj()->y_root;
}

Glib::RefPtr<Gdk::DragContext> EventDND::get_context()
{
  Glib::RefPtr<Gdk::DragContext> ref_ptr(Glib::wrap(gobj()->context));

  if(ref_ptr)
    ref_ptr->reference();

  return ref_ptr;
}

Glib::RefPtr<const Gdk::DragContext> EventDND::get_context() const
{
  Glib::RefPtr<const Gdk::DragContext> ref_ptr(Glib::wrap(gobj()->context));

  if(ref_ptr)
    ref_ptr->reference();

  return ref_ptr;
}


} // namespace Gdk


namespace Glib
{

Gdk::EventProximity wrap(GdkEventProximity* object, bool take_copy)
{
  return Gdk::EventProximity(object, take_copy);
}

} // namespace Glib

namespace Gdk
{


EventProximity::EventProximity()
:
  Event()
{
}

EventProximity::EventProximity(GdkEventProximity* gobject, bool make_a_copy)
:
  Event(reinterpret_cast<GdkEvent*>(gobject), make_a_copy)
{}


void EventProximity::swap(EventProximity& other) noexcept
{
  Event::swap(other);
}

GdkEventProximity* EventProximity::gobj_copy() const
{
  return reinterpret_cast<GdkEventProximity*>(Event::gobj_copy());
}

// The reinterpret_cast works because EventProximity is a standard-layout class
// whose only data member is a GdkEvent pointer.
const EventProximity& wrap_event(const GdkEventProximity*& event)
{
  return reinterpret_cast<const EventProximity&>(event);
}

EventProximity& wrap_event(GdkEventProximity*& event)
{
  return reinterpret_cast<EventProximity&>(event);
}

guint32 EventProximity::get_time() const
{
  return gobj()->time;
}

Glib::RefPtr<Gdk::Device> EventProximity::get_device()
{
  Glib::RefPtr<Gdk::Device> ref_ptr(Glib::wrap(gobj()->device));

  if(ref_ptr)
    ref_ptr->reference();

  return ref_ptr;
}

Glib::RefPtr<const Gdk::Device> EventProximity::get_device() const
{
  Glib::RefPtr<const Gdk::Device> ref_ptr(Glib::wrap(gobj()->device));

  if(ref_ptr)
    ref_ptr->reference();

  return ref_ptr;
}


} // namespace Gdk


namespace Glib
{

Gdk::EventWindowState wrap(GdkEventWindowState* object, bool take_copy)
{
  return Gdk::EventWindowState(object, take_copy);
}

} // namespace Glib

namespace Gdk
{


EventWindowState::EventWindowState()
:
  Event()
{
}

EventWindowState::EventWindowState(GdkEventWindowState* gobject, bool make_a_copy)
:
  Event(reinterpret_cast<GdkEvent*>(gobject), make_a_copy)
{}


void EventWindowState::swap(EventWindowState& other) noexcept
{
  Event::swap(other);
}

GdkEventWindowState* EventWindowState::gobj_copy() const
{
  return reinterpret_cast<GdkEventWindowState*>(Event::gobj_copy());
}

// The reinterpret_cast works because EventWindowState is a standard-layout class
// whose only data member is a GdkEvent pointer.
const EventWindowState& wrap_event(const GdkEventWindowState*& event)
{
  return reinterpret_cast<const EventWindowState&>(event);
}

EventWindowState& wrap_event(GdkEventWindowState*& event)
{
  return reinterpret_cast<EventWindowState&>(event);
}

Gdk::Window::State EventWindowState::get_mask() const
{
  return static_cast<Gdk::Window::State>(gobj()->changed_mask);
}

Gdk::Window::State EventWindowState::get_state() const
{
  return static_cast<Gdk::Window::State>(gobj()->new_window_state);
}


} // namespace Gdk


namespace Glib
{

Gdk::EventSetting wrap(GdkEventSetting* object, bool take_copy)
{
  return Gdk::EventSetting(object, take_copy);
}

} // namespace Glib

namespace Gdk
{


EventSetting::EventSetting()
:
  Event()
{
}

EventSetting::EventSetting(GdkEventSetting* gobject, bool make_a_copy)
:
  Event(reinterpret_cast<GdkEvent*>(gobject), make_a_copy)
{}


void EventSetting::swap(EventSetting& other) noexcept
{
  Event::swap(other);
}

GdkEventSetting* EventSetting::gobj_copy() const
{
  return reinterpret_cast<GdkEventSetting*>(Event::gobj_copy());
}

// The reinterpret_cast works because EventSetting is a standard-layout class
// whose only data member is a GdkEvent pointer.
const EventSetting& wrap_event(const GdkEventSetting*& event)
{
  return reinterpret_cast<const EventSetting&>(event);
}

EventSetting& wrap_event(GdkEventSetting*& event)
{
  return reinterpret_cast<EventSetting&>(event);
}

Gdk::SettingAction EventSetting::get_action() const
{
  return static_cast<Gdk::SettingAction>(gobj()->action);
}

Glib::ustring EventSetting::get_name() const
{
  return Glib::convert_const_gchar_ptr_to_ustring(gobj()->name);
}


} // namespace Gdk


namespace Glib
{

Gdk::EventGrabBroken wrap(GdkEventGrabBroken* object, bool take_copy)
{
  return Gdk::EventGrabBroken(object, take_copy);
}

} // namespace Glib

namespace Gdk
{


EventGrabBroken::EventGrabBroken()
:
  Event()
{
}

EventGrabBroken::EventGrabBroken(GdkEventGrabBroken* gobject, bool make_a_copy)
:
  Event(reinterpret_cast<GdkEvent*>(gobject), make_a_copy)
{}


void EventGrabBroken::swap(EventGrabBroken& other) noexcept
{
  Event::swap(other);
}

GdkEventGrabBroken* EventGrabBroken::gobj_copy() const
{
  return reinterpret_cast<GdkEventGrabBroken*>(Event::gobj_copy());
}

// The reinterpret_cast works because EventGrabBroken is a standard-layout class
// whose only data member is a GdkEvent pointer.
const EventGrabBroken& wrap_event(const GdkEventGrabBroken*& event)
{
  return reinterpret_cast<const EventGrabBroken&>(event);
}

EventGrabBroken& wrap_event(GdkEventGrabBroken*& event)
{
  return reinterpret_cast<EventGrabBroken&>(event);
}

Glib::RefPtr<Gdk::Window> EventGrabBroken::get_grab_window()
{
  Glib::RefPtr<Gdk::Window> ref_ptr(Glib::wrap(gobj()->grab_window));

  if(ref_ptr)
    ref_ptr->reference();

  return ref_ptr;
}

Glib::RefPtr<const Gdk::Window> EventGrabBroken::get_grab_window() const
{
  Glib::RefPtr<const Gdk::Window> ref_ptr(Glib::wrap(gobj()->grab_window));

  if(ref_ptr)
    ref_ptr->reference();

  return ref_ptr;
}


} // namespace Gdk


namespace Glib
{

Gdk::EventTouchpadSwipe wrap(GdkEventTouchpadSwipe* object, bool take_copy)
{
  return Gdk::EventTouchpadSwipe(object, take_copy);
}

} // namespace Glib

namespace Gdk
{


EventTouchpadSwipe::EventTouchpadSwipe()
:
  Event()
{
}

EventTouchpadSwipe::EventTouchpadSwipe(GdkEventTouchpadSwipe* gobject, bool make_a_copy)
:
  Event(reinterpret_cast<GdkEvent*>(gobject), make_a_copy)
{}


void EventTouchpadSwipe::swap(EventTouchpadSwipe& other) noexcept
{
  Event::swap(other);
}

GdkEventTouchpadSwipe* EventTouchpadSwipe::gobj_copy() const
{
  return reinterpret_cast<GdkEventTouchpadSwipe*>(Event::gobj_copy());
}

// The reinterpret_cast works because EventTouchpadSwipe is a standard-layout class
// whose only data member is a GdkEvent pointer.
const EventTouchpadSwipe& wrap_event(const GdkEventTouchpadSwipe*& event)
{
  return reinterpret_cast<const EventTouchpadSwipe&>(event);
}

EventTouchpadSwipe& wrap_event(GdkEventTouchpadSwipe*& event)
{
  return reinterpret_cast<EventTouchpadSwipe&>(event);
}

guint32 EventTouchpadSwipe::get_time() const
{
  return gobj()->time;
}

TouchpadGesturePhase EventTouchpadSwipe::get_phase() const
{
  return static_cast<TouchpadGesturePhase>(gobj()->phase);
}

int EventTouchpadSwipe::get_n_fingers() const
{
  return gobj()->n_fingers;
}

ModifierType EventTouchpadSwipe::get_state() const
{
  return static_cast<ModifierType>(gobj()->state);
}

double EventTouchpadSwipe::get_x() const
{
  return gobj()->x;
}

double EventTouchpadSwipe::get_y() const
{
  return gobj()->y;
}

double EventTouchpadSwipe::get_dx() const
{
  return gobj()->dx;
}

double EventTouchpadSwipe::get_dy() const
{
  return gobj()->dy;
}

double EventTouchpadSwipe::get_root_x() const
{
  return gobj()->x_root;
}

double EventTouchpadSwipe::get_root_y() const
{
  return gobj()->y_root;
}


} // namespace Gdk


namespace Glib
{

Gdk::EventTouchpadPinch wrap(GdkEventTouchpadPinch* object, bool take_copy)
{
  return Gdk::EventTouchpadPinch(object, take_copy);
}

} // namespace Glib

namespace Gdk
{


EventTouchpadPinch::EventTouchpadPinch()
:
  Event()
{
}

EventTouchpadPinch::EventTouchpadPinch(GdkEventTouchpadPinch* gobject, bool make_a_copy)
:
  Event(reinterpret_cast<GdkEvent*>(gobject), make_a_copy)
{}


void EventTouchpadPinch::swap(EventTouchpadPinch& other) noexcept
{
  Event::swap(other);
}

GdkEventTouchpadPinch* EventTouchpadPinch::gobj_copy() const
{
  return reinterpret_cast<GdkEventTouchpadPinch*>(Event::gobj_copy());
}

// The reinterpret_cast works because EventTouchpadPinch is a standard-layout class
// whose only data member is a GdkEvent pointer.
const EventTouchpadPinch& wrap_event(const GdkEventTouchpadPinch*& event)
{
  return reinterpret_cast<const EventTouchpadPinch&>(event);
}

EventTouchpadPinch& wrap_event(GdkEventTouchpadPinch*& event)
{
  return reinterpret_cast<EventTouchpadPinch&>(event);
}

guint32 EventTouchpadPinch::get_time() const
{
  return gobj()->time;
}

TouchpadGesturePhase EventTouchpadPinch::get_phase() const
{
  return static_cast<TouchpadGesturePhase>(gobj()->phase);
}

int EventTouchpadPinch::get_n_fingers() const
{
  return gobj()->n_fingers;
}

ModifierType EventTouchpadPinch::get_state() const
{
  return static_cast<ModifierType>(gobj()->state);
}

double EventTouchpadPinch::get_x() const
{
  return gobj()->x;
}

double EventTouchpadPinch::get_y() const
{
  return gobj()->y;
}

double EventTouchpadPinch::get_dx() const
{
  return gobj()->dx;
}

double EventTouchpadPinch::get_dy() const
{
  return gobj()->dy;
}

double EventTouchpadPinch::get_angle_delta() const
{
  return gobj()->angle_delta;
}

double EventTouchpadPinch::get_scale() const
{
  return gobj()->scale;
}

double EventTouchpadPinch::get_root_x() const
{
  return gobj()->x_root;
}

double EventTouchpadPinch::get_root_y() const
{
  return gobj()->y_root;
}


} // namespace Gdk


namespace Glib
{

Gdk::EventPadButton wrap(GdkEventPadButton* object, bool take_copy)
{
  return Gdk::EventPadButton(object, take_copy);
}

} // namespace Glib

namespace Gdk
{


EventPadButton::EventPadButton()
:
  Event()
{
}

EventPadButton::EventPadButton(GdkEventPadButton* gobject, bool make_a_copy)
:
  Event(reinterpret_cast<GdkEvent*>(gobject), make_a_copy)
{}


void EventPadButton::swap(EventPadButton& other) noexcept
{
  Event::swap(other);
}

GdkEventPadButton* EventPadButton::gobj_copy() const
{
  return reinterpret_cast<GdkEventPadButton*>(Event::gobj_copy());
}

// The reinterpret_cast works because EventPadButton is a standard-layout class
// whose only data member is a GdkEvent pointer.
const EventPadButton& wrap_event(const GdkEventPadButton*& event)
{
  return reinterpret_cast<const EventPadButton&>(event);
}

EventPadButton& wrap_event(GdkEventPadButton*& event)
{
  return reinterpret_cast<EventPadButton&>(event);
}

guint32 EventPadButton::get_time() const
{
  return gobj()->time;
}

guint EventPadButton::get_group() const
{
  return gobj()->group;
}

guint EventPadButton::get_button() const
{
  return gobj()->button;
}

guint EventPadButton::get_mode() const
{
  return gobj()->mode;
}


} // namespace Gdk


namespace Glib
{

Gdk::EventPadAxis wrap(GdkEventPadAxis* object, bool take_copy)
{
  return Gdk::EventPadAxis(object, take_copy);
}

} // namespace Glib

namespace Gdk
{


EventPadAxis::EventPadAxis()
:
  Event()
{
}

EventPadAxis::EventPadAxis(GdkEventPadAxis* gobject, bool make_a_copy)
:
  Event(reinterpret_cast<GdkEvent*>(gobject), make_a_copy)
{}


void EventPadAxis::swap(EventPadAxis& other) noexcept
{
  Event::swap(other);
}

GdkEventPadAxis* EventPadAxis::gobj_copy() const
{
  return reinterpret_cast<GdkEventPadAxis*>(Event::gobj_copy());
}

// The reinterpret_cast works because EventPadAxis is a standard-layout class
// whose only data member is a GdkEvent pointer.
const EventPadAxis& wrap_event(const GdkEventPadAxis*& event)
{
  return reinterpret_cast<const EventPadAxis&>(event);
}

EventPadAxis& wrap_event(GdkEventPadAxis*& event)
{
  return reinterpret_cast<EventPadAxis&>(event);
}

guint32 EventPadAxis::get_time() const
{
  return gobj()->time;
}

guint EventPadAxis::get_group() const
{
  return gobj()->group;
}

guint EventPadAxis::get_index() const
{
  return gobj()->index;
}

guint EventPadAxis::get_mode() const
{
  return gobj()->mode;
}

double EventPadAxis::get_value() const
{
  return gobj()->value;
}


} // namespace Gdk


namespace Glib
{

Gdk::EventPadGroupMode wrap(GdkEventPadGroupMode* object, bool take_copy)
{
  return Gdk::EventPadGroupMode(object, take_copy);
}

} // namespace Glib

namespace Gdk
{


EventPadGroupMode::EventPadGroupMode()
:
  Event()
{
}

EventPadGroupMode::EventPadGroupMode(GdkEventPadGroupMode* gobject, bool make_a_copy)
:
  Event(reinterpret_cast<GdkEvent*>(gobject), make_a_copy)
{}


void EventPadGroupMode::swap(EventPadGroupMode& other) noexcept
{
  Event::swap(other);
}

GdkEventPadGroupMode* EventPadGroupMode::gobj_copy() const
{
  return reinterpret_cast<GdkEventPadGroupMode*>(Event::gobj_copy());
}

// The reinterpret_cast works because EventPadGroupMode is a standard-layout class
// whose only data member is a GdkEvent pointer.
const EventPadGroupMode& wrap_event(const GdkEventPadGroupMode*& event)
{
  return reinterpret_cast<const EventPadGroupMode&>(event);
}

EventPadGroupMode& wrap_event(GdkEventPadGroupMode*& event)
{
  return reinterpret_cast<EventPadGroupMode&>(event);
}

guint32 EventPadGroupMode::get_time() const
{
  return gobj()->time;
}

guint EventPadGroupMode::get_group() const
{
  return gobj()->group;
}

guint EventPadGroupMode::get_mode() const
{
  return gobj()->mode;
}


} // namespace Gdk


