use ffi;
use glib_ffi;
use glib::error::ErrorDomain;
use glib::translate::*;
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum Align {
Fill,
Start,
End,
Center,
Baseline,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for Align {
type GlibType = ffi::GtkAlign;
fn to_glib(&self) -> ffi::GtkAlign {
match *self {
Align::Fill => ffi::GTK_ALIGN_FILL,
Align::Start => ffi::GTK_ALIGN_START,
Align::End => ffi::GTK_ALIGN_END,
Align::Center => ffi::GTK_ALIGN_CENTER,
Align::Baseline => ffi::GTK_ALIGN_BASELINE,
Align::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkAlign> for Align {
fn from_glib(value: ffi::GtkAlign) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_ALIGN_FILL => Align::Fill,
ffi::GTK_ALIGN_START => Align::Start,
ffi::GTK_ALIGN_END => Align::End,
ffi::GTK_ALIGN_CENTER => Align::Center,
ffi::GTK_ALIGN_BASELINE => Align::Baseline,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum ArrowType {
Up,
Down,
Left,
Right,
None,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for ArrowType {
type GlibType = ffi::GtkArrowType;
fn to_glib(&self) -> ffi::GtkArrowType {
match *self {
ArrowType::Up => ffi::GTK_ARROW_UP,
ArrowType::Down => ffi::GTK_ARROW_DOWN,
ArrowType::Left => ffi::GTK_ARROW_LEFT,
ArrowType::Right => ffi::GTK_ARROW_RIGHT,
ArrowType::None => ffi::GTK_ARROW_NONE,
ArrowType::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkArrowType> for ArrowType {
fn from_glib(value: ffi::GtkArrowType) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_ARROW_UP => ArrowType::Up,
ffi::GTK_ARROW_DOWN => ArrowType::Down,
ffi::GTK_ARROW_LEFT => ArrowType::Left,
ffi::GTK_ARROW_RIGHT => ArrowType::Right,
ffi::GTK_ARROW_NONE => ArrowType::None,
}
}
}
#[cfg(feature = "v3_10")]
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum BaselinePosition {
Top,
Center,
Bottom,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[cfg(feature = "v3_10")]
#[doc(hidden)]
impl ToGlib for BaselinePosition {
type GlibType = ffi::GtkBaselinePosition;
fn to_glib(&self) -> ffi::GtkBaselinePosition {
match *self {
BaselinePosition::Top => ffi::GTK_BASELINE_POSITION_TOP,
BaselinePosition::Center => ffi::GTK_BASELINE_POSITION_CENTER,
BaselinePosition::Bottom => ffi::GTK_BASELINE_POSITION_BOTTOM,
BaselinePosition::__Nonexhaustive(_) => panic!(),
}
}
}
#[cfg(feature = "v3_10")]
#[doc(hidden)]
impl FromGlib<ffi::GtkBaselinePosition> for BaselinePosition {
fn from_glib(value: ffi::GtkBaselinePosition) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_BASELINE_POSITION_TOP => BaselinePosition::Top,
ffi::GTK_BASELINE_POSITION_CENTER => BaselinePosition::Center,
ffi::GTK_BASELINE_POSITION_BOTTOM => BaselinePosition::Bottom,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum BuilderError {
InvalidTypeFunction,
UnhandledTag,
MissingAttribute,
InvalidAttribute,
InvalidTag,
MissingPropertyValue,
InvalidValue,
VersionMismatch,
DuplicateId,
ObjectTypeRefused,
TemplateMismatch,
InvalidProperty,
InvalidSignal,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for BuilderError {
type GlibType = ffi::GtkBuilderError;
fn to_glib(&self) -> ffi::GtkBuilderError {
match *self {
BuilderError::InvalidTypeFunction => ffi::GTK_BUILDER_ERROR_INVALID_TYPE_FUNCTION,
BuilderError::UnhandledTag => ffi::GTK_BUILDER_ERROR_UNHANDLED_TAG,
BuilderError::MissingAttribute => ffi::GTK_BUILDER_ERROR_MISSING_ATTRIBUTE,
BuilderError::InvalidAttribute => ffi::GTK_BUILDER_ERROR_INVALID_ATTRIBUTE,
BuilderError::InvalidTag => ffi::GTK_BUILDER_ERROR_INVALID_TAG,
BuilderError::MissingPropertyValue => ffi::GTK_BUILDER_ERROR_MISSING_PROPERTY_VALUE,
BuilderError::InvalidValue => ffi::GTK_BUILDER_ERROR_INVALID_VALUE,
BuilderError::VersionMismatch => ffi::GTK_BUILDER_ERROR_VERSION_MISMATCH,
BuilderError::DuplicateId => ffi::GTK_BUILDER_ERROR_DUPLICATE_ID,
BuilderError::ObjectTypeRefused => ffi::GTK_BUILDER_ERROR_OBJECT_TYPE_REFUSED,
BuilderError::TemplateMismatch => ffi::GTK_BUILDER_ERROR_TEMPLATE_MISMATCH,
BuilderError::InvalidProperty => ffi::GTK_BUILDER_ERROR_INVALID_PROPERTY,
BuilderError::InvalidSignal => ffi::GTK_BUILDER_ERROR_INVALID_SIGNAL,
BuilderError::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkBuilderError> for BuilderError {
fn from_glib(value: ffi::GtkBuilderError) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_BUILDER_ERROR_INVALID_TYPE_FUNCTION => BuilderError::InvalidTypeFunction,
ffi::GTK_BUILDER_ERROR_UNHANDLED_TAG => BuilderError::UnhandledTag,
ffi::GTK_BUILDER_ERROR_MISSING_ATTRIBUTE => BuilderError::MissingAttribute,
ffi::GTK_BUILDER_ERROR_INVALID_ATTRIBUTE => BuilderError::InvalidAttribute,
ffi::GTK_BUILDER_ERROR_INVALID_TAG => BuilderError::InvalidTag,
ffi::GTK_BUILDER_ERROR_MISSING_PROPERTY_VALUE => BuilderError::MissingPropertyValue,
ffi::GTK_BUILDER_ERROR_INVALID_VALUE => BuilderError::InvalidValue,
ffi::GTK_BUILDER_ERROR_VERSION_MISMATCH => BuilderError::VersionMismatch,
ffi::GTK_BUILDER_ERROR_DUPLICATE_ID => BuilderError::DuplicateId,
ffi::GTK_BUILDER_ERROR_OBJECT_TYPE_REFUSED => BuilderError::ObjectTypeRefused,
ffi::GTK_BUILDER_ERROR_TEMPLATE_MISMATCH => BuilderError::TemplateMismatch,
ffi::GTK_BUILDER_ERROR_INVALID_PROPERTY => BuilderError::InvalidProperty,
ffi::GTK_BUILDER_ERROR_INVALID_SIGNAL => BuilderError::InvalidSignal,
}
}
}
impl ErrorDomain for BuilderError {
fn domain() -> glib_ffi::GQuark {
skip_assert_initialized!();
unsafe { ffi::gtk_builder_error_quark() }
}
fn code(self) -> i32 {
self.to_glib() as i32
}
fn from(code: i32) -> Option<Self> {
skip_assert_initialized!();
match code {
x if x == ffi::GTK_BUILDER_ERROR_INVALID_TYPE_FUNCTION as i32 => Some(BuilderError::InvalidTypeFunction),
x if x == ffi::GTK_BUILDER_ERROR_UNHANDLED_TAG as i32 => Some(BuilderError::UnhandledTag),
x if x == ffi::GTK_BUILDER_ERROR_MISSING_ATTRIBUTE as i32 => Some(BuilderError::MissingAttribute),
x if x == ffi::GTK_BUILDER_ERROR_INVALID_ATTRIBUTE as i32 => Some(BuilderError::InvalidAttribute),
x if x == ffi::GTK_BUILDER_ERROR_INVALID_TAG as i32 => Some(BuilderError::InvalidTag),
x if x == ffi::GTK_BUILDER_ERROR_MISSING_PROPERTY_VALUE as i32 => Some(BuilderError::MissingPropertyValue),
x if x == ffi::GTK_BUILDER_ERROR_INVALID_VALUE as i32 => Some(BuilderError::InvalidValue),
x if x == ffi::GTK_BUILDER_ERROR_VERSION_MISMATCH as i32 => Some(BuilderError::VersionMismatch),
x if x == ffi::GTK_BUILDER_ERROR_DUPLICATE_ID as i32 => Some(BuilderError::DuplicateId),
x if x == ffi::GTK_BUILDER_ERROR_OBJECT_TYPE_REFUSED as i32 => Some(BuilderError::ObjectTypeRefused),
x if x == ffi::GTK_BUILDER_ERROR_TEMPLATE_MISMATCH as i32 => Some(BuilderError::TemplateMismatch),
x if x == ffi::GTK_BUILDER_ERROR_INVALID_PROPERTY as i32 => Some(BuilderError::InvalidProperty),
x if x == ffi::GTK_BUILDER_ERROR_INVALID_SIGNAL as i32 => Some(BuilderError::InvalidSignal),
_ => Some(BuilderError::__Nonexhaustive(())),
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum ButtonBoxStyle {
Spread,
Edge,
Start,
End,
Center,
Expand,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for ButtonBoxStyle {
type GlibType = ffi::GtkButtonBoxStyle;
fn to_glib(&self) -> ffi::GtkButtonBoxStyle {
match *self {
ButtonBoxStyle::Spread => ffi::GTK_BUTTONBOX_SPREAD,
ButtonBoxStyle::Edge => ffi::GTK_BUTTONBOX_EDGE,
ButtonBoxStyle::Start => ffi::GTK_BUTTONBOX_START,
ButtonBoxStyle::End => ffi::GTK_BUTTONBOX_END,
ButtonBoxStyle::Center => ffi::GTK_BUTTONBOX_CENTER,
ButtonBoxStyle::Expand => ffi::GTK_BUTTONBOX_EXPAND,
ButtonBoxStyle::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkButtonBoxStyle> for ButtonBoxStyle {
fn from_glib(value: ffi::GtkButtonBoxStyle) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_BUTTONBOX_SPREAD => ButtonBoxStyle::Spread,
ffi::GTK_BUTTONBOX_EDGE => ButtonBoxStyle::Edge,
ffi::GTK_BUTTONBOX_START => ButtonBoxStyle::Start,
ffi::GTK_BUTTONBOX_END => ButtonBoxStyle::End,
ffi::GTK_BUTTONBOX_CENTER => ButtonBoxStyle::Center,
ffi::GTK_BUTTONBOX_EXPAND => ButtonBoxStyle::Expand,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum ButtonsType {
None,
Ok,
Close,
Cancel,
YesNo,
OkCancel,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for ButtonsType {
type GlibType = ffi::GtkButtonsType;
fn to_glib(&self) -> ffi::GtkButtonsType {
match *self {
ButtonsType::None => ffi::GTK_BUTTONS_NONE,
ButtonsType::Ok => ffi::GTK_BUTTONS_OK,
ButtonsType::Close => ffi::GTK_BUTTONS_CLOSE,
ButtonsType::Cancel => ffi::GTK_BUTTONS_CANCEL,
ButtonsType::YesNo => ffi::GTK_BUTTONS_YES_NO,
ButtonsType::OkCancel => ffi::GTK_BUTTONS_OK_CANCEL,
ButtonsType::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkButtonsType> for ButtonsType {
fn from_glib(value: ffi::GtkButtonsType) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_BUTTONS_NONE => ButtonsType::None,
ffi::GTK_BUTTONS_OK => ButtonsType::Ok,
ffi::GTK_BUTTONS_CLOSE => ButtonsType::Close,
ffi::GTK_BUTTONS_CANCEL => ButtonsType::Cancel,
ffi::GTK_BUTTONS_YES_NO => ButtonsType::YesNo,
ffi::GTK_BUTTONS_OK_CANCEL => ButtonsType::OkCancel,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum CornerType {
TopLeft,
BottomLeft,
TopRight,
BottomRight,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for CornerType {
type GlibType = ffi::GtkCornerType;
fn to_glib(&self) -> ffi::GtkCornerType {
match *self {
CornerType::TopLeft => ffi::GTK_CORNER_TOP_LEFT,
CornerType::BottomLeft => ffi::GTK_CORNER_BOTTOM_LEFT,
CornerType::TopRight => ffi::GTK_CORNER_TOP_RIGHT,
CornerType::BottomRight => ffi::GTK_CORNER_BOTTOM_RIGHT,
CornerType::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkCornerType> for CornerType {
fn from_glib(value: ffi::GtkCornerType) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_CORNER_TOP_LEFT => CornerType::TopLeft,
ffi::GTK_CORNER_BOTTOM_LEFT => CornerType::BottomLeft,
ffi::GTK_CORNER_TOP_RIGHT => CornerType::TopRight,
ffi::GTK_CORNER_BOTTOM_RIGHT => CornerType::BottomRight,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum CssProviderError {
Failed,
Syntax,
Import,
Name,
Deprecated,
UnknownValue,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for CssProviderError {
type GlibType = ffi::GtkCssProviderError;
fn to_glib(&self) -> ffi::GtkCssProviderError {
match *self {
CssProviderError::Failed => ffi::GTK_CSS_PROVIDER_ERROR_FAILED,
CssProviderError::Syntax => ffi::GTK_CSS_PROVIDER_ERROR_SYNTAX,
CssProviderError::Import => ffi::GTK_CSS_PROVIDER_ERROR_IMPORT,
CssProviderError::Name => ffi::GTK_CSS_PROVIDER_ERROR_NAME,
CssProviderError::Deprecated => ffi::GTK_CSS_PROVIDER_ERROR_DEPRECATED,
CssProviderError::UnknownValue => ffi::GTK_CSS_PROVIDER_ERROR_UNKNOWN_VALUE,
CssProviderError::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkCssProviderError> for CssProviderError {
fn from_glib(value: ffi::GtkCssProviderError) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_CSS_PROVIDER_ERROR_FAILED => CssProviderError::Failed,
ffi::GTK_CSS_PROVIDER_ERROR_SYNTAX => CssProviderError::Syntax,
ffi::GTK_CSS_PROVIDER_ERROR_IMPORT => CssProviderError::Import,
ffi::GTK_CSS_PROVIDER_ERROR_NAME => CssProviderError::Name,
ffi::GTK_CSS_PROVIDER_ERROR_DEPRECATED => CssProviderError::Deprecated,
ffi::GTK_CSS_PROVIDER_ERROR_UNKNOWN_VALUE => CssProviderError::UnknownValue,
}
}
}
impl ErrorDomain for CssProviderError {
fn domain() -> glib_ffi::GQuark {
skip_assert_initialized!();
unsafe { ffi::gtk_css_provider_error_quark() }
}
fn code(self) -> i32 {
self.to_glib() as i32
}
fn from(code: i32) -> Option<Self> {
skip_assert_initialized!();
match code {
x if x == ffi::GTK_CSS_PROVIDER_ERROR_FAILED as i32 => Some(CssProviderError::Failed),
x if x == ffi::GTK_CSS_PROVIDER_ERROR_SYNTAX as i32 => Some(CssProviderError::Syntax),
x if x == ffi::GTK_CSS_PROVIDER_ERROR_IMPORT as i32 => Some(CssProviderError::Import),
x if x == ffi::GTK_CSS_PROVIDER_ERROR_NAME as i32 => Some(CssProviderError::Name),
x if x == ffi::GTK_CSS_PROVIDER_ERROR_DEPRECATED as i32 => Some(CssProviderError::Deprecated),
x if x == ffi::GTK_CSS_PROVIDER_ERROR_UNKNOWN_VALUE as i32 => Some(CssProviderError::UnknownValue),
_ => Some(CssProviderError::Failed),
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum CssSectionType {
Document,
Import,
ColorDefinition,
BindingSet,
Ruleset,
Selector,
Declaration,
Value,
Keyframes,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for CssSectionType {
type GlibType = ffi::GtkCssSectionType;
fn to_glib(&self) -> ffi::GtkCssSectionType {
match *self {
CssSectionType::Document => ffi::GTK_CSS_SECTION_DOCUMENT,
CssSectionType::Import => ffi::GTK_CSS_SECTION_IMPORT,
CssSectionType::ColorDefinition => ffi::GTK_CSS_SECTION_COLOR_DEFINITION,
CssSectionType::BindingSet => ffi::GTK_CSS_SECTION_BINDING_SET,
CssSectionType::Ruleset => ffi::GTK_CSS_SECTION_RULESET,
CssSectionType::Selector => ffi::GTK_CSS_SECTION_SELECTOR,
CssSectionType::Declaration => ffi::GTK_CSS_SECTION_DECLARATION,
CssSectionType::Value => ffi::GTK_CSS_SECTION_VALUE,
CssSectionType::Keyframes => ffi::GTK_CSS_SECTION_KEYFRAMES,
CssSectionType::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkCssSectionType> for CssSectionType {
fn from_glib(value: ffi::GtkCssSectionType) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_CSS_SECTION_DOCUMENT => CssSectionType::Document,
ffi::GTK_CSS_SECTION_IMPORT => CssSectionType::Import,
ffi::GTK_CSS_SECTION_COLOR_DEFINITION => CssSectionType::ColorDefinition,
ffi::GTK_CSS_SECTION_BINDING_SET => CssSectionType::BindingSet,
ffi::GTK_CSS_SECTION_RULESET => CssSectionType::Ruleset,
ffi::GTK_CSS_SECTION_SELECTOR => CssSectionType::Selector,
ffi::GTK_CSS_SECTION_DECLARATION => CssSectionType::Declaration,
ffi::GTK_CSS_SECTION_VALUE => CssSectionType::Value,
ffi::GTK_CSS_SECTION_KEYFRAMES => CssSectionType::Keyframes,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum DeleteType {
Chars,
WordEnds,
Words,
DisplayLines,
DisplayLineEnds,
ParagraphEnds,
Paragraphs,
Whitespace,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for DeleteType {
type GlibType = ffi::GtkDeleteType;
fn to_glib(&self) -> ffi::GtkDeleteType {
match *self {
DeleteType::Chars => ffi::GTK_DELETE_CHARS,
DeleteType::WordEnds => ffi::GTK_DELETE_WORD_ENDS,
DeleteType::Words => ffi::GTK_DELETE_WORDS,
DeleteType::DisplayLines => ffi::GTK_DELETE_DISPLAY_LINES,
DeleteType::DisplayLineEnds => ffi::GTK_DELETE_DISPLAY_LINE_ENDS,
DeleteType::ParagraphEnds => ffi::GTK_DELETE_PARAGRAPH_ENDS,
DeleteType::Paragraphs => ffi::GTK_DELETE_PARAGRAPHS,
DeleteType::Whitespace => ffi::GTK_DELETE_WHITESPACE,
DeleteType::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkDeleteType> for DeleteType {
fn from_glib(value: ffi::GtkDeleteType) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_DELETE_CHARS => DeleteType::Chars,
ffi::GTK_DELETE_WORD_ENDS => DeleteType::WordEnds,
ffi::GTK_DELETE_WORDS => DeleteType::Words,
ffi::GTK_DELETE_DISPLAY_LINES => DeleteType::DisplayLines,
ffi::GTK_DELETE_DISPLAY_LINE_ENDS => DeleteType::DisplayLineEnds,
ffi::GTK_DELETE_PARAGRAPH_ENDS => DeleteType::ParagraphEnds,
ffi::GTK_DELETE_PARAGRAPHS => DeleteType::Paragraphs,
ffi::GTK_DELETE_WHITESPACE => DeleteType::Whitespace,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum DirectionType {
TabForward,
TabBackward,
Up,
Down,
Left,
Right,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for DirectionType {
type GlibType = ffi::GtkDirectionType;
fn to_glib(&self) -> ffi::GtkDirectionType {
match *self {
DirectionType::TabForward => ffi::GTK_DIR_TAB_FORWARD,
DirectionType::TabBackward => ffi::GTK_DIR_TAB_BACKWARD,
DirectionType::Up => ffi::GTK_DIR_UP,
DirectionType::Down => ffi::GTK_DIR_DOWN,
DirectionType::Left => ffi::GTK_DIR_LEFT,
DirectionType::Right => ffi::GTK_DIR_RIGHT,
DirectionType::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkDirectionType> for DirectionType {
fn from_glib(value: ffi::GtkDirectionType) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_DIR_TAB_FORWARD => DirectionType::TabForward,
ffi::GTK_DIR_TAB_BACKWARD => DirectionType::TabBackward,
ffi::GTK_DIR_UP => DirectionType::Up,
ffi::GTK_DIR_DOWN => DirectionType::Down,
ffi::GTK_DIR_LEFT => DirectionType::Left,
ffi::GTK_DIR_RIGHT => DirectionType::Right,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum DragResult {
Success,
NoTarget,
UserCancelled,
TimeoutExpired,
GrabBroken,
Error,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for DragResult {
type GlibType = ffi::GtkDragResult;
fn to_glib(&self) -> ffi::GtkDragResult {
match *self {
DragResult::Success => ffi::GTK_DRAG_RESULT_SUCCESS,
DragResult::NoTarget => ffi::GTK_DRAG_RESULT_NO_TARGET,
DragResult::UserCancelled => ffi::GTK_DRAG_RESULT_USER_CANCELLED,
DragResult::TimeoutExpired => ffi::GTK_DRAG_RESULT_TIMEOUT_EXPIRED,
DragResult::GrabBroken => ffi::GTK_DRAG_RESULT_GRAB_BROKEN,
DragResult::Error => ffi::GTK_DRAG_RESULT_ERROR,
DragResult::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkDragResult> for DragResult {
fn from_glib(value: ffi::GtkDragResult) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_DRAG_RESULT_SUCCESS => DragResult::Success,
ffi::GTK_DRAG_RESULT_NO_TARGET => DragResult::NoTarget,
ffi::GTK_DRAG_RESULT_USER_CANCELLED => DragResult::UserCancelled,
ffi::GTK_DRAG_RESULT_TIMEOUT_EXPIRED => DragResult::TimeoutExpired,
ffi::GTK_DRAG_RESULT_GRAB_BROKEN => DragResult::GrabBroken,
ffi::GTK_DRAG_RESULT_ERROR => DragResult::Error,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum EntryIconPosition {
Primary,
Secondary,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for EntryIconPosition {
type GlibType = ffi::GtkEntryIconPosition;
fn to_glib(&self) -> ffi::GtkEntryIconPosition {
match *self {
EntryIconPosition::Primary => ffi::GTK_ENTRY_ICON_PRIMARY,
EntryIconPosition::Secondary => ffi::GTK_ENTRY_ICON_SECONDARY,
EntryIconPosition::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkEntryIconPosition> for EntryIconPosition {
fn from_glib(value: ffi::GtkEntryIconPosition) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_ENTRY_ICON_PRIMARY => EntryIconPosition::Primary,
ffi::GTK_ENTRY_ICON_SECONDARY => EntryIconPosition::Secondary,
}
}
}
#[cfg(feature = "v3_14")]
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum EventSequenceState {
None,
Claimed,
Denied,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[cfg(feature = "v3_14")]
#[doc(hidden)]
impl ToGlib for EventSequenceState {
type GlibType = ffi::GtkEventSequenceState;
fn to_glib(&self) -> ffi::GtkEventSequenceState {
match *self {
EventSequenceState::None => ffi::GTK_EVENT_SEQUENCE_NONE,
EventSequenceState::Claimed => ffi::GTK_EVENT_SEQUENCE_CLAIMED,
EventSequenceState::Denied => ffi::GTK_EVENT_SEQUENCE_DENIED,
EventSequenceState::__Nonexhaustive(_) => panic!(),
}
}
}
#[cfg(feature = "v3_14")]
#[doc(hidden)]
impl FromGlib<ffi::GtkEventSequenceState> for EventSequenceState {
fn from_glib(value: ffi::GtkEventSequenceState) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_EVENT_SEQUENCE_NONE => EventSequenceState::None,
ffi::GTK_EVENT_SEQUENCE_CLAIMED => EventSequenceState::Claimed,
ffi::GTK_EVENT_SEQUENCE_DENIED => EventSequenceState::Denied,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum FileChooserAction {
Open,
Save,
SelectFolder,
CreateFolder,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for FileChooserAction {
type GlibType = ffi::GtkFileChooserAction;
fn to_glib(&self) -> ffi::GtkFileChooserAction {
match *self {
FileChooserAction::Open => ffi::GTK_FILE_CHOOSER_ACTION_OPEN,
FileChooserAction::Save => ffi::GTK_FILE_CHOOSER_ACTION_SAVE,
FileChooserAction::SelectFolder => ffi::GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
FileChooserAction::CreateFolder => ffi::GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER,
FileChooserAction::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkFileChooserAction> for FileChooserAction {
fn from_glib(value: ffi::GtkFileChooserAction) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_FILE_CHOOSER_ACTION_OPEN => FileChooserAction::Open,
ffi::GTK_FILE_CHOOSER_ACTION_SAVE => FileChooserAction::Save,
ffi::GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER => FileChooserAction::SelectFolder,
ffi::GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER => FileChooserAction::CreateFolder,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum FileChooserConfirmation {
Confirm,
AcceptFilename,
SelectAgain,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for FileChooserConfirmation {
type GlibType = ffi::GtkFileChooserConfirmation;
fn to_glib(&self) -> ffi::GtkFileChooserConfirmation {
match *self {
FileChooserConfirmation::Confirm => ffi::GTK_FILE_CHOOSER_CONFIRMATION_CONFIRM,
FileChooserConfirmation::AcceptFilename => ffi::GTK_FILE_CHOOSER_CONFIRMATION_ACCEPT_FILENAME,
FileChooserConfirmation::SelectAgain => ffi::GTK_FILE_CHOOSER_CONFIRMATION_SELECT_AGAIN,
FileChooserConfirmation::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkFileChooserConfirmation> for FileChooserConfirmation {
fn from_glib(value: ffi::GtkFileChooserConfirmation) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_FILE_CHOOSER_CONFIRMATION_CONFIRM => FileChooserConfirmation::Confirm,
ffi::GTK_FILE_CHOOSER_CONFIRMATION_ACCEPT_FILENAME => FileChooserConfirmation::AcceptFilename,
ffi::GTK_FILE_CHOOSER_CONFIRMATION_SELECT_AGAIN => FileChooserConfirmation::SelectAgain,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum FileChooserError {
Nonexistent,
BadFilename,
AlreadyExists,
IncompleteHostname,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for FileChooserError {
type GlibType = ffi::GtkFileChooserError;
fn to_glib(&self) -> ffi::GtkFileChooserError {
match *self {
FileChooserError::Nonexistent => ffi::GTK_FILE_CHOOSER_ERROR_NONEXISTENT,
FileChooserError::BadFilename => ffi::GTK_FILE_CHOOSER_ERROR_BAD_FILENAME,
FileChooserError::AlreadyExists => ffi::GTK_FILE_CHOOSER_ERROR_ALREADY_EXISTS,
FileChooserError::IncompleteHostname => ffi::GTK_FILE_CHOOSER_ERROR_INCOMPLETE_HOSTNAME,
FileChooserError::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkFileChooserError> for FileChooserError {
fn from_glib(value: ffi::GtkFileChooserError) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_FILE_CHOOSER_ERROR_NONEXISTENT => FileChooserError::Nonexistent,
ffi::GTK_FILE_CHOOSER_ERROR_BAD_FILENAME => FileChooserError::BadFilename,
ffi::GTK_FILE_CHOOSER_ERROR_ALREADY_EXISTS => FileChooserError::AlreadyExists,
ffi::GTK_FILE_CHOOSER_ERROR_INCOMPLETE_HOSTNAME => FileChooserError::IncompleteHostname,
}
}
}
impl ErrorDomain for FileChooserError {
fn domain() -> glib_ffi::GQuark {
skip_assert_initialized!();
unsafe { ffi::gtk_file_chooser_error_quark() }
}
fn code(self) -> i32 {
self.to_glib() as i32
}
fn from(code: i32) -> Option<Self> {
skip_assert_initialized!();
match code {
x if x == ffi::GTK_FILE_CHOOSER_ERROR_NONEXISTENT as i32 => Some(FileChooserError::Nonexistent),
x if x == ffi::GTK_FILE_CHOOSER_ERROR_BAD_FILENAME as i32 => Some(FileChooserError::BadFilename),
x if x == ffi::GTK_FILE_CHOOSER_ERROR_ALREADY_EXISTS as i32 => Some(FileChooserError::AlreadyExists),
x if x == ffi::GTK_FILE_CHOOSER_ERROR_INCOMPLETE_HOSTNAME as i32 => Some(FileChooserError::IncompleteHostname),
_ => Some(FileChooserError::__Nonexhaustive(())),
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum IconSize {
Invalid,
Menu,
SmallToolbar,
LargeToolbar,
Button,
Dnd,
Dialog,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for IconSize {
type GlibType = ffi::GtkIconSize;
fn to_glib(&self) -> ffi::GtkIconSize {
match *self {
IconSize::Invalid => ffi::GTK_ICON_SIZE_INVALID,
IconSize::Menu => ffi::GTK_ICON_SIZE_MENU,
IconSize::SmallToolbar => ffi::GTK_ICON_SIZE_SMALL_TOOLBAR,
IconSize::LargeToolbar => ffi::GTK_ICON_SIZE_LARGE_TOOLBAR,
IconSize::Button => ffi::GTK_ICON_SIZE_BUTTON,
IconSize::Dnd => ffi::GTK_ICON_SIZE_DND,
IconSize::Dialog => ffi::GTK_ICON_SIZE_DIALOG,
IconSize::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkIconSize> for IconSize {
fn from_glib(value: ffi::GtkIconSize) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_ICON_SIZE_INVALID => IconSize::Invalid,
ffi::GTK_ICON_SIZE_MENU => IconSize::Menu,
ffi::GTK_ICON_SIZE_SMALL_TOOLBAR => IconSize::SmallToolbar,
ffi::GTK_ICON_SIZE_LARGE_TOOLBAR => IconSize::LargeToolbar,
ffi::GTK_ICON_SIZE_BUTTON => IconSize::Button,
ffi::GTK_ICON_SIZE_DND => IconSize::Dnd,
ffi::GTK_ICON_SIZE_DIALOG => IconSize::Dialog,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum IconThemeError {
NotFound,
Failed,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for IconThemeError {
type GlibType = ffi::GtkIconThemeError;
fn to_glib(&self) -> ffi::GtkIconThemeError {
match *self {
IconThemeError::NotFound => ffi::GTK_ICON_THEME_NOT_FOUND,
IconThemeError::Failed => ffi::GTK_ICON_THEME_FAILED,
IconThemeError::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkIconThemeError> for IconThemeError {
fn from_glib(value: ffi::GtkIconThemeError) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_ICON_THEME_NOT_FOUND => IconThemeError::NotFound,
ffi::GTK_ICON_THEME_FAILED => IconThemeError::Failed,
}
}
}
impl ErrorDomain for IconThemeError {
fn domain() -> glib_ffi::GQuark {
skip_assert_initialized!();
unsafe { ffi::gtk_icon_theme_error_quark() }
}
fn code(self) -> i32 {
self.to_glib() as i32
}
fn from(code: i32) -> Option<Self> {
skip_assert_initialized!();
match code {
x if x == ffi::GTK_ICON_THEME_NOT_FOUND as i32 => Some(IconThemeError::NotFound),
x if x == ffi::GTK_ICON_THEME_FAILED as i32 => Some(IconThemeError::Failed),
_ => Some(IconThemeError::Failed),
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum IconViewDropPosition {
NoDrop,
DropInto,
DropLeft,
DropRight,
DropAbove,
DropBelow,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for IconViewDropPosition {
type GlibType = ffi::GtkIconViewDropPosition;
fn to_glib(&self) -> ffi::GtkIconViewDropPosition {
match *self {
IconViewDropPosition::NoDrop => ffi::GTK_ICON_VIEW_NO_DROP,
IconViewDropPosition::DropInto => ffi::GTK_ICON_VIEW_DROP_INTO,
IconViewDropPosition::DropLeft => ffi::GTK_ICON_VIEW_DROP_LEFT,
IconViewDropPosition::DropRight => ffi::GTK_ICON_VIEW_DROP_RIGHT,
IconViewDropPosition::DropAbove => ffi::GTK_ICON_VIEW_DROP_ABOVE,
IconViewDropPosition::DropBelow => ffi::GTK_ICON_VIEW_DROP_BELOW,
IconViewDropPosition::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkIconViewDropPosition> for IconViewDropPosition {
fn from_glib(value: ffi::GtkIconViewDropPosition) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_ICON_VIEW_NO_DROP => IconViewDropPosition::NoDrop,
ffi::GTK_ICON_VIEW_DROP_INTO => IconViewDropPosition::DropInto,
ffi::GTK_ICON_VIEW_DROP_LEFT => IconViewDropPosition::DropLeft,
ffi::GTK_ICON_VIEW_DROP_RIGHT => IconViewDropPosition::DropRight,
ffi::GTK_ICON_VIEW_DROP_ABOVE => IconViewDropPosition::DropAbove,
ffi::GTK_ICON_VIEW_DROP_BELOW => IconViewDropPosition::DropBelow,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum ImageType {
Empty,
Pixbuf,
Stock,
IconSet,
Animation,
IconName,
Gicon,
Surface,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for ImageType {
type GlibType = ffi::GtkImageType;
fn to_glib(&self) -> ffi::GtkImageType {
match *self {
ImageType::Empty => ffi::GTK_IMAGE_EMPTY,
ImageType::Pixbuf => ffi::GTK_IMAGE_PIXBUF,
ImageType::Stock => ffi::GTK_IMAGE_STOCK,
ImageType::IconSet => ffi::GTK_IMAGE_ICON_SET,
ImageType::Animation => ffi::GTK_IMAGE_ANIMATION,
ImageType::IconName => ffi::GTK_IMAGE_ICON_NAME,
ImageType::Gicon => ffi::GTK_IMAGE_GICON,
ImageType::Surface => ffi::GTK_IMAGE_SURFACE,
ImageType::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkImageType> for ImageType {
fn from_glib(value: ffi::GtkImageType) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_IMAGE_EMPTY => ImageType::Empty,
ffi::GTK_IMAGE_PIXBUF => ImageType::Pixbuf,
ffi::GTK_IMAGE_STOCK => ImageType::Stock,
ffi::GTK_IMAGE_ICON_SET => ImageType::IconSet,
ffi::GTK_IMAGE_ANIMATION => ImageType::Animation,
ffi::GTK_IMAGE_ICON_NAME => ImageType::IconName,
ffi::GTK_IMAGE_GICON => ImageType::Gicon,
ffi::GTK_IMAGE_SURFACE => ImageType::Surface,
}
}
}
#[cfg(feature = "v3_6")]
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum InputPurpose {
FreeForm,
Alpha,
Digits,
Number,
Phone,
Url,
Email,
Name,
Password,
Pin,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[cfg(feature = "v3_6")]
#[doc(hidden)]
impl ToGlib for InputPurpose {
type GlibType = ffi::GtkInputPurpose;
fn to_glib(&self) -> ffi::GtkInputPurpose {
match *self {
InputPurpose::FreeForm => ffi::GTK_INPUT_PURPOSE_FREE_FORM,
InputPurpose::Alpha => ffi::GTK_INPUT_PURPOSE_ALPHA,
InputPurpose::Digits => ffi::GTK_INPUT_PURPOSE_DIGITS,
InputPurpose::Number => ffi::GTK_INPUT_PURPOSE_NUMBER,
InputPurpose::Phone => ffi::GTK_INPUT_PURPOSE_PHONE,
InputPurpose::Url => ffi::GTK_INPUT_PURPOSE_URL,
InputPurpose::Email => ffi::GTK_INPUT_PURPOSE_EMAIL,
InputPurpose::Name => ffi::GTK_INPUT_PURPOSE_NAME,
InputPurpose::Password => ffi::GTK_INPUT_PURPOSE_PASSWORD,
InputPurpose::Pin => ffi::GTK_INPUT_PURPOSE_PIN,
InputPurpose::__Nonexhaustive(_) => panic!(),
}
}
}
#[cfg(feature = "v3_6")]
#[doc(hidden)]
impl FromGlib<ffi::GtkInputPurpose> for InputPurpose {
fn from_glib(value: ffi::GtkInputPurpose) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_INPUT_PURPOSE_FREE_FORM => InputPurpose::FreeForm,
ffi::GTK_INPUT_PURPOSE_ALPHA => InputPurpose::Alpha,
ffi::GTK_INPUT_PURPOSE_DIGITS => InputPurpose::Digits,
ffi::GTK_INPUT_PURPOSE_NUMBER => InputPurpose::Number,
ffi::GTK_INPUT_PURPOSE_PHONE => InputPurpose::Phone,
ffi::GTK_INPUT_PURPOSE_URL => InputPurpose::Url,
ffi::GTK_INPUT_PURPOSE_EMAIL => InputPurpose::Email,
ffi::GTK_INPUT_PURPOSE_NAME => InputPurpose::Name,
ffi::GTK_INPUT_PURPOSE_PASSWORD => InputPurpose::Password,
ffi::GTK_INPUT_PURPOSE_PIN => InputPurpose::Pin,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum Justification {
Left,
Right,
Center,
Fill,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for Justification {
type GlibType = ffi::GtkJustification;
fn to_glib(&self) -> ffi::GtkJustification {
match *self {
Justification::Left => ffi::GTK_JUSTIFY_LEFT,
Justification::Right => ffi::GTK_JUSTIFY_RIGHT,
Justification::Center => ffi::GTK_JUSTIFY_CENTER,
Justification::Fill => ffi::GTK_JUSTIFY_FILL,
Justification::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkJustification> for Justification {
fn from_glib(value: ffi::GtkJustification) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_JUSTIFY_LEFT => Justification::Left,
ffi::GTK_JUSTIFY_RIGHT => Justification::Right,
ffi::GTK_JUSTIFY_CENTER => Justification::Center,
ffi::GTK_JUSTIFY_FILL => Justification::Fill,
}
}
}
#[cfg(feature = "v3_6")]
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum LevelBarMode {
Continuous,
Discrete,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[cfg(feature = "v3_6")]
#[doc(hidden)]
impl ToGlib for LevelBarMode {
type GlibType = ffi::GtkLevelBarMode;
fn to_glib(&self) -> ffi::GtkLevelBarMode {
match *self {
LevelBarMode::Continuous => ffi::GTK_LEVEL_BAR_MODE_CONTINUOUS,
LevelBarMode::Discrete => ffi::GTK_LEVEL_BAR_MODE_DISCRETE,
LevelBarMode::__Nonexhaustive(_) => panic!(),
}
}
}
#[cfg(feature = "v3_6")]
#[doc(hidden)]
impl FromGlib<ffi::GtkLevelBarMode> for LevelBarMode {
fn from_glib(value: ffi::GtkLevelBarMode) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_LEVEL_BAR_MODE_CONTINUOUS => LevelBarMode::Continuous,
ffi::GTK_LEVEL_BAR_MODE_DISCRETE => LevelBarMode::Discrete,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum License {
Unknown,
Custom,
Gpl20,
Gpl30,
Lgpl21,
Lgpl30,
Bsd,
MitX11,
Artistic,
Gpl20Only,
Gpl30Only,
Lgpl21Only,
Lgpl30Only,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for License {
type GlibType = ffi::GtkLicense;
fn to_glib(&self) -> ffi::GtkLicense {
match *self {
License::Unknown => ffi::GTK_LICENSE_UNKNOWN,
License::Custom => ffi::GTK_LICENSE_CUSTOM,
License::Gpl20 => ffi::GTK_LICENSE_GPL_2_0,
License::Gpl30 => ffi::GTK_LICENSE_GPL_3_0,
License::Lgpl21 => ffi::GTK_LICENSE_LGPL_2_1,
License::Lgpl30 => ffi::GTK_LICENSE_LGPL_3_0,
License::Bsd => ffi::GTK_LICENSE_BSD,
License::MitX11 => ffi::GTK_LICENSE_MIT_X11,
License::Artistic => ffi::GTK_LICENSE_ARTISTIC,
License::Gpl20Only => ffi::GTK_LICENSE_GPL_2_0_ONLY,
License::Gpl30Only => ffi::GTK_LICENSE_GPL_3_0_ONLY,
License::Lgpl21Only => ffi::GTK_LICENSE_LGPL_2_1_ONLY,
License::Lgpl30Only => ffi::GTK_LICENSE_LGPL_3_0_ONLY,
License::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkLicense> for License {
fn from_glib(value: ffi::GtkLicense) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_LICENSE_UNKNOWN => License::Unknown,
ffi::GTK_LICENSE_CUSTOM => License::Custom,
ffi::GTK_LICENSE_GPL_2_0 => License::Gpl20,
ffi::GTK_LICENSE_GPL_3_0 => License::Gpl30,
ffi::GTK_LICENSE_LGPL_2_1 => License::Lgpl21,
ffi::GTK_LICENSE_LGPL_3_0 => License::Lgpl30,
ffi::GTK_LICENSE_BSD => License::Bsd,
ffi::GTK_LICENSE_MIT_X11 => License::MitX11,
ffi::GTK_LICENSE_ARTISTIC => License::Artistic,
ffi::GTK_LICENSE_GPL_2_0_ONLY => License::Gpl20Only,
ffi::GTK_LICENSE_GPL_3_0_ONLY => License::Gpl30Only,
ffi::GTK_LICENSE_LGPL_2_1_ONLY => License::Lgpl21Only,
ffi::GTK_LICENSE_LGPL_3_0_ONLY => License::Lgpl30Only,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum MenuDirectionType {
Parent,
Child,
Next,
Prev,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for MenuDirectionType {
type GlibType = ffi::GtkMenuDirectionType;
fn to_glib(&self) -> ffi::GtkMenuDirectionType {
match *self {
MenuDirectionType::Parent => ffi::GTK_MENU_DIR_PARENT,
MenuDirectionType::Child => ffi::GTK_MENU_DIR_CHILD,
MenuDirectionType::Next => ffi::GTK_MENU_DIR_NEXT,
MenuDirectionType::Prev => ffi::GTK_MENU_DIR_PREV,
MenuDirectionType::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkMenuDirectionType> for MenuDirectionType {
fn from_glib(value: ffi::GtkMenuDirectionType) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_MENU_DIR_PARENT => MenuDirectionType::Parent,
ffi::GTK_MENU_DIR_CHILD => MenuDirectionType::Child,
ffi::GTK_MENU_DIR_NEXT => MenuDirectionType::Next,
ffi::GTK_MENU_DIR_PREV => MenuDirectionType::Prev,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum MessageType {
Info,
Warning,
Question,
Error,
Other,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for MessageType {
type GlibType = ffi::GtkMessageType;
fn to_glib(&self) -> ffi::GtkMessageType {
match *self {
MessageType::Info => ffi::GTK_MESSAGE_INFO,
MessageType::Warning => ffi::GTK_MESSAGE_WARNING,
MessageType::Question => ffi::GTK_MESSAGE_QUESTION,
MessageType::Error => ffi::GTK_MESSAGE_ERROR,
MessageType::Other => ffi::GTK_MESSAGE_OTHER,
MessageType::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkMessageType> for MessageType {
fn from_glib(value: ffi::GtkMessageType) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_MESSAGE_INFO => MessageType::Info,
ffi::GTK_MESSAGE_WARNING => MessageType::Warning,
ffi::GTK_MESSAGE_QUESTION => MessageType::Question,
ffi::GTK_MESSAGE_ERROR => MessageType::Error,
ffi::GTK_MESSAGE_OTHER => MessageType::Other,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum MovementStep {
LogicalPositions,
VisualPositions,
Words,
DisplayLines,
DisplayLineEnds,
Paragraphs,
ParagraphEnds,
Pages,
BufferEnds,
HorizontalPages,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for MovementStep {
type GlibType = ffi::GtkMovementStep;
fn to_glib(&self) -> ffi::GtkMovementStep {
match *self {
MovementStep::LogicalPositions => ffi::GTK_MOVEMENT_LOGICAL_POSITIONS,
MovementStep::VisualPositions => ffi::GTK_MOVEMENT_VISUAL_POSITIONS,
MovementStep::Words => ffi::GTK_MOVEMENT_WORDS,
MovementStep::DisplayLines => ffi::GTK_MOVEMENT_DISPLAY_LINES,
MovementStep::DisplayLineEnds => ffi::GTK_MOVEMENT_DISPLAY_LINE_ENDS,
MovementStep::Paragraphs => ffi::GTK_MOVEMENT_PARAGRAPHS,
MovementStep::ParagraphEnds => ffi::GTK_MOVEMENT_PARAGRAPH_ENDS,
MovementStep::Pages => ffi::GTK_MOVEMENT_PAGES,
MovementStep::BufferEnds => ffi::GTK_MOVEMENT_BUFFER_ENDS,
MovementStep::HorizontalPages => ffi::GTK_MOVEMENT_HORIZONTAL_PAGES,
MovementStep::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkMovementStep> for MovementStep {
fn from_glib(value: ffi::GtkMovementStep) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_MOVEMENT_LOGICAL_POSITIONS => MovementStep::LogicalPositions,
ffi::GTK_MOVEMENT_VISUAL_POSITIONS => MovementStep::VisualPositions,
ffi::GTK_MOVEMENT_WORDS => MovementStep::Words,
ffi::GTK_MOVEMENT_DISPLAY_LINES => MovementStep::DisplayLines,
ffi::GTK_MOVEMENT_DISPLAY_LINE_ENDS => MovementStep::DisplayLineEnds,
ffi::GTK_MOVEMENT_PARAGRAPHS => MovementStep::Paragraphs,
ffi::GTK_MOVEMENT_PARAGRAPH_ENDS => MovementStep::ParagraphEnds,
ffi::GTK_MOVEMENT_PAGES => MovementStep::Pages,
ffi::GTK_MOVEMENT_BUFFER_ENDS => MovementStep::BufferEnds,
ffi::GTK_MOVEMENT_HORIZONTAL_PAGES => MovementStep::HorizontalPages,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum NotebookTab {
First,
Last,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for NotebookTab {
type GlibType = ffi::GtkNotebookTab;
fn to_glib(&self) -> ffi::GtkNotebookTab {
match *self {
NotebookTab::First => ffi::GTK_NOTEBOOK_TAB_FIRST,
NotebookTab::Last => ffi::GTK_NOTEBOOK_TAB_LAST,
NotebookTab::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkNotebookTab> for NotebookTab {
fn from_glib(value: ffi::GtkNotebookTab) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_NOTEBOOK_TAB_FIRST => NotebookTab::First,
ffi::GTK_NOTEBOOK_TAB_LAST => NotebookTab::Last,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum NumberUpLayout {
Lrtb,
Lrbt,
Rltb,
Rlbt,
Tblr,
Tbrl,
Btlr,
Btrl,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for NumberUpLayout {
type GlibType = ffi::GtkNumberUpLayout;
fn to_glib(&self) -> ffi::GtkNumberUpLayout {
match *self {
NumberUpLayout::Lrtb => ffi::GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM,
NumberUpLayout::Lrbt => ffi::GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP,
NumberUpLayout::Rltb => ffi::GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM,
NumberUpLayout::Rlbt => ffi::GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP,
NumberUpLayout::Tblr => ffi::GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT,
NumberUpLayout::Tbrl => ffi::GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT,
NumberUpLayout::Btlr => ffi::GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT,
NumberUpLayout::Btrl => ffi::GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT,
NumberUpLayout::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkNumberUpLayout> for NumberUpLayout {
fn from_glib(value: ffi::GtkNumberUpLayout) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM => NumberUpLayout::Lrtb,
ffi::GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP => NumberUpLayout::Lrbt,
ffi::GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM => NumberUpLayout::Rltb,
ffi::GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP => NumberUpLayout::Rlbt,
ffi::GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT => NumberUpLayout::Tblr,
ffi::GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT => NumberUpLayout::Tbrl,
ffi::GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT => NumberUpLayout::Btlr,
ffi::GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT => NumberUpLayout::Btrl,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum Orientation {
Horizontal,
Vertical,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for Orientation {
type GlibType = ffi::GtkOrientation;
fn to_glib(&self) -> ffi::GtkOrientation {
match *self {
Orientation::Horizontal => ffi::GTK_ORIENTATION_HORIZONTAL,
Orientation::Vertical => ffi::GTK_ORIENTATION_VERTICAL,
Orientation::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkOrientation> for Orientation {
fn from_glib(value: ffi::GtkOrientation) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_ORIENTATION_HORIZONTAL => Orientation::Horizontal,
ffi::GTK_ORIENTATION_VERTICAL => Orientation::Vertical,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum PackDirection {
Ltr,
Rtl,
Ttb,
Btt,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for PackDirection {
type GlibType = ffi::GtkPackDirection;
fn to_glib(&self) -> ffi::GtkPackDirection {
match *self {
PackDirection::Ltr => ffi::GTK_PACK_DIRECTION_LTR,
PackDirection::Rtl => ffi::GTK_PACK_DIRECTION_RTL,
PackDirection::Ttb => ffi::GTK_PACK_DIRECTION_TTB,
PackDirection::Btt => ffi::GTK_PACK_DIRECTION_BTT,
PackDirection::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkPackDirection> for PackDirection {
fn from_glib(value: ffi::GtkPackDirection) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_PACK_DIRECTION_LTR => PackDirection::Ltr,
ffi::GTK_PACK_DIRECTION_RTL => PackDirection::Rtl,
ffi::GTK_PACK_DIRECTION_TTB => PackDirection::Ttb,
ffi::GTK_PACK_DIRECTION_BTT => PackDirection::Btt,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum PackType {
Start,
End,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for PackType {
type GlibType = ffi::GtkPackType;
fn to_glib(&self) -> ffi::GtkPackType {
match *self {
PackType::Start => ffi::GTK_PACK_START,
PackType::End => ffi::GTK_PACK_END,
PackType::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkPackType> for PackType {
fn from_glib(value: ffi::GtkPackType) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_PACK_START => PackType::Start,
ffi::GTK_PACK_END => PackType::End,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum PageOrientation {
Portrait,
Landscape,
ReversePortrait,
ReverseLandscape,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for PageOrientation {
type GlibType = ffi::GtkPageOrientation;
fn to_glib(&self) -> ffi::GtkPageOrientation {
match *self {
PageOrientation::Portrait => ffi::GTK_PAGE_ORIENTATION_PORTRAIT,
PageOrientation::Landscape => ffi::GTK_PAGE_ORIENTATION_LANDSCAPE,
PageOrientation::ReversePortrait => ffi::GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT,
PageOrientation::ReverseLandscape => ffi::GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE,
PageOrientation::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkPageOrientation> for PageOrientation {
fn from_glib(value: ffi::GtkPageOrientation) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_PAGE_ORIENTATION_PORTRAIT => PageOrientation::Portrait,
ffi::GTK_PAGE_ORIENTATION_LANDSCAPE => PageOrientation::Landscape,
ffi::GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT => PageOrientation::ReversePortrait,
ffi::GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE => PageOrientation::ReverseLandscape,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum PageSet {
All,
Even,
Odd,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for PageSet {
type GlibType = ffi::GtkPageSet;
fn to_glib(&self) -> ffi::GtkPageSet {
match *self {
PageSet::All => ffi::GTK_PAGE_SET_ALL,
PageSet::Even => ffi::GTK_PAGE_SET_EVEN,
PageSet::Odd => ffi::GTK_PAGE_SET_ODD,
PageSet::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkPageSet> for PageSet {
fn from_glib(value: ffi::GtkPageSet) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_PAGE_SET_ALL => PageSet::All,
ffi::GTK_PAGE_SET_EVEN => PageSet::Even,
ffi::GTK_PAGE_SET_ODD => PageSet::Odd,
}
}
}
#[cfg(feature = "v3_14")]
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum PanDirection {
Left,
Right,
Up,
Down,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[cfg(feature = "v3_14")]
#[doc(hidden)]
impl ToGlib for PanDirection {
type GlibType = ffi::GtkPanDirection;
fn to_glib(&self) -> ffi::GtkPanDirection {
match *self {
PanDirection::Left => ffi::GTK_PAN_DIRECTION_LEFT,
PanDirection::Right => ffi::GTK_PAN_DIRECTION_RIGHT,
PanDirection::Up => ffi::GTK_PAN_DIRECTION_UP,
PanDirection::Down => ffi::GTK_PAN_DIRECTION_DOWN,
PanDirection::__Nonexhaustive(_) => panic!(),
}
}
}
#[cfg(feature = "v3_14")]
#[doc(hidden)]
impl FromGlib<ffi::GtkPanDirection> for PanDirection {
fn from_glib(value: ffi::GtkPanDirection) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_PAN_DIRECTION_LEFT => PanDirection::Left,
ffi::GTK_PAN_DIRECTION_RIGHT => PanDirection::Right,
ffi::GTK_PAN_DIRECTION_UP => PanDirection::Up,
ffi::GTK_PAN_DIRECTION_DOWN => PanDirection::Down,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum PolicyType {
Always,
Automatic,
Never,
External,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for PolicyType {
type GlibType = ffi::GtkPolicyType;
fn to_glib(&self) -> ffi::GtkPolicyType {
match *self {
PolicyType::Always => ffi::GTK_POLICY_ALWAYS,
PolicyType::Automatic => ffi::GTK_POLICY_AUTOMATIC,
PolicyType::Never => ffi::GTK_POLICY_NEVER,
PolicyType::External => ffi::GTK_POLICY_EXTERNAL,
PolicyType::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkPolicyType> for PolicyType {
fn from_glib(value: ffi::GtkPolicyType) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_POLICY_ALWAYS => PolicyType::Always,
ffi::GTK_POLICY_AUTOMATIC => PolicyType::Automatic,
ffi::GTK_POLICY_NEVER => PolicyType::Never,
ffi::GTK_POLICY_EXTERNAL => PolicyType::External,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum PositionType {
Left,
Right,
Top,
Bottom,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for PositionType {
type GlibType = ffi::GtkPositionType;
fn to_glib(&self) -> ffi::GtkPositionType {
match *self {
PositionType::Left => ffi::GTK_POS_LEFT,
PositionType::Right => ffi::GTK_POS_RIGHT,
PositionType::Top => ffi::GTK_POS_TOP,
PositionType::Bottom => ffi::GTK_POS_BOTTOM,
PositionType::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkPositionType> for PositionType {
fn from_glib(value: ffi::GtkPositionType) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_POS_LEFT => PositionType::Left,
ffi::GTK_POS_RIGHT => PositionType::Right,
ffi::GTK_POS_TOP => PositionType::Top,
ffi::GTK_POS_BOTTOM => PositionType::Bottom,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum PrintDuplex {
Simplex,
Horizontal,
Vertical,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for PrintDuplex {
type GlibType = ffi::GtkPrintDuplex;
fn to_glib(&self) -> ffi::GtkPrintDuplex {
match *self {
PrintDuplex::Simplex => ffi::GTK_PRINT_DUPLEX_SIMPLEX,
PrintDuplex::Horizontal => ffi::GTK_PRINT_DUPLEX_HORIZONTAL,
PrintDuplex::Vertical => ffi::GTK_PRINT_DUPLEX_VERTICAL,
PrintDuplex::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkPrintDuplex> for PrintDuplex {
fn from_glib(value: ffi::GtkPrintDuplex) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_PRINT_DUPLEX_SIMPLEX => PrintDuplex::Simplex,
ffi::GTK_PRINT_DUPLEX_HORIZONTAL => PrintDuplex::Horizontal,
ffi::GTK_PRINT_DUPLEX_VERTICAL => PrintDuplex::Vertical,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum PrintError {
General,
InternalError,
Nomem,
InvalidFile,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for PrintError {
type GlibType = ffi::GtkPrintError;
fn to_glib(&self) -> ffi::GtkPrintError {
match *self {
PrintError::General => ffi::GTK_PRINT_ERROR_GENERAL,
PrintError::InternalError => ffi::GTK_PRINT_ERROR_INTERNAL_ERROR,
PrintError::Nomem => ffi::GTK_PRINT_ERROR_NOMEM,
PrintError::InvalidFile => ffi::GTK_PRINT_ERROR_INVALID_FILE,
PrintError::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkPrintError> for PrintError {
fn from_glib(value: ffi::GtkPrintError) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_PRINT_ERROR_GENERAL => PrintError::General,
ffi::GTK_PRINT_ERROR_INTERNAL_ERROR => PrintError::InternalError,
ffi::GTK_PRINT_ERROR_NOMEM => PrintError::Nomem,
ffi::GTK_PRINT_ERROR_INVALID_FILE => PrintError::InvalidFile,
}
}
}
impl ErrorDomain for PrintError {
fn domain() -> glib_ffi::GQuark {
skip_assert_initialized!();
unsafe { ffi::gtk_print_error_quark() }
}
fn code(self) -> i32 {
self.to_glib() as i32
}
fn from(code: i32) -> Option<Self> {
skip_assert_initialized!();
match code {
x if x == ffi::GTK_PRINT_ERROR_GENERAL as i32 => Some(PrintError::General),
x if x == ffi::GTK_PRINT_ERROR_INTERNAL_ERROR as i32 => Some(PrintError::InternalError),
x if x == ffi::GTK_PRINT_ERROR_NOMEM as i32 => Some(PrintError::Nomem),
x if x == ffi::GTK_PRINT_ERROR_INVALID_FILE as i32 => Some(PrintError::InvalidFile),
_ => Some(PrintError::__Nonexhaustive(())),
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum PrintPages {
All,
Current,
Ranges,
Selection,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for PrintPages {
type GlibType = ffi::GtkPrintPages;
fn to_glib(&self) -> ffi::GtkPrintPages {
match *self {
PrintPages::All => ffi::GTK_PRINT_PAGES_ALL,
PrintPages::Current => ffi::GTK_PRINT_PAGES_CURRENT,
PrintPages::Ranges => ffi::GTK_PRINT_PAGES_RANGES,
PrintPages::Selection => ffi::GTK_PRINT_PAGES_SELECTION,
PrintPages::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkPrintPages> for PrintPages {
fn from_glib(value: ffi::GtkPrintPages) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_PRINT_PAGES_ALL => PrintPages::All,
ffi::GTK_PRINT_PAGES_CURRENT => PrintPages::Current,
ffi::GTK_PRINT_PAGES_RANGES => PrintPages::Ranges,
ffi::GTK_PRINT_PAGES_SELECTION => PrintPages::Selection,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum PrintQuality {
Low,
Normal,
High,
Draft,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for PrintQuality {
type GlibType = ffi::GtkPrintQuality;
fn to_glib(&self) -> ffi::GtkPrintQuality {
match *self {
PrintQuality::Low => ffi::GTK_PRINT_QUALITY_LOW,
PrintQuality::Normal => ffi::GTK_PRINT_QUALITY_NORMAL,
PrintQuality::High => ffi::GTK_PRINT_QUALITY_HIGH,
PrintQuality::Draft => ffi::GTK_PRINT_QUALITY_DRAFT,
PrintQuality::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkPrintQuality> for PrintQuality {
fn from_glib(value: ffi::GtkPrintQuality) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_PRINT_QUALITY_LOW => PrintQuality::Low,
ffi::GTK_PRINT_QUALITY_NORMAL => PrintQuality::Normal,
ffi::GTK_PRINT_QUALITY_HIGH => PrintQuality::High,
ffi::GTK_PRINT_QUALITY_DRAFT => PrintQuality::Draft,
}
}
}
#[cfg(feature = "v3_14")]
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum PropagationPhase {
None,
Capture,
Bubble,
Target,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[cfg(feature = "v3_14")]
#[doc(hidden)]
impl ToGlib for PropagationPhase {
type GlibType = ffi::GtkPropagationPhase;
fn to_glib(&self) -> ffi::GtkPropagationPhase {
match *self {
PropagationPhase::None => ffi::GTK_PHASE_NONE,
PropagationPhase::Capture => ffi::GTK_PHASE_CAPTURE,
PropagationPhase::Bubble => ffi::GTK_PHASE_BUBBLE,
PropagationPhase::Target => ffi::GTK_PHASE_TARGET,
PropagationPhase::__Nonexhaustive(_) => panic!(),
}
}
}
#[cfg(feature = "v3_14")]
#[doc(hidden)]
impl FromGlib<ffi::GtkPropagationPhase> for PropagationPhase {
fn from_glib(value: ffi::GtkPropagationPhase) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_PHASE_NONE => PropagationPhase::None,
ffi::GTK_PHASE_CAPTURE => PropagationPhase::Capture,
ffi::GTK_PHASE_BUBBLE => PropagationPhase::Bubble,
ffi::GTK_PHASE_TARGET => PropagationPhase::Target,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum RecentChooserError {
NotFound,
InvalidUri,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for RecentChooserError {
type GlibType = ffi::GtkRecentChooserError;
fn to_glib(&self) -> ffi::GtkRecentChooserError {
match *self {
RecentChooserError::NotFound => ffi::GTK_RECENT_CHOOSER_ERROR_NOT_FOUND,
RecentChooserError::InvalidUri => ffi::GTK_RECENT_CHOOSER_ERROR_INVALID_URI,
RecentChooserError::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkRecentChooserError> for RecentChooserError {
fn from_glib(value: ffi::GtkRecentChooserError) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_RECENT_CHOOSER_ERROR_NOT_FOUND => RecentChooserError::NotFound,
ffi::GTK_RECENT_CHOOSER_ERROR_INVALID_URI => RecentChooserError::InvalidUri,
}
}
}
impl ErrorDomain for RecentChooserError {
fn domain() -> glib_ffi::GQuark {
skip_assert_initialized!();
unsafe { ffi::gtk_recent_chooser_error_quark() }
}
fn code(self) -> i32 {
self.to_glib() as i32
}
fn from(code: i32) -> Option<Self> {
skip_assert_initialized!();
match code {
x if x == ffi::GTK_RECENT_CHOOSER_ERROR_NOT_FOUND as i32 => Some(RecentChooserError::NotFound),
x if x == ffi::GTK_RECENT_CHOOSER_ERROR_INVALID_URI as i32 => Some(RecentChooserError::InvalidUri),
_ => Some(RecentChooserError::__Nonexhaustive(())),
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum RecentManagerError {
NotFound,
InvalidUri,
InvalidEncoding,
NotRegistered,
Read,
Write,
Unknown,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for RecentManagerError {
type GlibType = ffi::GtkRecentManagerError;
fn to_glib(&self) -> ffi::GtkRecentManagerError {
match *self {
RecentManagerError::NotFound => ffi::GTK_RECENT_MANAGER_ERROR_NOT_FOUND,
RecentManagerError::InvalidUri => ffi::GTK_RECENT_MANAGER_ERROR_INVALID_URI,
RecentManagerError::InvalidEncoding => ffi::GTK_RECENT_MANAGER_ERROR_INVALID_ENCODING,
RecentManagerError::NotRegistered => ffi::GTK_RECENT_MANAGER_ERROR_NOT_REGISTERED,
RecentManagerError::Read => ffi::GTK_RECENT_MANAGER_ERROR_READ,
RecentManagerError::Write => ffi::GTK_RECENT_MANAGER_ERROR_WRITE,
RecentManagerError::Unknown => ffi::GTK_RECENT_MANAGER_ERROR_UNKNOWN,
RecentManagerError::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkRecentManagerError> for RecentManagerError {
fn from_glib(value: ffi::GtkRecentManagerError) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_RECENT_MANAGER_ERROR_NOT_FOUND => RecentManagerError::NotFound,
ffi::GTK_RECENT_MANAGER_ERROR_INVALID_URI => RecentManagerError::InvalidUri,
ffi::GTK_RECENT_MANAGER_ERROR_INVALID_ENCODING => RecentManagerError::InvalidEncoding,
ffi::GTK_RECENT_MANAGER_ERROR_NOT_REGISTERED => RecentManagerError::NotRegistered,
ffi::GTK_RECENT_MANAGER_ERROR_READ => RecentManagerError::Read,
ffi::GTK_RECENT_MANAGER_ERROR_WRITE => RecentManagerError::Write,
ffi::GTK_RECENT_MANAGER_ERROR_UNKNOWN => RecentManagerError::Unknown,
}
}
}
impl ErrorDomain for RecentManagerError {
fn domain() -> glib_ffi::GQuark {
skip_assert_initialized!();
unsafe { ffi::gtk_recent_manager_error_quark() }
}
fn code(self) -> i32 {
self.to_glib() as i32
}
fn from(code: i32) -> Option<Self> {
skip_assert_initialized!();
match code {
x if x == ffi::GTK_RECENT_MANAGER_ERROR_NOT_FOUND as i32 => Some(RecentManagerError::NotFound),
x if x == ffi::GTK_RECENT_MANAGER_ERROR_INVALID_URI as i32 => Some(RecentManagerError::InvalidUri),
x if x == ffi::GTK_RECENT_MANAGER_ERROR_INVALID_ENCODING as i32 => Some(RecentManagerError::InvalidEncoding),
x if x == ffi::GTK_RECENT_MANAGER_ERROR_NOT_REGISTERED as i32 => Some(RecentManagerError::NotRegistered),
x if x == ffi::GTK_RECENT_MANAGER_ERROR_READ as i32 => Some(RecentManagerError::Read),
x if x == ffi::GTK_RECENT_MANAGER_ERROR_WRITE as i32 => Some(RecentManagerError::Write),
x if x == ffi::GTK_RECENT_MANAGER_ERROR_UNKNOWN as i32 => Some(RecentManagerError::Unknown),
_ => Some(RecentManagerError::__Nonexhaustive(())),
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum RecentSortType {
None,
Mru,
Lru,
Custom,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for RecentSortType {
type GlibType = ffi::GtkRecentSortType;
fn to_glib(&self) -> ffi::GtkRecentSortType {
match *self {
RecentSortType::None => ffi::GTK_RECENT_SORT_NONE,
RecentSortType::Mru => ffi::GTK_RECENT_SORT_MRU,
RecentSortType::Lru => ffi::GTK_RECENT_SORT_LRU,
RecentSortType::Custom => ffi::GTK_RECENT_SORT_CUSTOM,
RecentSortType::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkRecentSortType> for RecentSortType {
fn from_glib(value: ffi::GtkRecentSortType) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_RECENT_SORT_NONE => RecentSortType::None,
ffi::GTK_RECENT_SORT_MRU => RecentSortType::Mru,
ffi::GTK_RECENT_SORT_LRU => RecentSortType::Lru,
ffi::GTK_RECENT_SORT_CUSTOM => RecentSortType::Custom,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum ReliefStyle {
Normal,
Half,
None,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for ReliefStyle {
type GlibType = ffi::GtkReliefStyle;
fn to_glib(&self) -> ffi::GtkReliefStyle {
match *self {
ReliefStyle::Normal => ffi::GTK_RELIEF_NORMAL,
ReliefStyle::Half => ffi::GTK_RELIEF_HALF,
ReliefStyle::None => ffi::GTK_RELIEF_NONE,
ReliefStyle::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkReliefStyle> for ReliefStyle {
fn from_glib(value: ffi::GtkReliefStyle) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_RELIEF_NORMAL => ReliefStyle::Normal,
ffi::GTK_RELIEF_HALF => ReliefStyle::Half,
ffi::GTK_RELIEF_NONE => ReliefStyle::None,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum ResizeMode {
Parent,
Queue,
Immediate,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for ResizeMode {
type GlibType = ffi::GtkResizeMode;
fn to_glib(&self) -> ffi::GtkResizeMode {
match *self {
ResizeMode::Parent => ffi::GTK_RESIZE_PARENT,
ResizeMode::Queue => ffi::GTK_RESIZE_QUEUE,
ResizeMode::Immediate => ffi::GTK_RESIZE_IMMEDIATE,
ResizeMode::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkResizeMode> for ResizeMode {
fn from_glib(value: ffi::GtkResizeMode) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_RESIZE_PARENT => ResizeMode::Parent,
ffi::GTK_RESIZE_QUEUE => ResizeMode::Queue,
ffi::GTK_RESIZE_IMMEDIATE => ResizeMode::Immediate,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum ResponseType {
None,
Reject,
Accept,
DeleteEvent,
Ok,
Cancel,
Close,
Yes,
No,
Apply,
Help,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for ResponseType {
type GlibType = ffi::GtkResponseType;
fn to_glib(&self) -> ffi::GtkResponseType {
match *self {
ResponseType::None => ffi::GTK_RESPONSE_NONE,
ResponseType::Reject => ffi::GTK_RESPONSE_REJECT,
ResponseType::Accept => ffi::GTK_RESPONSE_ACCEPT,
ResponseType::DeleteEvent => ffi::GTK_RESPONSE_DELETE_EVENT,
ResponseType::Ok => ffi::GTK_RESPONSE_OK,
ResponseType::Cancel => ffi::GTK_RESPONSE_CANCEL,
ResponseType::Close => ffi::GTK_RESPONSE_CLOSE,
ResponseType::Yes => ffi::GTK_RESPONSE_YES,
ResponseType::No => ffi::GTK_RESPONSE_NO,
ResponseType::Apply => ffi::GTK_RESPONSE_APPLY,
ResponseType::Help => ffi::GTK_RESPONSE_HELP,
ResponseType::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkResponseType> for ResponseType {
fn from_glib(value: ffi::GtkResponseType) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_RESPONSE_NONE => ResponseType::None,
ffi::GTK_RESPONSE_REJECT => ResponseType::Reject,
ffi::GTK_RESPONSE_ACCEPT => ResponseType::Accept,
ffi::GTK_RESPONSE_DELETE_EVENT => ResponseType::DeleteEvent,
ffi::GTK_RESPONSE_OK => ResponseType::Ok,
ffi::GTK_RESPONSE_CANCEL => ResponseType::Cancel,
ffi::GTK_RESPONSE_CLOSE => ResponseType::Close,
ffi::GTK_RESPONSE_YES => ResponseType::Yes,
ffi::GTK_RESPONSE_NO => ResponseType::No,
ffi::GTK_RESPONSE_APPLY => ResponseType::Apply,
ffi::GTK_RESPONSE_HELP => ResponseType::Help,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum RevealerTransitionType {
None,
Crossfade,
SlideRight,
SlideLeft,
SlideUp,
SlideDown,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for RevealerTransitionType {
type GlibType = ffi::GtkRevealerTransitionType;
fn to_glib(&self) -> ffi::GtkRevealerTransitionType {
match *self {
RevealerTransitionType::None => ffi::GTK_REVEALER_TRANSITION_TYPE_NONE,
RevealerTransitionType::Crossfade => ffi::GTK_REVEALER_TRANSITION_TYPE_CROSSFADE,
RevealerTransitionType::SlideRight => ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT,
RevealerTransitionType::SlideLeft => ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT,
RevealerTransitionType::SlideUp => ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP,
RevealerTransitionType::SlideDown => ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN,
RevealerTransitionType::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkRevealerTransitionType> for RevealerTransitionType {
fn from_glib(value: ffi::GtkRevealerTransitionType) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_REVEALER_TRANSITION_TYPE_NONE => RevealerTransitionType::None,
ffi::GTK_REVEALER_TRANSITION_TYPE_CROSSFADE => RevealerTransitionType::Crossfade,
ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT => RevealerTransitionType::SlideRight,
ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT => RevealerTransitionType::SlideLeft,
ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP => RevealerTransitionType::SlideUp,
ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN => RevealerTransitionType::SlideDown,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum ScrollStep {
Steps,
Pages,
Ends,
HorizontalSteps,
HorizontalPages,
HorizontalEnds,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for ScrollStep {
type GlibType = ffi::GtkScrollStep;
fn to_glib(&self) -> ffi::GtkScrollStep {
match *self {
ScrollStep::Steps => ffi::GTK_SCROLL_STEPS,
ScrollStep::Pages => ffi::GTK_SCROLL_PAGES,
ScrollStep::Ends => ffi::GTK_SCROLL_ENDS,
ScrollStep::HorizontalSteps => ffi::GTK_SCROLL_HORIZONTAL_STEPS,
ScrollStep::HorizontalPages => ffi::GTK_SCROLL_HORIZONTAL_PAGES,
ScrollStep::HorizontalEnds => ffi::GTK_SCROLL_HORIZONTAL_ENDS,
ScrollStep::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkScrollStep> for ScrollStep {
fn from_glib(value: ffi::GtkScrollStep) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_SCROLL_STEPS => ScrollStep::Steps,
ffi::GTK_SCROLL_PAGES => ScrollStep::Pages,
ffi::GTK_SCROLL_ENDS => ScrollStep::Ends,
ffi::GTK_SCROLL_HORIZONTAL_STEPS => ScrollStep::HorizontalSteps,
ffi::GTK_SCROLL_HORIZONTAL_PAGES => ScrollStep::HorizontalPages,
ffi::GTK_SCROLL_HORIZONTAL_ENDS => ScrollStep::HorizontalEnds,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum ScrollType {
None,
Jump,
StepBackward,
StepForward,
PageBackward,
PageForward,
StepUp,
StepDown,
PageUp,
PageDown,
StepLeft,
StepRight,
PageLeft,
PageRight,
Start,
End,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for ScrollType {
type GlibType = ffi::GtkScrollType;
fn to_glib(&self) -> ffi::GtkScrollType {
match *self {
ScrollType::None => ffi::GTK_SCROLL_NONE,
ScrollType::Jump => ffi::GTK_SCROLL_JUMP,
ScrollType::StepBackward => ffi::GTK_SCROLL_STEP_BACKWARD,
ScrollType::StepForward => ffi::GTK_SCROLL_STEP_FORWARD,
ScrollType::PageBackward => ffi::GTK_SCROLL_PAGE_BACKWARD,
ScrollType::PageForward => ffi::GTK_SCROLL_PAGE_FORWARD,
ScrollType::StepUp => ffi::GTK_SCROLL_STEP_UP,
ScrollType::StepDown => ffi::GTK_SCROLL_STEP_DOWN,
ScrollType::PageUp => ffi::GTK_SCROLL_PAGE_UP,
ScrollType::PageDown => ffi::GTK_SCROLL_PAGE_DOWN,
ScrollType::StepLeft => ffi::GTK_SCROLL_STEP_LEFT,
ScrollType::StepRight => ffi::GTK_SCROLL_STEP_RIGHT,
ScrollType::PageLeft => ffi::GTK_SCROLL_PAGE_LEFT,
ScrollType::PageRight => ffi::GTK_SCROLL_PAGE_RIGHT,
ScrollType::Start => ffi::GTK_SCROLL_START,
ScrollType::End => ffi::GTK_SCROLL_END,
ScrollType::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkScrollType> for ScrollType {
fn from_glib(value: ffi::GtkScrollType) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_SCROLL_NONE => ScrollType::None,
ffi::GTK_SCROLL_JUMP => ScrollType::Jump,
ffi::GTK_SCROLL_STEP_BACKWARD => ScrollType::StepBackward,
ffi::GTK_SCROLL_STEP_FORWARD => ScrollType::StepForward,
ffi::GTK_SCROLL_PAGE_BACKWARD => ScrollType::PageBackward,
ffi::GTK_SCROLL_PAGE_FORWARD => ScrollType::PageForward,
ffi::GTK_SCROLL_STEP_UP => ScrollType::StepUp,
ffi::GTK_SCROLL_STEP_DOWN => ScrollType::StepDown,
ffi::GTK_SCROLL_PAGE_UP => ScrollType::PageUp,
ffi::GTK_SCROLL_PAGE_DOWN => ScrollType::PageDown,
ffi::GTK_SCROLL_STEP_LEFT => ScrollType::StepLeft,
ffi::GTK_SCROLL_STEP_RIGHT => ScrollType::StepRight,
ffi::GTK_SCROLL_PAGE_LEFT => ScrollType::PageLeft,
ffi::GTK_SCROLL_PAGE_RIGHT => ScrollType::PageRight,
ffi::GTK_SCROLL_START => ScrollType::Start,
ffi::GTK_SCROLL_END => ScrollType::End,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum ScrollablePolicy {
Minimum,
Natural,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for ScrollablePolicy {
type GlibType = ffi::GtkScrollablePolicy;
fn to_glib(&self) -> ffi::GtkScrollablePolicy {
match *self {
ScrollablePolicy::Minimum => ffi::GTK_SCROLL_MINIMUM,
ScrollablePolicy::Natural => ffi::GTK_SCROLL_NATURAL,
ScrollablePolicy::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkScrollablePolicy> for ScrollablePolicy {
fn from_glib(value: ffi::GtkScrollablePolicy) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_SCROLL_MINIMUM => ScrollablePolicy::Minimum,
ffi::GTK_SCROLL_NATURAL => ScrollablePolicy::Natural,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum SelectionMode {
None,
Single,
Browse,
Multiple,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for SelectionMode {
type GlibType = ffi::GtkSelectionMode;
fn to_glib(&self) -> ffi::GtkSelectionMode {
match *self {
SelectionMode::None => ffi::GTK_SELECTION_NONE,
SelectionMode::Single => ffi::GTK_SELECTION_SINGLE,
SelectionMode::Browse => ffi::GTK_SELECTION_BROWSE,
SelectionMode::Multiple => ffi::GTK_SELECTION_MULTIPLE,
SelectionMode::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkSelectionMode> for SelectionMode {
fn from_glib(value: ffi::GtkSelectionMode) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_SELECTION_NONE => SelectionMode::None,
ffi::GTK_SELECTION_SINGLE => SelectionMode::Single,
ffi::GTK_SELECTION_BROWSE => SelectionMode::Browse,
ffi::GTK_SELECTION_MULTIPLE => SelectionMode::Multiple,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum SensitivityType {
Auto,
On,
Off,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for SensitivityType {
type GlibType = ffi::GtkSensitivityType;
fn to_glib(&self) -> ffi::GtkSensitivityType {
match *self {
SensitivityType::Auto => ffi::GTK_SENSITIVITY_AUTO,
SensitivityType::On => ffi::GTK_SENSITIVITY_ON,
SensitivityType::Off => ffi::GTK_SENSITIVITY_OFF,
SensitivityType::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkSensitivityType> for SensitivityType {
fn from_glib(value: ffi::GtkSensitivityType) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_SENSITIVITY_AUTO => SensitivityType::Auto,
ffi::GTK_SENSITIVITY_ON => SensitivityType::On,
ffi::GTK_SENSITIVITY_OFF => SensitivityType::Off,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum ShadowType {
None,
In,
Out,
EtchedIn,
EtchedOut,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for ShadowType {
type GlibType = ffi::GtkShadowType;
fn to_glib(&self) -> ffi::GtkShadowType {
match *self {
ShadowType::None => ffi::GTK_SHADOW_NONE,
ShadowType::In => ffi::GTK_SHADOW_IN,
ShadowType::Out => ffi::GTK_SHADOW_OUT,
ShadowType::EtchedIn => ffi::GTK_SHADOW_ETCHED_IN,
ShadowType::EtchedOut => ffi::GTK_SHADOW_ETCHED_OUT,
ShadowType::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkShadowType> for ShadowType {
fn from_glib(value: ffi::GtkShadowType) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_SHADOW_NONE => ShadowType::None,
ffi::GTK_SHADOW_IN => ShadowType::In,
ffi::GTK_SHADOW_OUT => ShadowType::Out,
ffi::GTK_SHADOW_ETCHED_IN => ShadowType::EtchedIn,
ffi::GTK_SHADOW_ETCHED_OUT => ShadowType::EtchedOut,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum SizeGroupMode {
None,
Horizontal,
Vertical,
Both,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for SizeGroupMode {
type GlibType = ffi::GtkSizeGroupMode;
fn to_glib(&self) -> ffi::GtkSizeGroupMode {
match *self {
SizeGroupMode::None => ffi::GTK_SIZE_GROUP_NONE,
SizeGroupMode::Horizontal => ffi::GTK_SIZE_GROUP_HORIZONTAL,
SizeGroupMode::Vertical => ffi::GTK_SIZE_GROUP_VERTICAL,
SizeGroupMode::Both => ffi::GTK_SIZE_GROUP_BOTH,
SizeGroupMode::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkSizeGroupMode> for SizeGroupMode {
fn from_glib(value: ffi::GtkSizeGroupMode) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_SIZE_GROUP_NONE => SizeGroupMode::None,
ffi::GTK_SIZE_GROUP_HORIZONTAL => SizeGroupMode::Horizontal,
ffi::GTK_SIZE_GROUP_VERTICAL => SizeGroupMode::Vertical,
ffi::GTK_SIZE_GROUP_BOTH => SizeGroupMode::Both,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum SizeRequestMode {
HeightForWidth,
WidthForHeight,
ConstantSize,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for SizeRequestMode {
type GlibType = ffi::GtkSizeRequestMode;
fn to_glib(&self) -> ffi::GtkSizeRequestMode {
match *self {
SizeRequestMode::HeightForWidth => ffi::GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH,
SizeRequestMode::WidthForHeight => ffi::GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT,
SizeRequestMode::ConstantSize => ffi::GTK_SIZE_REQUEST_CONSTANT_SIZE,
SizeRequestMode::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkSizeRequestMode> for SizeRequestMode {
fn from_glib(value: ffi::GtkSizeRequestMode) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH => SizeRequestMode::HeightForWidth,
ffi::GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT => SizeRequestMode::WidthForHeight,
ffi::GTK_SIZE_REQUEST_CONSTANT_SIZE => SizeRequestMode::ConstantSize,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum SortType {
Ascending,
Descending,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for SortType {
type GlibType = ffi::GtkSortType;
fn to_glib(&self) -> ffi::GtkSortType {
match *self {
SortType::Ascending => ffi::GTK_SORT_ASCENDING,
SortType::Descending => ffi::GTK_SORT_DESCENDING,
SortType::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkSortType> for SortType {
fn from_glib(value: ffi::GtkSortType) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_SORT_ASCENDING => SortType::Ascending,
ffi::GTK_SORT_DESCENDING => SortType::Descending,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum SpinButtonUpdatePolicy {
Always,
IfValid,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for SpinButtonUpdatePolicy {
type GlibType = ffi::GtkSpinButtonUpdatePolicy;
fn to_glib(&self) -> ffi::GtkSpinButtonUpdatePolicy {
match *self {
SpinButtonUpdatePolicy::Always => ffi::GTK_UPDATE_ALWAYS,
SpinButtonUpdatePolicy::IfValid => ffi::GTK_UPDATE_IF_VALID,
SpinButtonUpdatePolicy::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkSpinButtonUpdatePolicy> for SpinButtonUpdatePolicy {
fn from_glib(value: ffi::GtkSpinButtonUpdatePolicy) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_UPDATE_ALWAYS => SpinButtonUpdatePolicy::Always,
ffi::GTK_UPDATE_IF_VALID => SpinButtonUpdatePolicy::IfValid,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum SpinType {
StepForward,
StepBackward,
PageForward,
PageBackward,
Home,
End,
UserDefined,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for SpinType {
type GlibType = ffi::GtkSpinType;
fn to_glib(&self) -> ffi::GtkSpinType {
match *self {
SpinType::StepForward => ffi::GTK_SPIN_STEP_FORWARD,
SpinType::StepBackward => ffi::GTK_SPIN_STEP_BACKWARD,
SpinType::PageForward => ffi::GTK_SPIN_PAGE_FORWARD,
SpinType::PageBackward => ffi::GTK_SPIN_PAGE_BACKWARD,
SpinType::Home => ffi::GTK_SPIN_HOME,
SpinType::End => ffi::GTK_SPIN_END,
SpinType::UserDefined => ffi::GTK_SPIN_USER_DEFINED,
SpinType::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkSpinType> for SpinType {
fn from_glib(value: ffi::GtkSpinType) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_SPIN_STEP_FORWARD => SpinType::StepForward,
ffi::GTK_SPIN_STEP_BACKWARD => SpinType::StepBackward,
ffi::GTK_SPIN_PAGE_FORWARD => SpinType::PageForward,
ffi::GTK_SPIN_PAGE_BACKWARD => SpinType::PageBackward,
ffi::GTK_SPIN_HOME => SpinType::Home,
ffi::GTK_SPIN_END => SpinType::End,
ffi::GTK_SPIN_USER_DEFINED => SpinType::UserDefined,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum StackTransitionType {
None,
Crossfade,
SlideRight,
SlideLeft,
SlideUp,
SlideDown,
SlideLeftRight,
SlideUpDown,
OverUp,
OverDown,
OverLeft,
OverRight,
UnderUp,
UnderDown,
UnderLeft,
UnderRight,
OverUpDown,
OverDownUp,
OverLeftRight,
OverRightLeft,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for StackTransitionType {
type GlibType = ffi::GtkStackTransitionType;
fn to_glib(&self) -> ffi::GtkStackTransitionType {
match *self {
StackTransitionType::None => ffi::GTK_STACK_TRANSITION_TYPE_NONE,
StackTransitionType::Crossfade => ffi::GTK_STACK_TRANSITION_TYPE_CROSSFADE,
StackTransitionType::SlideRight => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT,
StackTransitionType::SlideLeft => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT,
StackTransitionType::SlideUp => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_UP,
StackTransitionType::SlideDown => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN,
StackTransitionType::SlideLeftRight => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT,
StackTransitionType::SlideUpDown => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN,
StackTransitionType::OverUp => ffi::GTK_STACK_TRANSITION_TYPE_OVER_UP,
StackTransitionType::OverDown => ffi::GTK_STACK_TRANSITION_TYPE_OVER_DOWN,
StackTransitionType::OverLeft => ffi::GTK_STACK_TRANSITION_TYPE_OVER_LEFT,
StackTransitionType::OverRight => ffi::GTK_STACK_TRANSITION_TYPE_OVER_RIGHT,
StackTransitionType::UnderUp => ffi::GTK_STACK_TRANSITION_TYPE_UNDER_UP,
StackTransitionType::UnderDown => ffi::GTK_STACK_TRANSITION_TYPE_UNDER_DOWN,
StackTransitionType::UnderLeft => ffi::GTK_STACK_TRANSITION_TYPE_UNDER_LEFT,
StackTransitionType::UnderRight => ffi::GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT,
StackTransitionType::OverUpDown => ffi::GTK_STACK_TRANSITION_TYPE_OVER_UP_DOWN,
StackTransitionType::OverDownUp => ffi::GTK_STACK_TRANSITION_TYPE_OVER_DOWN_UP,
StackTransitionType::OverLeftRight => ffi::GTK_STACK_TRANSITION_TYPE_OVER_LEFT_RIGHT,
StackTransitionType::OverRightLeft => ffi::GTK_STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT,
StackTransitionType::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkStackTransitionType> for StackTransitionType {
fn from_glib(value: ffi::GtkStackTransitionType) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_STACK_TRANSITION_TYPE_NONE => StackTransitionType::None,
ffi::GTK_STACK_TRANSITION_TYPE_CROSSFADE => StackTransitionType::Crossfade,
ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT => StackTransitionType::SlideRight,
ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT => StackTransitionType::SlideLeft,
ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_UP => StackTransitionType::SlideUp,
ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN => StackTransitionType::SlideDown,
ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT => StackTransitionType::SlideLeftRight,
ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN => StackTransitionType::SlideUpDown,
ffi::GTK_STACK_TRANSITION_TYPE_OVER_UP => StackTransitionType::OverUp,
ffi::GTK_STACK_TRANSITION_TYPE_OVER_DOWN => StackTransitionType::OverDown,
ffi::GTK_STACK_TRANSITION_TYPE_OVER_LEFT => StackTransitionType::OverLeft,
ffi::GTK_STACK_TRANSITION_TYPE_OVER_RIGHT => StackTransitionType::OverRight,
ffi::GTK_STACK_TRANSITION_TYPE_UNDER_UP => StackTransitionType::UnderUp,
ffi::GTK_STACK_TRANSITION_TYPE_UNDER_DOWN => StackTransitionType::UnderDown,
ffi::GTK_STACK_TRANSITION_TYPE_UNDER_LEFT => StackTransitionType::UnderLeft,
ffi::GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT => StackTransitionType::UnderRight,
ffi::GTK_STACK_TRANSITION_TYPE_OVER_UP_DOWN => StackTransitionType::OverUpDown,
ffi::GTK_STACK_TRANSITION_TYPE_OVER_DOWN_UP => StackTransitionType::OverDownUp,
ffi::GTK_STACK_TRANSITION_TYPE_OVER_LEFT_RIGHT => StackTransitionType::OverLeftRight,
ffi::GTK_STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT => StackTransitionType::OverRightLeft,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum StateType {
Normal,
Active,
Prelight,
Selected,
Insensitive,
Inconsistent,
Focused,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for StateType {
type GlibType = ffi::GtkStateType;
fn to_glib(&self) -> ffi::GtkStateType {
match *self {
StateType::Normal => ffi::GTK_STATE_NORMAL,
StateType::Active => ffi::GTK_STATE_ACTIVE,
StateType::Prelight => ffi::GTK_STATE_PRELIGHT,
StateType::Selected => ffi::GTK_STATE_SELECTED,
StateType::Insensitive => ffi::GTK_STATE_INSENSITIVE,
StateType::Inconsistent => ffi::GTK_STATE_INCONSISTENT,
StateType::Focused => ffi::GTK_STATE_FOCUSED,
StateType::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkStateType> for StateType {
fn from_glib(value: ffi::GtkStateType) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_STATE_NORMAL => StateType::Normal,
ffi::GTK_STATE_ACTIVE => StateType::Active,
ffi::GTK_STATE_PRELIGHT => StateType::Prelight,
ffi::GTK_STATE_SELECTED => StateType::Selected,
ffi::GTK_STATE_INSENSITIVE => StateType::Insensitive,
ffi::GTK_STATE_INCONSISTENT => StateType::Inconsistent,
ffi::GTK_STATE_FOCUSED => StateType::Focused,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum TextDirection {
None,
Ltr,
Rtl,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for TextDirection {
type GlibType = ffi::GtkTextDirection;
fn to_glib(&self) -> ffi::GtkTextDirection {
match *self {
TextDirection::None => ffi::GTK_TEXT_DIR_NONE,
TextDirection::Ltr => ffi::GTK_TEXT_DIR_LTR,
TextDirection::Rtl => ffi::GTK_TEXT_DIR_RTL,
TextDirection::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkTextDirection> for TextDirection {
fn from_glib(value: ffi::GtkTextDirection) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_TEXT_DIR_NONE => TextDirection::None,
ffi::GTK_TEXT_DIR_LTR => TextDirection::Ltr,
ffi::GTK_TEXT_DIR_RTL => TextDirection::Rtl,
}
}
}
#[cfg(feature = "v3_16")]
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum TextExtendSelection {
Word,
Line,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[cfg(feature = "v3_16")]
#[doc(hidden)]
impl ToGlib for TextExtendSelection {
type GlibType = ffi::GtkTextExtendSelection;
fn to_glib(&self) -> ffi::GtkTextExtendSelection {
match *self {
TextExtendSelection::Word => ffi::GTK_TEXT_EXTEND_SELECTION_WORD,
TextExtendSelection::Line => ffi::GTK_TEXT_EXTEND_SELECTION_LINE,
TextExtendSelection::__Nonexhaustive(_) => panic!(),
}
}
}
#[cfg(feature = "v3_16")]
#[doc(hidden)]
impl FromGlib<ffi::GtkTextExtendSelection> for TextExtendSelection {
fn from_glib(value: ffi::GtkTextExtendSelection) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_TEXT_EXTEND_SELECTION_WORD => TextExtendSelection::Word,
ffi::GTK_TEXT_EXTEND_SELECTION_LINE => TextExtendSelection::Line,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum TextWindowType {
Private,
Widget,
Text,
Left,
Right,
Top,
Bottom,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for TextWindowType {
type GlibType = ffi::GtkTextWindowType;
fn to_glib(&self) -> ffi::GtkTextWindowType {
match *self {
TextWindowType::Private => ffi::GTK_TEXT_WINDOW_PRIVATE,
TextWindowType::Widget => ffi::GTK_TEXT_WINDOW_WIDGET,
TextWindowType::Text => ffi::GTK_TEXT_WINDOW_TEXT,
TextWindowType::Left => ffi::GTK_TEXT_WINDOW_LEFT,
TextWindowType::Right => ffi::GTK_TEXT_WINDOW_RIGHT,
TextWindowType::Top => ffi::GTK_TEXT_WINDOW_TOP,
TextWindowType::Bottom => ffi::GTK_TEXT_WINDOW_BOTTOM,
TextWindowType::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkTextWindowType> for TextWindowType {
fn from_glib(value: ffi::GtkTextWindowType) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_TEXT_WINDOW_PRIVATE => TextWindowType::Private,
ffi::GTK_TEXT_WINDOW_WIDGET => TextWindowType::Widget,
ffi::GTK_TEXT_WINDOW_TEXT => TextWindowType::Text,
ffi::GTK_TEXT_WINDOW_LEFT => TextWindowType::Left,
ffi::GTK_TEXT_WINDOW_RIGHT => TextWindowType::Right,
ffi::GTK_TEXT_WINDOW_TOP => TextWindowType::Top,
ffi::GTK_TEXT_WINDOW_BOTTOM => TextWindowType::Bottom,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum ToolbarStyle {
Icons,
Text,
Both,
BothHoriz,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for ToolbarStyle {
type GlibType = ffi::GtkToolbarStyle;
fn to_glib(&self) -> ffi::GtkToolbarStyle {
match *self {
ToolbarStyle::Icons => ffi::GTK_TOOLBAR_ICONS,
ToolbarStyle::Text => ffi::GTK_TOOLBAR_TEXT,
ToolbarStyle::Both => ffi::GTK_TOOLBAR_BOTH,
ToolbarStyle::BothHoriz => ffi::GTK_TOOLBAR_BOTH_HORIZ,
ToolbarStyle::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkToolbarStyle> for ToolbarStyle {
fn from_glib(value: ffi::GtkToolbarStyle) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_TOOLBAR_ICONS => ToolbarStyle::Icons,
ffi::GTK_TOOLBAR_TEXT => ToolbarStyle::Text,
ffi::GTK_TOOLBAR_BOTH => ToolbarStyle::Both,
ffi::GTK_TOOLBAR_BOTH_HORIZ => ToolbarStyle::BothHoriz,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum TreeViewColumnSizing {
GrowOnly,
Autosize,
Fixed,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for TreeViewColumnSizing {
type GlibType = ffi::GtkTreeViewColumnSizing;
fn to_glib(&self) -> ffi::GtkTreeViewColumnSizing {
match *self {
TreeViewColumnSizing::GrowOnly => ffi::GTK_TREE_VIEW_COLUMN_GROW_ONLY,
TreeViewColumnSizing::Autosize => ffi::GTK_TREE_VIEW_COLUMN_AUTOSIZE,
TreeViewColumnSizing::Fixed => ffi::GTK_TREE_VIEW_COLUMN_FIXED,
TreeViewColumnSizing::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkTreeViewColumnSizing> for TreeViewColumnSizing {
fn from_glib(value: ffi::GtkTreeViewColumnSizing) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_TREE_VIEW_COLUMN_GROW_ONLY => TreeViewColumnSizing::GrowOnly,
ffi::GTK_TREE_VIEW_COLUMN_AUTOSIZE => TreeViewColumnSizing::Autosize,
ffi::GTK_TREE_VIEW_COLUMN_FIXED => TreeViewColumnSizing::Fixed,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum TreeViewDropPosition {
Before,
After,
IntoOrBefore,
IntoOrAfter,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for TreeViewDropPosition {
type GlibType = ffi::GtkTreeViewDropPosition;
fn to_glib(&self) -> ffi::GtkTreeViewDropPosition {
match *self {
TreeViewDropPosition::Before => ffi::GTK_TREE_VIEW_DROP_BEFORE,
TreeViewDropPosition::After => ffi::GTK_TREE_VIEW_DROP_AFTER,
TreeViewDropPosition::IntoOrBefore => ffi::GTK_TREE_VIEW_DROP_INTO_OR_BEFORE,
TreeViewDropPosition::IntoOrAfter => ffi::GTK_TREE_VIEW_DROP_INTO_OR_AFTER,
TreeViewDropPosition::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkTreeViewDropPosition> for TreeViewDropPosition {
fn from_glib(value: ffi::GtkTreeViewDropPosition) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_TREE_VIEW_DROP_BEFORE => TreeViewDropPosition::Before,
ffi::GTK_TREE_VIEW_DROP_AFTER => TreeViewDropPosition::After,
ffi::GTK_TREE_VIEW_DROP_INTO_OR_BEFORE => TreeViewDropPosition::IntoOrBefore,
ffi::GTK_TREE_VIEW_DROP_INTO_OR_AFTER => TreeViewDropPosition::IntoOrAfter,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum TreeViewGridLines {
None,
Horizontal,
Vertical,
Both,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for TreeViewGridLines {
type GlibType = ffi::GtkTreeViewGridLines;
fn to_glib(&self) -> ffi::GtkTreeViewGridLines {
match *self {
TreeViewGridLines::None => ffi::GTK_TREE_VIEW_GRID_LINES_NONE,
TreeViewGridLines::Horizontal => ffi::GTK_TREE_VIEW_GRID_LINES_HORIZONTAL,
TreeViewGridLines::Vertical => ffi::GTK_TREE_VIEW_GRID_LINES_VERTICAL,
TreeViewGridLines::Both => ffi::GTK_TREE_VIEW_GRID_LINES_BOTH,
TreeViewGridLines::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkTreeViewGridLines> for TreeViewGridLines {
fn from_glib(value: ffi::GtkTreeViewGridLines) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_TREE_VIEW_GRID_LINES_NONE => TreeViewGridLines::None,
ffi::GTK_TREE_VIEW_GRID_LINES_HORIZONTAL => TreeViewGridLines::Horizontal,
ffi::GTK_TREE_VIEW_GRID_LINES_VERTICAL => TreeViewGridLines::Vertical,
ffi::GTK_TREE_VIEW_GRID_LINES_BOTH => TreeViewGridLines::Both,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum Unit {
None,
Points,
Inch,
Mm,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for Unit {
type GlibType = ffi::GtkUnit;
fn to_glib(&self) -> ffi::GtkUnit {
match *self {
Unit::None => ffi::GTK_UNIT_NONE,
Unit::Points => ffi::GTK_UNIT_POINTS,
Unit::Inch => ffi::GTK_UNIT_INCH,
Unit::Mm => ffi::GTK_UNIT_MM,
Unit::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkUnit> for Unit {
fn from_glib(value: ffi::GtkUnit) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_UNIT_NONE => Unit::None,
ffi::GTK_UNIT_POINTS => Unit::Points,
ffi::GTK_UNIT_INCH => Unit::Inch,
ffi::GTK_UNIT_MM => Unit::Mm,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum WidgetHelpType {
Tooltip,
WhatsThis,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for WidgetHelpType {
type GlibType = ffi::GtkWidgetHelpType;
fn to_glib(&self) -> ffi::GtkWidgetHelpType {
match *self {
WidgetHelpType::Tooltip => ffi::GTK_WIDGET_HELP_TOOLTIP,
WidgetHelpType::WhatsThis => ffi::GTK_WIDGET_HELP_WHATS_THIS,
WidgetHelpType::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkWidgetHelpType> for WidgetHelpType {
fn from_glib(value: ffi::GtkWidgetHelpType) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_WIDGET_HELP_TOOLTIP => WidgetHelpType::Tooltip,
ffi::GTK_WIDGET_HELP_WHATS_THIS => WidgetHelpType::WhatsThis,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum WindowPosition {
None,
Center,
Mouse,
CenterAlways,
CenterOnParent,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for WindowPosition {
type GlibType = ffi::GtkWindowPosition;
fn to_glib(&self) -> ffi::GtkWindowPosition {
match *self {
WindowPosition::None => ffi::GTK_WIN_POS_NONE,
WindowPosition::Center => ffi::GTK_WIN_POS_CENTER,
WindowPosition::Mouse => ffi::GTK_WIN_POS_MOUSE,
WindowPosition::CenterAlways => ffi::GTK_WIN_POS_CENTER_ALWAYS,
WindowPosition::CenterOnParent => ffi::GTK_WIN_POS_CENTER_ON_PARENT,
WindowPosition::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkWindowPosition> for WindowPosition {
fn from_glib(value: ffi::GtkWindowPosition) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_WIN_POS_NONE => WindowPosition::None,
ffi::GTK_WIN_POS_CENTER => WindowPosition::Center,
ffi::GTK_WIN_POS_MOUSE => WindowPosition::Mouse,
ffi::GTK_WIN_POS_CENTER_ALWAYS => WindowPosition::CenterAlways,
ffi::GTK_WIN_POS_CENTER_ON_PARENT => WindowPosition::CenterOnParent,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum WindowType {
Toplevel,
Popup,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for WindowType {
type GlibType = ffi::GtkWindowType;
fn to_glib(&self) -> ffi::GtkWindowType {
match *self {
WindowType::Toplevel => ffi::GTK_WINDOW_TOPLEVEL,
WindowType::Popup => ffi::GTK_WINDOW_POPUP,
WindowType::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkWindowType> for WindowType {
fn from_glib(value: ffi::GtkWindowType) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_WINDOW_TOPLEVEL => WindowType::Toplevel,
ffi::GTK_WINDOW_POPUP => WindowType::Popup,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum WrapMode {
None,
Char,
Word,
WordChar,
#[doc(hidden)]
__Nonexhaustive(()),
}
#[doc(hidden)]
impl ToGlib for WrapMode {
type GlibType = ffi::GtkWrapMode;
fn to_glib(&self) -> ffi::GtkWrapMode {
match *self {
WrapMode::None => ffi::GTK_WRAP_NONE,
WrapMode::Char => ffi::GTK_WRAP_CHAR,
WrapMode::Word => ffi::GTK_WRAP_WORD,
WrapMode::WordChar => ffi::GTK_WRAP_WORD_CHAR,
WrapMode::__Nonexhaustive(_) => panic!(),
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::GtkWrapMode> for WrapMode {
fn from_glib(value: ffi::GtkWrapMode) -> Self {
skip_assert_initialized!();
match value {
ffi::GTK_WRAP_NONE => WrapMode::None,
ffi::GTK_WRAP_CHAR => WrapMode::Char,
ffi::GTK_WRAP_WORD => WrapMode::Word,
ffi::GTK_WRAP_WORD_CHAR => WrapMode::WordChar,
}
}
}