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.

impl WindowManagerFlags

pub const fn empty() -> Self

Get a flags value with all bits unset.

pub const fn all() -> Self

Get a flags value with all known bits set.

pub const fn bits(&self) -> u32

Get the underlying bits value.

The returned value is exactly the bits set in this flags value.

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

Convert from a bits value.

This method will return None if any unknown bits are set.

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

Convert from a bits value, unsetting any unknown bits.

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

Convert from a bits value exactly.

pub fn from_name(name: &str) -> Option<Self>

Get a flags value with the bits of a flag with the given name set.

This method will return None if name is empty or doesn’t correspond to any named flag.

pub const fn is_empty(&self) -> bool

Whether all bits in this flags value are unset.

pub const fn is_all(&self) -> bool

Whether all known bits in this flags value are set.

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

Whether any set bits in a source flags value are also set in a target flags value.

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

Whether all set bits in a source flags value are also set in a target flags value.

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

The bitwise or (|) of the bits in two flags values.

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

The intersection of a source flags value with the complement of a target flags value (&!).

This method is not equivalent to self & !other when other has unknown bits set. remove won’t truncate other, but the ! operator will.

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

The bitwise exclusive-or (^) of the bits in two flags values.

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

Call insert when value is true or remove when value is false.

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

The bitwise and (&) of the bits in two flags values.

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

The bitwise or (|) of the bits in two flags values.

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

The intersection of a source flags value with the complement of a target flags value (&!).

This method is not equivalent to self & !other when other has unknown bits set. difference won’t truncate other, but the ! operator will.

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

The bitwise exclusive-or (^) of the bits in two flags values.

pub const fn complement(self) -> Self

The bitwise negation (!) of the bits in a flags value, truncating the result.

impl WindowManagerFlags

pub const fn iter(&self) -> Iter<WindowManagerFlags>

Yield a set of contained flags values.

Each yielded flags value will correspond to a defined named flag. Any unknown bits will be yielded together as a final flags value.

pub const fn iter_names(&self) -> IterNames<WindowManagerFlags>

Yield a set of contained named flags values.

This method is like iter, except only yields bits in contained named flags. Any unknown bits, or bits not corresponding to a contained flag will not be yielded.

Trait Implementations

impl Binary for WindowManagerFlags

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

Formats the value using the given formatter.

impl BitAnd for WindowManagerFlags

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

The bitwise and (&) of the bits in two flags values.

type Output = WindowManagerFlags

The resulting type after applying the & operator.

impl BitAndAssign for WindowManagerFlags

fn bitand_assign(&mut self, other: Self)

The bitwise and (&) of the bits in two flags values.

impl BitOr for WindowManagerFlags

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

The bitwise or (|) of the bits in two flags values.

type Output = WindowManagerFlags

The resulting type after applying the | operator.

impl BitOrAssign for WindowManagerFlags

fn bitor_assign(&mut self, other: Self)

The bitwise or (|) of the bits in two flags values.

impl BitXor for WindowManagerFlags

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

The bitwise exclusive-or (^) of the bits in two flags values.

type Output = WindowManagerFlags

The resulting type after applying the ^ operator.

impl BitXorAssign for WindowManagerFlags

fn bitxor_assign(&mut self, other: Self)

The bitwise exclusive-or (^) of the bits in two flags values.

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)

The bitwise or (|) of the bits in each flags value.

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 Flags for WindowManagerFlags

const FLAGS: &'static [Flag<WindowManagerFlags>] = _

The set of defined flags.

type Bits = u32

The underlying bits type.

fn bits(&self) -> u32

Get the underlying bits value.

fn from_bits_retain(bits: u32) -> WindowManagerFlags

Convert from a bits value exactly.

fn empty() -> Self

Get a flags value with all bits unset.

fn all() -> Self

Get a flags value with all known bits set.

fn from_bits(bits: Self::Bits) -> Option<Self>

Convert from a bits value.

fn from_bits_truncate(bits: Self::Bits) -> Self

Convert from a bits value, unsetting any unknown bits.

fn from_name(name: &str) -> Option<Self>

Get a flags value with the bits of a flag with the given name set.

fn iter(&self) -> Iter<Self>

Yield a set of contained flags values.

fn iter_names(&self) -> IterNames<Self>

Yield a set of contained named flags values.

fn is_empty(&self) -> bool

Whether all bits in this flags value are unset.

fn is_all(&self) -> bool

Whether all known bits in this flags value are set.

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

where Self: Sized,

Whether any set bits in a source flags value are also set in a target flags value.

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

where Self: Sized,

Whether all set bits in a source flags value are also set in a target flags value.

fn insert(&mut self, other: Self)

where Self: Sized,

The bitwise or (|) of the bits in two flags values.

fn remove(&mut self, other: Self)

where Self: Sized,

The intersection of a source flags value with the complement of a target flags value (&!).

fn toggle(&mut self, other: Self)

where Self: Sized,

The bitwise exclusive-or (^) of the bits in two flags values.

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

where Self: Sized,

Call Flags::insert when value is true or Flags::remove when value is false.

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

The bitwise and (&) of the bits in two flags values.

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

The bitwise or (|) of the bits in two flags values.

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

The intersection of a source flags value with the complement of a target flags value (&!).

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

The bitwise exclusive-or (^) of the bits in two flags values.

fn complement(self) -> Self

The bitwise negation (!) of the bits in a flags value, truncating the result.

impl FromIterator<WindowManagerFlags> for WindowManagerFlags

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

The bitwise or (|) of the bits in each flags value.

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 IntoIterator for WindowManagerFlags

type Item = WindowManagerFlags

The type of the elements being iterated over.

type IntoIter = Iter<WindowManagerFlags>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

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

The bitwise negation (!) of the bits in a flags value, truncating the result.

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 PartialEq 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 PublicFlags for WindowManagerFlags

type Primitive = u32

The type of the underlying storage.

type Internal = InternalBitFlags

The type of the internal field on the generated flags type.

impl Sub for WindowManagerFlags

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

The intersection of a source flags value with the complement of a target flags value (&!).

This method is not equivalent to self & !other when other has unknown bits set. difference won’t truncate other, but the ! operator will.

type Output = WindowManagerFlags

The resulting type after applying the - operator.

impl SubAssign for WindowManagerFlags

fn sub_assign(&mut self, other: Self)

The intersection of a source flags value with the complement of a target flags value (&!).

This method is not equivalent to self & !other when other has unknown bits set. difference won’t truncate other, but the ! operator will.

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 StructuralPartialEq for WindowManagerFlags