// This file was generated by gir (6bcd52a) from gir-files (1069259)
// DO NOT EDIT

use ffi;
use glib::Type;
use glib::StaticType;
use glib::value::{Value, SetValue, FromValue, FromValueOptional};
use gobject_ffi;
use glib::translate::*;

bitflags! {
    pub struct AccelFlags: u32 {
        const ACCEL_VISIBLE = 1;
        const ACCEL_LOCKED = 2;
        const ACCEL_MASK = 7;
    }
}

#[doc(hidden)]
impl ToGlib for AccelFlags {
    type GlibType = ffi::GtkAccelFlags;

    fn to_glib(&self) -> ffi::GtkAccelFlags {
        ffi::GtkAccelFlags::from_bits_truncate(self.bits())
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkAccelFlags> for AccelFlags {
    fn from_glib(value: ffi::GtkAccelFlags) -> AccelFlags {
        skip_assert_initialized!();
        AccelFlags::from_bits_truncate(value.bits())
    }
}

impl StaticType for AccelFlags {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gtk_accel_flags_get_type()) }
    }
}

impl<'a> FromValueOptional<'a> for AccelFlags {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

impl<'a> FromValue<'a> for AccelFlags {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(ffi::GtkAccelFlags::from_bits_truncate(gobject_ffi::g_value_get_flags(value.to_glib_none().0)))
    }
}

impl SetValue for AccelFlags {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib().bits())
    }
}

bitflags! {
    pub struct ApplicationInhibitFlags: u32 {
        const APPLICATION_INHIBIT_LOGOUT = 1;
        const APPLICATION_INHIBIT_SWITCH = 2;
        const APPLICATION_INHIBIT_SUSPEND = 4;
        const APPLICATION_INHIBIT_IDLE = 8;
    }
}

#[doc(hidden)]
impl ToGlib for ApplicationInhibitFlags {
    type GlibType = ffi::GtkApplicationInhibitFlags;

    fn to_glib(&self) -> ffi::GtkApplicationInhibitFlags {
        ffi::GtkApplicationInhibitFlags::from_bits_truncate(self.bits())
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkApplicationInhibitFlags> for ApplicationInhibitFlags {
    fn from_glib(value: ffi::GtkApplicationInhibitFlags) -> ApplicationInhibitFlags {
        skip_assert_initialized!();
        ApplicationInhibitFlags::from_bits_truncate(value.bits())
    }
}

impl StaticType for ApplicationInhibitFlags {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gtk_application_inhibit_flags_get_type()) }
    }
}

impl<'a> FromValueOptional<'a> for ApplicationInhibitFlags {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

impl<'a> FromValue<'a> for ApplicationInhibitFlags {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(ffi::GtkApplicationInhibitFlags::from_bits_truncate(gobject_ffi::g_value_get_flags(value.to_glib_none().0)))
    }
}

impl SetValue for ApplicationInhibitFlags {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib().bits())
    }
}

bitflags! {
    pub struct CalendarDisplayOptions: u32 {
        const CALENDAR_SHOW_HEADING = 1;
        const CALENDAR_SHOW_DAY_NAMES = 2;
        const CALENDAR_NO_MONTH_CHANGE = 4;
        const CALENDAR_SHOW_WEEK_NUMBERS = 8;
        const CALENDAR_SHOW_DETAILS = 32;
    }
}

#[doc(hidden)]
impl ToGlib for CalendarDisplayOptions {
    type GlibType = ffi::GtkCalendarDisplayOptions;

    fn to_glib(&self) -> ffi::GtkCalendarDisplayOptions {
        ffi::GtkCalendarDisplayOptions::from_bits_truncate(self.bits())
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkCalendarDisplayOptions> for CalendarDisplayOptions {
    fn from_glib(value: ffi::GtkCalendarDisplayOptions) -> CalendarDisplayOptions {
        skip_assert_initialized!();
        CalendarDisplayOptions::from_bits_truncate(value.bits())
    }
}

impl StaticType for CalendarDisplayOptions {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gtk_calendar_display_options_get_type()) }
    }
}

impl<'a> FromValueOptional<'a> for CalendarDisplayOptions {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

impl<'a> FromValue<'a> for CalendarDisplayOptions {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(ffi::GtkCalendarDisplayOptions::from_bits_truncate(gobject_ffi::g_value_get_flags(value.to_glib_none().0)))
    }
}

impl SetValue for CalendarDisplayOptions {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib().bits())
    }
}

bitflags! {
    pub struct CellRendererState: u32 {
        const CELL_RENDERER_SELECTED = 1;
        const CELL_RENDERER_PRELIT = 2;
        const CELL_RENDERER_INSENSITIVE = 4;
        const CELL_RENDERER_SORTED = 8;
        const CELL_RENDERER_FOCUSED = 16;
        const CELL_RENDERER_EXPANDABLE = 32;
        const CELL_RENDERER_EXPANDED = 64;
    }
}

#[doc(hidden)]
impl ToGlib for CellRendererState {
    type GlibType = ffi::GtkCellRendererState;

    fn to_glib(&self) -> ffi::GtkCellRendererState {
        ffi::GtkCellRendererState::from_bits_truncate(self.bits())
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkCellRendererState> for CellRendererState {
    fn from_glib(value: ffi::GtkCellRendererState) -> CellRendererState {
        skip_assert_initialized!();
        CellRendererState::from_bits_truncate(value.bits())
    }
}

impl StaticType for CellRendererState {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gtk_cell_renderer_state_get_type()) }
    }
}

impl<'a> FromValueOptional<'a> for CellRendererState {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

impl<'a> FromValue<'a> for CellRendererState {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(ffi::GtkCellRendererState::from_bits_truncate(gobject_ffi::g_value_get_flags(value.to_glib_none().0)))
    }
}

impl SetValue for CellRendererState {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib().bits())
    }
}

bitflags! {
    pub struct DestDefaults: u32 {
        const DEST_DEFAULT_MOTION = 1;
        const DEST_DEFAULT_HIGHLIGHT = 2;
        const DEST_DEFAULT_DROP = 4;
        const DEST_DEFAULT_ALL = 7;
    }
}

#[doc(hidden)]
impl ToGlib for DestDefaults {
    type GlibType = ffi::GtkDestDefaults;

    fn to_glib(&self) -> ffi::GtkDestDefaults {
        ffi::GtkDestDefaults::from_bits_truncate(self.bits())
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkDestDefaults> for DestDefaults {
    fn from_glib(value: ffi::GtkDestDefaults) -> DestDefaults {
        skip_assert_initialized!();
        DestDefaults::from_bits_truncate(value.bits())
    }
}

impl StaticType for DestDefaults {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gtk_dest_defaults_get_type()) }
    }
}

impl<'a> FromValueOptional<'a> for DestDefaults {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

impl<'a> FromValue<'a> for DestDefaults {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(ffi::GtkDestDefaults::from_bits_truncate(gobject_ffi::g_value_get_flags(value.to_glib_none().0)))
    }
}

impl SetValue for DestDefaults {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib().bits())
    }
}

bitflags! {
    pub struct DialogFlags: u32 {
        const DIALOG_MODAL = 1;
        const DIALOG_DESTROY_WITH_PARENT = 2;
        const DIALOG_USE_HEADER_BAR = 4;
    }
}

#[doc(hidden)]
impl ToGlib for DialogFlags {
    type GlibType = ffi::GtkDialogFlags;

    fn to_glib(&self) -> ffi::GtkDialogFlags {
        ffi::GtkDialogFlags::from_bits_truncate(self.bits())
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkDialogFlags> for DialogFlags {
    fn from_glib(value: ffi::GtkDialogFlags) -> DialogFlags {
        skip_assert_initialized!();
        DialogFlags::from_bits_truncate(value.bits())
    }
}

impl StaticType for DialogFlags {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gtk_dialog_flags_get_type()) }
    }
}

impl<'a> FromValueOptional<'a> for DialogFlags {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

impl<'a> FromValue<'a> for DialogFlags {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(ffi::GtkDialogFlags::from_bits_truncate(gobject_ffi::g_value_get_flags(value.to_glib_none().0)))
    }
}

impl SetValue for DialogFlags {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib().bits())
    }
}

bitflags! {
    pub struct FileFilterFlags: u32 {
        const FILE_FILTER_FILENAME = 1;
        const FILE_FILTER_URI = 2;
        const FILE_FILTER_DISPLAY_NAME = 4;
        const FILE_FILTER_MIME_TYPE = 8;
    }
}

#[doc(hidden)]
impl ToGlib for FileFilterFlags {
    type GlibType = ffi::GtkFileFilterFlags;

    fn to_glib(&self) -> ffi::GtkFileFilterFlags {
        ffi::GtkFileFilterFlags::from_bits_truncate(self.bits())
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkFileFilterFlags> for FileFilterFlags {
    fn from_glib(value: ffi::GtkFileFilterFlags) -> FileFilterFlags {
        skip_assert_initialized!();
        FileFilterFlags::from_bits_truncate(value.bits())
    }
}

impl StaticType for FileFilterFlags {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gtk_file_filter_flags_get_type()) }
    }
}

impl<'a> FromValueOptional<'a> for FileFilterFlags {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

impl<'a> FromValue<'a> for FileFilterFlags {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(ffi::GtkFileFilterFlags::from_bits_truncate(gobject_ffi::g_value_get_flags(value.to_glib_none().0)))
    }
}

impl SetValue for FileFilterFlags {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib().bits())
    }
}

bitflags! {
    pub struct IconLookupFlags: u32 {
        const ICON_LOOKUP_NO_SVG = 1;
        const ICON_LOOKUP_FORCE_SVG = 2;
        const ICON_LOOKUP_USE_BUILTIN = 4;
        const ICON_LOOKUP_GENERIC_FALLBACK = 8;
        const ICON_LOOKUP_FORCE_SIZE = 16;
        const ICON_LOOKUP_FORCE_REGULAR = 32;
        const ICON_LOOKUP_FORCE_SYMBOLIC = 64;
        const ICON_LOOKUP_DIR_LTR = 128;
        const ICON_LOOKUP_DIR_RTL = 256;
    }
}

#[doc(hidden)]
impl ToGlib for IconLookupFlags {
    type GlibType = ffi::GtkIconLookupFlags;

    fn to_glib(&self) -> ffi::GtkIconLookupFlags {
        ffi::GtkIconLookupFlags::from_bits_truncate(self.bits())
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkIconLookupFlags> for IconLookupFlags {
    fn from_glib(value: ffi::GtkIconLookupFlags) -> IconLookupFlags {
        skip_assert_initialized!();
        IconLookupFlags::from_bits_truncate(value.bits())
    }
}

impl StaticType for IconLookupFlags {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gtk_icon_lookup_flags_get_type()) }
    }
}

impl<'a> FromValueOptional<'a> for IconLookupFlags {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

impl<'a> FromValue<'a> for IconLookupFlags {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(ffi::GtkIconLookupFlags::from_bits_truncate(gobject_ffi::g_value_get_flags(value.to_glib_none().0)))
    }
}

impl SetValue for IconLookupFlags {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib().bits())
    }
}

#[cfg(feature = "v3_6")]
bitflags! {
    pub struct InputHints: u32 {
        const INPUT_HINT_NONE = 0;
        const INPUT_HINT_SPELLCHECK = 1;
        const INPUT_HINT_NO_SPELLCHECK = 2;
        const INPUT_HINT_WORD_COMPLETION = 4;
        const INPUT_HINT_LOWERCASE = 8;
        const INPUT_HINT_UPPERCASE_CHARS = 16;
        const INPUT_HINT_UPPERCASE_WORDS = 32;
        const INPUT_HINT_UPPERCASE_SENTENCES = 64;
        const INPUT_HINT_INHIBIT_OSK = 128;
        const INPUT_HINT_VERTICAL_WRITING = 256;
    }
}

#[cfg(feature = "v3_6")]
#[doc(hidden)]
impl ToGlib for InputHints {
    type GlibType = ffi::GtkInputHints;

    fn to_glib(&self) -> ffi::GtkInputHints {
        ffi::GtkInputHints::from_bits_truncate(self.bits())
    }
}

#[cfg(feature = "v3_6")]
#[doc(hidden)]
impl FromGlib<ffi::GtkInputHints> for InputHints {
    fn from_glib(value: ffi::GtkInputHints) -> InputHints {
        skip_assert_initialized!();
        InputHints::from_bits_truncate(value.bits())
    }
}

#[cfg(feature = "v3_6")]
impl StaticType for InputHints {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gtk_input_hints_get_type()) }
    }
}

#[cfg(feature = "v3_6")]
impl<'a> FromValueOptional<'a> for InputHints {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

#[cfg(feature = "v3_6")]
impl<'a> FromValue<'a> for InputHints {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(ffi::GtkInputHints::from_bits_truncate(gobject_ffi::g_value_get_flags(value.to_glib_none().0)))
    }
}

#[cfg(feature = "v3_6")]
impl SetValue for InputHints {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib().bits())
    }
}

bitflags! {
    pub struct JunctionSides: u32 {
        const JUNCTION_NONE = 0;
        const JUNCTION_CORNER_TOPLEFT = 1;
        const JUNCTION_CORNER_TOPRIGHT = 2;
        const JUNCTION_CORNER_BOTTOMLEFT = 4;
        const JUNCTION_CORNER_BOTTOMRIGHT = 8;
        const JUNCTION_TOP = 3;
        const JUNCTION_BOTTOM = 12;
        const JUNCTION_LEFT = 5;
        const JUNCTION_RIGHT = 10;
    }
}

#[doc(hidden)]
impl ToGlib for JunctionSides {
    type GlibType = ffi::GtkJunctionSides;

    fn to_glib(&self) -> ffi::GtkJunctionSides {
        ffi::GtkJunctionSides::from_bits_truncate(self.bits())
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkJunctionSides> for JunctionSides {
    fn from_glib(value: ffi::GtkJunctionSides) -> JunctionSides {
        skip_assert_initialized!();
        JunctionSides::from_bits_truncate(value.bits())
    }
}

impl StaticType for JunctionSides {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gtk_junction_sides_get_type()) }
    }
}

impl<'a> FromValueOptional<'a> for JunctionSides {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

impl<'a> FromValue<'a> for JunctionSides {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(ffi::GtkJunctionSides::from_bits_truncate(gobject_ffi::g_value_get_flags(value.to_glib_none().0)))
    }
}

impl SetValue for JunctionSides {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib().bits())
    }
}

bitflags! {
    pub struct PlacesOpenFlags: u32 {
        const PLACES_OPEN_NORMAL = 1;
        const PLACES_OPEN_NEW_TAB = 2;
        const PLACES_OPEN_NEW_WINDOW = 4;
    }
}

#[doc(hidden)]
impl ToGlib for PlacesOpenFlags {
    type GlibType = ffi::GtkPlacesOpenFlags;

    fn to_glib(&self) -> ffi::GtkPlacesOpenFlags {
        ffi::GtkPlacesOpenFlags::from_bits_truncate(self.bits())
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkPlacesOpenFlags> for PlacesOpenFlags {
    fn from_glib(value: ffi::GtkPlacesOpenFlags) -> PlacesOpenFlags {
        skip_assert_initialized!();
        PlacesOpenFlags::from_bits_truncate(value.bits())
    }
}

impl StaticType for PlacesOpenFlags {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gtk_places_open_flags_get_type()) }
    }
}

impl<'a> FromValueOptional<'a> for PlacesOpenFlags {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

impl<'a> FromValue<'a> for PlacesOpenFlags {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(ffi::GtkPlacesOpenFlags::from_bits_truncate(gobject_ffi::g_value_get_flags(value.to_glib_none().0)))
    }
}

impl SetValue for PlacesOpenFlags {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib().bits())
    }
}

bitflags! {
    pub struct RecentFilterFlags: u32 {
        const RECENT_FILTER_URI = 1;
        const RECENT_FILTER_DISPLAY_NAME = 2;
        const RECENT_FILTER_MIME_TYPE = 4;
        const RECENT_FILTER_APPLICATION = 8;
        const RECENT_FILTER_GROUP = 16;
        const RECENT_FILTER_AGE = 32;
    }
}

#[doc(hidden)]
impl ToGlib for RecentFilterFlags {
    type GlibType = ffi::GtkRecentFilterFlags;

    fn to_glib(&self) -> ffi::GtkRecentFilterFlags {
        ffi::GtkRecentFilterFlags::from_bits_truncate(self.bits())
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkRecentFilterFlags> for RecentFilterFlags {
    fn from_glib(value: ffi::GtkRecentFilterFlags) -> RecentFilterFlags {
        skip_assert_initialized!();
        RecentFilterFlags::from_bits_truncate(value.bits())
    }
}

impl StaticType for RecentFilterFlags {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gtk_recent_filter_flags_get_type()) }
    }
}

impl<'a> FromValueOptional<'a> for RecentFilterFlags {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

impl<'a> FromValue<'a> for RecentFilterFlags {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(ffi::GtkRecentFilterFlags::from_bits_truncate(gobject_ffi::g_value_get_flags(value.to_glib_none().0)))
    }
}

impl SetValue for RecentFilterFlags {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib().bits())
    }
}

bitflags! {
    pub struct RegionFlags: u32 {
        const REGION_EVEN = 1;
        const REGION_ODD = 2;
        const REGION_FIRST = 4;
        const REGION_LAST = 8;
        const REGION_ONLY = 16;
        const REGION_SORTED = 32;
    }
}

#[doc(hidden)]
impl ToGlib for RegionFlags {
    type GlibType = ffi::GtkRegionFlags;

    fn to_glib(&self) -> ffi::GtkRegionFlags {
        ffi::GtkRegionFlags::from_bits_truncate(self.bits())
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkRegionFlags> for RegionFlags {
    fn from_glib(value: ffi::GtkRegionFlags) -> RegionFlags {
        skip_assert_initialized!();
        RegionFlags::from_bits_truncate(value.bits())
    }
}

impl StaticType for RegionFlags {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gtk_region_flags_get_type()) }
    }
}

impl<'a> FromValueOptional<'a> for RegionFlags {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

impl<'a> FromValue<'a> for RegionFlags {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(ffi::GtkRegionFlags::from_bits_truncate(gobject_ffi::g_value_get_flags(value.to_glib_none().0)))
    }
}

impl SetValue for RegionFlags {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib().bits())
    }
}

bitflags! {
    pub struct StateFlags: u32 {
        const STATE_FLAG_NORMAL = 0;
        const STATE_FLAG_ACTIVE = 1;
        const STATE_FLAG_PRELIGHT = 2;
        const STATE_FLAG_SELECTED = 4;
        const STATE_FLAG_INSENSITIVE = 8;
        const STATE_FLAG_INCONSISTENT = 16;
        const STATE_FLAG_FOCUSED = 32;
        const STATE_FLAG_BACKDROP = 64;
        const STATE_FLAG_DIR_LTR = 128;
        const STATE_FLAG_DIR_RTL = 256;
        const STATE_FLAG_LINK = 512;
        const STATE_FLAG_VISITED = 1024;
        const STATE_FLAG_CHECKED = 2048;
        const STATE_FLAG_DROP_ACTIVE = 4096;
    }
}

#[doc(hidden)]
impl ToGlib for StateFlags {
    type GlibType = ffi::GtkStateFlags;

    fn to_glib(&self) -> ffi::GtkStateFlags {
        ffi::GtkStateFlags::from_bits_truncate(self.bits())
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkStateFlags> for StateFlags {
    fn from_glib(value: ffi::GtkStateFlags) -> StateFlags {
        skip_assert_initialized!();
        StateFlags::from_bits_truncate(value.bits())
    }
}

impl StaticType for StateFlags {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gtk_state_flags_get_type()) }
    }
}

impl<'a> FromValueOptional<'a> for StateFlags {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

impl<'a> FromValue<'a> for StateFlags {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(ffi::GtkStateFlags::from_bits_truncate(gobject_ffi::g_value_get_flags(value.to_glib_none().0)))
    }
}

impl SetValue for StateFlags {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib().bits())
    }
}

bitflags! {
    pub struct StyleContextPrintFlags: u32 {
        const STYLE_CONTEXT_PRINT_NONE = 0;
        const STYLE_CONTEXT_PRINT_RECURSE = 1;
        const STYLE_CONTEXT_PRINT_SHOW_STYLE = 2;
    }
}

#[doc(hidden)]
impl ToGlib for StyleContextPrintFlags {
    type GlibType = ffi::GtkStyleContextPrintFlags;

    fn to_glib(&self) -> ffi::GtkStyleContextPrintFlags {
        ffi::GtkStyleContextPrintFlags::from_bits_truncate(self.bits())
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkStyleContextPrintFlags> for StyleContextPrintFlags {
    fn from_glib(value: ffi::GtkStyleContextPrintFlags) -> StyleContextPrintFlags {
        skip_assert_initialized!();
        StyleContextPrintFlags::from_bits_truncate(value.bits())
    }
}

impl StaticType for StyleContextPrintFlags {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gtk_style_context_print_flags_get_type()) }
    }
}

impl<'a> FromValueOptional<'a> for StyleContextPrintFlags {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

impl<'a> FromValue<'a> for StyleContextPrintFlags {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(ffi::GtkStyleContextPrintFlags::from_bits_truncate(gobject_ffi::g_value_get_flags(value.to_glib_none().0)))
    }
}

impl SetValue for StyleContextPrintFlags {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib().bits())
    }
}

bitflags! {
    pub struct TargetFlags: u32 {
        const TARGET_SAME_APP = 1;
        const TARGET_SAME_WIDGET = 2;
        const TARGET_OTHER_APP = 4;
        const TARGET_OTHER_WIDGET = 8;
    }
}

#[doc(hidden)]
impl ToGlib for TargetFlags {
    type GlibType = ffi::GtkTargetFlags;

    fn to_glib(&self) -> ffi::GtkTargetFlags {
        ffi::GtkTargetFlags::from_bits_truncate(self.bits())
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkTargetFlags> for TargetFlags {
    fn from_glib(value: ffi::GtkTargetFlags) -> TargetFlags {
        skip_assert_initialized!();
        TargetFlags::from_bits_truncate(value.bits())
    }
}

impl StaticType for TargetFlags {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gtk_target_flags_get_type()) }
    }
}

impl<'a> FromValueOptional<'a> for TargetFlags {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

impl<'a> FromValue<'a> for TargetFlags {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(ffi::GtkTargetFlags::from_bits_truncate(gobject_ffi::g_value_get_flags(value.to_glib_none().0)))
    }
}

impl SetValue for TargetFlags {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib().bits())
    }
}

bitflags! {
    pub struct TextSearchFlags: u32 {
        const TEXT_SEARCH_VISIBLE_ONLY = 1;
        const TEXT_SEARCH_TEXT_ONLY = 2;
        const TEXT_SEARCH_CASE_INSENSITIVE = 4;
    }
}

#[doc(hidden)]
impl ToGlib for TextSearchFlags {
    type GlibType = ffi::GtkTextSearchFlags;

    fn to_glib(&self) -> ffi::GtkTextSearchFlags {
        ffi::GtkTextSearchFlags::from_bits_truncate(self.bits())
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkTextSearchFlags> for TextSearchFlags {
    fn from_glib(value: ffi::GtkTextSearchFlags) -> TextSearchFlags {
        skip_assert_initialized!();
        TextSearchFlags::from_bits_truncate(value.bits())
    }
}

impl StaticType for TextSearchFlags {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gtk_text_search_flags_get_type()) }
    }
}

impl<'a> FromValueOptional<'a> for TextSearchFlags {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

impl<'a> FromValue<'a> for TextSearchFlags {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(ffi::GtkTextSearchFlags::from_bits_truncate(gobject_ffi::g_value_get_flags(value.to_glib_none().0)))
    }
}

impl SetValue for TextSearchFlags {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib().bits())
    }
}

bitflags! {
    pub struct ToolPaletteDragTargets: u32 {
        const TOOL_PALETTE_DRAG_ITEMS = 1;
        const TOOL_PALETTE_DRAG_GROUPS = 2;
    }
}

#[doc(hidden)]
impl ToGlib for ToolPaletteDragTargets {
    type GlibType = ffi::GtkToolPaletteDragTargets;

    fn to_glib(&self) -> ffi::GtkToolPaletteDragTargets {
        ffi::GtkToolPaletteDragTargets::from_bits_truncate(self.bits())
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkToolPaletteDragTargets> for ToolPaletteDragTargets {
    fn from_glib(value: ffi::GtkToolPaletteDragTargets) -> ToolPaletteDragTargets {
        skip_assert_initialized!();
        ToolPaletteDragTargets::from_bits_truncate(value.bits())
    }
}

impl StaticType for ToolPaletteDragTargets {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gtk_tool_palette_drag_targets_get_type()) }
    }
}

impl<'a> FromValueOptional<'a> for ToolPaletteDragTargets {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

impl<'a> FromValue<'a> for ToolPaletteDragTargets {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(ffi::GtkToolPaletteDragTargets::from_bits_truncate(gobject_ffi::g_value_get_flags(value.to_glib_none().0)))
    }
}

impl SetValue for ToolPaletteDragTargets {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib().bits())
    }
}

bitflags! {
    pub struct TreeModelFlags: u32 {
        const TREE_MODEL_ITERS_PERSIST = 1;
        const TREE_MODEL_LIST_ONLY = 2;
    }
}

#[doc(hidden)]
impl ToGlib for TreeModelFlags {
    type GlibType = ffi::GtkTreeModelFlags;

    fn to_glib(&self) -> ffi::GtkTreeModelFlags {
        ffi::GtkTreeModelFlags::from_bits_truncate(self.bits())
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkTreeModelFlags> for TreeModelFlags {
    fn from_glib(value: ffi::GtkTreeModelFlags) -> TreeModelFlags {
        skip_assert_initialized!();
        TreeModelFlags::from_bits_truncate(value.bits())
    }
}

impl StaticType for TreeModelFlags {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gtk_tree_model_flags_get_type()) }
    }
}

impl<'a> FromValueOptional<'a> for TreeModelFlags {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

impl<'a> FromValue<'a> for TreeModelFlags {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(ffi::GtkTreeModelFlags::from_bits_truncate(gobject_ffi::g_value_get_flags(value.to_glib_none().0)))
    }
}

impl SetValue for TreeModelFlags {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib().bits())
    }
}