Struct android_activity::WindowManagerFlags

pub struct WindowManagerFlags { /* private fields */ }

Flags for AndroidApp::set_window_flags as per the android.view.WindowManager.LayoutParams Java API

Implementations

impl WindowManagerFlags

pub const ALLOW_LOCK_WHILE_SCREEN_ON: Self = _

As long as this window is visible to the user, allow the lock screen to activate while the screen is on. This can be used independently, or in combination with Self::KEEP_SCREEN_ON and/or Self::SHOW_WHEN_LOCKED

pub const DIM_BEHIND: Self = _

Everything behind this window will be dimmed. */

pub const BLUR_BEHIND: Self = _

👎Deprecated: Blurring is no longer supported

Blur everything behind this window.

pub const NOT_FOCUSABLE: Self = _

This window won’t ever get key input focus, so the user can not send key or other button events to it. Those will instead go to whatever focusable window is behind it. This flag will also enable Self::NOT_TOUCH_MODAL whether or not that is explicitly set.

Setting this flag also implies that the window will not need to interact with a soft input method, so it will be Z-ordered and positioned independently of any active input method (typically this means it gets Z-ordered on top of the input method, so it can use the full screen for its content and cover the input method if needed. You can use Self::ALT_FOCUSABLE_IM to modify this behavior.

pub const NOT_TOUCHABLE: Self = _

This window can never receive touch events.

pub const NOT_TOUCH_MODAL: Self = _

Even when this window is focusable (if Self::NOT_FOCUSABLE is not set), allow any pointer events outside of the window to be sent to the windows behind it. Otherwise it will consume all pointer events itself, regardless of whether they are inside of the window.

pub const TOUCHABLE_WHEN_WAKING: Self = _

👎Deprecated

When set, if the device is asleep when the touch screen is pressed, you will receive this first touch event. Usually the first touch event is consumed by the system since the user can not see what they are pressing on.

pub const KEEP_SCREEN_ON: Self = _

As long as this window is visible to the user, keep the device’s screen turned on and bright.

pub const LAYOUT_IN_SCREEN: Self = _

Place the window within the entire screen, ignoring decorations around the border (such as the status bar). The window must correctly position its contents to take the screen decoration into account.

pub const LAYOUT_NO_LIMITS: Self = _

Allows the window to extend outside of the screen.

pub const FULLSCREEN: Self = _

Hide all screen decorations (such as the status bar) while this window is displayed. This allows the window to use the entire display space for itself – the status bar will be hidden when an app window with this flag set is on the top layer. A fullscreen window will ignore a value of [Self::SOFT_INPUT_ADJUST_RESIZE] the window will stay fullscreen and will not resize.

pub const FORCE_NOT_FULLSCREEN: Self = _

Override Self::FULLSCREEN and force the screen decorations (such as the status bar) to be shown.

pub const DITHER: Self = _

👎Deprecated: This flag is no longer used

Turn on dithering when compositing this window to the screen.

pub const SECURE: Self = _

Treat the content of the window as secure, preventing it from appearing in screenshots or from being viewed on non-secure displays.

pub const SCALED: Self = _

A special mode where the layout parameters are used to perform scaling of the surface when it is composited to the screen.

pub const IGNORE_CHEEK_PRESSES: Self = _

Intended for windows that will often be used when the user is holding the screen against their face, it will aggressively filter the event stream to prevent unintended presses in this situation that may not be desired for a particular window, when such an event stream is detected, the application will receive a AMOTION_EVENT_ACTION_CANCEL to indicate this so applications can handle this accordingly by taking no action on the event until the finger is released.

pub const LAYOUT_INSET_DECOR: Self = _

A special option only for use in combination with Self::LAYOUT_IN_SCREEN. When requesting layout in the screen your window may appear on top of or behind screen decorations such as the status bar. By also including this flag, the window manager will report the inset rectangle needed to ensure your content is not covered by screen decorations.

pub const ALT_FOCUSABLE_IM: Self = _

Invert the state of Self::NOT_FOCUSABLE with respect to how this window interacts with the current method. That is, if Self::NOT_FOCUSABLE is set and this flag is set, then the window will behave as if it needs to interact with the input method and thus be placed behind/away from it; if Self::NOT_FOCUSABLE is not set and this flag is set, then the window will behave as if it doesn’t need to interact with the input method and can be placed to use more space and cover the input method.

pub const WATCH_OUTSIDE_TOUCH: Self = _

If you have set Self::NOT_TOUCH_MODAL, you can set this flag to receive a single special MotionEvent with the action AMOTION_EVENT_ACTION_OUTSIDE for touches that occur outside of your window. Note that you will not receive the full down/move/up gesture, only the location of the first down as an AMOTION_EVENT_ACTION_OUTSIDE.

pub const SHOW_WHEN_LOCKED: Self = _

Special flag to let windows be shown when the screen is locked. This will let application windows take precedence over key guard or any other lock screens. Can be used with Self::KEEP_SCREEN_ON to turn screen on and display windows directly before showing the key guard window. Can be used with Self::DISMISS_KEYGUARD to automatically fully dismiss non-secure key guards. This flag only applies to the top-most full-screen window.

pub const SHOW_WALLPAPER: Self = _

Ask that the system wallpaper be shown behind your window. The window surface must be translucent to be able to actually see the wallpaper behind it; this flag just ensures that the wallpaper surface will be there if this window actually has translucent regions.

pub const TURN_SCREEN_ON: Self = _

When set as a window is being added or made visible, once the window has been shown then the system will poke the power manager’s user activity (as if the user had woken up the device) to turn the screen on.

pub const DISMISS_KEYGUARD: Self = _

When set the window will cause the key guard to be dismissed, only if it is not a secure lock key guard. Because such a key guard is not needed for security, it will never re-appear if the user navigates to another window (in contrast to Self::SHOW_WHEN_LOCKED, which will only temporarily hide both secure and non-secure key guards but ensure they reappear when the user moves to another UI that doesn’t hide them). If the key guard is currently active and is secure (requires an unlock pattern) then the user will still need to confirm it before seeing this window, unless Self::SHOW_WHEN_LOCKED has also been set.

pub const fn empty() -> Self

Returns an empty set of flags.

pub const fn all() -> Self

Returns the set containing all flags.

pub const fn bits(&self) -> u32

Returns the raw value of the flags currently stored.

pub const fn from_bits(bits: u32) -> Option<Self>

Convert from underlying bit representation, unless that representation contains bits that do not correspond to a flag.

pub const fn from_bits_truncate(bits: u32) -> Self

Convert from underlying bit representation, dropping any bits that do not correspond to flags.

pub const unsafe fn from_bits_unchecked(bits: u32) -> Self

Convert from underlying bit representation, preserving all bits (even those not corresponding to a defined flag).

Safety

The caller of the bitflags! macro can chose to allow or disallow extra bits for their bitflags type.

The caller of from_bits_unchecked() has to ensure that all bits correspond to a defined flag or that extra bits are valid for this bitflags type.

pub const fn is_empty(&self) -> bool

Returns true if no flags are currently stored.

pub const fn is_all(&self) -> bool

Returns true if all flags are currently set.

pub const fn intersects(&self, other: Self) -> bool

Returns true if there are flags common to both self and other.

pub const fn contains(&self, other: Self) -> bool

Returns true if all of the flags in other are contained within self.

pub fn insert(&mut self, other: Self)

Inserts the specified flags in-place.

pub fn remove(&mut self, other: Self)

Removes the specified flags in-place.

pub fn toggle(&mut self, other: Self)

Toggles the specified flags in-place.

pub fn set(&mut self, other: Self, value: bool)

Inserts or removes the specified flags depending on the passed value.

pub const fn intersection(self, other: Self) -> Self

Returns the intersection between the flags in self and other.

Specifically, the returned set contains only the flags which are present in both self and other.

This is equivalent to using the & operator (e.g. ops::BitAnd), as in flags & other.

pub const fn union(self, other: Self) -> Self

Returns the union of between the flags in self and other.

Specifically, the returned set contains all flags which are present in either self or other, including any which are present in both (see Self::symmetric_difference if that is undesirable).

This is equivalent to using the | operator (e.g. ops::BitOr), as in flags | other.

pub const fn difference(self, other: Self) -> Self

Returns the difference between the flags in self and other.

Specifically, the returned set contains all flags present in self, except for the ones present in other.

It is also conceptually equivalent to the “bit-clear” operation: flags & !other (and this syntax is also supported).

This is equivalent to using the - operator (e.g. ops::Sub), as in flags - other.

pub const fn symmetric_difference(self, other: Self) -> Self

Returns the symmetric difference between the flags in self and other.

Specifically, the returned set contains the flags present which are present in self or other, but that are not present in both. Equivalently, it contains the flags present in exactly one of the sets self and other.

This is equivalent to using the ^ operator (e.g. ops::BitXor), as in flags ^ other.

pub const fn complement(self) -> Self

Returns the complement of this set of flags.

Specifically, the returned set contains all the flags which are not set in self, but which are allowed for this type.

Alternatively, it can be thought of as the set difference between Self::all() and self (e.g. Self::all() - self)

This is equivalent to using the ! operator (e.g. ops::Not), as in !flags.

Trait Implementations

impl Binary for WindowManagerFlags

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl BitAnd<WindowManagerFlags> for WindowManagerFlags

fn bitand(self, other: Self) -> Self

Returns the intersection between the two sets of flags.

type Output = WindowManagerFlags

The resulting type after applying the & operator.

impl BitAndAssign<WindowManagerFlags> for WindowManagerFlags

fn bitand_assign(&mut self, other: Self)

Disables all flags disabled in the set.

impl BitOr<WindowManagerFlags> for WindowManagerFlags

fn bitor(self, other: WindowManagerFlags) -> Self

Returns the union of the two sets of flags.

type Output = WindowManagerFlags

The resulting type after applying the | operator.

impl BitOrAssign<WindowManagerFlags> for WindowManagerFlags

fn bitor_assign(&mut self, other: Self)

Adds the set of flags.

impl BitXor<WindowManagerFlags> for WindowManagerFlags

fn bitxor(self, other: Self) -> Self

Returns the left flags, but with all the right flags toggled.

type Output = WindowManagerFlags

The resulting type after applying the ^ operator.

impl BitXorAssign<WindowManagerFlags> for WindowManagerFlags

fn bitxor_assign(&mut self, other: Self)

Toggles the set of flags.

impl Clone for WindowManagerFlags

fn clone(&self) -> WindowManagerFlags

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for WindowManagerFlags

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Extend<WindowManagerFlags> for WindowManagerFlags

fn extend<T: IntoIterator<Item = Self>>(&mut self, iterator: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl FromIterator<WindowManagerFlags> for WindowManagerFlags

fn from_iter<T: IntoIterator<Item = Self>>(iterator: T) -> Self

Creates a value from an iterator.

impl Hash for WindowManagerFlags

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl LowerHex for WindowManagerFlags

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Not for WindowManagerFlags

fn not(self) -> Self

Returns the complement of this set of flags.

type Output = WindowManagerFlags

The resulting type after applying the ! operator.

impl Octal for WindowManagerFlags

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Ord for WindowManagerFlags

fn cmp(&self, other: &WindowManagerFlags) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<WindowManagerFlags> for WindowManagerFlags

fn eq(&self, other: &WindowManagerFlags) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd<WindowManagerFlags> for WindowManagerFlags

fn partial_cmp(&self, other: &WindowManagerFlags) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Sub<WindowManagerFlags> for WindowManagerFlags

fn sub(self, other: Self) -> Self

Returns the set difference of the two sets of flags.

type Output = WindowManagerFlags

The resulting type after applying the - operator.

impl SubAssign<WindowManagerFlags> for WindowManagerFlags

fn sub_assign(&mut self, other: Self)

Disables all flags enabled in the set.

impl UpperHex for WindowManagerFlags

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Copy for WindowManagerFlags

impl Eq for WindowManagerFlags

impl StructuralEq for WindowManagerFlags

impl StructuralPartialEq for WindowManagerFlags