Qt Namespace
El espacio de nombres Qt contiene diversos identificadores que se utilizan en toda la biblioteca Qt. Más información...
| Encabezado: | #include <Qt> |
| CMake: | find_package(Qt6 REQUIRED COMPONENTS Core) target_link_libraries(mytarget PRIVATE Qt6::Core) |
| qmake: | QT += core |
Espacios de nombres
| namespace | Literals |
Clases
(since 6.12) struct | has_qt_compare_three_way |
(since 6.7) class | partial_ordering |
(since 6.7) class | strong_ordering |
(since 6.8) class | totally_ordered_wrapper |
(since 6.7) class | weak_ordering |
Tipos
| flags | Alignment |
| enum | AlignmentFlag { AlignLeft, AlignRight, AlignHCenter, AlignJustify, AlignTop, …, AlignVertical_Mask } |
| enum | AnchorPoint { AnchorLeft, AnchorHorizontalCenter, AnchorRight, AnchorTop, AnchorVerticalCenter, AnchorBottom } |
| enum | ApplicationAttribute { AA_QtQuickUseDefaultSizePolicy, AA_DontShowIconsInMenus, AA_DontShowShortcutsInContextMenus, AA_NativeWindows, AA_DontCreateNativeWidgetSiblings, …, AA_DontUseNativeMenuWindows } |
| enum | ApplicationState { ApplicationSuspended, ApplicationHidden, ApplicationInactive, ApplicationActive } |
| flags | ApplicationStates |
| enum | ArrowType { NoArrow, UpArrow, DownArrow, LeftArrow, RightArrow } |
| enum | AspectRatioMode { IgnoreAspectRatio, KeepAspectRatio, KeepAspectRatioByExpanding } |
| enum | Axis { XAxis, YAxis, ZAxis } |
| enum | BGMode { TransparentMode, OpaqueMode } |
| enum | BrushStyle { NoBrush, SolidPattern, Dense1Pattern, Dense2Pattern, Dense3Pattern, …, TexturePattern } |
| enum | CaseSensitivity { CaseInsensitive, CaseSensitive } |
| enum | CheckState { Unchecked, PartiallyChecked, Checked } |
| enum | ChecksumType { ChecksumIso3309, ChecksumItuV41 } |
| enum | ClipOperation { NoClip, ReplaceClip, IntersectClip } |
| enum class | ColorScheme { Unknown, Light, Dark } |
| enum | ConnectionType { AutoConnection, DirectConnection, QueuedConnection, BlockingQueuedConnection, UniqueConnection, SingleShotConnection } |
| enum | ContextMenuPolicy { NoContextMenu, PreventContextMenu, DefaultContextMenu, ActionsContextMenu, CustomContextMenu } |
(since 6.8) enum class | ContextMenuTrigger { Press, Release } |
(since 6.10) enum class | ContrastPreference { NoPreference, HighContrast } |
| enum | CoordinateSystem { DeviceCoordinates, LogicalCoordinates } |
| enum | Corner { TopLeftCorner, TopRightCorner, BottomLeftCorner, BottomRightCorner } |
| enum | CursorMoveStyle { LogicalMoveStyle, VisualMoveStyle } |
| enum | CursorShape { ArrowCursor, UpArrowCursor, CrossCursor, WaitCursor, IBeamCursor, …, BitmapCursor } |
| enum | DateFormat { TextDate, ISODateWithMs, ISODate, RFC2822Date } |
| enum | DayOfWeek { Monday, Tuesday, Wednesday, Thursday, Friday, …, Sunday } |
| enum | DockWidgetArea { LeftDockWidgetArea, RightDockWidgetArea, TopDockWidgetArea, BottomDockWidgetArea, AllDockWidgetAreas, NoDockWidgetArea } |
| flags | DockWidgetAreas |
| enum | DropAction { CopyAction, MoveAction, LinkAction, ActionMask, IgnoreAction, TargetMoveAction } |
| flags | DropActions |
| enum | Edge { TopEdge, LeftEdge, RightEdge, BottomEdge } |
| flags | Edges |
| enum | EnterKeyType { EnterKeyDefault, EnterKeyReturn, EnterKeyDone, EnterKeyGo, EnterKeySend, …, EnterKeyPrevious } |
| enum | EventPriority { HighEventPriority, NormalEventPriority, LowEventPriority } |
| enum | FillRule { OddEvenFill, WindingFill } |
| enum | FindChildOption { FindDirectChildrenOnly, FindChildrenRecursively } |
| flags | FindChildOptions |
| enum | FocusPolicy { TabFocus, ClickFocus, StrongFocus, WheelFocus, NoFocus } |
| enum | FocusReason { MouseFocusReason, TabFocusReason, BacktabFocusReason, ActiveWindowFocusReason, PopupFocusReason, …, OtherFocusReason } |
| enum | GestureFlag { DontStartGestureOnChildren, ReceivePartialGestures, IgnoredGesturesPropagateToParent } |
| flags | GestureFlags |
| enum | GestureState { NoGesture, GestureStarted, GestureUpdated, GestureFinished, GestureCanceled } |
| enum | GestureType { TapGesture, TapAndHoldGesture, PanGesture, PinchGesture, SwipeGesture, CustomGesture } |
| enum | GlobalColor { white, black, red, darkRed, green, …, color1 } |
| HANDLE | |
| enum class | HighDpiScaleFactorRoundingPolicy { Round, Ceil, Floor, RoundPreferFloor, PassThrough } |
| enum | HitTestAccuracy { ExactHit, FuzzyHit } |
| enum | ImageConversionFlag { AutoColor, ColorOnly, MonoOnly, DiffuseDither, OrderedDither, …, NoFormatConversion } |
| flags | ImageConversionFlags |
| enum | InputMethodHint { ImhNone, ImhHiddenText, ImhSensitiveData, ImhNoAutoUppercase, ImhPreferNumbers, …, ImhExclusiveInputMask } |
| flags | InputMethodHints |
| flags | InputMethodQueries |
| enum | InputMethodQuery { ImEnabled, ImCursorRectangle, ImFont, ImCursorPosition, ImSurroundingText, …, ImQueryAll } |
| enum | ItemDataRole { DisplayRole, DecorationRole, EditRole, ToolTipRole, StatusTipRole, …, UserRole } |
| enum | ItemFlag { NoItemFlags, ItemIsSelectable, ItemIsEditable, ItemIsDragEnabled, ItemIsDropEnabled, …, ItemIsUserTristate } |
| flags | ItemFlags |
| enum | ItemSelectionMode { ContainsItemShape, IntersectsItemShape, ContainsItemBoundingRect, IntersectsItemBoundingRect } |
| enum | ItemSelectionOperation { ReplaceSelection, AddToSelection } |
| enum | Key { Key_Escape, Key_Tab, Key_Backtab, Key_Backspace, Key_Return, …, Key_Cancel } |
| enum | KeyboardModifier { NoModifier, ShiftModifier, ControlModifier, AltModifier, MetaModifier, …, GroupSwitchModifier } |
| flags | KeyboardModifiers |
| enum | LayoutDirection { LeftToRight, RightToLeft, LayoutDirectionAuto } |
| enum | MaskMode { MaskInColor, MaskOutColor } |
| enum | MatchFlag { MatchExactly, MatchFixedString, MatchContains, MatchStartsWith, MatchEndsWith, …, MatchRecursive } |
| flags | MatchFlags |
| enum | Modifier { SHIFT, META, CTRL, ALT } |
| flags | Modifiers |
(since 6.12) enum class | MotionPreference { NoPreference, ReducedMotion } |
| enum | MouseButton { NoButton, AllButtons, LeftButton, RightButton, MiddleButton, …, ExtraButton24 } |
| flags | MouseButtons |
| enum | MouseEventFlag { MouseEventCreatedDoubleClick } |
| flags | MouseEventFlags |
| enum | MouseEventSource { MouseEventNotSynthesized, MouseEventSynthesizedBySystem, MouseEventSynthesizedByQt, MouseEventSynthesizedByApplication } |
| enum | NativeGestureType { BeginNativeGesture, EndNativeGesture, PanNativeGesture, ZoomNativeGesture, SmartZoomNativeGesture, …, SwipeNativeGesture } |
| enum | Orientation { Horizontal, Vertical } |
| flags | Orientations |
| enum | PenCapStyle { FlatCap, SquareCap, RoundCap } |
| enum | PenJoinStyle { MiterJoin, BevelJoin, RoundJoin, SvgMiterJoin } |
| enum | PenStyle { NoPen, SolidLine, DashLine, DotLine, DashDotLine, …, CustomDashLine } |
(since 6.5) enum class | PermissionStatus { Undetermined, Granted, Denied } |
| enum | ReturnByValueConstant { } |
| enum | ScreenOrientation { PrimaryOrientation, LandscapeOrientation, PortraitOrientation, InvertedLandscapeOrientation, InvertedPortraitOrientation } |
| flags | ScreenOrientations |
| enum | ScrollBarPolicy { ScrollBarAsNeeded, ScrollBarAlwaysOff, ScrollBarAlwaysOn } |
| enum | ScrollPhase { NoScrollPhase, ScrollBegin, ScrollUpdate, ScrollEnd, ScrollMomentum } |
| enum | ShortcutContext { WidgetShortcut, WidgetWithChildrenShortcut, WindowShortcut, ApplicationShortcut } |
| enum | SizeHint { MinimumSize, PreferredSize, MaximumSize, MinimumDescent } |
| enum | SizeMode { AbsoluteSize, RelativeSize } |
| enum | SortOrder { AscendingOrder, DescendingOrder } |
| flags | SplitBehavior |
| enum | SplitBehaviorFlags { KeepEmptyParts, SkipEmptyParts } |
| enum | TabFocusBehavior { NoTabFocus, TabFocusTextControls, TabFocusListControls, TabFocusAllControls } |
| enum | TextElideMode { ElideLeft, ElideRight, ElideMiddle, ElideNone } |
| enum | TextFlag { TextSingleLine, TextDontClip, TextExpandTabs, TextShowMnemonic, TextWordWrap, …, TextJustificationForced } |
| enum | TextFormat { PlainText, RichText, AutoText, MarkdownText } |
| enum | TextInteractionFlag { NoTextInteraction, TextSelectableByMouse, TextSelectableByKeyboard, LinksAccessibleByMouse, LinksAccessibleByKeyboard, …, TextBrowserInteraction } |
| flags | TextInteractionFlags |
| enum | TileRule { StretchTile, RepeatTile, RoundTile } |
| enum | TimeSpec { LocalTime, UTC, OffsetFromUTC, TimeZone } |
(since 6.8) enum class | TimerId { Invalid } |
| enum | TimerType { PreciseTimer, CoarseTimer, VeryCoarseTimer } |
| enum | ToolBarArea { LeftToolBarArea, RightToolBarArea, TopToolBarArea, BottomToolBarArea, AllToolBarAreas, NoToolBarArea } |
| flags | ToolBarAreas |
| enum | ToolButtonStyle { ToolButtonIconOnly, ToolButtonTextOnly, ToolButtonTextBesideIcon, ToolButtonTextUnderIcon, ToolButtonFollowStyle } |
| enum | TouchPointState { TouchPointUnknownState, TouchPointPressed, TouchPointMoved, TouchPointStationary, TouchPointReleased } |
| flags | TouchPointStates |
| enum | TransformationMode { FastTransformation, SmoothTransformation } |
| enum | UIEffect { UI_AnimateMenu, UI_FadeMenu, UI_AnimateCombo, UI_AnimateTooltip, UI_FadeTooltip, UI_AnimateToolBox } |
| enum | WhiteSpaceMode { WhiteSpaceNormal, WhiteSpacePre, WhiteSpaceNoWrap } |
| enum | WidgetAttribute { WA_AcceptDrops, WA_AlwaysShowToolTips, WA_CustomWhatsThis, WA_DeleteOnClose, WA_Disabled, …, WA_ContentsMarginsRespectsSafeArea } |
| flags | WindowFlags |
| enum | WindowFrameSection { NoSection, LeftSection, TopLeftSection, TopSection, TopRightSection, …, TitleBarArea } |
| enum | WindowModality { NonModal, WindowModal, ApplicationModal } |
| enum | WindowState { WindowNoState, WindowMinimized, WindowMaximized, WindowFullScreen, WindowActive } |
| flags | WindowStates |
| enum | WindowType { Widget, Window, Dialog, Sheet, Drawer, …, WindowType_Mask } |
(since 6.12) | if_has_qt_compare_three_way |
Funciones
(since 6.2) void | beginPropertyUpdateGroup() |
| QTextStream & | bin(QTextStream&stream) |
| QTextStream & | bom(QTextStream&stream) |
| QTextStream & | center(QTextStream&stream) |
(since 6.7) Qt::strong_ordering | compareThreeWay(Enum lhs, Enum rhs) |
(since 6.7) auto | compareThreeWay(FloatType lhs, IntType rhs) |
(since 6.7) auto | compareThreeWay(IntType lhs, FloatType rhs) |
(since 6.7) auto | compareThreeWay(LeftFloat lhs, RightFloat rhs) |
(since 6.7) auto | compareThreeWay(LeftInt lhs, RightInt rhs) |
(since 6.8) Qt::strong_ordering | compareThreeWay(Qt::totally_ordered_wrapper<T *> lhs, Qt::totally_ordered_wrapper<U *> rhs) |
(since 6.8) Qt::strong_ordering | compareThreeWay(Qt::totally_ordered_wrapper<T *> lhs, U*rhs) |
(since 6.8) Qt::strong_ordering | compareThreeWay(Qt::totally_ordered_wrapper<T *> lhs, std::nullptr_t rhs) |
(since 6.8) Qt::strong_ordering | compareThreeWay(U*lhs, Qt::totally_ordered_wrapper<T *> rhs) |
(since 6.12) auto | compareThreeWay(const std::pair<T1, T2>&lhs, const std::pair<U1, U2>&rhs) |
(since 6.8) Qt::strong_ordering | compareThreeWay(std::nullptr_t lhs, Qt::totally_ordered_wrapper<T *> rhs) |
| QString | convertFromPlainText(const QString&plain, Qt::WhiteSpaceMode mode = WhiteSpacePre) |
| QTextStream & | dec(QTextStream&stream) |
(since 6.2) void | endPropertyUpdateGroup() |
| QTextStream & | endl(QTextStream&stream) |
| QTextStream & | fixed(QTextStream&stream) |
| QTextStream & | flush(QTextStream&stream) |
| QTextStream & | forcepoint(QTextStream&stream) |
| QTextStream & | forcesign(QTextStream&stream) |
| QTextStream & | hex(QTextStream&stream) |
| QTextStream & | left(QTextStream&stream) |
| QTextStream & | lowercasebase(QTextStream&stream) |
| QTextStream & | lowercasedigits(QTextStream&stream) |
| bool | mightBeRichText(QAnyStringView texto) |
| QTextStream & | noforcepoint(QTextStream&stream) |
| QTextStream & | noforcesign(QTextStream&stream) |
| QTextStream & | noshowbase(QTextStream&stream) |
| QTextStream & | oct(QTextStream&stream) |
| QTextStream & | reset(QTextStream&stream) |
| QTextStream & | right(QTextStream&stream) |
| QTextStream & | scientific(QTextStream&stream) |
| QTextStream & | showbase(QTextStream&stream) |
| QTextStream & | uppercasebase(QTextStream&stream) |
| QTextStream & | uppercasedigits(QTextStream&stream) |
| QTextStream & | ws(QTextStream&stream) |
| QKeyCombination | operator|(Qt::Key clave, Qt::KeyboardModifier modificador) |
| QKeyCombination | operator|(Qt::Key key, Qt::KeyboardModifiers modifiers) |
| QKeyCombination | operator|(Qt::Key key, Qt::Modifier modificador) |
| QKeyCombination | operator|(Qt::Key key, Qt::Modifiers modifiers) |
| QKeyCombination | operator|(Qt::KeyboardModifier modificador, Qt::Key tecla) |
| QKeyCombination | operator|(Qt::KeyboardModifiers modificadores, Qt::Key tecla) |
| QKeyCombination | operator|(Qt::Modifier modificador, Qt::Key tecla) |
| QKeyCombination | operator|(Qt::Modifiers modificadores, Qt::Key tecla) |
Clases
clase has_qt_compare_three_way
Un rasgo de tipo para comprobar si un tipo admite la comparación de tres elementos ( compareThreeWay()). Más...
clase partial_ordering
Qt::partial_ordering representa el resultado de una comparación que admite resultados sin ordenar. Más...
clase strong_ordering
Qt::strong_ordering representa una comparación en la que los valores equivalentes son indistinguibles. Más...
clase totally_ordered_wrapper
Qt::totally_ordered_wrapper es un tipo envoltorio que proporciona un orden total estricto para los tipos envueltos. Más...
clase weak_ordering
Qt::weak_ordering representa una comparación en la que los valores equivalentes siguen siendo distinguibles. Más...
Documentación de tipos
enum Qt::AlignmentFlag
flags Qt::Alignment
Este tipo de enumeración se utiliza para describir la alineación. Contiene indicadores horizontales y verticales que pueden combinarse para producir el efecto deseado.
La enumeración ` TextElideMode ` también se puede utilizar en muchas situaciones para ajustar con precisión el aspecto del texto alineado.
Los indicadores horizontales son:
| Constante | Valor | Descripción |
|---|---|---|
Qt::AlignLeft | 0x0001 | Alinea con el borde izquierdo. |
Qt::AlignRight | 0x0002 | Se alinea con el borde derecho. |
Qt::AlignHCenter | 0x0004 | Centra horizontalmente en el espacio disponible. |
Qt::AlignJustify | 0x0008 | Justifica el texto en el espacio disponible. |
Los indicadores verticales son:
| Constante | Valor | Descripción |
|---|---|---|
Qt::AlignTop | 0x0020 | Alinea con la parte superior. |
Qt::AlignBottom | 0x0040 | Se alinea con la parte inferior. |
Qt::AlignVCenter | 0x0080 | Centra verticalmente en el espacio disponible. |
Qt::AlignBaseline | 0x0100 | Se alinea con la línea de base. |
Solo puedes utilizar uno de los indicadores horizontales a la vez. Hay un indicador bidimensional:
| Constante | Valor | Descripción |
|---|---|---|
Qt::AlignCenter | AlignVCenter | AlignHCenter | Centra en ambas dimensiones. |
Se puede utilizar como máximo un indicador horizontal y uno vertical a la vez. Qt::AlignCenter cuenta tanto como indicador horizontal como vertical.
Hay tres valores de enumeración útiles en aplicaciones que pueden ejecutarse en modo de escritura de derecha a izquierda:
| Constante | Valor | Descripción |
|---|---|---|
Qt::AlignAbsolute | 0x0010 | Si la dirección de disposición del widget es « Qt::RightToLeft » (en lugar de « Qt::LeftToRight », que es el valor por defecto), Qt::AlignLeft se refiere al borde derecho y Qt::AlignRight al borde izquierdo. Este suele ser el comportamiento deseado. Si deseas que Qt::AlignLeft siempre signifique «izquierda» y Qt::AlignRight siempre signifique «derecha», combina el indicador con Qt::AlignAbsolute. |
Qt::AlignLeading | AlignLeft | Sinónimo de Qt::AlignLeft. |
Qt::AlignTrailing | AlignRight | Sinónimo de Qt::AlignRight. |
Máscaras:
| Constante | Valor |
|---|---|
Qt::AlignHorizontal_Mask | AlignLeft | AlignRight | AlignHCenter | AlignJustify | AlignAbsolute |
Qt::AlignVertical_Mask | AlignTop | AlignBottom | AlignVCenter | AlignBaseline |
Las combinaciones conflictivas de indicadores tienen significados indefinidos.
El tipo Alignment es un typedef para QFlags<AlignmentFlag>. Almacena una combinación OR de valores de AlignmentFlag.
enum Qt::AnchorPoint
Especifica un lado de un elemento de diseño que se puede anclar. Lo utiliza la función ` QGraphicsAnchorLayout`.
| Constante | Valor | Descripción |
|---|---|---|
Qt::AnchorLeft | 0 | El lado izquierdo de un elemento de diseño. |
Qt::AnchorHorizontalCenter | 1 | Un lado «virtual» situado en el centro entre el lado izquierdo y el derecho de un elemento de diseño. |
Qt::AnchorRight | 2 | El lado derecho de un elemento de diseño. |
Qt::AnchorTop | 3 | El lado superior de un elemento de diseño. |
Qt::AnchorVerticalCenter | 4 | Un lado «virtual» situado en el centro entre los lados superior e inferior de un elemento de diseño. |
Qt::AnchorBottom | 5 | El lado inferior de un elemento de diseño. |
Véase también « QGraphicsAnchorLayout ».
enum Qt::ApplicationAttribute
Esta enumeración describe los atributos que modifican el comportamiento de las funciones de toda la aplicación. Se activan y desactivan mediante ` QCoreApplication::setAttribute()` y se puede comprobar su estado con ` QCoreApplication::testAttribute()`.
| Constante | Valor | Descripción |
|---|---|---|
Qt::AA_QtQuickUseDefaultSizePolicy (since Qt 6.7) | 1 | Qt Quick Los diseños utilizan la política de tamaño integrada de ` Item`. Por ejemplo, cuando se establece esta opción, ` Button ` ocupa todo el ancho disponible, pero tiene una altura fija. Cuando no se establece, utilizará el comportamiento de dimensionamiento predeterminado del diseño en el que se encuentra, que consiste en utilizar su tamaño implícito como tamaño preferido. Esto se explica en detalle en «Especificación del tamaño preferido » y «Restricciones de tamaño». Cuando se establece, la política de tamaño predeterminada del elemento con el diseño puede anularse estableciendo explícitamente Layout.fillWidth o Layout.fillHeight. |
Qt::AA_DontShowIconsInMenus | 2 | Las acciones con la propiedad «Icon» no se mostrarán en ningún menú a menos que se establezca específicamente mediante la propiedad « QAction::iconVisibleInMenu ». El valor por defecto de este atributo depende de la plataforma. Para anular el comportamiento por defecto, configura el atributo después de que se haya instanciado « QGuiApplication ». Es posible que los menús que estén abiertos en ese momento o los ya creados en la barra de menús nativa de macOS no reflejen un cambio en este atributo. Los cambios en la propiedad QAction::iconVisibleInMenu siempre se reflejarán. |
Qt::AA_DontShowShortcutsInContextMenus | 28 | Las acciones con la propiedad «Shortcut» no se mostrarán en ningún menú contextual a menos que se especifique expresamente mediante la propiedad « QAction::shortcutVisibleInContextMenu ». Este valor se añadió en Qt 5.10 y, por defecto, se basa en el valor devuelto por QStyleHints::showShortcutsInContextMenus(). Para anular el comportamiento predeterminado, establece la sugerencia de estilo antes de que se haya instanciado ` QCoreApplication `, o bien establece este atributo después de que se haya instanciado ` QCoreApplication `. |
Qt::AA_NativeWindows | 3 | Garantiza que los widgets tengan ventanas nativas. |
Qt::AA_DontCreateNativeWidgetSiblings | 4 | Garantiza que los elementos hermanos de los widgets nativos sigan siendo no nativos, a menos que se especifique lo contrario mediante el atributo Qt::WA_NativeWindow. |
Qt::AA_PluginApplication | 5 | Indica que se utiliza Qt para crear un complemento. Dependiendo del sistema operativo, suprime inicializaciones específicas que no tienen por qué tener sentido en el caso de un complemento. Por ejemplo, en macOS, esto incluye evitar la carga de nuestro nib para el menú principal y no tomar el control de la barra de menús nativa. Establecer este atributo en «true» también establecerá el atributo AA_DontUseNativeMenuBar en «true». Además, desactiva los filtros de eventos nativos. Este atributo debe establecerse antes de que se construya QGuiApplication. Este valor se añadió en Qt 5.7. |
Qt::AA_DontUseNativeMenuBar | 6 | Todas las barras de menú creadas mientras este atributo esté establecido en «true» no se utilizarán como barra de menú nativa (por ejemplo, la barra de menú situada en la parte superior de la pantalla principal en macOS). |
Qt::AA_MacDontSwapCtrlAndMeta | 7 | Los atajos de teclado en las plataformas de Apple suelen basarse en el modificador de teclado «Command» (o «Cmd»), representado por el símbolo ⌘. Por ejemplo, la acción «Copiar» es «Command+C» (⌘+C). Para facilitar el desarrollo multiplataforma, Qt reasigna por defecto «Command» a la tecla Qt::ControlModifier, a fin de alinearse con otras plataformas. Esto permite crear atajos de teclado como «Ctrl+J», que en macOS se asignará a Comando+J, tal y como esperan los usuarios de macOS. El modificador Control (o Ctrl) real en las plataformas de Apple, representado por ⌃, se asigna a Qt::MetaModifier. |
Cuando este atributo tiene el valor «true», Qt no realizará la reasignación, y al pulsar el modificador «Command» se obtendrá « Qt::MetaModifier », mientras que al pulsar el modificador «Control» se obtendrá « Qt::ControlModifier ».
Ten en cuenta que las secuencias de « QKeySequence::StandardKey » siempre se basarán en el mismo modificador (es decir, « QKeySequence::Copy » será «Command+C» independientemente del valor establecido), pero el resultado de « QKeySequence::toString()» será diferente.
| Constante | Valor | Descripción |
|---|---|---|
Qt::AA_Use96Dpi | 8 | Asume que la pantalla tiene una resolución de 96 ppp en lugar de utilizar la resolución proporcionada por el sistema operativo. Esto hará que la representación de las fuentes sea coherente en píxeles por punto en todos los dispositivos, en lugar de definir 1 punto como 1/72 de pulgada. |
Qt::AA_SynthesizeTouchForUnhandledMouseEvents | 11 | Todos los eventos del ratón que no sean aceptados por la aplicación se traducirán en eventos táctiles. |
Qt::AA_SynthesizeMouseForUnhandledTouchEvents | 12 | Todos los eventos táctiles que la aplicación no acepte se convertirán en eventos del botón izquierdo del ratón. Este atributo está activado por defecto. |
Qt::AA_ForceRasterWidgets | 14 | Hace que los widgets de nivel superior utilicen superficies ráster puras y no admita widgets hijos no nativos basados en GL. |
Qt::AA_UseDesktopOpenGL | 15 | Fuerza el uso de OpenGL de escritorio (por ejemplo, opengl32.dll o libGL.so) en plataformas que utilizan la carga dinámica de la implementación de OpenGL. Este atributo debe establecerse antes de que se construya QGuiApplication. Este valor se añadió en Qt 5.3. |
Qt::AA_UseOpenGLES | 16 | Fuerza el uso de OpenGL ES 2.0 o superior en plataformas que utilizan la carga dinámica de la implementación de OpenGL. Este atributo debe establecerse antes de que se construya QGuiApplication. Este valor se añadió en Qt 5.3. |
Qt::AA_UseSoftwareOpenGL | 17 | Fuerza el uso de una implementación de OpenGL basada en software en plataformas que utilizan la carga dinámica de la implementación de OpenGL. Normalmente se tratará de una versión parcheada de Mesa llvmpipe, que proporciona OpenGL 2.1. Es posible que el valor no tenga ningún efecto si no hay disponible dicha implementación de OpenGL. El nombre predeterminado de esta biblioteca es opengl32sw.dll y puede sobrescribirse configurando la variable de entorno QT_OPENGL_DLL. Consulte las páginas específicas de cada plataforma, por ejemplo, Qt para Windows, para obtener más información. Este atributo debe establecerse antes de la construcción de QGuiApplication. Este valor se añadió en Qt 5.4. |
Qt::AA_ShareOpenGLContexts | 18 | Habilita el uso compartido de recursos entre los contextos OpenGL utilizados por clases como QOpenGLWidget y QQuickWidget. Esto permite compartir recursos OpenGL, como texturas, entre instancias de QOpenGLWidget que pertenecen a diferentes ventanas de nivel superior. Este valor se añadió en Qt 5.4. |
Qt::AA_SetPalette | 19 | Indica si se ha establecido explícitamente una paleta en ` QGuiApplication`. Este valor se añadió en Qt 5.5. |
Qt::AA_UseStyleSheetPropagationInWidgetStyles | 22 | Por defecto, las hojas de estilo de Qt desactivan la propagación habitual de la paleta y las fuentes de QWidget. Cuando se activa este indicador, los cambios en las fuentes y la paleta realizados desde una hoja de estilo se propagarán una sola vez, al establecer la hoja de estilo. Consulta «La sintaxis de las hojas de estilo: herencia» para obtener más detalles. Este valor se añadió en Qt 5.7. |
Qt::AA_DontUseNativeDialogs | 23 | Todos los cuadros de diálogo creados mientras este atributo esté establecido en «true» no utilizarán los cuadros de diálogo nativos proporcionados por la plataforma. Este valor se añadió en Qt 5.7. |
Qt::AA_SynthesizeMouseForUnhandledTabletEvents | 24 | Todos los eventos de tableta que la aplicación no acepte se convertirán en eventos de ratón. Este atributo está activado por defecto. Este valor se añadió en Qt 5.7. |
Qt::AA_CompressHighFrequencyEvents | 25 | Habilita la compresión de determinados eventos frecuentes. En el sistema de ventanas X11, el valor por defecto es «true», lo que significa que QEvent::MouseMove, QEvent::TouchUpdate y los cambios en el tamaño y la posición de las ventanas se combinarán siempre que se produzcan con mayor frecuencia de la que la aplicación puede gestionar, para que no se acumulen y sobrecarguen la aplicación posteriormente. En Windows 8 y versiones posteriores, el valor por defecto también es «true», pero solo se aplica a los eventos táctiles. Los eventos del ratón y de las ventanas no se ven afectados por este indicador. En Wayland, el valor por defecto también es «true», pero solo se aplica a los eventos del ratón. En otras plataformas, el valor por defecto es «false». (En el futuro, es posible que la función de compresión se implemente en todas las plataformas). Puedes comprobar el atributo para ver si la compresión está habilitada. Si tu aplicación necesita gestionar todos los eventos sin compresión, puedes desactivar este atributo. Ten en cuenta que los eventos de entrada procedentes de tabletas no se comprimirán. Consulta AA_CompressTabletEvents si deseas que estos también se compriman. Este valor se añadió en Qt 5.7. |
Qt::AA_CompressTabletEvents | 29 | Habilita la compresión de los eventos de entrada procedentes de tabletas. Ten en cuenta que AA_CompressHighFrequencyEvents debe ser «true» para que se habilite la compresión de eventos, y que este indicador amplía el anterior a los eventos de tabletas. Actualmente es compatible con el sistema de ventanas X11, Windows 8 y versiones posteriores. El valor por defecto es «false». Este valor se añadió en Qt 5.10. |
Qt::AA_DontCheckOpenGLContextThreadAffinity | 26 | Al establecer un contexto como actual mediante ` QOpenGLContext`, no se comprueba que el ` QObject thread affinity ` del objeto ` QOpenGLContext ` sea el mismo hilo que llama a ` makeCurrent()`. Este valor se añadió en Qt 5.8. |
Qt::AA_DisableShaderDiskCache | 27 | Desactiva el almacenamiento en caché de los binarios de los programas de shader en el disco. Por defecto, Qt Quick, el backend OpenGL de QPainter y cualquier aplicación que utilice QOpenGLShaderProgram con una de sus sobrecargas de addCacheableShaderFromSource emplearán una caché de binarios de programas basada en disco, ya sea en la ubicación de almacenamiento compartida o por proceso, en sistemas que admitan glProgramBinary(). En el improbable caso de que esto suponga un problema, establezca este atributo para desactivar todo el almacenamiento en caché de shaders basado en disco. |
Qt::AA_DisableSessionManager | 31 | Desactiva la función « QSessionManager ». Por defecto, Qt se conectará a un gestor de sesiones en ejecución para una aplicación GUI en las plataformas compatibles; el uso de un gestor de sesiones puede resultar redundante para los servicios del sistema. Este atributo debe configurarse antes de que se construya ` QGuiApplication `. Este valor se añadió en la versión 5.14 |
Qt::AA_DisableNativeVirtualKeyboard | 9 | Cuando se establece este atributo, el teclado virtual nativo en pantalla no se mostrará automáticamente cuando un widget de entrada de texto obtenga el foco en un sistema sin teclado físico. Actualmente solo es compatible con la plataforma Windows. Este valor se añadió en la versión 5.15 |
Qt::AA_DontUseNativeMenuWindows | 10 | Las ventanas emergentes de menú (por ejemplo, menús contextuales, menús de cuadros combinados y menús de la barra de menús no nativos) creadas mientras este atributo está establecido en «true» no se representarán como ventanas nativas de nivel superior, a menos que lo requiera la implementación. Este valor se añadió en Qt 6.8. |
enum Qt::ApplicationState
flags Qt::ApplicationStates
Este tipo de enumeración se utiliza para especificar el estado actual de la aplicación.
Los estados son
| Constante | Valor | Descripción |
|---|---|---|
Qt::ApplicationSuspended | 0x00000000 | La aplicación está a punto de suspenderse. Al entrar en este estado, la aplicación debe guardar su estado, detener todas las actividades y prepararse para que se detenga la ejecución del código. Mientras está suspendida, la aplicación puede cerrarse en cualquier momento sin más avisos (por ejemplo, cuando la falta de memoria obliga al sistema operativo a eliminar las aplicaciones suspendidas). |
Qt::ApplicationHidden | 0x00000001 | La aplicación está oculta y se ejecuta en segundo plano. Este es el estado normal de las aplicaciones que necesitan realizar procesos en segundo plano, como reproducir música, mientras el usuario interactúa con otras aplicaciones. La aplicación debe liberar todos los recursos gráficos al entrar en este estado. |
Qt::ApplicationInactive | 0x00000002 | La aplicación está visible, pero no seleccionada para estar en primer plano. En plataformas de escritorio, esto suele significar que el usuario ha activado otra aplicación. En plataformas móviles, es más habitual entrar en este estado cuando el sistema operativo interrumpe al usuario con, por ejemplo, llamadas entrantes o mensajes SMS. Mientras se encuentre en este estado, considera la posibilidad de reducir las tareas que consumen muchos recursos de la CPU. |
Qt::ApplicationActive | 0x00000004 | La aplicación está visible y seleccionada para estar en primer plano. |
El tipo `ApplicationStates` es una definición de tipo (`typedef`) para ` QFlags<ApplicationState>`. Almacena una combinación OR de valores de `ApplicationState`.
enum Qt::ArrowType
| Constante | Valor |
|---|---|
Qt::NoArrow | 0 |
Qt::UpArrow | 1 |
Qt::DownArrow | 2 |
Qt::LeftArrow | 3 |
Qt::RightArrow | 4 |
enum Qt::AspectRatioMode
Este tipo de enumeración define qué ocurre con la relación de aspecto al cambiar la escala de un rectángulo.

| Constante | Valor | Descripción |
|---|---|---|
Qt::IgnoreAspectRatio | 0 | El tamaño se escala libremente. No se conserva la relación de aspecto. |
Qt::KeepAspectRatio | 1 | El tamaño se escala a un rectángulo lo más grande posible dentro de un rectángulo dado, conservando la relación de aspecto. |
Qt::KeepAspectRatioByExpanding | 2 | El tamaño se adapta a un rectángulo lo más pequeño posible fuera de un rectángulo dado, conservando la relación de aspecto. |
Véase también QSize::scale() y QImage::scaled().
enum Qt::Axis
Este tipo de enumeración define tres valores que representan los tres ejes del sistema de coordenadas cartesianas.
| Constante | Valor | Descripción |
|---|---|---|
Qt::XAxis | 0 | El eje X. |
Qt::YAxis | 1 | El eje Y. |
Qt::ZAxis | 2 | El eje Z. |
Véase también QTransform::rotate() y QTransform::rotateRadians().
enum Qt::BGMode
Modo en segundo plano:
| Constante | Valor |
|---|---|
Qt::TransparentMode | 0 |
Qt::OpaqueMode | 1 |
enum Qt::BrushStyle
Este tipo de enumeración define los estilos de pincel compatibles con Qt, es decir, el patrón de relleno de las figuras dibujadas mediante ` QPainter`.

| Constante | Valor | Descripción |
|---|---|---|
Qt::NoBrush | 0 | Sin patrón de pincel. |
Qt::SolidPattern | 1 | Color uniforme. |
Qt::Dense1Pattern | 2 | Patrón de pincelada extremadamente denso. |
Qt::Dense2Pattern | 3 | Patrón de pincelada muy denso. |
Qt::Dense3Pattern | 4 | Patrón de pinceladas algo denso. |
Qt::Dense4Pattern | 5 | Patrón de pinceladas medianamente denso. |
Qt::Dense5Pattern | 6 | Patrón de pinceladas algo escaso. |
Qt::Dense6Pattern | 7 | Patrón de pinceladas muy escaso. |
Qt::Dense7Pattern | 8 | Patrón de pinceladas extremadamente escaso. |
Qt::HorPattern | 9 | Líneas horizontales. |
Qt::VerPattern | 10 | Líneas verticales. |
Qt::CrossPattern | 11 | Líneas horizontales y verticales que se cruzan. |
Qt::BDiagPattern | 12 | Líneas diagonales hacia atrás. |
Qt::FDiagPattern | 13 | Líneas diagonales hacia delante. |
Qt::DiagCrossPattern | 14 | Líneas diagonales cruzadas. |
Qt::LinearGradientPattern | 15 | Degradado lineal (configurado mediante un constructor específico de QBrush ). |
Qt::ConicalGradientPattern | 17 | Degradado cónico (configurado mediante un constructor específico de QBrush ). |
Qt::RadialGradientPattern | 16 | Degradado radial (configurado mediante un constructor específico de ` QBrush `). |
Qt::TexturePattern | 24 | Patrón personalizado (véase QBrush::setTexture()). |
Véase también ` QBrush`.
enum Qt::CaseSensitivity
| Constante | Valor |
|---|---|
Qt::CaseInsensitive | 0 |
Qt::CaseSensitive | 1 |
enum Qt::CheckState
Esta enumeración describe el estado de los elementos marcables, los controles y los widgets.
| Constante | Valor | Descripción |
|---|---|---|
Qt::Unchecked | 0 | El elemento no está marcado. |
Qt::PartiallyChecked | 1 | El elemento está parcialmente marcado. Los elementos de los modelos jerárquicos pueden estar parcialmente marcados si algunos de sus elementos secundarios están marcados, pero no todos. |
Qt::Checked | 2 | El elemento está marcado. |
Véase también « QCheckBox », « Qt::ItemFlags » y « Qt::ItemDataRole ».
enum Qt::ChecksumType
Esta enumeración describe los posibles estándares utilizados por qChecksum().
| Constante | Valor | Descripción |
|---|---|---|
Qt::ChecksumIso3309 | 0 | Cálculo de la suma de comprobación basado en la norma ISO 3309. |
Qt::ChecksumItuV41 | 1 | Cálculo de la suma de comprobación según la norma ITU-V.41. |
enum Qt::ClipOperation
| Constante | Valor | Descripción |
|---|---|---|
Qt::NoClip | 0 | Esta operación desactiva el recorte. |
Qt::ReplaceClip | 1 | Sustituye la ruta, el rectángulo o la región de recorte actual por la proporcionada en la llamada a la función. |
Qt::IntersectClip | 2 | Intersecta la ruta, el rectángulo o la región de recorte actual con la proporcionada en la llamada a la función. |
enum class Qt::ColorScheme
Representa el aspecto del tema de una aplicación, definido mediante ` QGuiApplication::palette()`.
| Constante | Valor | Descripción |
|---|---|---|
Qt::ColorScheme::Unknown | 0 | Se desconoce la apariencia. |
Qt::ColorScheme::Light | 1 | Los colores de fondo son más claros que el color del texto, es decir, el tema es claro. |
Qt::ColorScheme::Dark | 2 | Los colores de fondo son más oscuros que el color del texto, es decir, el tema es oscuro. |
enum Qt::ConnectionType
Esta enumeración describe los tipos de conexión que pueden utilizarse entre señales y ranuras. En concreto, determina si una señal concreta se envía a una ranura de forma inmediata o si se pone en cola para su envío más adelante.
| Constante | Valor | Descripción |
|---|---|---|
Qt::AutoConnection | 0 | (Por defecto) Si el receptor lives in al hilo que emite la señal, se utiliza Qt::DirectConnection. En caso contrario, se utiliza Qt::QueuedConnection. El tipo de conexión se determina cuando se emite la señal. |
Qt::DirectConnection | 1 | La ranura se invoca inmediatamente cuando se emite la señal. La ranura se ejecuta en el hilo emisor de la señal. |
Qt::QueuedConnection | 2 | La ranura se invoca cuando el control vuelve al bucle de eventos del hilo del receptor. La ranura se ejecuta en el hilo del receptor. |
Qt::BlockingQueuedConnection | 3 | Igual que Qt::QueuedConnection, salvo que el hilo emisor de la señal se bloquea hasta que la ranura devuelve un resultado. Esta conexión no debe utilizarse si el receptor reside en el hilo emisor de la señal, ya que, de lo contrario, la aplicación entrará en un interbloqueo. |
Qt::UniqueConnection | 0x80 | Se trata de un indicador que puede combinarse con cualquiera de los tipos de conexión anteriores, utilizando un OR bit a bit. Cuando se establece Qt::UniqueConnection, la función ` QObject::connect()` fallará si la conexión ya existe (es decir, si la misma señal ya está conectada al mismo slot para el mismo par de objetos). |
Qt::SingleShotConnection | 0x100 | Se trata de un indicador que puede combinarse con cualquiera de los tipos de conexión anteriores, utilizando un OR bit a bit. Cuando se establece Qt::SingleShotConnection, la ranura solo se llamará una vez; la conexión se interrumpirá automáticamente cuando se emita la señal. Este indicador se introdujo en Qt 6.0. |
Con las conexiones en cola, los parámetros deben ser de tipos conocidos por el sistema de metaobjetos de Qt, ya que Qt necesita copiar los argumentos para almacenarlos en un evento en segundo plano. Si intentas utilizar una conexión en cola y recibes el mensaje de error:
QObject::connect: Cannot queue arguments of type 'MyType'Llama a qRegisterMetaType() para registrar el tipo de datos antes de establecer la conexión.
Al utilizar señales y ranuras con varios subprocesos, consulta «Señales y ranuras entre subprocesos».
Véase también «Multihilo en Qt», « QObject::connect()», « qRegisterMetaType()» y « Q_DECLARE_METATYPE()».
enum Qt::ContextMenuPolicy
Este tipo de enumeración define las distintas políticas que puede tener un widget en lo que respecta a la visualización de un menú contextual.
| Constante | Valor | Descripción |
|---|---|---|
Qt::NoContextMenu | 0 | el widget no dispone de menú contextual; la gestión del menú contextual se delega al padre del widget. |
Qt::PreventContextMenu | 4 | El widget no dispone de menú contextual y, a diferencia de ` NoContextMenu`, la gestión no se delega al padre del widget. Esto significa que se garantiza que todos los eventos del botón derecho del ratón se transmitan al propio widget a través de ` QWidget::mousePressEvent()` y ` QWidget::mouseReleaseEvent()`. |
Qt::DefaultContextMenu | 1 | Se invoca el controlador QWidget::contextMenuEvent() del widget. |
Qt::ActionsContextMenu | 2 | El widget muestra su QWidget::actions() como menú contextual. |
Qt::CustomContextMenu | 3 | El widget emite la señal QWidget::customContextMenuRequested(). |
[since 6.8] enum class Qt::ContextMenuTrigger
Este tipo de enumeración define el evento del ratón que se utiliza para activar un evento del menú contextual.
| Constante | Valor | Descripción |
|---|---|---|
Qt::ContextMenuTrigger::Press | 0 | menú contextual al pulsar el botón del ratón, valor predeterminado en sistemas UNIX. |
Qt::ContextMenuTrigger::Release | 1 | Menú contextual al soltar el botón del ratón; valor predeterminado en Windows. |
Esta enumeración se introdujo en Qt 6.8.
Véase también QStyleHints::contextMenuTrigger.
[since 6.10] enum class Qt::ContrastPreference
Representa la configuración de contraste preferida por el usuario. Los estilos pueden respetar esta configuración aumentando el contraste entre los colores de primer plano y de fondo, así como aplicando bordes más gruesos a los widgets y controles.
| Constante | Valor | Descripción |
|---|---|---|
Qt::ContrastPreference::NoPreference | 0 | Sin preferencias específicas. |
Qt::ContrastPreference::HighContrast | 1 | El usuario prefiere que la aplicación se muestre con alto contraste. |
Esta enumeración se introdujo en Qt 6.10.
enum Qt::CoordinateSystem
Esta enumeración especifica el sistema de coordenadas.
| Constante | Valor | Descripción |
|---|---|---|
Qt::DeviceCoordinates | 0 | Las coordenadas son relativas a la esquina superior izquierda del dispositivo de dibujo del objeto. |
Qt::LogicalCoordinates | 1 | Las coordenadas son relativas a la esquina superior izquierda del objeto. |
enum Qt::Corner
Este tipo de enumeración especifica una esquina de un rectángulo:
| Constante | Valor | Descripción |
|---|---|---|
Qt::TopLeftCorner | 0x00000 | La esquina superior izquierda del rectángulo. |
Qt::TopRightCorner | 0x00001 | La esquina superior derecha del rectángulo. |
Qt::BottomLeftCorner | 0x00002 | La esquina inferior izquierda del rectángulo. |
Qt::BottomRightCorner | 0x00003 | La esquina inferior derecha del rectángulo. |
enum Qt::CursorMoveStyle
Esta enumeración describe los estilos de desplazamiento disponibles para los cursores de texto. Las opciones son:
| Constante | Valor | Descripción |
|---|---|---|
Qt::LogicalMoveStyle | 0 | En un bloque de texto de izquierda a derecha, al pulsar la tecla de flecha izquierda, la posición del cursor se desplaza hacia la izquierda; al pulsar la tecla de flecha derecha, la posición del cursor se desplaza hacia la derecha. Si el bloque de texto es de derecha a izquierda, se aplica el comportamiento contrario. |
Qt::VisualMoveStyle | 1 | Al pulsar la tecla de flecha izquierda, el cursor siempre se desplazará hacia la izquierda, independientemente de la dirección de escritura del texto. Al pulsar la tecla de flecha derecha, el cursor siempre se desplazará hacia la derecha. |
enum Qt::CursorShape
Este tipo de enumeración define los distintos cursores que se pueden utilizar.
El cursor de flecha estándar es el predeterminado para los widgets en estado normal.
| Constante | Valor | Descripción |
|---|---|---|
Qt::ArrowCursor | 0 | El cursor de flecha estándar. |
Qt::UpArrowCursor | 1 | Una flecha que apunta hacia arriba, hacia la parte superior de la pantalla. |
Qt::CrossCursor | 2 | Un cursor en forma de cruz, que suele utilizarse para ayudar al usuario a seleccionar con precisión un punto de la pantalla. |
Qt::WaitCursor | 3 | Un cursor en forma de reloj de arena o de reloj, que suele aparecer durante operaciones que impiden al usuario interactuar con la aplicación. |
Qt::IBeamCursor | 4 | Un cursor en forma de carrete o de barra, que indica que un control puede aceptar y mostrar texto introducido. |
Qt::SizeVerCursor | 5 | Un cursor utilizado para elementos que sirven para cambiar el tamaño vertical de las ventanas de nivel superior. |
Qt::SizeHorCursor | 6 | Un cursor utilizado para elementos que sirven para cambiar el tamaño horizontal de las ventanas de nivel superior. |
Qt::SizeBDiagCursor | 7 | Un cursor utilizado para elementos que sirven para cambiar el tamaño en diagonal de las ventanas de nivel superior en sus esquinas superior derecha e inferior izquierda. |
Qt::SizeFDiagCursor | 8 | Un cursor utilizado para elementos que sirven para cambiar el tamaño en diagonal de ventanas de nivel superior por sus esquinas superior izquierda e inferior derecha. |
Qt::SizeAllCursor | 9 | Un cursor utilizado para elementos que sirven para cambiar el tamaño de las ventanas de nivel superior en cualquier dirección. |
Qt::BlankCursor | 10 | Un cursor en blanco o invisible, que suele utilizarse cuando es necesario ocultar la forma del cursor. |
Qt::SplitVCursor | 11 | Un cursor utilizado para divisores verticales, que indica que se puede arrastrar un controlador horizontalmente para ajustar el uso del espacio disponible. |
Qt::SplitHCursor | 12 | Un cursor utilizado para divisores horizontales, que indica que se puede arrastrar un controlador verticalmente para ajustar el uso del espacio disponible. |
Qt::PointingHandCursor | 13 | Un cursor en forma de mano que suele utilizarse para elementos en los que se puede hacer clic, como los hipervínculos. |
Qt::ForbiddenCursor | 14 | Un cursor de círculo tachado, que se utiliza normalmente durante las operaciones de arrastrar y soltar para indicar que el contenido arrastrado no se puede soltar en determinados widgets o dentro de ciertas regiones. |
Qt::OpenHandCursor | 17 | Un cursor que representa una mano abierta, que se utiliza habitualmente para indicar que el área situada debajo del cursor es la parte visible de un lienzo en la que el usuario puede hacer clic y arrastrar para desplazarse. |
Qt::ClosedHandCursor | 18 | Un cursor que representa una mano cerrada, que suele utilizarse para indicar que se está realizando una operación de arrastre que implica desplazamiento. |
Qt::WhatsThisCursor | 15 | Una flecha con un signo de interrogación, que suele utilizarse para indicar la presencia de la ayuda «¿Qué es esto?» para un widget. |
Qt::BusyCursor | 16 | Un cursor en forma de reloj de arena o de reloj, que suele aparecer durante operaciones que permiten al usuario interactuar con la aplicación mientras se realizan en segundo plano. |
Qt::DragMoveCursor | 20 | Un cursor que se suele utilizar al arrastrar un elemento. |
Qt::DragCopyCursor | 19 | Un cursor que se suele utilizar al arrastrar un elemento para copiarlo. |
Qt::DragLinkCursor | 21 | Un cursor que se suele utilizar al arrastrar un elemento para crear un enlace hacia él. |
Qt::BitmapCursor | 24 |
enum Qt::DateFormat
| Constante | Valor | Descripción |
|---|---|---|
Qt::TextDate | 0 | El formato predeterminado de Qt, que incluye el nombre del día y del mes, el número del día del mes y el año completo. Los nombres del día y del mes serán abreviaturas en inglés (configuración regional C). Esto utiliza, en la práctica, para una fecha, el formato ddd MMM d yyyy; para una hora, HH:mm:ss; y combina ambos como ddd MMM d HH:mm:ss yyyy para una fecha y hora, con un sufijo opcional de desfase horario, cuando sea pertinente. Al leer desde una cadena, también se reconoce una parte fraccionaria en los segundos de la parte de hora, como HH:mm:ss.zzz, y pueden reconocerse algunas variantes menores del formato, para garantizar la compatibilidad con versiones anteriores de Qt y con los cambios en el formato previstos para el futuro. En concreto, el sufijo de zona horaria y desfase utiliza actualmente GMT[±tzoff] con un tzoff en formato HH[[:]mm] (hora de dos dígitos y minutos opcionales de dos dígitos, con separador de dos puntos opcional); esto cambiará para utilizar UTC en lugar de GMT en una futura versión de Qt, de modo que se reconozca el formato previsto UTC. |
Qt::ISODateWithMs | 9 | Formato ampliadoISO 8601: utiliza yyyy-MM-dd para las fechas, HH:mm:ss.zzz para las horas o yyyy-MM-ddTHH:mm:ss.zzz (p. ej., 2017-07-24T15:46:29.739) para fechas y horas combinadas, opcionalmente con un sufijo de zona horaria (Z para UTC o, en su defecto, un desfase como ±HH:mm) cuando proceda. Al analizarlo, se puede utilizar un único espacio, ' ', en lugar del separador « 'T' » entre la fecha y la hora; no se permiten otros caracteres de espaciado. Este formato también admite los formatos HH:mm y HH sin formato para la parte de la hora, cualquiera de los cuales puede incluir una parte fraccionaria, HH:mm.zzz o HH.zzz, aplicada al último campo presente (hora o minuto). |
Qt::ISODate | 1 | Formato ampliadoISO 8601, igual que en ISODateWithMs, pero omitiendo la parte de los milisegundos (.zzz) al convertir a una cadena de caracteres. No hay diferencia a la hora de leer desde una cadena: si hay una parte fraccionaria en el último campo de hora, cualquiera de los dos formatos la aceptará. |
Qt::RFC2822Date | 8 | FormatoRFC 2822, RFC 850 y RFC 1036: al convertir fechas a cadena, se utiliza el formato dd MMM yyyy; para las horas, el formato es HH:mm:ss. En el caso de fechas y horas combinadas, se combinan como dd MMM yyyy HH:mm:ss ±tzoff (omitiendo el día de la semana opcional al principio del primer formato reconocido). Al leer una cadena, se reconocerán tanto [ddd,] dd MMM yyyy [HH:mm[:ss]][ ±tzoff] como ddd MMM dd[ HH:mm:ss] yyyy[ ±tzoff] para fechas y horas combinadas, donde tzoff es una diferencia horaria en formato HHmm. Pueden aparecer espacios arbitrarios antes o después del texto, y cualquier espacio no vacío puede sustituir a los espacios de este formato. En el caso de fechas y horas por separado, se comparan los mismos formatos y se ignoran las partes no deseadas. En particular, hay que tener en cuenta que no se reconoce una hora si no va acompañada de una fecha. |
En los formatos ISODate, cada y, M y d representa un único dígito del año, el mes y el día utilizados para especificar la fecha. Cada H, m y s representa un único dígito de la hora (hasta 24), el minuto y el segundo utilizados para especificar la hora. Una hora igual a 24, con cero en todos los demás campos de hora, se interpreta como el inicio del día siguiente. Un « .zzz » representa un sufijo de fracción en el campo anterior, que puede estar separado de dicho campo mediante una coma ',' o un punto '.', tal y como se muestra. Se acepta una precisión superior a los milisegundos, pero se descarta, redondeándose al milisegundo representable más cercano. La presencia del carácter literal T se utiliza para separar la fecha y la hora cuando se especifican ambas. Para los formatos TextDate y RFC2822Date, ddd representa las tres primeras letras del nombre del día de la semana y MMM representa las tres primeras letras del nombre del mes. Los nombres de los días y los meses están siempre en inglés (configuración regional C), independientemente de las preferencias del usuario o de la configuración del sistema. Los demás caracteres de formato tienen el mismo significado que en el formato ISODate, salvo que no se acepta el 24 como hora. Las partes de un formato entre corchetes [...] son opcionales; los corchetes no forman parte del formato. El carácter más o menos '±' representa aquí cualquiera de los dos signos, '-' para el signo menos o '+' para el signo más.
Nota: Las diferencias horariasde las zonas se miden como positivas al este de Greenwich y negativas al oeste, tal y como es habitual en las notaciones de diferencia horaria basadas en el UTC (lo que entra en conflicto con algunos nombres de zonas basados en el GMT, como Etc/GMT+3, que utilizan la convención opuesta).
Véanse también QDate::toString(), QTime::toString(), QDateTime::toString(), QDate::fromString(), QTime::fromString() y QDateTime::fromString().
enum Qt::DayOfWeek
| Constante | Valor |
|---|---|
Qt::Monday | 1 |
Qt::Tuesday | 2 |
Qt::Wednesday | 3 |
Qt::Thursday | 4 |
Qt::Friday | 5 |
Qt::Saturday | 6 |
Qt::Sunday | 7 |
enum Qt::DockWidgetArea
flags Qt::DockWidgetAreas
Muestra las áreas en las que se puede acoplar un « QDockWidget ».
Nota: Un widget de muelle flotante con pestañas se puede acoplar en cualquier lugar.
| Constante | Valor | Descripción |
|---|---|---|
Qt::LeftDockWidgetArea | 0x1 | El área de acoplamiento izquierda de un « QMainWindow ». |
Qt::RightDockWidgetArea | 0x2 | El área de acoplamiento derecha de un « QMainWindow ». |
Qt::TopDockWidgetArea | 0x4 | La zona superior de acoplamiento de un « QMainWindow ». |
Qt::BottomDockWidgetArea | 0x8 | La zona inferior del dock de un QMainWindow. |
Qt::AllDockWidgetAreas | DockWidgetArea_Mask | Todas las áreas de widgets del dock (por defecto). |
Qt::NoDockWidgetArea | 0 | Sin áreas de widgets del Dock. |
El tipo DockWidgetAreas es un typedef para QFlags<DockWidgetArea>. Almacena una combinación OR de valores de DockWidgetArea.
Véase también ` QDockWidget::setAllowedAreas ` y ` QDockWidget::isAreaAllowed`.
enum Qt::DropAction
flags Qt::DropActions
| Constante | Valor | Descripción |
|---|---|---|
Qt::CopyAction | 0x1 | Copiar los datos al destino. |
Qt::MoveAction | 0x2 | Mover los datos desde el origen al destino. |
Qt::LinkAction | 0x4 | Crear un enlace desde el origen al destino. |
Qt::ActionMask | 0xff | |
Qt::IgnoreAction | 0x0 | Ignora la acción (no hace nada con los datos). |
Qt::TargetMoveAction | 0x8002 | En Windows, este valor se utiliza cuando la aplicación de destino debe asumir la propiedad de los datos arrastrados y soltados, es decir, la aplicación de origen no debe eliminar los datos. En X11, este valor se utiliza para realizar un desplazamiento. TargetMoveAction no se utiliza en Mac. |
El tipo DropActions es un typedef para QFlags<DropAction>. Almacena una combinación OR de valores de DropAction.
enum Qt::Edge
flags Qt::Edges
Este tipo de enumeración especifica un borde de un rectángulo:
| Constante | Valor | Descripción |
|---|---|---|
Qt::TopEdge | 0x00001 | El borde superior del rectángulo. |
Qt::LeftEdge | 0x00002 | El borde izquierdo del rectángulo. |
Qt::RightEdge | 0x00004 | El borde derecho del rectángulo. |
Qt::BottomEdge | 0x00008 | El borde inferior del rectángulo. |
El tipo «Edges» es una definición de tipo (typedef) para QFlags<Edge>. Almacena una combinación OR de valores de Edge.
enum Qt::EnterKeyType
Esto permite modificar el aspecto de la tecla «Intro» en un teclado en pantalla.
Nota: No todos estos valores son compatibles con todas las plataformas. En el caso de los valores no compatibles, se utilizará la tecla por defecto en su lugar.
| Constante | Valor | Descripción |
|---|---|---|
Qt::EnterKeyDefault | 0 | La tecla Intro predeterminada. Puede ser un botón que cierre el teclado o un botón «Intro» que genere una nueva línea en el caso de un campo de entrada de varias líneas. |
Qt::EnterKeyReturn | 1 | Muestra un botón «Retorno» que inserta una nueva línea. El teclado no se cerrará al pulsar este botón. |
Qt::EnterKeyDone | 2 | Mostrar un botón «Hecho». El teclado se cerrará al pulsar este botón. |
Qt::EnterKeyGo | 3 | Mostrar un botón «Ir». Se suele utilizar en la barra de direcciones al introducir una URL; el teclado se cerrará al pulsar este botón. |
Qt::EnterKeySend | 4 | Mostrar un botón «Enviar». El teclado se cerrará al pulsar este botón. |
Qt::EnterKeySearch | 5 | Mostrar un botón «Buscar». El teclado se cerrará al pulsar este botón. |
Qt::EnterKeyNext | 6 | Mostrar un botón «Siguiente». Se utiliza habitualmente en un formulario para permitir pasar al siguiente campo de entrada; el teclado no se cerrará al pulsar este botón. |
Qt::EnterKeyPrevious | 7 | Mostrar un botón «Anterior». El teclado no se cerrará al pulsar este botón. |
enum Qt::EventPriority
Esta enumeración se puede utilizar para especificar las prioridades de los eventos.
| Constante | Valor | Descripción |
|---|---|---|
Qt::HighEventPriority | 1 | Los eventos con esta prioridad se envían antes que los eventos con «NormalEventPriority» o «LowEventPriority». |
Qt::NormalEventPriority | 0 | Los eventos con esta prioridad se envían después de los eventos con HighEventPriority, pero antes de los eventos con LowEventPriority. |
Qt::LowEventPriority | -1 | Los eventos con esta prioridad se envían después de los eventos con «HighEventPriority» o «NormalEventPriority». |
Ten en cuenta que estos valores se proporcionan únicamente por comodidad, ya que las prioridades de los eventos pueden ser cualquier valor comprendido entre INT_MAX y INT_MIN, ambos inclusive. Por ejemplo, puedes definir prioridades personalizadas que sean relativas entre sí:
enum CustomEventPriority
{
// An important event
ImportantEventPriority = Qt::HighEventPriority,
// A more important event
MoreImportantEventPriority = ImportantEventPriority + 1,
// A critical event
CriticalEventPriority = 100 * MoreImportantEventPriority,
// Not that important
StatusEventPriority = Qt::LowEventPriority,
// These are less important than Status events
IdleProcessingDoneEventPriority = StatusEventPriority - 1
};Véase también QCoreApplication::postEvent().
enum Qt::FillRule
Especifica qué método debe utilizarse para rellenar las rutas y los polígonos.
| Constante | Valor | Descripción |
|---|---|---|
Qt::OddEvenFill | 0 | Especifica que la región se rellena utilizando la regla de relleno par-impar. Con esta regla, se determina si un punto se encuentra dentro de la forma mediante el siguiente método. Traza una línea horizontal desde el punto hasta un punto situado fuera de la forma y cuenta el número de intersecciones. Si el número de intersecciones es impar, el punto se encuentra dentro de la forma. Este modo es el predeterminado. |
Qt::WindingFill | 1 | Especifica que la región se rellena utilizando la regla de «enrollamiento distinto de cero». Con esta regla, se determina si un punto está dentro de la forma mediante el siguiente método: se traza una línea horizontal desde el punto hasta un punto situado fuera de la forma y se cuenta el número de intersecciones. Si el número de intersecciones es impar, el punto está dentro de la forma. Este modo es el predeterminado. El número de enrollamiento se determina sumando la dirección de cada intersección. Si el número es distinto de cero, el punto se encuentra dentro de la figura. Este modo de relleno también puede considerarse, en la mayoría de los casos, como la intersección de figuras cerradas. |
enum Qt::FindChildOption
flags Qt::FindChildOptions
| Constante | Valor | Descripción |
|---|---|---|
Qt::FindDirectChildrenOnly | 0x0 | Solo tiene en cuenta los hijos directos del objeto. |
Qt::FindChildrenRecursively | 0x1 | Toma en cuenta todos los hijos del objeto (búsqueda recursiva). |
El tipo FindChildOptions es una definición de tipo para QFlags<FindChildOption>. Almacena una combinación OR de valores de FindChildOption.
enum Qt::FocusPolicy
Este tipo de enumeración define las distintas políticas que puede tener un widget en lo que respecta a la obtención del foco del teclado.
| Constante | Valor | Descripción |
|---|---|---|
Qt::TabFocus | 0x1 | El widget acepta el foco mediante la tecla Tab. |
Qt::ClickFocus | 0x2 | El widget acepta el foco al hacer clic. |
Qt::StrongFocus | TabFocus | ClickFocus | 0x8 | El widget acepta el foco tanto con la tecla Tab como haciendo clic. En macOS, esto también indicará que el widget acepta el foco con la tecla Tab cuando se encuentra en «modo de foco de texto/lista». |
Qt::WheelFocus | StrongFocus | 0x4 | Igual que Qt::StrongFocus, pero además el widget acepta el foco mediante la rueda del ratón. |
Qt::NoFocus | 0 | El widget no acepta el foco. |
enum Qt::FocusReason
Esta enumeración especifica el motivo por el que ha cambiado el foco. Se transmitirá a través de ` QWidget::setFocus ` y se puede recuperar en el ` QFocusEvent ` enviado al widget al producirse el cambio de foco.
| Constante | Valor | Descripción |
|---|---|---|
Qt::MouseFocusReason | 0 | Se ha producido una acción del ratón. |
Qt::TabFocusReason | 1 | Se ha pulsado la tecla Tab. |
Qt::BacktabFocusReason | 2 | Se ha producido un «Backtab». La entrada correspondiente puede incluir las teclas Mayús o Control; p. ej., Mayús+Tab. |
Qt::ActiveWindowFocusReason | 3 | El sistema de ventanas ha activado o desactivado esta ventana. |
Qt::PopupFocusReason | 4 | La aplicación ha abierto o cerrado una ventana emergente que ha capturado o liberado el foco del teclado. |
Qt::ShortcutFocusReason | 5 | El usuario ha escrito el atajo asociado a una etiqueta |
Qt::MenuBarFocusReason | 6 | La barra de menús ha obtenido el foco. |
Qt::OtherFocusReason | 7 | Otra razón, normalmente específica de la aplicación. |
Véase también «Foco del teclado en widgets».
enum Qt::GestureFlag
flags Qt::GestureFlags
Este tipo de enumeración describe los indicadores adicionales que se pueden utilizar al suscribirse a un gesto.
| Constante | Valor | Descripción |
|---|---|---|
Qt::DontStartGestureOnChildren | 0x01 | Por defecto, los gestos pueden iniciarse en el widget o en cualquiera de sus elementos secundarios. Utiliza este indicador para desactivar esta opción y permitir que un gesto se inicie únicamente en el widget. |
Qt::ReceivePartialGestures | 0x02 | Permite que cualquier evento de gesto ignorado se propague a los widgets padres que hayan especificado esta indicación. De forma predeterminada, solo se propagan los gestos que se encuentran en el estado « Qt::GestureStarted » (inicio de la secuencia) y el widget siempre recibe la secuencia completa del gesto, comenzando con un gesto en el estado « Qt::GestureStarted » (inicio de la secuencia) y terminando con un gesto en los estados « Qt::GestureFinished » (fin de la secuencia) o « Qt::GestureCanceled » (fin de la secuencia). |
Qt::IgnoredGesturesPropagateToParent (since Qt 4.7) | 0x04 | Permite ajustar con precisión la propagación de eventos de gestos. Al activar el indicador al grabbing un gesto, todos los gestos parciales ignorados se propagarán a sus elementos padres. |
El tipo `GestureFlags` es una definición de tipo (`typedef`) para ` QFlags<GestureFlag>`. Almacena una combinación OR de valores de `GestureFlag`.
Véanse también QWidget::grabGesture() y QGraphicsObject::grabGesture().
enum Qt::GestureState
Este tipo de enumeración describe el estado de un gesto.
| Constante | Valor | Descripción |
|---|---|---|
Qt::NoGesture | 0 | No se ha detectado ningún gesto. |
Qt::GestureStarted | 1 | Se ha iniciado un gesto continuo. |
Qt::GestureUpdated | 2 | Un gesto continúa. |
Qt::GestureFinished | 3 | Ha finalizado un gesto. |
Qt::GestureCanceled | 4 | Se ha cancelado un gesto. |
Véase también « QGesture ».
enum Qt::GestureType
Este tipo de enumeración describe los gestos estándar.
| Constante | Valor | Descripción |
|---|---|---|
Qt::TapGesture | 1 | Un gesto de pulsación. |
Qt::TapAndHoldGesture | 2 | Un gesto de pulsación y mantenimiento (pulsación prolongada). |
Qt::PanGesture | 3 | Un gesto de desplazamiento. |
Qt::PinchGesture | 4 | Un gesto de pellizcar. |
Qt::SwipeGesture | 5 | Un gesto de deslizamiento. |
Qt::CustomGesture | 0x0100 | Un indicador que se puede utilizar para comprobar si el gesto tiene un identificador definido por el usuario. |
Los gestos definidos por el usuario se registran con la función QGestureRecognizer::registerRecognizer(), que genera un identificador de gesto personalizado con el indicador Qt::CustomGesture activado.
Véase también QGesture, QWidget::grabGesture() y QGraphicsObject::grabGesture().
enum Qt::GlobalColor
Objetos predefinidos de Qt XML en « QColor »:
| Constante | Valor | Descripción |
|---|---|---|
Qt::white | 3 | Blanco (#ffffff) |
Qt::black | 2 | Negro (#000000) |
Qt::red | 7 | Rojo (#ff0000) |
Qt::darkRed | 13 | Rojo oscuro (#800000) |
Qt::green | 8 | Verde (#00ff00) |
Qt::darkGreen | 14 | Verde oscuro (#008000) |
Qt::blue | 9 | Azul (#0000ff) |
Qt::darkBlue | 15 | Azul oscuro (#000080) |
Qt::cyan | 10 | Cian (#00ffff) |
Qt::darkCyan | 16 | Cian oscuro (#008080) |
Qt::magenta | 11 | Magenta (#ff00ff) |
Qt::darkMagenta | 17 | Magenta oscuro (#800080) |
Qt::yellow | 12 | Amarillo (#ffff00) |
Qt::darkYellow | 18 | Amarillo oscuro (#808000) |
Qt::gray | 5 | Gris (#a0a0a4) |
Qt::darkGray | 4 | Gris oscuro (#808080) |
Qt::lightGray | 6 | Gris claro (#c0c0c0) |
Qt::transparent | 19 | un valor de negro transparente (es decir, QColor(0, 0, 0, 0)) |
Qt::color0 | 0 | valor de 0 píxeles (para mapas de bits) |
Qt::color1 | 1 | Valor de 1 píxel (para mapas de bits) |
Véase también QColor.
Qt::HANDLE
Un tipo de identificador para objetos del sistema, definido como « void * » en todas las plataformas.
enum class Qt::HighDpiScaleFactorRoundingPolicy
Esta enumeración describe las posibles políticas de redondeo del factor de escala de alta resolución (High-DPI), que determinan cómo se gestionan los factores de escala no enteros (como el 150 % de Windows).
La política activa se establece llamando a ` QGuiApplication::setHighDpiScaleFactorRoundingPolicy()` antes de crear el objeto de la aplicación.
| Constante | Valor | Descripción |
|---|---|---|
Qt::HighDpiScaleFactorRoundingPolicy::Round | 1 | Redondear al alza para valores de 0,5 o superiores. |
Qt::HighDpiScaleFactorRoundingPolicy::Ceil | 2 | Redondear siempre al alza. |
Qt::HighDpiScaleFactorRoundingPolicy::Floor | 3 | Redondear siempre a la baja. |
Qt::HighDpiScaleFactorRoundingPolicy::RoundPreferFloor | 4 | Redondea al alza a partir de 0,75. |
Qt::HighDpiScaleFactorRoundingPolicy::PassThrough | 5 | No redondear. |
Véase también QGuiApplication::setHighDpiScaleFactorRoundingPolicy().
enum Qt::HitTestAccuracy
Esta enumeración contiene los tipos de precisión que puede utilizar la clase ` QTextDocument ` al detectar clics del ratón en documentos de texto.
| Constante | Valor | Descripción |
|---|---|---|
Qt::ExactHit | 0 | El punto en el que se produjo la entrada debe coincidir exactamente con las partes del documento sensibles a la entrada. |
Qt::FuzzyHit | 1 | El punto en el que se produjo la entrada puede situarse cerca de las partes del documento sensibles a la entrada. |
enum Qt::ImageConversionFlag
flags Qt::ImageConversionFlags
Las opciones marcadas como «(por defecto)» se establecen si no se incluye ningún otro valor de la lista (ya que los valores por defecto son cero):
Preferencia de color/monocromo (se ignora en QBitmap):
| Constante | Valor | Descripción |
|---|---|---|
Qt::AutoColor | 0x00000000 | (por defecto) - Si la imagen tiene depth 1 y solo contiene píxeles en blanco y negro, el mapa de píxeles se convierte en monocromo. |
Qt::ColorOnly | 0x00000003 | El mapa de píxeles se somete a tramado o se convierte al modo « native display depth ». |
Qt::MonoOnly | 0x00000002 | El mapa de píxeles pasa a ser monocromo. Si es necesario, se le aplica un efecto de difuminado utilizando el algoritmo de difuminado elegido. |
Preferencia de modo de tramado:
| Constante | Valor | Descripción |
|---|---|---|
Qt::DiffuseDither | 0x00000000 | (predeterminado) - Un tramado de alta calidad que utiliza difusión de errores. |
Qt::OrderedDither | 0x00000010 | Un dithering más rápido y ordenado. |
Qt::ThresholdDither | 0x00000020 | Sin difuminado; se utiliza el color más cercano. |
Preferencia de modo de difuminado para máscaras alfa de 1 bit:
| Constante | Valor | Descripción |
|---|---|---|
Qt::ThresholdAlphaDither | 0x00000000 | (por defecto) - Sin difuminado. |
Qt::OrderedAlphaDither | 0x00000004 | Un tramado ordenado más rápido. |
Qt::DiffuseAlphaDither | 0x00000008 | Un dither de alta calidad que utiliza difusión de errores. |
Preferencia entre la correspondencia de colores y el tramado:
| Constante | Valor | Descripción |
|---|---|---|
Qt::PreferDither | 0x00000040 | Aplicar siempre el tramado a las imágenes al convertirlas a espacios de color más reducidos. |
Qt::AvoidDither | 0x00000080 | Aplicar dithering a formatos indexados solo si la imagen de origen utiliza más colores diferentes que el tamaño de la tabla de colores del formato de destino. |
Qt::AutoDither | 0x00000000 | (por defecto) - Aplicar dithering solo al convertir a formatos indexados de 1 u 8 bits. |
Qt::NoOpaqueDetection | 0x00000100 | No compruebe si la imagen contiene píxeles no opacos. Utiliza esta opción si sabes que la imagen es semitransparente y quieres evitar la sobrecarga que supone comprobar los píxeles de la imagen hasta encontrar uno no opaco, o si quieres que el mapa de píxeles conserve un canal alfa por alguna otra razón. Si la imagen no tiene canal alfa, esta opción no tiene ningún efecto. |
Qt::NoFormatConversion | 0x00000200 | No realice ninguna conversión de formato en la imagen. Puede resultar útil, por ejemplo, al convertir un ` QImage ` a un ` QPixmap ` para una operación de renderizado puntual. Tenga en cuenta que un ` QPixmap ` que no esté en el formato preferido será mucho más lento como dispositivo de pintura. |
El tipo `ImageConversionFlags` es un `typedef` para ` QFlags<ImageConversionFlag>`. Almacena una combinación OR de valores de `ImageConversionFlag`.
enum Qt::InputMethodHint
flags Qt::InputMethodHints
| Constante | Valor | Descripción |
|---|---|---|
Qt::ImhNone | 0x0 | Sin sugerencias. |
Indicadores que modifican el comportamiento:
| Constante | Valor | Descripción |
|---|---|---|
Qt::ImhHiddenText | 0x1 | El método de entrada no debe mostrar los caracteres mientras se escribe. Esto se configura automáticamente al establecer « QLineEdit::echoMode » en « Password ». Ten en cuenta que establecer « ImhHiddenText » no cambia el modo de eco. |
Ten en cuenta que los IME de Android permiten deliberadamente solo la introducción de caracteres latinos/ASCII en los campos de contraseña.
| Constante | Valor | Descripción |
|---|---|---|
Qt::ImhSensitiveData | 0x2 | El texto escrito no debe ser almacenado por el método de entrada activo en ningún almacenamiento persistente, como el diccionario predictivo del usuario. |
Tenga en cuenta que el marco Qt trata esto como una contraseña visible y, en este caso, los IME de Android permiten deliberadamente solo la introducción de caracteres latinos/ASCII.
| Constante | Valor | Descripción |
|---|---|---|
Qt::ImhNoAutoUppercase | 0x4 | El método de entrada no debe intentar cambiar automáticamente a mayúsculas al finalizar una frase. |
Qt::ImhPreferNumbers | 0x8 | Se prefieren los números (aunque no son obligatorios). |
Qt::ImhPreferUppercase | 0x10 | Se prefieren las mayúsculas (aunque no son obligatorias). |
Qt::ImhPreferLowercase | 0x20 | Se prefieren las letras minúsculas (aunque no son obligatorias). |
Qt::ImhNoPredictiveText | 0x40 | No utilices el texto predictivo (es decir, la búsqueda en el diccionario) mientras escribes. |
Qt::ImhDate | 0x80 | El editor de texto funciona como un campo de fecha. |
Qt::ImhTime | 0x100 | El editor de texto funciona como un campo de hora. |
Qt::ImhPreferLatin | 0x200 | Se recomienda utilizar caracteres latinos (aunque no es obligatorio). |
Qt::ImhMultiLine | 0x400 | Se pueden introducir varias líneas en el campo de texto. |
Qt::ImhNoEditMenu | 0x800 | No utilices el menú de edición integrado. Esta opción se introdujo en Qt 5.11. |
Qt::ImhNoTextHandles | 0x1000 | No utilices el cursor de texto ni los controladores de selección integrados. Esta opción se introdujo en Qt 5.11. |
Qt::ImhNoFullscreen (since Qt 6.12) | 0x2000 | No utilices el método de entrada a pantalla completa. |
Opciones que restringen la entrada (opciones exclusivas):
| Constante | Valor | Descripción |
|---|---|---|
Qt::ImhDigitsOnly | 0x10000 | Solo se permiten dígitos. |
Qt::ImhDecimalNumbersOnly (since Qt 6.12) | 0x1000000 | Solo se permite la introducción de números. Esto incluye el punto decimal, pero no los números negativos. |
Qt::ImhFormattedNumbersOnly | 0x20000 | Solo se permite introducir números. Esto incluye el punto decimal y el signo menos. |
Qt::ImhUppercaseOnly | 0x40000 | Solo se permite introducir letras mayúsculas. |
Qt::ImhLowercaseOnly | 0x80000 | Solo se permite introducir letras minúsculas. |
Qt::ImhDialableCharactersOnly | 0x100000 | Solo se permiten caracteres aptos para marcar un número de teléfono. |
Qt::ImhEmailCharactersOnly | 0x200000 | Solo se permiten caracteres aptos para direcciones de correo electrónico. |
Qt::ImhUrlCharactersOnly | 0x400000 | Solo se permiten caracteres adecuados para direcciones URL. |
Qt::ImhLatinOnly | 0x800000 | Solo se permite la introducción de caracteres del alfabeto latino. |
Máscaras:
| Constante | Valor | Descripción |
|---|---|---|
Qt::ImhExclusiveInputMask | 0xffff0000 | Esta máscara devuelve un valor distinto de cero si se utiliza cualquiera de los indicadores exclusivos. Nota: Si se combinan varias banderas exclusivas mediante la operación OR, el conjunto de caracteres resultante consistirá en la unión de los conjuntos especificados. Por ejemplo, si se especifica |
El tipo `InputMethodHints` es una definición de tipo (typedef) para ` QFlags<InputMethodHint>`. Almacena una combinación mediante la operación OR de valores de `InputMethodHint`.
Véase también QGraphicsItem::inputMethodHints().
enum Qt::InputMethodQuery
flags Qt::InputMethodQueries
| Constante | Valor | Descripción |
|---|---|---|
Qt::ImEnabled | 0x1 | El widget acepta la entrada del método de entrada. |
Qt::ImCursorRectangle | 0x2 | El rectángulo que abarca el área del cursor de entrada en coordenadas del widget. |
Qt::ImFont | 0x4 | La fuente utilizada actualmente para la introducción de texto. |
Qt::ImCursorPosition | 0x8 | La posición lógica del cursor dentro del texto que rodea el área de entrada (véase ImSurroundingText). La posición no incluye el desplazamiento del cursor dentro del área de preedición, tal y como se controla mediante QInputMethodEvent::Cursor. |
Qt::ImSurroundingText | 0x10 | El texto sin formato que rodea el área de entrada, por ejemplo, el párrafo actual. |
Qt::ImCurrentSelection | 0x20 | El texto seleccionado actualmente. |
Qt::ImMaximumTextLength | 0x40 | El número máximo de caracteres que puede contener el widget. Si no hay límite, se devuelve QVariant::QVariant(). |
Qt::ImAnchorPosition | 0x80 | La posición del ancla de selección. Puede ser menor o mayor que ImCursorPosition, dependiendo del lado de la selección en el que se encuentre el cursor. Si no hay selección, devuelve lo mismo que ImCursorPosition. |
Qt::ImHints | 0x100 | Las sugerencias para el método de entrada sobre la entrada esperada. (Véase Qt::InputMethodHints) |
Qt::ImPreferredLanguage | 0x200 | El idioma de entrada preferido. |
Qt::ImPlatformData | 0x80000000 | Datos específicos de la plataforma para el método de entrada. |
Qt::ImAbsolutePosition | 0x400 | La posición lógica del cursor dentro de todo el documento. La posición no incluye el desplazamiento del cursor dentro del área de preedición, tal y como se controla mediante QInputMethodEvent::Cursor. |
Qt::ImTextBeforeCursor | 0x800 | El texto sin formato situado antes del cursor. El widget puede decidir cuánto texto devolver, pero no debe devolver una cadena vacía a menos que el cursor se encuentre al principio del documento. |
Qt::ImTextAfterCursor | 0x1000 | El texto sin formato situado después del cursor. El widget puede decidir cuánto texto devolver, pero no debe devolver una cadena vacía a menos que el cursor se encuentre al final del documento. |
Qt::ImEnterKeyType | 0x2000 | El tipo de tecla Intro. |
Qt::ImAnchorRectangle | 0x4000 | El rectángulo delimitador del ancla de selección. Este valor se añadió en Qt 5.7. |
Qt::ImInputItemClipRectangle | 0x8000 | El rectángulo real del elemento de entrada expuesto. Es posible que algunas partes del elemento de entrada queden recortadas. Este valor tendrá en cuenta el recorte y devolverá el rectángulo real del elemento dibujado. El rectángulo está expresado en coordenadas del widget. |
Qt::ImReadOnly | 0x10000 | El widget es de solo lectura. Este valor se añadió en Qt 6.2. |
Máscaras:
| Constante | Valor | Descripción |
|---|---|---|
Qt::ImQueryInput | ImCursorRectangle | ImCursorPosition | ImSurroundingText |
ImCurrentSelection | ImAnchorRectangle | ImAnchorPosition | Propiedades que suelen modificarse al introducir datos. |
Qt::ImQueryAll | 0xffffffff | Consulta de todas las propiedades del método de entrada. |
El tipo InputMethodQueries es una definición de tipo (typedef) para QFlags<InputMethodQuery>. Almacena una combinación «OR» de valores de InputMethodQuery.
Véase también QInputMethodQueryEvent.
enum Qt::ItemDataRole
Cada elemento del modelo tiene asociado un conjunto de elementos de datos, cada uno con su propia función. La vista utiliza estas funciones para indicar al modelo qué tipo de datos necesita. Los modelos personalizados deben devolver datos de estos tipos.
Las funciones de uso general (y los tipos asociados) son:
| Constante | Valor | Descripción |
|---|---|---|
Qt::DisplayRole | 0 | Los datos clave que se mostrarán en forma de texto. (QString) |
Qt::DecorationRole | 1 | Los datos que se mostrarán como elemento decorativo en forma de icono. (QColor, QIcon o QPixmap) |
Qt::EditRole | 2 | Los datos en un formato adecuado para su edición en un editor. (QString) |
Qt::ToolTipRole | 3 | Los datos que se muestran en la información sobre herramientas del elemento. (QString) |
Qt::StatusTipRole | 4 | Los datos que se muestran en la barra de estado. (QString) |
Qt::WhatsThisRole | 5 | Los datos que se muestran para el elemento en el modo «¿Qué es esto?». (QString) |
Qt::SizeHintRole | 13 | La indicación de tamaño del elemento que se proporcionará a las vistas. (QSize) |
Roles que describen la apariencia y los metadatos (con los tipos asociados):
| Constante | Valor | Descripción |
|---|---|---|
Qt::FontRole | 6 | La fuente utilizada para los elementos representados con el delegado predeterminado. (QFont) |
Qt::TextAlignmentRole | 7 | La alineación del texto de los elementos representados con el delegado predeterminado. (Qt::Alignment) |
Qt::BackgroundRole | 8 | El pincel de fondo utilizado para los elementos representados con el delegado predeterminado. (QBrush) |
Qt::ForegroundRole | 9 | El pincel de primer plano (normalmente, el color del texto) utilizado para los elementos representados con el delegado predeterminado. (QBrush) |
Qt::CheckStateRole | 10 | Esta función se utiliza para obtener el estado marcado de un elemento. (Qt::CheckState) |
Qt::InitialSortOrderRole | 14 | Esta función se utiliza para obtener el orden de clasificación inicial de una sección de la vista de encabezado. (Qt::SortOrder). |
Roles de accesibilidad (con tipos asociados):
| Constante | Valor | Descripción |
|---|---|---|
Qt::AccessibleTextRole | 11 | El texto que deben utilizar las extensiones y los complementos de accesibilidad, como los lectores de pantalla. (QString) |
Qt::AccessibleDescriptionRole | 12 | Descripción del elemento a efectos de accesibilidad. (QString) |
Roles de usuario:
| Constante | Valor | Descripción |
|---|---|---|
Qt::UserRole | 0x0100 | El primer rol que se puede utilizar para fines específicos de la aplicación. |
En el caso de los roles de usuario, corresponde al desarrollador decidir qué tipos utilizar y asegurarse de que los componentes utilicen los tipos correctos al acceder a los datos y al configurarlos.
enum Qt::ItemFlag
flags Qt::ItemFlags
Esta enumeración describe las propiedades de un elemento:
| Constante | Valor | Descripción |
|---|---|---|
Qt::NoItemFlags | 0 | No tiene ninguna propiedad definida. |
Qt::ItemIsSelectable | 1 | Se puede seleccionar. |
Qt::ItemIsEditable | 2 | Se puede editar. |
Qt::ItemIsDragEnabled | 4 | Se puede arrastrar. |
Qt::ItemIsDropEnabled | 8 | Se puede utilizar como destino de arrastre. |
Qt::ItemIsUserCheckable | 16 | El usuario puede marcarlo o desmarcarlo. |
Qt::ItemIsEnabled | 32 | El usuario puede interactuar con el elemento. |
Qt::ItemIsAutoTristate | 64 | El estado del elemento depende del estado de sus elementos secundarios. Esto permite la gestión automática del estado de los elementos principales en QTreeWidget (marcado si todos los elementos secundarios están marcados, desmarcado si todos los elementos secundarios están desmarcados, o parcialmente marcado si solo algunos elementos secundarios están marcados). |
Qt::ItemNeverHasChildren | 128 | El elemento nunca tiene elementos hijos. Esto se utiliza únicamente con fines de optimización. |
Qt::ItemIsUserTristate | 256 | El usuario puede alternar entre tres estados distintos. Este valor se añadió en Qt 5.5. |
Ten en cuenta que a los elementos marcables se les debe asignar tanto un conjunto adecuado de indicadores como un estado inicial, que indique si el elemento está marcado o no. Esto se gestiona automáticamente para los componentes de modelo/vista, pero debe establecerse explícitamente para las instancias de ` QListWidgetItem`, ` QTableWidgetItem` y ` QTreeWidgetItem`.
Ten en cuenta que se considera un comportamiento indefinido reimplementar ` QAbstractItemModel::hasChildren ` para que devuelva `true` para un índice si dicho índice tiene activado el indicador `Qt::ItemNeverHasChildren`.
El tipo `ItemFlags` es un `typedef` de ` QFlags<ItemFlag>`. Almacena una combinación OR de valores de `ItemFlag`.
Véase también ` QAbstractItemModel`.
enum Qt::ItemSelectionMode
Esta enumeración se utiliza en QGraphicsItem, QGraphicsScene y QGraphicsView para especificar cómo se seleccionan los elementos o cómo determinar si las formas y los elementos colisionan.
| Constante | Valor | Descripción |
|---|---|---|
Qt::ContainsItemShape | 0x0 | La lista de resultados contiene únicamente elementos cuyo ` shape ` esté completamente incluido dentro del área de selección. No se incluyen los elementos que se cruzan con el contorno del área. |
Qt::IntersectsItemShape | 0x1 | La lista de resultados contiene tanto los elementos cuyo « shape » está completamente dentro del área de selección como los que se cruzan con el contorno de dicha área. Este es un modo habitual para la selección de «goma elástica». |
Qt::ContainsItemBoundingRect | 0x2 | La lista de resultados contiene únicamente elementos cuyo área de « bounding rectangle » esté completamente dentro del área de selección. No se incluyen los elementos que se superponen al contorno del área. |
Qt::IntersectsItemBoundingRect | 0x3 | La lista de resultados contiene tanto los elementos cuyo ` bounding rectangle ` está completamente dentro del área de selección como los que se superponen al contorno de dicha área. Este método se utiliza habitualmente para determinar las áreas que deben redibujarse. |
Véase también QGraphicsScene::items(), QGraphicsScene::collidingItems(), QGraphicsView::items(), QGraphicsItem::collidesWithItem() y QGraphicsItem::collidesWithPath().
enum Qt::ItemSelectionOperation
Esta enumeración se utiliza en QGraphicsScene para especificar qué hacer con los elementos seleccionados actualmente al establecer un área de selección.
| Constante | Valor | Descripción |
|---|---|---|
Qt::ReplaceSelection | 0 | Los elementos seleccionados actualmente se sustituyen por los elementos del área de selección. |
Qt::AddToSelection | 1 | Los elementos del área de selección se añaden a los elementos seleccionados actualmente. |
Véase también QGraphicsScene::setSelectionArea().
enum Qt::Key
Los nombres clave utilizados por Qt.
| Constante | Valor | Descripción |
|---|---|---|
Qt::Key_Escape | 0x01000000 | |
Qt::Key_Tab | 0x01000001 | |
Qt::Key_Backtab | 0x01000002 | |
Qt::Key_Backspace | 0x01000003 | |
Qt::Key_Return | 0x01000004 | |
Qt::Key_Enter | 0x01000005 | Suele encontrarse en el teclado. |
Qt::Key_Insert | 0x01000006 | |
Qt::Key_Delete | 0x01000007 | |
Qt::Key_Pause | 0x01000008 | La tecla «Pausa/Interrupción» (Nota: no tiene nada que ver con la pausa de los contenidos multimedia) |
Qt::Key_Print | 0x01000009 | |
Qt::Key_SysReq | 0x0100000a | |
Qt::Key_Clear | 0x0100000b | Equivale a la tecla «Clear» en determinados modelos de teclado de Apple. En otros sistemas, suele asignarse a la tecla 5 del teclado numérico cuando Num Lock está des off. |
Qt::Key_Home | 0x01000010 | |
Qt::Key_End | 0x01000011 | |
Qt::Key_Left | 0x01000012 | |
Qt::Key_Up | 0x01000013 | |
Qt::Key_Right | 0x01000014 | |
Qt::Key_Down | 0x01000015 | |
Qt::Key_PageUp | 0x01000016 | |
Qt::Key_PageDown | 0x01000017 | |
Qt::Key_Shift | 0x01000020 | |
Qt::Key_Control | 0x01000021 | En macOS, esto se corresponde con las teclas Comando. |
Qt::Key_Meta | 0x01000022 | En macOS, esto se corresponde con las teclas Control. En los teclados de Windows, esta tecla está asignada a la tecla Windows. |
Qt::Key_Alt | 0x01000023 | |
Qt::Key_AltGr | 0x01001103 | En Windows, cuando se envía el evento « KeyDown » para esta tecla, también se activan los modificadores Ctrl+Alt. |
Qt::Key_CapsLock | 0x01000024 | |
Qt::Key_NumLock | 0x01000025 | |
Qt::Key_ScrollLock | 0x01000026 | |
Qt::Key_F1 | 0x01000030 | |
Qt::Key_F2 | 0x01000031 | |
Qt::Key_F3 | 0x01000032 | |
Qt::Key_F4 | 0x01000033 | |
Qt::Key_F5 | 0x01000034 | |
Qt::Key_F6 | 0x01000035 | |
Qt::Key_F7 | 0x01000036 | |
Qt::Key_F8 | 0x01000037 | |
Qt::Key_F9 | 0x01000038 | |
Qt::Key_F10 | 0x01000039 | |
Qt::Key_F11 | 0x0100003a | |
Qt::Key_F12 | 0x0100003b | |
Qt::Key_F13 | 0x0100003c | |
Qt::Key_F14 | 0x0100003d | |
Qt::Key_F15 | 0x0100003e | |
Qt::Key_F16 | 0x0100003f | |
Qt::Key_F17 | 0x01000040 | |
Qt::Key_F18 | 0x01000041 | |
Qt::Key_F19 | 0x01000042 | |
Qt::Key_F20 | 0x01000043 | |
Qt::Key_F21 | 0x01000044 | |
Qt::Key_F22 | 0x01000045 | |
Qt::Key_F23 | 0x01000046 | |
Qt::Key_F24 | 0x01000047 | |
Qt::Key_F25 | 0x01000048 | |
Qt::Key_F26 | 0x01000049 | |
Qt::Key_F27 | 0x0100004a | |
Qt::Key_F28 | 0x0100004b | |
Qt::Key_F29 | 0x0100004c | |
Qt::Key_F30 | 0x0100004d | |
Qt::Key_F31 | 0x0100004e | |
Qt::Key_F32 | 0x0100004f | |
Qt::Key_F33 | 0x01000050 | |
Qt::Key_F34 | 0x01000051 | |
Qt::Key_F35 | 0x01000052 | |
Qt::Key_Super_L | 0x01000053 | |
Qt::Key_Super_R | 0x01000054 | |
Qt::Key_Menu | 0x01000055 | |
Qt::Key_Hyper_L | 0x01000056 | |
Qt::Key_Hyper_R | 0x01000057 | |
Qt::Key_Help | 0x01000058 | |
Qt::Key_Direction_L | 0x01000059 | |
Qt::Key_Direction_R | 0x01000060 | |
Qt::Key_Space | 0x20 | |
Qt::Key_Any | Key_Space | |
Qt::Key_Exclam | 0x21 | |
Qt::Key_QuoteDbl | 0x22 | |
Qt::Key_NumberSign | 0x23 | |
Qt::Key_Dollar | 0x24 | |
Qt::Key_Percent | 0x25 | |
Qt::Key_Ampersand | 0x26 | |
Qt::Key_Apostrophe | 0x27 | |
Qt::Key_ParenLeft | 0x28 | |
Qt::Key_ParenRight | 0x29 | |
Qt::Key_Asterisk | 0x2a | |
Qt::Key_Plus | 0x2b | |
Qt::Key_Comma | 0x2c | |
Qt::Key_Minus | 0x2d | |
Qt::Key_Period | 0x2e | |
Qt::Key_Slash | 0x2f | |
Qt::Key_0 | 0x30 | |
Qt::Key_1 | 0x31 | |
Qt::Key_2 | 0x32 | |
Qt::Key_3 | 0x33 | |
Qt::Key_4 | 0x34 | |
Qt::Key_5 | 0x35 | |
Qt::Key_6 | 0x36 | |
Qt::Key_7 | 0x37 | |
Qt::Key_8 | 0x38 | |
Qt::Key_9 | 0x39 | |
Qt::Key_Colon | 0x3a | |
Qt::Key_Semicolon | 0x3b | |
Qt::Key_Less | 0x3c | |
Qt::Key_Equal | 0x3d | |
Qt::Key_Greater | 0x3e | |
Qt::Key_Question | 0x3f | |
Qt::Key_At | 0x40 | |
Qt::Key_A | 0x41 | |
Qt::Key_B | 0x42 | |
Qt::Key_C | 0x43 | |
Qt::Key_D | 0x44 | |
Qt::Key_E | 0x45 | |
Qt::Key_F | 0x46 | |
Qt::Key_G | 0x47 | |
Qt::Key_H | 0x48 | |
Qt::Key_I | 0x49 | |
Qt::Key_J | 0x4a | |
Qt::Key_K | 0x4b | |
Qt::Key_L | 0x4c | |
Qt::Key_M | 0x4d | |
Qt::Key_N | 0x4e | |
Qt::Key_O | 0x4f | |
Qt::Key_P | 0x50 | |
Qt::Key_Q | 0x51 | |
Qt::Key_R | 0x52 | |
Qt::Key_S | 0x53 | |
Qt::Key_T | 0x54 | |
Qt::Key_U | 0x55 | |
Qt::Key_V | 0x56 | |
Qt::Key_W | 0x57 | |
Qt::Key_X | 0x58 | |
Qt::Key_Y | 0x59 | |
Qt::Key_Z | 0x5a | |
Qt::Key_BracketLeft | 0x5b | |
Qt::Key_Backslash | 0x5c | |
Qt::Key_BracketRight | 0x5d | |
Qt::Key_AsciiCircum | 0x5e | |
Qt::Key_Underscore | 0x5f | |
Qt::Key_QuoteLeft | 0x60 | |
Qt::Key_BraceLeft | 0x7b | |
Qt::Key_Bar | 0x7c | |
Qt::Key_BraceRight | 0x7d | |
Qt::Key_AsciiTilde | 0x7e | |
Qt::Key_nobreakspace | 0x0a0 | |
Qt::Key_exclamdown | 0x0a1 | |
Qt::Key_cent | 0x0a2 | |
Qt::Key_sterling | 0x0a3 | |
Qt::Key_currency | 0x0a4 | |
Qt::Key_yen | 0x0a5 | |
Qt::Key_brokenbar | 0x0a6 | |
Qt::Key_section | 0x0a7 | |
Qt::Key_diaeresis | 0x0a8 | |
Qt::Key_copyright | 0x0a9 | |
Qt::Key_ordfeminine | 0x0aa | |
Qt::Key_guillemotleft | 0x0ab | |
Qt::Key_notsign | 0x0ac | |
Qt::Key_hyphen | 0x0ad | |
Qt::Key_registered | 0x0ae | |
Qt::Key_macron | 0x0af | |
Qt::Key_degree | 0x0b0 | |
Qt::Key_plusminus | 0x0b1 | |
Qt::Key_twosuperior | 0x0b2 | |
Qt::Key_threesuperior | 0x0b3 | |
Qt::Key_acute | 0x0b4 | |
Qt::Key_micro (since Qt 6.7) | 0x0b5 | |
Qt::Key_mu | Key_micro | Alias obsoleto para Key_micro |
Qt::Key_paragraph | 0x0b6 | |
Qt::Key_periodcentered | 0x0b7 | |
Qt::Key_cedilla | 0x0b8 | |
Qt::Key_onesuperior | 0x0b9 | |
Qt::Key_masculine | 0x0ba | |
Qt::Key_guillemotright | 0x0bb | |
Qt::Key_onequarter | 0x0bc | |
Qt::Key_onehalf | 0x0bd | |
Qt::Key_threequarters | 0x0be | |
Qt::Key_questiondown | 0x0bf | |
Qt::Key_Agrave | 0x0c0 | |
Qt::Key_Aacute | 0x0c1 | |
Qt::Key_Acircumflex | 0x0c2 | |
Qt::Key_Atilde | 0x0c3 | |
Qt::Key_Adiaeresis | 0x0c4 | |
Qt::Key_Aring | 0x0c5 | |
Qt::Key_AE | 0x0c6 | |
Qt::Key_Ccedilla | 0x0c7 | |
Qt::Key_Egrave | 0x0c8 | |
Qt::Key_Eacute | 0x0c9 | |
Qt::Key_Ecircumflex | 0x0ca | |
Qt::Key_Ediaeresis | 0x0cb | |
Qt::Key_Igrave | 0x0cc | |
Qt::Key_Iacute | 0x0cd | |
Qt::Key_Icircumflex | 0x0ce | |
Qt::Key_Idiaeresis | 0x0cf | |
Qt::Key_ETH | 0x0d0 | |
Qt::Key_Ntilde | 0x0d1 | |
Qt::Key_Ograve | 0x0d2 | |
Qt::Key_Oacute | 0x0d3 | |
Qt::Key_Ocircumflex | 0x0d4 | |
Qt::Key_Otilde | 0x0d5 | |
Qt::Key_Odiaeresis | 0x0d6 | |
Qt::Key_multiply | 0x0d7 | |
Qt::Key_Ooblique | 0x0d8 | |
Qt::Key_Ugrave | 0x0d9 | |
Qt::Key_Uacute | 0x0da | |
Qt::Key_Ucircumflex | 0x0db | |
Qt::Key_Udiaeresis | 0x0dc | |
Qt::Key_Yacute | 0x0dd | |
Qt::Key_THORN | 0x0de | |
Qt::Key_ssharp | 0x0df | |
Qt::Key_division | 0x0f7 | |
Qt::Key_ydiaeresis | 0x0ff | |
Qt::Key_Multi_key | 0x01001120 | |
Qt::Key_Codeinput | 0x01001137 | |
Qt::Key_SingleCandidate | 0x0100113c | |
Qt::Key_MultipleCandidate | 0x0100113d | |
Qt::Key_PreviousCandidate | 0x0100113e | |
Qt::Key_Mode_switch | 0x0100117e | |
Qt::Key_Kanji | 0x01001121 | |
Qt::Key_Muhenkan | 0x01001122 | |
Qt::Key_Henkan | 0x01001123 | |
Qt::Key_Romaji | 0x01001124 | |
Qt::Key_Hiragana | 0x01001125 | |
Qt::Key_Katakana | 0x01001126 | |
Qt::Key_Hiragana_Katakana | 0x01001127 | |
Qt::Key_Zenkaku | 0x01001128 | |
Qt::Key_Hankaku | 0x01001129 | |
Qt::Key_Zenkaku_Hankaku | 0x0100112a | |
Qt::Key_Touroku | 0x0100112b | |
Qt::Key_Massyo | 0x0100112c | |
Qt::Key_Kana_Lock | 0x0100112d | |
Qt::Key_Kana_Shift | 0x0100112e | |
Qt::Key_Eisu_Shift | 0x0100112f | |
Qt::Key_Eisu_toggle | 0x01001130 | |
Qt::Key_Hangul | 0x01001131 | |
Qt::Key_Hangul_Start | 0x01001132 | |
Qt::Key_Hangul_End | 0x01001133 | |
Qt::Key_Hangul_Hanja | 0x01001134 | |
Qt::Key_Hangul_Jamo | 0x01001135 | |
Qt::Key_Hangul_Romaja | 0x01001136 | |
Qt::Key_Hangul_Jeonja | 0x01001138 | |
Qt::Key_Hangul_Banja | 0x01001139 | |
Qt::Key_Hangul_PreHanja | 0x0100113a | |
Qt::Key_Hangul_PostHanja | 0x0100113b | |
Qt::Key_Hangul_Special | 0x0100113f | |
Qt::Key_Dead_Grave | 0x01001250 | |
Qt::Key_Dead_Acute | 0x01001251 | |
Qt::Key_Dead_Circumflex | 0x01001252 | |
Qt::Key_Dead_Tilde | 0x01001253 | |
Qt::Key_Dead_Macron | 0x01001254 | |
Qt::Key_Dead_Breve | 0x01001255 | |
Qt::Key_Dead_Abovedot | 0x01001256 | |
Qt::Key_Dead_Diaeresis | 0x01001257 | |
Qt::Key_Dead_Abovering | 0x01001258 | |
Qt::Key_Dead_Doubleacute | 0x01001259 | |
Qt::Key_Dead_Caron | 0x0100125a | |
Qt::Key_Dead_Cedilla | 0x0100125b | |
Qt::Key_Dead_Ogonek | 0x0100125c | |
Qt::Key_Dead_Iota | 0x0100125d | |
Qt::Key_Dead_Voiced_Sound | 0x0100125e | |
Qt::Key_Dead_Semivoiced_Sound | 0x0100125f | |
Qt::Key_Dead_Belowdot | 0x01001260 | |
Qt::Key_Dead_Hook | 0x01001261 | |
Qt::Key_Dead_Horn | 0x01001262 | |
Qt::Key_Dead_Stroke | 0x01001263 | |
Qt::Key_Dead_Abovecomma | 0x01001264 | |
Qt::Key_Dead_Abovereversedcomma | 0x01001265 | |
Qt::Key_Dead_Doublegrave | 0x01001266 | |
Qt::Key_Dead_Belowring | 0x01001267 | |
Qt::Key_Dead_Belowmacron | 0x01001268 | |
Qt::Key_Dead_Belowcircumflex | 0x01001269 | |
Qt::Key_Dead_Belowtilde | 0x0100126a | |
Qt::Key_Dead_Belowbreve | 0x0100126b | |
Qt::Key_Dead_Belowdiaeresis | 0x0100126c | |
Qt::Key_Dead_Invertedbreve | 0x0100126d | |
Qt::Key_Dead_Belowcomma | 0x0100126e | |
Qt::Key_Dead_Currency | 0x0100126f | |
Qt::Key_Dead_a | 0x01001280 | |
Qt::Key_Dead_A | 0x01001281 | |
Qt::Key_Dead_e | 0x01001282 | |
Qt::Key_Dead_E | 0x01001283 | |
Qt::Key_Dead_i | 0x01001284 | |
Qt::Key_Dead_I | 0x01001285 | |
Qt::Key_Dead_o | 0x01001286 | |
Qt::Key_Dead_O | 0x01001287 | |
Qt::Key_Dead_u | 0x01001288 | |
Qt::Key_Dead_U | 0x01001289 | |
Qt::Key_Dead_Small_Schwa | 0x0100128a | |
Qt::Key_Dead_Capital_Schwa | 0x0100128b | |
Qt::Key_Dead_Greek | 0x0100128c | |
Qt::Key_Dead_Lowline | 0x01001290 | |
Qt::Key_Dead_Aboveverticalline | 0x01001291 | |
Qt::Key_Dead_Belowverticalline | 0x01001292 | |
Qt::Key_Dead_Longsolidusoverlay | 0x01001293 | |
Qt::Key_Back | 0x01000061 | |
Qt::Key_Forward | 0x01000062 | |
Qt::Key_Stop | 0x01000063 | |
Qt::Key_Refresh | 0x01000064 | |
Qt::Key_VolumeDown | 0x01000070 | |
Qt::Key_VolumeMute | 0x01000071 | |
Qt::Key_VolumeUp | 0x01000072 | |
Qt::Key_BassBoost | 0x01000073 | |
Qt::Key_BassUp | 0x01000074 | |
Qt::Key_BassDown | 0x01000075 | |
Qt::Key_TrebleUp | 0x01000076 | |
Qt::Key_TrebleDown | 0x01000077 | |
Qt::Key_MediaPlay | 0x01000080 | Una clave que establece el estado del reproductor multimedia para que reproduzca |
Qt::Key_MediaStop | 0x01000081 | Una tecla que establece el estado del reproductor multimedia para detener la reproducción |
Qt::Key_MediaPrevious | 0x01000082 | |
Qt::Key_MediaNext | 0x01000083 | |
Qt::Key_MediaRecord | 0x01000084 | |
Qt::Key_MediaPause | 0x01000085 | Una tecla que establece el estado del reproductor multimedia en pausa (Nota: no es la tecla de pausa/interrupción) |
Qt::Key_MediaTogglePlayPause | 0x01000086 | Una tecla para alternar entre los estados de reproducción y pausa en el reproductor multimedia (en lugar de establecer un estado absoluto) |
Qt::Key_HomePage | 0x01000090 | |
Qt::Key_Favorites | 0x01000091 | |
Qt::Key_Search | 0x01000092 | |
Qt::Key_Standby | 0x01000093 | |
Qt::Key_OpenUrl | 0x01000094 | |
Qt::Key_LaunchMail | 0x010000a0 | |
Qt::Key_LaunchMedia | 0x010000a1 | |
Qt::Key_Launch0 | 0x010000a2 | |
Qt::Key_Launch1 | 0x010000a3 | |
Qt::Key_Launch2 | 0x010000a4 | |
Qt::Key_Launch3 | 0x010000a5 | |
Qt::Key_Launch4 | 0x010000a6 | |
Qt::Key_Launch5 | 0x010000a7 | |
Qt::Key_Launch6 | 0x010000a8 | |
Qt::Key_Launch7 | 0x010000a9 | |
Qt::Key_Launch8 | 0x010000aa | |
Qt::Key_Launch9 | 0x010000ab | |
Qt::Key_LaunchA | 0x010000ac | |
Qt::Key_LaunchB | 0x010000ad | |
Qt::Key_LaunchC | 0x010000ae | |
Qt::Key_LaunchD | 0x010000af | |
Qt::Key_LaunchE | 0x010000b0 | |
Qt::Key_LaunchF | 0x010000b1 | |
Qt::Key_LaunchG | 0x0100010e | |
Qt::Key_LaunchH | 0x0100010f | |
Qt::Key_MonBrightnessUp | 0x010000b2 | |
Qt::Key_MonBrightnessDown | 0x010000b3 | |
Qt::Key_KeyboardLightOnOff | 0x010000b4 | |
Qt::Key_KeyboardBrightnessUp | 0x010000b5 | |
Qt::Key_KeyboardBrightnessDown | 0x010000b6 | |
Qt::Key_PowerOff | 0x010000b7 | |
Qt::Key_WakeUp | 0x010000b8 | |
Qt::Key_Eject | 0x010000b9 | |
Qt::Key_ScreenSaver | 0x010000ba | |
Qt::Key_WWW | 0x010000bb | |
Qt::Key_Memo | 0x010000bc | |
Qt::Key_LightBulb | 0x010000bd | |
Qt::Key_Shop | 0x010000be | |
Qt::Key_History | 0x010000bf | |
Qt::Key_AddFavorite | 0x010000c0 | |
Qt::Key_HotLinks | 0x010000c1 | |
Qt::Key_BrightnessAdjust | 0x010000c2 | |
Qt::Key_Finance | 0x010000c3 | |
Qt::Key_Community | 0x010000c4 | |
Qt::Key_AudioRewind | 0x010000c5 | |
Qt::Key_BackForward | 0x010000c6 | |
Qt::Key_ApplicationLeft | 0x010000c7 | |
Qt::Key_ApplicationRight | 0x010000c8 | |
Qt::Key_Book | 0x010000c9 | |
Qt::Key_CD | 0x010000ca | |
Qt::Key_Calculator | 0x010000cb | |
Qt::Key_ToDoList | 0x010000cc | |
Qt::Key_ClearGrab | 0x010000cd | |
Qt::Key_Close | 0x010000ce | |
Qt::Key_Copy | 0x010000cf | |
Qt::Key_Cut | 0x010000d0 | |
Qt::Key_Display | 0x010000d1 | |
Qt::Key_DOS | 0x010000d2 | |
Qt::Key_Documents | 0x010000d3 | |
Qt::Key_Excel | 0x010000d4 | |
Qt::Key_Explorer | 0x010000d5 | |
Qt::Key_Game | 0x010000d6 | |
Qt::Key_Go | 0x010000d7 | |
Qt::Key_iTouch | 0x010000d8 | |
Qt::Key_LogOff | 0x010000d9 | |
Qt::Key_Market | 0x010000da | |
Qt::Key_Meeting | 0x010000db | |
Qt::Key_MenuKB | 0x010000dc | |
Qt::Key_MenuPB | 0x010000dd | |
Qt::Key_MySites | 0x010000de | |
Qt::Key_News | 0x010000df | |
Qt::Key_OfficeHome | 0x010000e0 | |
Qt::Key_Option | 0x010000e1 | |
Qt::Key_Paste | 0x010000e2 | |
Qt::Key_Phone | 0x010000e3 | |
Qt::Key_Calendar | 0x010000e4 | |
Qt::Key_Reply | 0x010000e5 | |
Qt::Key_Reload | 0x010000e6 | |
Qt::Key_RotateWindows | 0x010000e7 | |
Qt::Key_RotationPB | 0x010000e8 | |
Qt::Key_RotationKB | 0x010000e9 | |
Qt::Key_Save | 0x010000ea | |
Qt::Key_Send | 0x010000eb | |
Qt::Key_Spell | 0x010000ec | |
Qt::Key_SplitScreen | 0x010000ed | |
Qt::Key_Support | 0x010000ee | |
Qt::Key_TaskPane | 0x010000ef | |
Qt::Key_Terminal | 0x010000f0 | |
Qt::Key_Tools | 0x010000f1 | |
Qt::Key_Travel | 0x010000f2 | |
Qt::Key_Video | 0x010000f3 | |
Qt::Key_Word | 0x010000f4 | |
Qt::Key_Xfer | 0x010000f5 | |
Qt::Key_ZoomIn | 0x010000f6 | |
Qt::Key_ZoomOut | 0x010000f7 | |
Qt::Key_Away | 0x010000f8 | |
Qt::Key_Messenger | 0x010000f9 | |
Qt::Key_WebCam | 0x010000fa | |
Qt::Key_MailForward | 0x010000fb | |
Qt::Key_Pictures | 0x010000fc | |
Qt::Key_Music | 0x010000fd | |
Qt::Key_Battery | 0x010000fe | |
Qt::Key_Bluetooth | 0x010000ff | |
Qt::Key_WLAN | 0x01000100 | |
Qt::Key_UWB | 0x01000101 | |
Qt::Key_AudioForward | 0x01000102 | |
Qt::Key_AudioRepeat | 0x01000103 | |
Qt::Key_AudioRandomPlay | 0x01000104 | |
Qt::Key_Subtitle | 0x01000105 | |
Qt::Key_AudioCycleTrack | 0x01000106 | |
Qt::Key_Time | 0x01000107 | |
Qt::Key_Hibernate | 0x01000108 | |
Qt::Key_View | 0x01000109 | |
Qt::Key_TopMenu | 0x0100010a | |
Qt::Key_PowerDown | 0x0100010b | |
Qt::Key_Suspend | 0x0100010c | |
Qt::Key_ContrastAdjust | 0x0100010d | |
Qt::Key_TouchpadToggle | 0x01000110 | |
Qt::Key_TouchpadOn | 0x01000111 | |
Qt::Key_TouchpadOff | 0x01000112 | |
Qt::Key_MicMute | 0x01000113 | |
Qt::Key_Red | 0x01000114 | |
Qt::Key_Green | 0x01000115 | |
Qt::Key_Yellow | 0x01000116 | |
Qt::Key_Blue | 0x01000117 | |
Qt::Key_ChannelUp | 0x01000118 | |
Qt::Key_ChannelDown | 0x01000119 | |
Qt::Key_Guide | 0x0100011a | |
Qt::Key_Info | 0x0100011b | |
Qt::Key_Settings | 0x0100011c | |
Qt::Key_MicVolumeUp | 0x0100011d | |
Qt::Key_MicVolumeDown | 0x0100011e | |
Qt::Key_Keyboard | 0x0100011f | |
Qt::Key_New | 0x01000120 | |
Qt::Key_Open | 0x01000121 | |
Qt::Key_Find | 0x01000122 | |
Qt::Key_Undo | 0x01000123 | |
Qt::Key_Redo | 0x01000124 | |
Qt::Key_MediaLast | 0x0100ffff | |
Qt::Key_unknown | 0x01ffffff | |
Qt::Key_Call | 0x01100004 | Una tecla para responder o iniciar una llamada (véase Qt::Key_ToggleCallHangup para una tecla que alterna el estado actual de la llamada) |
Qt::Key_Camera | 0x01100020 | Una tecla para activar el obturador de la cámara. En Windows Runtime, la variable de entorno QT_QPA_ENABLE_CAMERA_KEYS debe estar configurada para recibir el evento. |
Qt::Key_CameraFocus | 0x01100021 | Una tecla para enfocar la cámara. En Windows Runtime, debe configurarse la variable de entorno QT_QPA_ENABLE_CAMERA_KEYS para recibir el evento. |
Qt::Key_Context1 | 0x01100000 | |
Qt::Key_Context2 | 0x01100001 | |
Qt::Key_Context3 | 0x01100002 | |
Qt::Key_Context4 | 0x01100003 | |
Qt::Key_Flip | 0x01100006 | |
Qt::Key_Hangup | 0x01100005 | Una tecla para finalizar una llamada en curso (véase Qt::Key_ToggleCallHangup para conocer la tecla que permite alternar el estado de la llamada actual) |
Qt::Key_No | 0x01010002 | |
Qt::Key_Select | 0x01010000 | |
Qt::Key_Yes | 0x01010001 | |
Qt::Key_ToggleCallHangup | 0x01100007 | Una tecla para alternar el estado de la llamada actual (es decir, responder o colgar) en función del estado actual de la llamada |
Qt::Key_VoiceDial | 0x01100008 | |
Qt::Key_LastNumberRedial | 0x01100009 | |
Qt::Key_Execute | 0x01020003 | |
Qt::Key_Printer | 0x01020002 | |
Qt::Key_Play | 0x01020005 | |
Qt::Key_Sleep | 0x01020004 | |
Qt::Key_Zoom | 0x01020006 | |
Qt::Key_Exit | 0x0102000a | |
Qt::Key_Cancel | 0x01020001 |
Véase también QKeyEvent::key().
enum Qt::KeyboardModifier
flags Qt::KeyboardModifiers
Esta enumeración describe las teclas modificadoras.
| Constante | Valor | Descripción |
|---|---|---|
Qt::NoModifier | 0x00000000 | No se ha pulsado ninguna tecla modificadora. |
Qt::ShiftModifier | 0x02000000 | Se ha pulsado una tecla «Shift» del teclado. |
Qt::ControlModifier | 0x04000000 | Se pulsa la tecla Ctrl del teclado. |
Qt::AltModifier | 0x08000000 | Se pulsa la tecla Alt del teclado. |
Qt::MetaModifier | 0x10000000 | Se pulsa la tecla Meta del teclado. |
Qt::KeypadModifier | 0x20000000 | Se pulsa un botón del teclado numérico. |
Qt::GroupSwitchModifier | 0x40000000 | Solo en X11 (a menos que se active en Windows mediante un argumento de línea de comandos). Se pulsa una tecla Mode_switch del teclado. Nota: En macOS, el valor « Nota: En los teclados de Windows, Qt::MetaModifier y Qt::Key_Meta se asignan a la tecla Windows. |
El tipo KeyboardModifiers es un typedef para QFlags<KeyboardModifier>. Almacena una combinación OR de valores de KeyboardModifier.
Véase también MouseButton y Modifier.
enum Qt::LayoutDirection
Especifica la dirección de los diseños y el tratamiento del texto en Qt.
| Constante | Valor | Descripción |
|---|---|---|
Qt::LeftToRight | 0 | Diseño de izquierda a derecha. |
Qt::RightToLeft | 1 | Diseño de derecha a izquierda. |
Qt::LayoutDirectionAuto | 2 | Disposición automática. |
Los diseños de derecha a izquierda son necesarios para determinados idiomas, sobre todo el árabe y el hebreo.
LayoutDirectionAuto tiene dos funciones. Cuando se utiliza junto con widgets y diseños, implica que se utilice la dirección de diseño establecida en el widget padre o en QApplication. Esto tiene el mismo efecto que QWidget::unsetLayoutDirection().
Cuando se utiliza `LayoutDirectionAuto` junto con la maquetación de texto, se determinará la dirección del texto a partir del contenido de la cadena que se va a maquetar.
Véanse también QGuiApplication::setLayoutDirection(), QWidget::setLayoutDirection(), QTextOption::setTextDirection() y QString::isRightToLeft().
enum Qt::MaskMode
Esta enumeración especifica el comportamiento de las funciones QPixmap::createMaskFromColor() y QImage::createMaskFromColor().
| Constante | Valor | Descripción |
|---|---|---|
Qt::MaskInColor | 0 | Crea una máscara en la que todos los píxeles que coincidan con el color dado son opacos. |
Qt::MaskOutColor | 1 | Crea una máscara en la que todos los píxeles que coincidan con el color especificado son transparentes. |
enum Qt::MatchFlag
flags Qt::MatchFlags
Esta enumeración describe los tipos de coincidencia que se pueden utilizar al buscar elementos en un modelo.
| Constante | Valor | Descripción |
|---|---|---|
Qt::MatchExactly | 0 | Realiza una coincidencia basada en el indicador « QVariant ». |
Qt::MatchFixedString | 8 | Realiza una coincidencia basada en cadenas. Las comparaciones basadas en cadenas no distinguen entre mayúsculas y minúsculas, a menos que también se especifique el indicador « MatchCaseSensitive ». |
Qt::MatchContains | 1 | El término de búsqueda está contenido en el elemento. |
Qt::MatchStartsWith | 2 | El término de búsqueda coincide con el inicio del elemento. |
Qt::MatchEndsWith | 3 | El término de búsqueda coincide con el final del elemento. |
Qt::MatchCaseSensitive | 16 | La búsqueda distingue entre mayúsculas y minúsculas. |
Qt::MatchRegularExpression | 4 | Realiza una búsqueda basada en cadenas utilizando una expresión regular como término de búsqueda. Utiliza QRegularExpression. Al utilizar este indicador, se puede pasar un objeto QRegularExpression como parámetro y se utilizará directamente para realizar la búsqueda. Se ignorará el indicador de distinción entre mayúsculas y minúsculas, ya que se espera que el objeto QRegularExpression esté completamente configurado. Este valor de enumeración se añadió en Qt 5.15. |
Qt::MatchWildcard | 5 | Realiza una coincidencia basada en cadenas utilizando una cadena con comodines como término de búsqueda. |
Qt::MatchWrap | 32 | Realiza una búsqueda cíclica, de modo que, cuando la búsqueda llega al último elemento del modelo, vuelve a empezar por el primer elemento y continúa hasta que se hayan examinado todos los elementos. |
Qt::MatchRecursive | 64 | Busca en toda la jerarquía. Nota: Qt ::MatchExactly, Qt::MatchContains, Qt::MatchStartsWith, Qt::MatchEndsWith, Qt::MatchRegularExpression, Qt::MatchWildcard y Qt::MatchFixedString son mutuamente excluyentes. El comportamiento que se obtiene al establecer varios de ellos en un argumento Qt::MatchFlags es indefinido. |
El tipo MatchFlags es un typedef de QFlags<MatchFlag>. Almacena una combinación OR de valores de MatchFlag.
Véase también QString::compare() y QRegularExpression.
enum Qt::Modifier
flags Qt::Modifiers
Esta enumeración proporciona nombres más cortos para las teclas modificadoras del teclado compatibles con Qt.
Nota: En macOS, el valor « CTRL » corresponde a las teclas «Comando» del teclado, y el valor « META » corresponde a las teclas «Control».
| Constante | Valor | Descripción |
|---|---|---|
Qt::SHIFT | Qt::ShiftModifier | Las teclas Shift presentes en todos los teclados estándar. |
Qt::META | Qt::MetaModifier | Las teclas Meta. |
Qt::CTRL | Qt::ControlModifier | Las teclas Ctrl. |
Qt::ALT | Qt::AltModifier | Las teclas Alt normales, pero no teclas como AltGr. |
El tipo «Modifiers» es una definición de tipo (typedef) para QFlags<Modifier>. Almacena una combinación OR de valores de «Modifier».
Véase también KeyboardModifier y MouseButton.
[since 6.12] enum class Qt::MotionPreference
Representa la configuración preferida del usuario en cuanto a animaciones y movimientos. Los controles, estilos y aplicaciones pueden respetar esta configuración limitando la cantidad de animaciones en función del valor de la enumeración.
| Constante | Valor | Descripción |
|---|---|---|
Qt::MotionPreference::NoPreference | 0 | Sin preferencias específicas. |
Qt::MotionPreference::ReducedMotion | 1 | El usuario prefiere que haya menos animaciones en su interfaz de usuario. |
Esta enumeración se introdujo en Qt 6.12.
enum Qt::MouseButton
flags Qt::MouseButtons
Este tipo de enumeración describe los diferentes botones del ratón.
| Constante | Valor | Descripción |
|---|---|---|
Qt::NoButton | 0x00000000 | El estado del botón no hace referencia a ningún botón en concreto (véase QMouseEvent::button()). |
Qt::AllButtons | 0x07ffffff | Este valor corresponde a una máscara de todos los botones posibles del ratón. Úsalo para establecer la propiedad «acceptedButtons» de un MouseArea para que acepte TODOS los botones del ratón. |
Qt::LeftButton | 0x00000001 | Se ha pulsado el botón izquierdo, o un evento se refiere al botón izquierdo. (El botón izquierdo puede ser el botón derecho en ratones para zurdos). |
Qt::RightButton | 0x00000002 | El botón derecho. |
Qt::MiddleButton | 0x00000004 | El botón central. |
Qt::BackButton | 0x00000008 | El botón «Atrás». (Suele estar situado en el lado del «pulgar» de los ratones con botones adicionales. NO se trata de la rueda de inclinación.) |
Qt::XButton1 | BackButton | El botón «Atrás». |
Qt::ExtraButton1 | XButton1 | El botón «Atrás». |
Qt::ForwardButton | 0x00000010 | El botón «Adelante». (Normalmente se encuentra junto al botón «Atrás» y también se pulsa con el pulgar.) |
Qt::XButton2 | ForwardButton | El botón «Adelante». |
Qt::ExtraButton2 | ForwardButton | El botón «Adelante». |
Qt::TaskButton | 0x00000020 | El botón «Tarea». |
Qt::ExtraButton3 | TaskButton | El botón «Tarea». |
Qt::ExtraButton4 | 0x00000040 | El séptimo botón del ratón (que no es la rueda). |
Qt::ExtraButton5 | 0x00000080 | El octavo botón del ratón que no es la rueda. |
Qt::ExtraButton6 | 0x00000100 | El noveno botón del ratón (que no es la rueda). |
Qt::ExtraButton7 | 0x00000200 | El décimo botón del ratón que no es la rueda. |
Qt::ExtraButton8 | 0x00000400 | El undécimo botón del ratón que no es la rueda. |
Qt::ExtraButton9 | 0x00000800 | El duodécimo botón del ratón que no es la rueda. |
Qt::ExtraButton10 | 0x00001000 | El decimotercer botón del ratón que no es la rueda. |
Qt::ExtraButton11 | 0x00002000 | El decimocuarto botón del ratón que no es la rueda. |
Qt::ExtraButton12 | 0x00004000 | El decimoquinto botón del ratón que no es la rueda. |
Qt::ExtraButton13 | 0x00008000 | El decimosexto botón del ratón que no es la rueda. |
Qt::ExtraButton14 | 0x00010000 | El 17.º botón del ratón que no es la rueda. |
Qt::ExtraButton15 | 0x00020000 | El 18.º botón del ratón que no es la rueda. |
Qt::ExtraButton16 | 0x00040000 | El decimonoveno botón del ratón que no es la rueda. |
Qt::ExtraButton17 | 0x00080000 | El vigésimo botón del ratón que no es la rueda. |
Qt::ExtraButton18 | 0x00100000 | El 21.º botón del ratón sin rueda. |
Qt::ExtraButton19 | 0x00200000 | El botón n.º 22 del ratón sin rueda. |
Qt::ExtraButton20 | 0x00400000 | El vigésimo tercer botón del ratón sin rueda. |
Qt::ExtraButton21 | 0x00800000 | El vigésimo cuarto botón del ratón que no es la rueda. |
Qt::ExtraButton22 | 0x01000000 | El botón 25 del ratón sin rueda. |
Qt::ExtraButton23 | 0x02000000 | El botón n.º 26 del ratón sin rueda. |
Qt::ExtraButton24 | 0x04000000 | El botón 27 del ratón (sin rueda). Nota: Algunos modelos de ratones con varios botones vienen preconfigurados con botones de números altos que emulan secuencias de teclado, para su uso en juegos específicos. Para que estos botones se consideren «botones del ratón» propiamente dichos, es necesario reconfigurar el dispositivo (utilizando la herramienta de configuración del fabricante). |
El tipo «MouseButtons» es un typedef para QFlags<MouseButton>. Almacena una combinación OR de valores de MouseButton.
Véase también KeyboardModifier y Modifier.
enum Qt::MouseEventFlag
flags Qt::MouseEventFlags
Esta enumeración proporciona información adicional sobre un ` QMouseEvent`.
| Constante | Valor | Descripción |
|---|---|---|
Qt::MouseEventCreatedDoubleClick | 0x01 | Indica que Qt ha creado un evento « MouseButtonDblClick » a partir de este evento. El indicador se establece en el « MouseButtonPress » causante, y no en el « MouseButtonDblClick » resultante. |
El tipo `MouseEventFlags` es un `typedef` para ` QFlags<MouseEventFlag>`. Almacena una combinación OR de valores de `MouseEventFlag`.
enum Qt::MouseEventSource
Esta enumeración describe el origen de un evento del ratón y puede resultar útil para determinar si se trata de un evento artificial procedente de otro dispositivo, como una pantalla táctil.
| Constante | Valor | Descripción |
|---|---|---|
Qt::MouseEventNotSynthesized | 0 | El valor más habitual. En las plataformas en las que se dispone de dicha información, este valor indica que el evento se generó en respuesta a un evento de ratón auténtico en el sistema. |
Qt::MouseEventSynthesizedBySystem | 1 | Indica que la plataforma ha sintetizado el evento del ratón a partir de un evento táctil. |
Qt::MouseEventSynthesizedByQt | 2 | Indica que Qt sintetizó el evento del ratón a partir de un evento táctil no gestionado. |
Qt::MouseEventSynthesizedByApplication | 3 | Indica que el evento del ratón fue sintetizado por la aplicación. Esto permite distinguir los eventos del ratón generados por la aplicación de los que proceden del sistema o son sintetizados por Qt. Este valor se introdujo en Qt 5.6 |
Véase también Qt::AA_SynthesizeMouseForUnhandledTouchEvents.
enum Qt::NativeGestureType
Esta enumeración devuelve el tipo de gesto.
| Constante | Valor | Descripción |
|---|---|---|
Qt::BeginNativeGesture | 0 | Se envía antes del flujo de eventos de gestos. |
Qt::EndNativeGesture | 1 | Se envía tras el flujo de eventos de gestos. |
Qt::PanNativeGesture | 2 | Especifica el delta de desplazamiento en píxeles. |
Qt::ZoomNativeGesture | 3 | Especifica el delta de ampliación en porcentaje. |
Qt::SmartZoomNativeGesture | 4 | Estado de ampliación (booleano). |
Qt::RotateNativeGesture | 5 | Especifica el delta de rotación en grados. |
Qt::SwipeNativeGesture | 6 | Se envía tras un movimiento de deslizamiento. |
enum Qt::Orientation
flags Qt::Orientations
Este tipo se utiliza para indicar la orientación de un objeto.
| Constante | Valor |
|---|---|
Qt::Horizontal | 0x1 |
Qt::Vertical | 0x2 |
La orientación se utiliza, por ejemplo, con « QScrollBar ».
El tipo «Orientations» es una definición de tipo (typedef) para QFlags<Orientation>. Almacena una combinación OR de valores de «Orientation».
enum Qt::PenCapStyle
Este tipo de enumeración define los estilos de remate de línea compatibles con Qt, es decir, los remates de línea que se pueden dibujar utilizando ` QPainter`.
![]() | ![]() | ![]() |
| Qt::SquareCap | Qt::FlatCap | Qt::RoundCap |
| Constante | Valor | Descripción |
|---|---|---|
Qt::FlatCap | 0x00 | un extremo de línea cuadrado que no cubre el punto final de la línea. |
Qt::SquareCap | 0x10 | Un extremo de línea cuadrado que cubre el punto final y se extiende más allá de él en la mitad del ancho de la línea. |
Qt::RoundCap | 0x20 | Un extremo de línea redondeado. |
Véase también « QPen ».
enum Qt::PenJoinStyle
Este tipo de enumeración define los estilos de unión de trazos compatibles con Qt, es decir, qué uniones entre dos líneas conectadas se pueden dibujar utilizando ` QPainter`.
![]() | ![]() | ![]() |
| Qt::BevelJoin | Qt::MiterJoin | Qt::RoundJoin |
| Constante | Valor | Descripción |
|---|---|---|
Qt::MiterJoin | 0x00 | Los bordes exteriores de las líneas se extienden hasta encontrarse en ángulo, y esta zona se rellena. |
Qt::BevelJoin | 0x40 | Se rellena la muesca triangular entre las dos líneas. |
Qt::RoundJoin | 0x80 | Se rellena un arco circular entre las dos líneas. |
Qt::SvgMiterJoin | 0x100 | Una unión en inglete que se ajusta a la definición de «unión en inglete» de la especificación SVG 1.2 Tiny. |
Véase también QPen.
enum Qt::PenStyle
Este tipo de enumeración define los estilos de trazo que se pueden dibujar utilizando ` QPainter`. Los estilos son:
![]() | ![]() | ![]() |
| Qt::SolidLine | Qt::DashLine | Qt::DotLine |
![]() | ![]() | ![]() |
| Qt::DashDotLine | Qt::DashDotDotLine | Qt::Línea de guiones personalizada |
| Constante | Valor | Descripción |
|---|---|---|
Qt::NoPen | 0 | No se dibuja ninguna línea. Por ejemplo, ` QPainter::drawRect()` rellena pero no dibuja ninguna línea de contorno. |
Qt::SolidLine | 1 | Una línea simple. |
Qt::DashLine | 2 | Guiones separados por unos pocos píxeles. |
Qt::DotLine | 3 | Puntos separados por unos pocos píxeles. |
Qt::DashDotLine | 4 | Puntos y guiones alternados. |
Qt::DashDotDotLine | 5 | Un guion, dos puntos, un guion, dos puntos. |
Qt::CustomDashLine | 6 | Un patrón personalizado definido mediante la función ` QPainterPathStroker::setDashPattern()`. |
Véase también QPen.
[since 6.5] enum class Qt::PermissionStatus
Esta enumeración describe los posibles estados de un permiso.
| Constante | Valor | Descripción |
|---|---|---|
Qt::PermissionStatus::Undetermined | 0 | Aún se desconoce el estado del permiso. Se debe solicitar el permiso mediante QCoreApplication::requestPermission() para determinar su estado real. Este estado nunca será el resultado de solicitar un permiso. |
Qt::PermissionStatus::Granted | 1 | El usuario ha concedido explícitamente el permiso a la aplicación, o se sabe que el permiso no requiere autorización del usuario en la plataforma en cuestión. |
Qt::PermissionStatus::Denied | 2 | El usuario ha denegado explícitamente a la aplicación el permiso solicitado, o se sabe que dicho permiso no es accesible ni aplicable a las aplicaciones en la plataforma en cuestión. Nota: En Android, las API de la plataforma no proporcionan el estado « |
Esta enumeración se introdujo en Qt 6.5.
Véase también QCoreApplication::requestPermission(), QCoreApplication::checkPermission() y Permisos de la aplicación.
enum Qt::ReturnByValueConstant
Se trata de un tipo ficticio, diseñado para ayudar a los usuarios a pasar de determinadas API obsoletas a las API que las sustituyen.
Véase también QCursor::bitmap(), QCursor::mask(), QLabel::picture() y QLabel::pixmap().
enum Qt::ScreenOrientation
flags Qt::ScreenOrientations
Este tipo de enumeración especifica las distintas orientaciones que puede tener una pantalla.
| Constante | Valor | Descripción |
|---|---|---|
Qt::PrimaryOrientation | 0x00000000 | La orientación principal de la pantalla. |
Qt::LandscapeOrientation | 0x00000002 | Orientación horizontal: el ancho de la pantalla es mayor que su altura. |
Qt::PortraitOrientation | 0x00000001 | Orientación vertical: la altura de la pantalla es mayor que su anchura, girada 90 grados en el sentido de las agujas del reloj respecto a la orientación horizontal. |
Qt::InvertedLandscapeOrientation | 0x00000008 | Orientación horizontal invertida: girada 180 grados respecto a la horizontal. |
Qt::InvertedPortraitOrientation | 0x00000004 | Orientación vertical invertida: girada 180 grados respecto a la vertical. |
El tipo `ScreenOrientations` es una definición de tipo para ` QFlags<ScreenOrientation>`. Almacena una combinación OR de valores de `ScreenOrientation`.
enum Qt::ScrollBarPolicy
Este tipo de enumeración describe los distintos modos de las barras de desplazamiento de QAbstractScrollArea.
| Constante | Valor | Descripción |
|---|---|---|
Qt::ScrollBarAsNeeded | 0 | QAbstractScrollArea muestra una barra de desplazamiento cuando el contenido es demasiado grande para caber y, en caso contrario, no la muestra. Este es el valor por defecto. |
Qt::ScrollBarAlwaysOff | 1 | QAbstractScrollArea Nunca muestra una barra de desplazamiento. |
Qt::ScrollBarAlwaysOn | 2 | QAbstractScrollArea siempre muestra una barra de desplazamiento. Esta propiedad se ignora en sistemas con barras de desplazamiento transitorias (por ejemplo, en Mac a partir de la versión 10.7). |
(Los modos de las barras de desplazamiento horizontal y vertical son independientes).
enum Qt::ScrollPhase
Esta enumeración describe la fase de desplazamiento.
| Constante | Valor | Descripción |
|---|---|---|
Qt::NoScrollPhase | 0 | El dispositivo de entrada no admite la fase de desplazamiento. Este valor se introdujo en Qt 5.7. |
Qt::ScrollBegin | 1 | El desplazamiento está a punto de comenzar, pero la distancia de desplazamiento aún no ha cambiado. |
Qt::ScrollUpdate | 2 | La distancia de desplazamiento ha cambiado (valor por defecto). |
Qt::ScrollEnd | 3 | El desplazamiento ha finalizado y la distancia de desplazamiento ya no cambia. |
Qt::ScrollMomentum | 4 | El usuario ya no toca el dispositivo de entrada, pero el desplazamiento continúa debido al impulso de desplazamiento. Este valor se introdujo en Qt 5.12. |
enum Qt::ShortcutContext
Para que se produzca un evento « QEvent::Shortcut », el usuario debe introducir la secuencia de teclas del atajo en un contexto en el que dicho atajo esté activo. Los contextos posibles son los siguientes:
| Constante | Valor | Descripción |
|---|---|---|
Qt::WidgetShortcut | 0 | El atajo está activo cuando su widget padre tiene el foco. |
Qt::WidgetWithChildrenShortcut | 3 | El atajo está activo cuando su widget padre, o cualquiera de sus hijos, tiene el foco. Los hijos que son widgets de nivel superior, excepto las ventanas emergentes, no se ven afectados por este contexto de atajo. |
Qt::WindowShortcut | 1 | El atajo está activo cuando su widget padre es un subwidget lógico de la ventana de nivel superior activa. |
Qt::ApplicationShortcut | 2 | El atajo está activo cuando una de las ventanas de la aplicación está activa. |
enum Qt::SizeHint
Esta enumeración la utiliza QGraphicsLayoutItem::sizeHint()
| Constante | Valor | Descripción |
|---|---|---|
Qt::MinimumSize | 0 | Se utiliza para especificar el tamaño mínimo de un elemento de diseño gráfico. |
Qt::PreferredSize | 1 | Se utiliza para especificar el tamaño preferido de un elemento de diseño gráfico. |
Qt::MaximumSize | 2 | Se utiliza para especificar el tamaño máximo de un elemento de diseño gráfico. |
Qt::MinimumDescent | 3 | Se utiliza para especificar el descenso mínimo de una cadena de texto en un elemento de diseño gráfico. |
Véase también QGraphicsLayoutItem::sizeHint().
enum Qt::SizeMode
Esta enumeración es utilizada por las funciones QPainter::drawRoundedRect() y QPainterPath::addRoundedRect() para especificar los radios de las esquinas de los rectángulos con respecto a las dimensiones de los rectángulos delimitadores especificados.
| Constante | Valor | Descripción |
|---|---|---|
Qt::AbsoluteSize | 0 | Especifica el tamaño utilizando medidas absolutas. |
Qt::RelativeSize | 1 | Especifica el tamaño en relación con el rectángulo delimitador, normalmente utilizando medidas porcentuales. |
enum Qt::SortOrder
Esta enumeración describe cómo se ordenan los elementos de un widget.
| Constante | Valor | Descripción |
|---|---|---|
Qt::AscendingOrder | 0 | Los elementos se ordenan de forma ascendente; por ejemplo, los que empiezan por «AAA» y terminan por «ZZZ» en las configuraciones regionales Latin-1 |
Qt::DescendingOrder | 1 | Los elementos se ordenan de forma descendente; por ejemplo, empiezan por «ZZZ» y terminan por «AAA» en las configuraciones regionales Latin-1 |
enum Qt::SplitBehaviorFlags
flags Qt::SplitBehavior
Esta enumeración especifica cómo deben comportarse las funciones ` QString::split()` con respecto a las cadenas vacías.
| Constante | Valor | Descripción |
|---|---|---|
Qt::KeepEmptyParts | 0 | Si un campo está vacío, manténlo en el resultado. |
Qt::SkipEmptyParts | 0x1 | Si un campo está vacío, no lo incluya en el resultado. |
El tipo SplitBehavior es un typedef para QFlags<SplitBehaviorFlags>. Almacena una combinación OR de valores de SplitBehaviorFlags.
Véase también ` QString::split()`.
enum Qt::TabFocusBehavior
Este tipo de enumeración ofrece diferentes comportamientos de foco para la navegación mediante la tecla Tab.
| Constante | Valor | Descripción |
|---|---|---|
Qt::NoTabFocus | 0x00 | No iterar nada. |
Qt::TabFocusTextControls | 0x01 | Recorre los controles de texto y los widgets. |
Qt::TabFocusListControls | 0x02 | Recorrer controles de lista y widgets. |
Qt::TabFocusAllControls | 0xff | Recorrer todos los controles y widgets. |
enum Qt::TextElideMode
Esta enumeración especifica dónde deben aparecer los puntos suspensivos al mostrar textos que no caben:
| Constante | Valor | Descripción |
|---|---|---|
Qt::ElideLeft | 0 | Los puntos suspensivos deben aparecer al principio del texto. |
Qt::ElideRight | 1 | Los puntos suspensivos deben aparecer al final del texto. |
Qt::ElideMiddle | 2 | Los puntos suspensivos deben aparecer en medio del texto. |
Qt::ElideNone | 3 | Los puntos suspensivos NO deben aparecer en el texto. Cuando se pasa a funciones como ` QFontMetrics::elidedText()`, esto hará que se devuelva la cadena completa, a menos que el texto contenga variantes de longitud variable. En este caso, la elisión debe realizarse recortando el texto al ancho del componente. |
Qt::ElideMiddle suele ser la opción más adecuada para las URL (p. ej., «http://bugreports.qt.../QTWEBSITE-13/»), mientras que Qt::ElideRight es adecuado para otras cadenas (p. ej.,«Deploying Applications on Ma...»).
Véase también QAbstractItemView::textElideMode, QFontMetrics::elidedText(), AlignmentFlag y QTabBar::elideMode.
enum Qt::TextFlag
Este tipo de enumeración se utiliza para definir algunos indicadores modificadores. Algunos de estos indicadores solo tienen sentido en el contexto de la impresión:
| Constante | Valor | Descripción |
|---|---|---|
Qt::TextSingleLine | 0x0100 | Trata todos los espacios en blanco como espacios y imprime solo una línea. |
Qt::TextDontClip | 0x0200 | Si no es posible mantenerse dentro de los límites establecidos, se imprime fuera de ellos. |
Qt::TextExpandTabs | 0x0400 | Hace que el carácter U+0009 (tabulador ASCII) se desplace a la siguiente posición de tabulación. |
Qt::TextShowMnemonic | 0x0800 | Muestra la cadena «&P» como P. Para un símbolo «&», utiliza «&&». |
Qt::TextWordWrap | 0x1000 | Divide las líneas en los puntos adecuados, por ejemplo, al final de las palabras. |
Qt::TextWrapAnywhere | 0x2000 | Divide las líneas en cualquier lugar, incluso dentro de las palabras. |
Qt::TextHideMnemonic | 0x8000 | Igual que Qt::TextShowMnemonic, pero no dibuja los subrayados. |
Qt::TextDontPrint | 0x4000 | Trata este texto como «oculto» y no lo muestra. |
Qt::TextIncludeTrailingSpaces | 0x08000000 | Cuando se activa esta opción, QTextLine::naturalTextWidth() y QTextLine::naturalTextRect() devolverán un valor que incluye el ancho de los espacios finales del texto; de lo contrario, este ancho se excluye. |
Qt::TextJustificationForced | 0x10000 | Asegura que las líneas de texto estén justificadas. |
Se pueden utilizar tantos indicadores modificadores como se desee, salvo que Qt::TextSingleLine y Qt::TextWordWrap no se pueden combinar.
Los indicadores que no sean adecuados para un uso concreto suelen ignorarse.
enum Qt::TextFormat
Esta enumeración se utiliza en widgets que pueden mostrar tanto texto sin formato como texto con formato, por ejemplo, QLabel. Se emplea para determinar si una cadena de texto debe interpretarse como uno u otro. Normalmente, esto se hace pasando uno de los valores de la enumeración a la función QStaticText::setTextFormat().
| Constante | Valor | Descripción |
|---|---|---|
Qt::PlainText | 0 | La cadena de texto se interpreta como una cadena de texto sin formato. |
Qt::RichText | 1 | La cadena de texto se interpreta como una cadena de texto con formato. Consulte «Subconjunto de HTML compatible» para ver la definición de texto con formato. |
Qt::AutoText | 2 | La cadena de texto se interpreta como Qt::RichText si Qt::mightBeRichText() devuelve true; en caso contrario, se interpreta como Qt::PlainText. |
Qt::MarkdownText | 3 | La cadena de texto se interpreta como texto con formato Markdown. Este valor de la enumeración se añadió en Qt 5.14. |
enum Qt::TextInteractionFlag
flags Qt::TextInteractionFlags
Esta enumeración especifica cómo reacciona un widget de visualización de texto ante las entradas del usuario.
| Constante | Valor | Descripción |
|---|---|---|
Qt::NoTextInteraction | 0 | No es posible interactuar con el texto. |
Qt::TextSelectableByMouse | 1 | El texto se puede seleccionar con el ratón y copiar al portapapeles mediante el menú contextual o los atajos de teclado estándar. |
Qt::TextSelectableByKeyboard | 2 | El texto se puede seleccionar con las teclas de cursor del teclado. Se muestra un cursor de texto. |
Qt::LinksAccessibleByMouse | 4 | Los enlaces se pueden resaltar y activar con el ratón. |
Qt::LinksAccessibleByKeyboard | 8 | Se puede seleccionar un enlace con la tecla Tab y activarlo con la tecla Intro. |
Qt::TextEditable | 16 | El texto es totalmente editable. |
Qt::TextEditorInteraction | TextSelectableByMouse | TextSelectableByKeyboard | TextEditable | Es el valor predeterminado para un editor de texto. |
Qt::TextBrowserInteraction | TextSelectableByMouse | LinksAccessibleByMouse | LinksAccessibleByKeyboard | El valor predeterminado para « QTextBrowser ». |
El tipo `TextInteractionFlags` es una definición de tipo para `QFlags<TextInteractionFlag>`. Almacena una combinación OR de valores de `TextInteractionFlag`.
enum Qt::TileRule
Esta enumeración describe cómo repetir o estirar las partes de una imagen al dibujar.
| Constante | Valor | Descripción |
|---|---|---|
Qt::StretchTile | 0 | Escala la imagen para que se ajuste al área disponible. |
Qt::RepeatTile | 1 | Repite la imagen hasta que no quede más espacio. Puede recortar la última imagen. |
Qt::RoundTile | 2 | Similar a «Repetir», pero reduce la imagen para garantizar que no se recorte el último mosaico. |
enum Qt::TimeSpec
| Constante | Valor | Descripción |
|---|---|---|
Qt::LocalTime | 0 | Hora local, controlada por la configuración de la zona horaria del sistema. |
Qt::UTC | 1 | Tiempo Universal Coordinado. |
Qt::OffsetFromUTC | 2 | Una diferencia en segundos respecto al Tiempo Universal Coordinado. |
Qt::TimeZone | 3 | Una zona horaria con nombre. |
Tanto LocalTime como TimeZone se encargarán de las transiciones, como el inicio y el fin del horario de verano. El UTC es la hora estándar con respecto a la cual se suelen especificar las zonas horarias: la hora media de Greenwich tiene una diferencia de cero respecto a él. Ni el UTC ni OffsetFromUTC tienen transiciones.
Al especificar una fecha y hora utilizando OffsetFromUTC, también debe indicarse la desviación respecto al UTC (se mide en segundos). Para especificar una fecha y hora utilizando `TimeZone`, se debe proporcionar un objeto ` QTimeZone `. A partir de Qt 6.5, un objeto ` QTimeZone ` puede ahora empaquetar una especificación de tiempo (`timespec`) con, cuando sea necesario, una diferencia horaria como descripción ligera de la hora, de modo que pasar un objeto ` QTimeZone ` proporciona ahora una forma uniforme de utilizar las API de fecha y hora, evitando la necesidad de llamarlas de forma diferente para distintas especificaciones de tiempo.
Nota: Tras un cambio en la configuración de la zona horaria del sistema, el comportamiento de los objetos ` QDateTime ` basados en `LocalTime` creados antes del cambio es indefinido: ` QDateTime ` puede tener datos almacenados en caché que el cambio invalide. (Esto no se produce por las transiciones de la zona horaria del sistema.) En procesos de larga duración, las actualizaciones de los datos de zona horaria del sistema (por ejemplo, cuando los políticos modifican las normas de una zona) pueden provocar igualmente conflictos entre la información actualizada de la zona horaria y los datos almacenados en caché por los objetos ` QDateTime ` creados antes de la actualización, ya sea utilizando `LocalTime` o `TimeZone`.
Véase también QTimeZone y QDateTime.
[since 6.8] enum class TimerId
Se utiliza para representar identificadores de temporizador (por ejemplo, QTimer y QChronoTimer). El tipo subyacente es int. Puedes utilizar qToUnderlying() para convertir Qt::TimerId en int.
| Constante | Valor | Descripción |
|---|---|---|
QObject::TimerId::Invalid | 0 | Representa un identificador de temporizador sin operación; su uso depende del contexto; por ejemplo, este es el valor que devuelve QObject::startTimer() para indicar que no se ha podido iniciar un temporizador; mientras que QChronoTimer::id() devuelve este valor cuando el temporizador está inactivo, es decir, timer.isActive() devuelve false. |
Esta enumeración se introdujo en Qt 6.8.
Véase también QTimer::id(), QChronoTimer::id() y QObject::startTimer().
enum Qt::TimerType
El tipo de temporizador indica el grado de precisión que puede alcanzar.
| Constante | Valor | Descripción |
|---|---|---|
Qt::PreciseTimer | 0 | Los temporizadores de precisión intentan mantener una precisión de milisegundos |
Qt::CoarseTimer | 1 | Los temporizadores aproximados intentan mantener una precisión dentro del 5 % del intervalo deseado |
Qt::VeryCoarseTimer | 2 | Los temporizadores muy aproximados solo mantienen una precisión de segundos enteros |
En UNIX (incluidos Linux, macOS e iOS), Qt mantendrá una precisión de milisegundos para Qt::PreciseTimer. En el caso de Qt::CoarseTimer, el intervalo se ajustará hasta un 5 % para sincronizar el temporizador con otros temporizadores que se espera que se activen al mismo tiempo o en un momento cercano. El objetivo es que la mayoría de los temporizadores se activen al mismo tiempo, reduciendo así las activaciones de la CPU y el consumo de energía.
En Windows, Qt utilizará la función de temporizador multimedia de Windows (si está disponible) para Qt::PreciseTimer y los temporizadores normales de Windows para Qt::CoarseTimer y Qt::VeryCoarseTimer.
En todas las plataformas, el intervalo de Qt::VeryCoarseTimer se redondea al segundo entero más cercano (por ejemplo, un intervalo de 23 500 ms se redondeará a 24 000 ms, y uno de 20 300 ms, a 20 000 ms).
enum Qt::ToolBarArea
flags Qt::ToolBarAreas
| Constante | Valor |
|---|---|
Qt::LeftToolBarArea | 0x1 |
Qt::RightToolBarArea | 0x2 |
Qt::TopToolBarArea | 0x4 |
Qt::BottomToolBarArea | 0x8 |
Qt::AllToolBarAreas | ToolBarArea_Mask |
Qt::NoToolBarArea | 0 |
El tipo ToolBarAreas es una definición de tipo (typedef) para QFlags<ToolBarArea>. Almacena una combinación OR de valores de ToolBarArea.
enum Qt::ToolButtonStyle
El estilo del botón de la herramienta, que describe cómo deben mostrarse el texto y el icono del botón.
| Constante | Valor | Descripción |
|---|---|---|
Qt::ToolButtonIconOnly | 0 | Mostrar solo el icono. |
Qt::ToolButtonTextOnly | 1 | Mostrar únicamente el texto. |
Qt::ToolButtonTextBesideIcon | 2 | El texto aparece junto al icono. |
Qt::ToolButtonTextUnderIcon | 3 | El texto aparece debajo del icono. |
Qt::ToolButtonFollowStyle | 4 | Sigue las instrucciones de style. |
enum Qt::TouchPointState
flags Qt::TouchPointStates
Esta enumeración representa el estado de un punto táctil en el momento en que se produjo un « QTouchEvent ».
| Constante | Valor | Descripción |
|---|---|---|
Qt::TouchPointUnknownState | 0x00 | Se desconoce el estado del punto táctil. |
Qt::TouchPointPressed | 0x01 | El punto táctil está ahora pulsado. |
Qt::TouchPointMoved | 0x02 | El punto táctil se ha movido. |
Qt::TouchPointStationary | 0x04 | El punto táctil no se ha movido. |
Qt::TouchPointReleased | 0x08 | El punto táctil se ha soltado. |
El tipo `TouchPointStates` es una definición de tipo para ` QFlags<TouchPointState>`. Almacena una combinación OR de valores de `TouchPointState`.
enum Qt::TransformationMode
Este tipo de enumeración define si las transformaciones de imágenes (por ejemplo, el cambio de escala) deben ser suaves o no.
| Constante | Valor | Descripción |
|---|---|---|
Qt::FastTransformation | 0 | La transformación se realiza rápidamente, sin suavizado. |
Qt::SmoothTransformation | 1 | La imagen resultante se transforma mediante filtrado bilineal. |
Véase también QImage::scaled().
enum Qt::UIEffect
Esta enumeración describe los efectos de interfaz de usuario disponibles.
Por defecto, Qt intentará utilizar la configuración de escritorio específica de la plataforma para cada efecto. Utiliza la función ` QApplication::setDesktopSettingsAware()` (pasando ` false ` como argumento) para evitarlo, y la función ` QApplication::setEffectEnabled()` para activar o desactivar un efecto concreto.
Ten en cuenta que todos los efectos están desactivados en pantallas que funcionan con una profundidad de color inferior a 16 bits.
| Constante | Valor | Descripción |
|---|---|---|
Qt::UI_AnimateMenu | 1 | Mostrar menús animados. |
Qt::UI_FadeMenu | 2 | Mostrar menús difuminados. |
Qt::UI_AnimateCombo | 3 | Mostrar cuadros combinados animados. |
Qt::UI_AnimateTooltip | 4 | Mostrar animaciones en las descripciones emergentes. |
Qt::UI_FadeTooltip | 5 | Mostrar efectos de desvanecimiento en las descripciones emergentes. |
Qt::UI_AnimateToolBox | 6 | Reservado |
Véase también QApplication::setEffectEnabled() y QGuiApplication::setDesktopSettingsAware().
enum Qt::WhiteSpaceMode
Esta enumeración describe los tipos de modo de espacios en blanco que utiliza la clase ` QTextDocument ` para adaptarse a los requisitos de los distintos tipos de información textual.
| Constante | Valor | Descripción |
|---|---|---|
Qt::WhiteSpaceNormal | 0 | El modo de espacios en blanco utilizado para mostrar texto normal con ajuste de línea en párrafos. |
Qt::WhiteSpacePre | 1 | Un modo de texto preformateado en el que los espacios en blanco se reproducen exactamente. |
Qt::WhiteSpaceNoWrap | 2 |
enum Qt::WidgetAttribute
Este tipo de enumeración se utiliza para especificar diversos atributos de los widgets. Los atributos se establecen y se desactivan mediante ` QWidget::setAttribute()` y se consultan mediante ` QWidget::testAttribute()`, aunque algunos cuentan con funciones especiales de uso sencillo que se mencionan a continuación.
| Constante | Valor | Descripción |
|---|---|---|
Qt::WA_AcceptDrops | 78 | Permite que los datos de las operaciones de arrastrar y soltar se coloquen en el widget (véase QWidget::setAcceptDrops()). |
Qt::WA_AlwaysShowToolTips | 84 | Habilita las descripciones emergentes para las ventanas inactivas. |
Qt::WA_CustomWhatsThis | 47 | Indica que el widget desea seguir funcionando con normalidad en el modo «¿Qué es esto?». Esto lo establece el autor del widget. |
Qt::WA_DeleteOnClose | 55 | Hace que Qt elimine este widget cuando este haya aceptado el evento de cierre (véase QWidget::closeEvent()). |
Qt::WA_Disabled | 0 | Indica que el widget está desactivado, es decir, que no recibe ningún evento del ratón ni del teclado. También existe una función de obtención QWidget::isEnabled(). El núcleo de Qt se encarga de activarla o desactivarla. |
Qt::WA_DontShowOnScreen | 103 | Indica que el widget está oculto o que no forma parte del escritorio visible. |
Qt::WA_ForceDisabled | 32 | Indica que el widget está desactivado explícitamente, es decir, permanecerá desactivado incluso cuando todos sus antecesores estén en estado activado. Esto implica WA_Disabled. Se establece o se desactiva mediante QWidget::setEnabled() y QWidget::setDisabled(). |
Qt::WA_ForceUpdatesDisabled | 59 | Indica que las actualizaciones están desactivadas explícitamente para el widget; es decir, permanecerá desactivado incluso cuando todos sus antepasados estén en estado de actualizaciones activadas. Esto implica WA_UpdatesDisabled. Se activa o desactiva mediante QWidget::setUpdatesEnabled(). |
Qt::WA_Hover | 74 | Obliga a Qt a generar eventos de dibujo cuando el ratón entra o sale del widget. Esta característica se utiliza normalmente al implementar estilos personalizados. |
Qt::WA_InputMethodEnabled | 14 | Habilita los métodos de entrada para idiomas asiáticos. Debe activarse al crear widgets de edición de texto personalizados. |
Qt::WA_KeyboardFocusChange | 77 | Se establece en una ventana de nivel superior cuando el usuario cambia el foco con el teclado (tecla Tab, tecla Backtab o atajo). |
Qt::WA_KeyCompression | 33 | Habilita la compresión de eventos de teclas si se activa, y la deshabilita si no se activa. Por defecto, la compresión de teclas está desactivada, por lo que los widgets reciben un evento de pulsación de tecla por cada pulsación (o más, ya que la repetición automática suele estar activada). Si lo activas y tu programa no sigue el ritmo de la entrada de teclas, Qt puede intentar comprimir los eventos de tecla para que se pueda procesar más de un carácter en cada evento. Por ejemplo, un widget de procesador de textos podría recibir 2, 3 o más caracteres en cada QKeyEvent::text(), si el recálculo de la disposición lleva demasiado tiempo a la CPU. Si un widget admite la entrada de múltiples caracteres Unicode, siempre es seguro activar la compresión. Qt realiza la compresión de eventos de teclas únicamente para caracteres imprimibles. Las teclas « Qt::Modifier », las teclas de desplazamiento del cursor, las teclas de función y las teclas de acción diversas (por ejemplo, Escape, Enter, Backspace, PrintScreen) detendrán la compresión de eventos de teclas, incluso si hay más eventos de teclas comprimibles disponibles. Las plataformas distintas de Mac y X11 no admiten esta compresión, por lo que activarla no tendrá ningún efecto. El autor del widget es quien la activa o desactiva. |
Qt::WA_LayoutOnEntireRect | 48 | Indica que el widget desea que ` QLayout ` actúe sobre todo el ` QWidget::rect()` (área de trabajo), y no solo sobre ` QWidget::contentsRect()` (área de trabajo). Esta opción la configura el autor del widget. |
Qt::WA_LayoutUsesWidgetRect | 92 | Ignora el elemento de diseño «rect» del estilo al distribuir este widget con QLayout. |
Qt::WA_MacOpaqueSizeGrip | 85 | Indica que el control de tamaño nativo debe ser opaco en lugar de transparente (valor por defecto). Este atributo solo es aplicable a macOS y lo establece el autor del widget. |
Qt::WA_MacShowFocusRect | 88 | Indica que este widget debe tener un « QFocusFrame » a su alrededor. Algunos widgets dibujan su propio halo de foco independientemente de este atributo. Ten en cuenta que el « QWidget::focusPolicy » también desempeña un papel fundamental a la hora de determinar si se le da el foco a algo o no; esto solo controla si se le aplica o no el marco de foco. Este atributo solo es aplicable a macOS. |
Qt::WA_MacNormalSize | 89 | Indica que el widget debe tener el tamaño normal de los widgets en macOS. Este atributo solo es aplicable a macOS. |
Qt::WA_MacSmallSize | 90 | Indica que el widget debe tener el tamaño pequeño propio de los widgets en macOS. Este atributo solo es aplicable a macOS. |
Qt::WA_MacMiniSize | 91 | Indica que el widget debe tener el tamaño «mini» para widgets en macOS. Este atributo solo es aplicable a macOS. |
Qt::WA_Mapped | 11 | Indica que el widget está mapeado en pantalla. El núcleo de Qt se encarga de activarlo o desactivarlo. |
Qt::WA_MouseNoMask | 71 | Hace que el widget reciba eventos del ratón para todo el widget, independientemente de la máscara establecida actualmente, anulando ` QWidget::setMask()`. Esto no es aplicable a las ventanas de nivel superior. |
Qt::WA_MouseTracking | 2 | Indica que el widget tiene habilitado el seguimiento del ratón. Véase QWidget::mouseTracking. |
Qt::WA_Moved | 43 | Indica que el widget tiene una posición explícita. Esta opción se activa o desactiva mediante ` QWidget::move()` y ` QWidget::setGeometry()`. |
Qt::WA_NoChildEventsForParent | 58 | Indica que el widget no desea que se envíen eventos de tipo « ChildAdded » o « ChildRemoved » a su padre. Esto rara vez es necesario, pero puede ayudar a evitar la inserción automática de widgets como divisores y diseños. Lo establece el autor del widget. |
Qt::WA_NoChildEventsFromChildren | 39 | Indica que el widget no desea recibir eventos de tipo « ChildAdded » o « ChildRemoved » enviados desde sus hijos. Lo configura el autor del widget. |
Qt::WA_NoMouseReplay | 54 | Se utiliza para widgets emergentes. Indica que el evento de pulsación del ratón más reciente no debe reproducirse cuando se cierre el widget emergente. El autor del widget activa este indicador y el núcleo de Qt lo desactiva cada vez que el widget recibe un nuevo evento de ratón. |
Qt::WA_NoMousePropagation | 73 | Impide que los eventos del ratón se propaguen al widget padre. Este atributo está desactivado por defecto. |
Qt::WA_TransparentForMouseEvents | 51 | Cuando está habilitado, este atributo deshabilita el envío de eventos de ratón al widget y a sus hijos. Los eventos de ratón se envían a otros widgets como si el widget y sus hijos no estuvieran presentes en la jerarquía de widgets; los clics del ratón y otros eventos, en la práctica, «atraviesan» dichos elementos. Este atributo está deshabilitado por defecto. |
Qt::WA_NoSystemBackground | 9 | Indica que el widget no tiene fondo; es decir, cuando el widget recibe eventos de pintura, el fondo no se repinta automáticamente. Nota: A diferencia de WA_OpaquePaintEvent, las áreas recién expuestas nunca se rellenan con el fondo (por ejemplo, tras mostrar una ventana por primera vez, el usuario puede ver «a través» de ella hasta que la aplicación procese los eventos de pintura). El autor del widget es quien activa o desactiva este indicador. |
Qt::WA_OpaquePaintEvent | 4 | Indica que el widget dibuja todos sus píxeles cuando recibe un evento de dibujo. Por lo tanto, no es necesario que operaciones como la actualización, el cambio de tamaño, el desplazamiento y los cambios de foco borren el widget antes de generar eventos de dibujo. El uso de WA_OpaquePaintEvent proporciona una pequeña optimización, ya que ayuda a reducir el parpadeo en sistemas que no admiten doble búfer y evita los ciclos computacionales necesarios para borrar el fondo antes de pintar. Nota: A diferencia de WA_NoSystemBackground, WA_OpaquePaintEvent intenta evitar los fondos de ventana transparentes. El autor del widget es quien activa o desactiva este indicador. |
Qt::WA_OutsideWSRange | 49 | Indica que el widget se encuentra fuera del rango válido del sistema de coordenadas del sistema de ventanas. Un widget fuera del rango válido no puede representarse en pantalla. El núcleo de Qt lo activa o desactiva. |
Qt::WA_PaintOnScreen | 8 | Indica que el widget desea dibujar directamente en la pantalla. Los widgets con este atributo activado no participan en la gestión de la composición; es decir, no pueden ser semitransparentes ni traslucir a través de widgets superpuestos semitransparentes. Nota: Este indicador solo es compatible con X11 y desactiva el doble búfer. En Qt para Linux embebido, el indicador solo funciona cuando se establece en un widget de nivel superior y depende de la compatibilidad del controlador de pantalla activo. El autor del widget es quien establece o desactiva este indicador. Para renderizar fuera del sistema de pintura de Qt, por ejemplo, si se necesitan primitivas de pintura nativas, es necesario reimplementar ` QWidget::paintEngine()` para que devuelva 0 y establecer este indicador. |
Qt::WA_PaintUnclipped | 52 | Hace que todos los pintores que operen en este widget no se recorten. Los hijos de este widget u otros widgets situados delante de él no recortan el área en la que el pintor puede pintar. Este indicador solo es compatible con widgets que tengan activado el indicador WA_PaintOnScreen. La forma recomendada de hacerlo de manera multiplataforma es crear un widget transparente que se sitúe delante de los demás widgets. |
Qt::WA_PendingMoveEvent | 34 | Indica que hay un evento de desplazamiento pendiente, por ejemplo, cuando se ha desplazado un widget oculto. El núcleo de Qt activa o desactiva esta bandera. |
Qt::WA_PendingResizeEvent | 35 | Indica que hay un evento de redimensionamiento pendiente, por ejemplo, cuando se ha redimensionado un widget oculto. El núcleo de Qt activa o desactiva este indicador. |
Qt::WA_QuitOnClose | 76 | Indica que se debe tener en cuenta el widget a la hora de decidir si se cierra la aplicación cuando se cierre la última ventana. Este comportamiento se puede modificar con la propiedad ` QGuiApplication::quitOnLastWindowClosed `. Por defecto, este atributo está activado para todos los widgets de tipo ` Qt::Window`. |
Qt::WA_Resized | 42 | Indica que el widget tiene un tamaño explícito. Este indicador se activa o desactiva mediante ` QWidget::resize()` y ` QWidget::setGeometry()`. |
Qt::WA_RightToLeft | 56 | Indica que la dirección de disposición del widget es de derecha a izquierda. |
Qt::WA_SetCursor | 38 | Indica que el widget tiene su propio cursor. Este indicador se activa o desactiva mediante QWidget::setCursor() y QWidget::unsetCursor(). |
Qt::WA_SetFont | 37 | Indica que el widget tiene su propia fuente. Este indicador se activa o desactiva mediante QWidget::setFont(). |
Qt::WA_SetPalette | 36 | Indica que el widget tiene su propia paleta. Este indicador se activa o desactiva mediante QWidget::setPalette(). |
Qt::WA_SetStyle | 86 | Indica que el widget tiene un estilo propio. Este indicador se activa o desactiva mediante la función ` QWidget::setStyle()`. |
Qt::WA_ShowModal | 70 | Este atributo ha quedado obsoleto. Utiliza en su lugar ` QWidget::windowModality `. |
Qt::WA_StaticContents | 5 | Indica que el contenido del widget está alineado al noroeste y es estático. Al cambiar de tamaño, dicho widget recibirá eventos de dibujo únicamente para aquellas partes del mismo que hayan quedado visibles recientemente. El autor del widget establece o desactiva este indicador. |
Qt::WA_StyleSheet | 97 | Indica que el estilo del widget se aplica mediante una hoja de estilo. WA_StyleSheet se activa siempre que un widget esté sujeto a una hoja de estilo, incluso si esta no ha afectado a su apariencia. |
Qt::WA_StyleSheetTarget | 131 | Indica que la apariencia del widget se ha modificado mediante una hoja de estilo. También se activará WA_StyleSheet. Este valor se introdujo en Qt 5.12. |
Qt::WA_TabletTracking | 129 | Indica que el widget tiene habilitado el seguimiento de tabletas. Véase QWidget::tabletTracking. |
Qt::WA_TranslucentBackground | 120 | Indica que el widget debe tener un fondo translúcido; es decir, cualquier región no opaca del widget será translúcida, ya que el widget tendrá un canal alfa. Al activar este indicador, se activa WA_NoSystemBackground. En Windows, el widget también necesita que se active el indicador de ventana Qt::FramelessWindowHint. El autor del widget es quien activa o desactiva este indicador. A partir de Qt 5.0, cambiar este atributo una vez que el widget se ha mostrado no es compatible de manera uniforme en todas las plataformas. Si se desea un fondo translúcido, establezca el atributo al principio, al crear el widget, y evite modificarlo posteriormente. |
Qt::WA_UnderMouse | 1 | Indica que el widget se encuentra bajo el cursor del ratón. El valor no se actualiza correctamente durante las operaciones de arrastrar y soltar. También existe una función de obtención, QWidget::underMouse(). Esta bandera la activa o desactiva el núcleo de Qt. |
Qt::WA_UpdatesDisabled | 10 | Indica que las actualizaciones están bloqueadas (incluido el fondo del sistema). El núcleo de Qt activa o desactiva este indicador. Advertencia: El autor del widget nunca debe activar ni desactivar este indicador. |
Qt::WA_WindowModified | 41 | Indica que la ventana está marcada como modificada. En algunas plataformas, este indicador no tiene ningún efecto; en otras (incluidas macOS y Windows), la ventana adoptará un aspecto de modificada. Este indicador lo activa o desactiva la función QWidget::setWindowModified(). |
Qt::WA_WindowPropagation | 80 | Hace que una ventana de nivel superior herede la fuente, la paleta y la configuración regional de su ventana principal. |
Qt::WA_MacAlwaysShowToolWindow | 96 | En macOS, muestra la ventana de herramientas incluso cuando la aplicación no está activa. Por defecto, todas las ventanas de herramientas se ocultan cuando la aplicación está inactiva. |
Qt::WA_SetLocale | 87 | Indica que se debe tener en cuenta la configuración regional en el widget. |
Qt::WA_StyledBackground | 93 | Indica que el widget debe dibujarse utilizando un fondo con estilo. |
Qt::WA_ShowWithoutActivating | 98 | Muestra el widget sin activarlo. |
Qt::WA_NativeWindow | 100 | Indica que se crea una ventana nativa para el widget. Al habilitar este indicador, también se forzará la creación de una ventana nativa para los antepasados del widget, a menos que se haya establecido Qt::WA_DontCreateNativeAncestors. |
Qt::WA_DontCreateNativeAncestors | 101 | Indica que los antepasados del widget se mantienen como no nativos aunque el propio widget sea nativo. |
Qt::WA_X11NetWmWindowTypeDesktop | 104 | Añade _NET_WM_WINDOW_TYPE_DESKTOP a la propiedad de ventana X11 _NET_WM_WINDOW_TYPE de la ventana. Consulte http://standards.freedesktop.org/wm-spec/ para obtener más detalles. Este atributo no tiene ningún efecto en plataformas que no sean X11. |
Qt::WA_X11NetWmWindowTypeDock | 105 | Añade _NET_WM_WINDOW_TYPE_DOCK a la propiedad de ventana X11 _NET_WM_WINDOW_TYPE de la ventana. Consulte http://standards.freedesktop.org/wm-spec/ para obtener más detalles. Este atributo no tiene ningún efecto en plataformas que no sean X11. |
Qt::WA_X11NetWmWindowTypeToolBar | 106 | Añade _NET_WM_WINDOW_TYPE_TOOLBAR a la propiedad de ventana X11 _NET_WM_WINDOW_TYPE de la ventana. Consulte http://standards.freedesktop.org/wm-spec/ para obtener más detalles. Este atributo no tiene ningún efecto en plataformas que no sean X11. Nota: Qt establece automáticamente este atributo para QToolBar. |
Qt::WA_X11NetWmWindowTypeMenu | 107 | Añade _NET_WM_WINDOW_TYPE_MENU a la propiedad de ventana X11 _NET_WM_WINDOW_TYPE de la ventana. Consulte http://standards.freedesktop.org/wm-spec/ para obtener más detalles. Este atributo no tiene ningún efecto en plataformas que no sean X11. Nota: Qt establece automáticamente este atributo para QMenu cuando la ventana está separada. |
Qt::WA_X11NetWmWindowTypeUtility | 108 | Añade _NET_WM_WINDOW_TYPE_UTILITY a la propiedad X11 _NET_WM_WINDOW_TYPE de la ventana. Consulte http://standards.freedesktop.org/wm-spec/ para obtener más detalles. Este atributo no tiene ningún efecto en plataformas que no sean X11. Nota: Qt establece automáticamente este atributo para el tipo de ventana « Qt::Tool ». |
Qt::WA_X11NetWmWindowTypeSplash | 109 | Añade _NET_WM_WINDOW_TYPE_SPLASH a la propiedad de ventana X11 _NET_WM_WINDOW_TYPE de la ventana. Consulte http://standards.freedesktop.org/wm-spec/ para obtener más detalles. Este atributo no tiene ningún efecto en plataformas que no sean X11. Nota: Qt establece automáticamente este atributo para el tipo de ventana « Qt::SplashScreen ». |
Qt::WA_X11NetWmWindowTypeDialog | 110 | Añade _NET_WM_WINDOW_TYPE_DIALOG a la propiedad de ventana X11 _NET_WM_WINDOW_TYPE de la ventana. Consulte http://standards.freedesktop.org/wm-spec/ para obtener más detalles. Este atributo no tiene ningún efecto en plataformas que no sean X11. Nota: Qt establece automáticamente este atributo para los tipos de ventana « Qt::Dialog » y « Qt::Sheet ». |
Qt::WA_X11NetWmWindowTypeDropDownMenu | 111 | Añade _NET_WM_WINDOW_TYPE_DROPDOWN_MENU a la propiedad de ventana X11 _NET_WM_WINDOW_TYPE de la ventana. Consulte http://standards.freedesktop.org/wm-spec/ para obtener más detalles. Este atributo no tiene ningún efecto en plataformas que no sean X11. Nota: Qt establece automáticamente este atributo para los objetos ` QMenu ` añadidos a un ` QMenuBar`. |
Qt::WA_X11NetWmWindowTypePopupMenu | 112 | Añade _NET_WM_WINDOW_TYPE_POPUP_MENU a la propiedad de ventana X11 _NET_WM_WINDOW_TYPE de la ventana. Consulta http://standards.freedesktop.org/wm-spec/ para obtener más detalles. Este atributo no tiene ningún efecto en plataformas que no sean X11. Nota: Qt establece automáticamente este atributo para QMenu. |
Qt::WA_X11NetWmWindowTypeToolTip | 113 | Añade _NET_WM_WINDOW_TYPE_TOOLTIP a la propiedad de ventana X11 _NET_WM_WINDOW_TYPE de la ventana. Consulte http://standards.freedesktop.org/wm-spec/ para obtener más detalles. Este atributo no tiene ningún efecto en plataformas que no sean X11. Nota: Qt establece automáticamente este atributo para el tipo de ventana Qt::ToolTip. |
Qt::WA_X11NetWmWindowTypeNotification | 114 | Añade _NET_WM_WINDOW_TYPE_NOTIFICATION a la propiedad de ventana X11 _NET_WM_WINDOW_TYPE de la ventana. Consulte http://standards.freedesktop.org/wm-spec/ para obtener más detalles. Este atributo no tiene ningún efecto en plataformas que no sean X11. |
Qt::WA_X11NetWmWindowTypeCombo | 115 | Añade _NET_WM_WINDOW_TYPE_COMBO a la propiedad de ventana X11 _NET_WM_WINDOW_TYPE de la ventana. Consulte http://standards.freedesktop.org/wm-spec/ para obtener más detalles. Este atributo no tiene ningún efecto en plataformas que no sean X11. Nota: Qt establece automáticamente este atributo para la ventana emergente « QComboBox ». |
Qt::WA_X11NetWmWindowTypeDND | 116 | Añade _NET_WM_WINDOW_TYPE_DND a la propiedad de ventana X11 _NET_WM_WINDOW_TYPE de la ventana. Consulte http://standards.freedesktop.org/wm-spec/ para obtener más detalles. Este atributo no tiene ningún efecto en plataformas que no sean X11. Nota: Qt establece automáticamente este atributo en el widget de retroalimentación utilizado durante un arrastre. |
Qt::WA_AcceptTouchEvents | 121 | Permite que se envíen eventos táctiles (véase QTouchEvent) al widget. Debe establecerse en todos los widgets que puedan gestionar eventos táctiles. Si no se establece este atributo, los eventos procedentes de un dispositivo táctil se enviarán como eventos de ratón. |
Qt::WA_TouchPadAcceptSingleTouchEvents | 123 | Permite que se envíen al widget eventos táctiles de un solo toque del panel táctil. |
Qt::WA_X11DoNotAcceptFocus | 126 | Indica al gestor de ventanas que no conceda el foco a esta ventana de nivel superior. Este atributo no tiene ningún efecto en plataformas que no sean X11. |
Qt::WA_AlwaysStackOnTop (since Qt 5.4) | 128 | Obliga a que QOpenGLWidget y QQuickWidget se dibujen en último lugar, por encima de otros widgets. Se ignora en otros tipos de widgets. Establecer este atributo rompe el orden de superposición, pero permite tener un widget OpenGL semitransparente con otros widgets visibles debajo. Se recomienda encarecidamente llamar a update() en la ventana de nivel superior del widget después de habilitar o deshabilitar este atributo. |
Qt::WA_ContentsMarginsRespectsSafeArea | 130 | Un « QWidget » respeta los márgenes del área segura de una ventana al incorporar dichos márgenes en los márgenes de su contenido de forma predeterminada. Esto significa que un « QLayout » utilizará el área de contenido de un widget para su diseño, a menos que se establezca el atributo Qt::WA_LayoutOnEntireRect. Esto, junto con un margen de contenido de 0, se puede utilizar en el diseño real para permitir, por ejemplo, que una imagen de fondo se sitúe debajo de la barra de estado y otras áreas del sistema en un dispositivo iOS, al tiempo que se permite que los widgets hijos de ese fondo se ajusten en función del área segura. |
enum Qt::WindowFrameSection
Esta enumeración se utiliza para describir las partes del marco de una ventana. La función ` QGraphicsWidget::windowFrameSectionAt()` la devuelve para indicar qué sección del marco de la ventana se encuentra bajo el cursor del ratón.
| Constante | Valor |
|---|---|
Qt::NoSection | 0 |
Qt::LeftSection | 1 |
Qt::TopLeftSection | 2 |
Qt::TopSection | 3 |
Qt::TopRightSection | 4 |
Qt::RightSection | 5 |
Qt::BottomRightSection | 6 |
Qt::BottomSection | 7 |
Qt::BottomLeftSection | 8 |
Qt::TitleBarArea | 9 |
Véase también QGraphicsWidget::windowFrameEvent(), QGraphicsWidget::paintWindowFrame() y QGraphicsWidget::windowFrameSectionAt().
enum Qt::WindowModality
Esta enumeración especifica el comportamiento de una ventana modal. Una ventana modal es aquella que bloquea la entrada a otras ventanas. Ten en cuenta que las ventanas que son subordinadas de una ventana modal no quedan bloqueadas.
Los valores son:
| Constante | Valor | Descripción |
|---|---|---|
Qt::NonModal | 0 | La ventana no es modal y no bloquea la entrada a otras ventanas. |
Qt::WindowModal | 1 | La ventana es modal respecto a una única jerarquía de ventanas y bloquea la entrada a su ventana principal, a todas las ventanas de nivel superior y a todas las ventanas de igual nivel que sean de su ventana principal o de las ventanas de nivel superior. |
Qt::ApplicationModal | 2 | La ventana es modal respecto a la aplicación y bloquea la entrada a todas las ventanas. |
Véase también QWidget::windowModality y QDialog.
enum Qt::WindowState
flags Qt::WindowStates
Este tipo de enumeración se utiliza para especificar el estado actual de una ventana de nivel superior.
Los estados son
| Constante | Valor | Descripción |
|---|---|---|
Qt::WindowNoState | 0x00000000 | La ventana no tiene ningún estado establecido (se encuentra en estado normal). |
Qt::WindowMinimized | 0x00000001 | La ventana está minimizada (es decir, reducida a un icono). |
Qt::WindowMaximized | 0x00000002 | La ventana está maximizada y rodeada por un marco. |
Qt::WindowFullScreen | 0x00000004 | La ventana ocupa toda la pantalla sin ningún marco a su alrededor. |
Qt::WindowActive | 0x00000008 | La ventana es la ventana activa, es decir, tiene el foco del teclado. |
El tipo `WindowStates` es una definición de tipo para ` QFlags<WindowState>`. Almacena una combinación OR de valores de `WindowState`.
enum Qt::WindowType
flags Qt::WindowFlags
Este tipo de enumeración se utiliza para especificar diversas propiedades del sistema de ventanas para el widget. Son bastante poco habituales, pero necesarias en algunos casos. Algunas de estas opciones dependen de si el gestor de ventanas subyacente las admite.
Los tipos principales son
| Constante | Valor | Descripción |
|---|---|---|
Qt::Widget | 0x00000000 | Este es el tipo por defecto para ` QWidget`. Los widgets de este tipo son widgets hijos si tienen un padre, y ventanas independientes si no lo tienen. Véase también `Qt::Window` y `Qt::SubWindow`. |
Qt::Window | 0x00000001 | Indica que el widget es una ventana, normalmente con un marco del sistema de ventanas y una barra de título, independientemente de si el widget tiene un padre o no. Ten en cuenta que no es posible desactivar este indicador si el widget no tiene un padre. |
Qt::Dialog | 0x00000002 | Window | Indica que el widget es una ventana que debe decorarse como un cuadro de diálogo (es decir, normalmente sin botones de maximizar o minimizar en la barra de título). Este es el tipo predeterminado para QDialog. Si se desea utilizarlo como un cuadro de diálogo modal, debe iniciarse desde otra ventana, o bien tener un padre y utilizarse con la propiedad QWidget::windowModality. Si lo configuras como modal, el cuadro de diálogo impedirá que otras ventanas de nivel superior de la aplicación reciban entradas. Nos referimos a una ventana de nivel superior que tiene una ventana principal como «ventana secundaria ». |
Qt::Sheet | 0x00000004 | Window | Indica que la ventana es una «sheet» en macOS. Dado que el uso de una «sheet» implica la modalidad de la ventana, se recomienda utilizar en su lugar QWidget::setWindowModality() o QDialog::open(). |
Qt::Drawer | Sheet | Dialog | Indica que el widget es un cajón en macOS. Esta característica está obsoleta. Establecer el indicador no tiene ningún efecto. |
Qt::Popup | 0x00000008 | Window | Indica que el widget es una ventana emergente de nivel superior, es decir, que es modal, pero tiene un marco del sistema de ventanas adecuado para menús emergentes. |
Qt::Tool | Popup | Dialog | Indica que el widget es una ventana de herramientas. Una ventana de herramientas suele ser una ventana pequeña con una barra de título y una decoración más reducidas de lo habitual, que se utiliza normalmente para agrupar botones de herramientas. Si hay una ventana padre, la ventana de herramientas siempre se mantendrá encima de ella. Si no hay una ventana padre, también puedes plantearte utilizar Qt::WindowStaysOnTopHint. Si el sistema de ventanas lo admite, una ventana de herramientas puede decorarse con un marco algo más claro. También puede combinarse con Qt::FramelessWindowHint. En macOS, las ventanas de herramientas se corresponden con la clase de ventanas NSPanel. Esto significa que la ventana se sitúa en un nivel por encima de las ventanas normales, lo que hace imposible colocar una ventana normal encima de ella. Por defecto, las ventanas de herramientas desaparecerán cuando la aplicación esté inactiva. Esto se puede controlar mediante el atributo Qt::WA_MacAlwaysShowToolWindow. |
Qt::ToolTip | Popup | Sheet | Indica que el widget es una información sobre herramientas. Se utiliza internamente para implementar tooltips. |
Qt::SplashScreen | ToolTip | Dialog | Indica que la ventana es una pantalla de bienvenida. Este es el tipo predeterminado para ` QSplashScreen`. |
Qt::SubWindow | 0x00000012 | Indica que este widget es una subventana, como un widget ` QMdiSubWindow `. |
Qt::ForeignWindow | 0x00000020 | Window | Indica que este objeto de ventana es un identificador que representa una ventana nativa de la plataforma creada por otro proceso o manualmente mediante código nativo. |
Qt::CoverWindow | 0x00000040 | Window | Indica que la ventana representa una ventana de cubierta, que se muestra cuando la aplicación está minimizada en algunas plataformas. |
También hay una serie de indicadores que puedes utilizar para personalizar el aspecto de las ventanas de nivel superior. Estos no tienen ningún efecto sobre otras ventanas:
| Constante | Valor | Descripción |
|---|---|---|
Qt::MSWindowsFixedSizeDialogHint | 0x00000100 | Aporta a la ventana un borde de diálogo fino en Windows. Este estilo se utiliza tradicionalmente para diálogos de tamaño fijo. Nota: No se recomiendael uso de este indicador en entornos con varios monitores. Esto se debe a que el sistema obligará a que la ventana mantenga su tamaño nativo al moverla de una pantalla a otra. Esto resulta especialmente indeseable cuando se utilizan monitores con resoluciones diferentes. |
Qt::MSWindowsOwnDC | 0x00000200 | Proporciona a la ventana su propio contexto de visualización en Windows. |
Qt::BypassWindowManagerHint | 0x00000400 | Este indicador se puede utilizar para indicar al complemento de la plataforma que deben desactivarse «todos» los protocolos del gestor de ventanas. Este indicador se comportará de forma diferente dependiendo del sistema operativo en el que se ejecute la aplicación y del gestor de ventanas que esté en funcionamiento. El indicador se puede utilizar para obtener una ventana nativa sin ninguna configuración establecida. |
Qt::X11BypassWindowManagerHint | BypassWindowManagerHint | Omite por completo el gestor de ventanas. Esto da como resultado una ventana sin bordes que no se gestiona en absoluto (es decir, no se admite la entrada del teclado a menos que se llame manualmente a ` QWidget::activateWindow()`). |
Qt::FramelessWindowHint | 0x00000800 | Genera una ventana sin bordes. |
En X11, el resultado de este indicador depende del gestor de ventanas y de su capacidad para interpretar las sugerencias de Motif y/o NETWM. La mayoría de los gestores de ventanas modernos actuales pueden gestionarlo.
Nota: Si el gestor de ventanas se basa en el marco para manipular la ventana de forma interactiva, el usuario ya no podrá mover ni cambiar el tamaño de la ventana a través del sistema de ventanas, pero no se debe dar por sentado este efecto secundario. Para crear una ventana de tamaño fijo que no se pueda redimensionar, establece QWindow::setMinimumSize() y QWindow::setMaximumSize() en el mismo tamaño.
| Constante | Valor | Descripción |
|---|---|---|
Qt::NoDropShadowWindowHint | 0x40000000 | Desactiva la sombra de la ventana en las plataformas compatibles. |
El indicador CustomizeWindowHint se utiliza para habilitar la personalización de los controles de la ventana. Este indicador debe estar activado para permitir modificar los indicadores WindowTitleHint, WindowSystemMenuHint, WindowMinimizeButtonHint, WindowMaximizeButtonHint y WindowCloseButtonHint.
| Constante | Valor | Descripción |
|---|---|---|
Qt::CustomizeWindowHint | 0x02000000 | Desactiva las sugerencias predeterminadas del título de la ventana. |
Qt::WindowTitleHint | 0x00001000 | Añade una barra de título a la ventana. |
Qt::WindowSystemMenuHint | 0x00002000 | Añade un menú del sistema de ventanas y, posiblemente, un botón de cierre (por ejemplo, en Mac). Si necesitas ocultar o mostrar un botón de cierre, es más portátil utilizar ` WindowCloseButtonHint`. |
Qt::WindowMinimizeButtonHint | 0x00004000 | Añade un botón de minimizar. En algunas plataformas, para que funcione es necesario utilizar `Qt::WindowSystemMenuHint`. Nota: En muchos sistemas basados en Wayland, las sugerencias de botones no son compatibles con las decoraciones del lado del servidor. |
Qt::WindowMaximizeButtonHint | 0x00008000 | Añade un botón de maximizar. En algunas plataformas, para que funcione es necesario utilizar Qt::WindowSystemMenuHint. Nota: En muchos sistemas basados en Wayland, las sugerencias de botones no son compatibles con las decoraciones del lado del servidor. |
Qt::WindowMinMaxButtonsHint | WindowMinimizeButtonHint | WindowMaximizeButtonHint | Añade un botón para minimizar y otro para maximizar. En algunas plataformas, para que funcione es necesario utilizar Qt::WindowSystemMenuHint. Nota: En muchos sistemas basados en Wayland, las sugerencias de botones no son compatibles con las decoraciones del lado del servidor. |
Qt::WindowCloseButtonHint | 0x08000000 | Añade un botón de cierre. En algunas plataformas, para que funcione, se requiere Qt::WindowSystemMenuHint. Nota: En muchos sistemas basados en Wayland, las sugerencias de botones no son compatibles con las decoraciones del lado del servidor. |
Qt::WindowContextHelpButtonHint | 0x00010000 | Añade un botón de ayuda contextual a los cuadros de diálogo. En algunas plataformas, para que funcione es necesario utilizar Qt::WindowSystemMenuHint. |
Qt::WindowFullscreenButtonHint | 0x80000000 | En macOS, añade un botón de pantalla completa. |
Qt::BypassGraphicsProxyWidget | 0x20000000 | Evita que la ventana y sus elementos secundarios se incrusten automáticamente en una « QGraphicsProxyWidget » si el widget padre ya está incrustado. Puedes activar este indicador si deseas que tu widget sea siempre un widget de nivel superior en el escritorio, independientemente de si el widget padre está incrustado en una escena o no. |
Qt::WindowShadeButtonHint | 0x00020000 | Añade un botón de ocultación en lugar del botón de minimizar si el gestor de ventanas subyacente lo admite. |
Qt::WindowStaysOnTopHint | 0x00040000 | Indica al sistema de ventanas que la ventana debe permanecer encima de todas las demás ventanas. Ten en cuenta que, en algunos gestores de ventanas de X11, también es necesario pasar Qt::X11BypassWindowManagerHint para que este indicador funcione correctamente. |
Qt::WindowStaysOnBottomHint | 0x04000000 | Indica al sistema de ventanas que la ventana debe permanecer debajo de todas las demás ventanas. Nota: En X11, esta indicación solo funcionará en gestores de ventanas que admitan el átomo _NET_WM_STATE_BELOW. Si una ventana que permanece siempre en el fondo tiene una ventana padre, esta también se mantendrá en el fondo. Actualmente, esta indicación de ventana no está implementada para macOS. Nota: En Windows, esto solo funcionará para ventanas sin marco o a pantalla completa. |
Qt::WindowTransparentForInput | 0x00080000 | Indica al sistema de ventanas que esta ventana se utiliza únicamente para salida (mostrar algo) y no acepta entradas. Por lo tanto, los eventos de entrada deben pasar a través de ella como si no estuviera ahí. |
Qt::WindowOverridesSystemGestures | 0x00100000 | Indica al sistema de ventanas que esta ventana implementa su propio conjunto de gestos y que los gestos a nivel del sistema, como por ejemplo el cambio de escritorio con tres dedos, deben desactivarse. |
Qt::WindowDoesNotAcceptFocus | 0x00200000 | Indica al sistema de ventanas que esta ventana no debe recibir el foco de entrada. Nota: En Windows, esto evita que la ventana aparezca en la barra de tareas. |
Qt::MaximizeUsingFullscreenGeometryHint | 0x00400000 | Alias obsoleto de Qt::ExpandedClientAreaHint |
Qt::ExpandedClientAreaHint (since Qt 6.9) | 0x00400000 | Solicita que el área de cliente de la ventana se amplíe a aquellas zonas en las que pueda quedar oculta o entre en conflicto con otros elementos de la interfaz de usuario, como los controles de la barra de título de la ventana u otras interfaces de usuario del sistema. El « safe area margins » de la ventana reflejará cualquier zona que pueda contener elementos de la interfaz de usuario conflictivos. |
Qt::NoTitleBarBackgroundHint (since Qt 6.9) | 0x00800000 | Solicita que la barra de título de la ventana se dibuje sin color de fondo. Este indicador resulta útil en combinación con Qt::ExpandedClientAreaHint, para dar la impresión de que el área de cliente de la ventana se integra a la perfección con el área de la barra de título y los controles. |
Qt::WindowType_Mask | 0x000000ff | Una máscara para extraer la parte correspondiente al tipo de ventana de los indicadores de ventana. |
El tipo WindowFlags es un typedef para QFlags<WindowType>. Almacena una combinación OR de valores de WindowType.
Véase también « QWidget::windowFlags » y «Ejemplo de indicadores de ventana».
[alias, since 6.12] template <typename T, typename U> if_has_qt_compare_three_way
Un alias de conveniencia para ` std::enable_if_t ` que se puede utilizar para restringir las plantillas de función a tipos que admitan la comparación de tres elementos mediante ` compareThreeWay()`.
Esta definición de tipo se introdujo en Qt 6.12.
Véase también Qt::has_qt_compare_three_way.
Documentación de la función
[since 6.2] void beginPropertyUpdateGroup()
Marca el inicio de un grupo de actualización de propiedades. Dentro de este grupo, al modificar una propiedad no se actualizan inmediatamente las propiedades dependientes ni se activan notificaciones de cambio. Estas se aplazan hasta que el grupo finalice mediante una llamada a ` endPropertyUpdateGroup`.
Los grupos pueden anidarse. En ese caso, el aplazamiento solo finaliza una vez que se ha cerrado el grupo más externo.
Nota: Las notificacionesde cambio solo se envían una vez que todos los valores de las propiedades afectadas por el grupo se han actualizado a sus nuevos valores. Esto permite restablecer una invariante de clase si es necesario actualizar varias propiedades, evitando así que cualquier observador externo detecte un estado incoherente.
Esta función se introdujo en Qt 6.2.
Véase también Qt::endPropertyUpdateGroup y QScopedPropertyUpdateGroup.
QTextStream &Qt::bin(QTextStream &stream)
Llama a ` QTextStream::setIntegerBase(2)` en ` stream ` y devuelve ` stream`.
Véase también oct(), dec(), hex() y QTextStream manipulators.
QTextStream &Qt::bom(QTextStream &stream)
Activa o desactiva la inserción de la marca de orden de bytes (Byte Order Mark) en stream cuando se utiliza QTextStream con una codificación UTF.
Véase también QTextStream::setGenerateByteOrderMark() y QTextStream manipulators.
QTextStream &Qt::center(QTextStream &stream)
Llama a ` QTextStream::setFieldAlignment` (QTextStream::AlignCenter) en ` stream ` y devuelve ` stream`.
Véase también left(), right() y QTextStream manipulators.
[constexpr noexcept, since 6.7] template <typename Enum> requires if_enum<Enum> Qt::strong_ordering compareThreeWay(Enum lhs, Enum rhs)
Implementa la comparación a tres bandas de tipos enumerados.
Esta función convierte Enum a su tipo subyacente y llama a la sobrecarga para tipos enteros.
Devuelve una instancia de ` Qt::strong_ordering ` que representa la relación entre ` lhs ` y ` rhs`.
Restricciones
Participa en la resolución de sobrecarga solo si Enum es un tipo enumerado.
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.7.
[constexpr noexcept, since 6.7] template <typename FloatType, typename IntType> requires if_floating_point<FloatType> && if_integral<IntType> auto compareThreeWay(FloatType lhs, IntType rhs)
Implementa la comparación a tres bandas entre tipos de punto flotante y tipos enteros.
Esta función convierte rhs en FloatType y llama a la sobrecarga para los tipos de punto flotante.
Devuelve una instancia de ` Qt::partial_ordering ` que representa la relación entre ` lhs ` y ` rhs`. Si ` lhs ` no es un número (NaN), se devuelve ` Qt::partial_ordering::unordered `.
Restricciones
Participa en la resolución de sobrecarga solo si FloatType es un tipo de punto flotante integrado y IntType es un tipo entero integrado.
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.7.
[constexpr noexcept, since 6.7] template <typename IntType, typename FloatType> requires if_integral<IntType> && if_floating_point<FloatType> auto compareThreeWay(IntType lhs, FloatType rhs)
Lleva a cabo una comparación a tres bandas entre tipos enteros y de coma flotante.
Esta función convierte lhs en FloatType y llama a la sobrecarga para los tipos de punto flotante.
Devuelve una instancia de ` Qt::partial_ordering ` que representa la relación entre ` lhs ` y ` rhs`. Si ` rhs ` no es un número (NaN), se devuelve ` Qt::partial_ordering::unordered `.
Restricciones
Participa en la resolución de sobrecarga solo si IntType es un tipo entero integrado y FloatType es un tipo de punto flotante integrado.
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.7.
[constexpr noexcept, since 6.7] template <typename LeftFloat, typename RightFloat> requires if_floating_point<LeftFloat> && if_floating_point<RightFloat> auto compareThreeWay(LeftFloat lhs, RightFloat rhs)
Implementa la comparación a tres bandas de tipos de punto flotante.
Devuelve un ` lhs <=> rhs`, siempre que ` LeftFloat ` y ` RightFloat ` sean tipos de punto flotante integrados. A diferencia de ` operator<=>()`, esta plantilla de función también está disponible en C++17. Consulte cppreference para obtener más detalles.
Esta función también se puede utilizar en funciones personalizadas de ` compareThreeWay() `, al ordenar los miembros de una clase personalizada representada por tipos integrados:
class MyClass {
public:
...
private:
double value;
...
friend Qt::partial_ordering
compareThreeWay(const MyClass &lhs, const MyClass &rhs) noexcept
{ return Qt::compareThreeWay(lhs.value, rhs.value); }
Q_DECLARE_PARTIALLY_ORDERED(MyClass)
};Devuelve una instancia de ` Qt::partial_ordering ` que representa la relación entre ` lhs ` y ` rhs`. Si ` lhs ` o ` rhs ` no es un número (NaN), se devuelve ` Qt::partial_ordering::unordered `.
Restricciones
Participa en la resolución de sobrecarga solo si tanto LeftFloat como RightFloat son tipos de punto flotante integrados.
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.7.
[constexpr noexcept, since 6.7] template <typename LeftInt, typename RightInt> requires if_integral<LeftInt> && if_integral<RightInt> auto compareThreeWay(LeftInt lhs, RightInt rhs)
Implementa la comparación a tres bandas de tipos enteros.
Devuelve ` lhs <=> rhs`, siempre que ` LeftInt ` y ` RightInt ` sean tipos enteros predefinidos. A diferencia de ` operator<=>()`, esta plantilla de función también está disponible en C++17. Consulta cppreference para obtener más detalles.
Esta función también se puede utilizar en funciones personalizadas de ` compareThreeWay() `, al ordenar los miembros de una clase personalizada representada por tipos integrados:
class MyClass {
public:
...
private:
int value;
...
friend Qt::strong_ordering
compareThreeWay(const MyClass &lhs, const MyClass &rhs) noexcept
{ return Qt::compareThreeWay(lhs.value, rhs.value); }
Q_DECLARE_STRONGLY_ORDERED(MyClass)
};Devuelve una instancia de ` Qt::strong_ordering ` que representa la relación entre ` lhs ` y ` rhs`.
Restricciones
Participa en la resolución de sobrecarga solo si tanto ` LeftInt ` como ` RightInt ` son tipos enteros predefinidos.
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.7.
[constexpr noexcept, since 6.8] template <typename T, typename U> requires if_compatible_pointers<T, U> Qt::strong_ordering compareThreeWay(Qt::totally_ordered_wrapper<T *> lhs, Qt::totally_ordered_wrapper<U *> rhs)
Implementa una comparación a tres bandas de punteros envueltos en ` Qt::totally_ordered_wrapper`. Utiliza un orden total estricto sobre los punteros al realizar la comparación.
Devuelve una instancia de ` Qt::strong_ordering ` que representa la relación entre ` lhs ` y ` rhs`.
Restricciones
Participa en la resolución de sobrecargas únicamente si T y U son del mismo tipo, o si son tipos base y derivados.
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.8.
[constexpr noexcept, since 6.8] template <typename T, typename U> requires if_compatible_pointers<T, U> Qt::strong_ordering compareThreeWay(Qt::totally_ordered_wrapper<T *> lhs, U *rhs)
Implementa la comparación a tres bandas entre un puntero envuelto en ` Qt::totally_ordered_wrapper ` y un puntero normal. Utiliza un orden total estricto sobre los punteros al realizar la comparación.
Devuelve una instancia de ` Qt::strong_ordering ` que representa la relación entre ` lhs ` y ` rhs`.
Restricciones
Participa en la resolución de sobrecargas solo si T y U son del mismo tipo, o si son tipos base y derivados.
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.8.
[constexpr noexcept, since 6.8] template <typename T> Qt::strong_ordering compareThreeWay(Qt::totally_ordered_wrapper<T *> lhs, std::nullptr_t rhs)
Implementa la comparación a tres bandas de un puntero envuelto en ` Qt::totally_ordered_wrapper ` con ` std::nullptr_t`.
Devuelve una instancia de ` Qt::strong_ordering ` que representa la relación entre ` lhs ` y ` rhs`.
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.8.
[constexpr noexcept, since 6.8] template <typename T, typename U> requires if_compatible_pointers<T, U> Qt::strong_ordering compareThreeWay(U *lhs, Qt::totally_ordered_wrapper<T *> rhs)
Implementa una comparación a tres bandas entre un puntero normal y un puntero envuelto en ` Qt::totally_ordered_wrapper`. Utiliza un orden total estricto sobre los punteros al realizar la comparación.
Devuelve una instancia de ` Qt::strong_ordering ` que representa la relación entre ` lhs ` y ` rhs`.
Restricciones
Participa en la resolución de sobrecarga solo si ` T ` y ` U ` son del mismo tipo, o si son tipos base y derivados.
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.8.
[since 6.12] template <
typename T1,
typename T2,
typename U1,
typename U2
>
auto compareThreeWay(const std::pair<T1, T2> &lhs, const std::pair<U1, U2> &rhs)
Nota: T1 debería ser comparable a U1 y T2 debería ser comparable a U2 utilizando compareThreeWay() o operator<().
Esta sobrecarga utiliza el tipo de retorno auto, ya que la fuerza del orden depende de los argumentos de plantilla del par. Por ejemplo, si cualquiera de los argumentos es de tipo flotante, el orden sería Qt::partial_ordering; si ambos son enteros, sería Qt::strong_ordering.
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.12.
[constexpr noexcept, since 6.8] template <typename T> Qt::strong_ordering compareThreeWay(std::nullptr_t lhs, Qt::totally_ordered_wrapper<T *> rhs)
Implementa la comparación a tres bandas de ` std::nullptr_t ` con un puntero envuelto en ` Qt::totally_ordered_wrapper`.
Devuelve una instancia de ` Qt::strong_ordering ` que representa la relación entre ` lhs ` y ` rhs`.
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.8.
QTextStream &Qt::dec(QTextStream &stream)
Llama a ` QTextStream::setIntegerBase(10)` en ` stream ` y devuelve ` stream`.
Véase también bin(), oct(), hex() y QTextStream manipulators.
[since 6.2] void endPropertyUpdateGroup()
Finaliza un grupo de actualización de propiedades. Si se ha finalizado el grupo más externo, en ese momento se llevan a cabo las evaluaciones de enlace aplazadas y las notificaciones.
Advertencia: Llamar a `endPropertyUpdateGroup` sin haber llamado previamente a ` beginPropertyUpdateGroup ` da lugar a un comportamiento indefinido.
Esta función se introdujo en Qt 6.2.
Véase también « Qt::beginPropertyUpdateGroup » y « QScopedPropertyUpdateGroup ».
QTextStream &Qt::endl(QTextStream &stream)
Escribe «\n » en el objeto ` stream ` y vacía el flujo.
Equivalente a
stream << '\n' << Qt::flush;Nota: En Windows, todos los caracteres «\n » se escriben como «\r\n » si el dispositivo o la cadena de QTextStream se abre utilizando el indicador QIODeviceBase::Text.
Véase también flush(), reset() y QTextStream manipulators.
QTextStream &Qt::fixed(QTextStream &stream)
Llama a ` QTextStream::setRealNumberNotation` (QTextStream::FixedNotation) en ` stream ` y devuelve ` stream`.
Véase también scientific() y QTextStream manipulators.
QTextStream &Qt::flush(QTextStream &stream)
Llama a ` QTextStream::flush()` en ` stream ` y devuelve ` stream`.
Véase también endl(), reset() y QTextStream manipulators.
QTextStream &Qt::forcepoint(QTextStream &stream)
Llama a QTextStream::setNumberFlags(QTextStream::numberFlags() | QTextStream::ForcePoint) en stream y devuelve stream.
Véase también noforcepoint(), forcesign(), showbase() y QTextStream manipulators.
QTextStream &Qt::forcesign(QTextStream &stream)
Llama a QTextStream::setNumberFlags(QTextStream::numberFlags() | QTextStream::ForceSign) en stream y devuelve stream.
Véase también noforcesign(), forcepoint(), showbase() y QTextStream manipulators.
QTextStream &Qt::hex(QTextStream &stream)
Llama a ` QTextStream::setIntegerBase(16)` en ` stream ` y devuelve ` stream`.
Nota: El modificador «hex» solo se puede utilizar para escribir en flujos.
Véase también bin(), oct(), dec() y QTextStream manipulators.
QTextStream &Qt::left(QTextStream &stream)
Llama a ` QTextStream::setFieldAlignment` (QTextStream::AlignLeft) en ` stream ` y devuelve ` stream`.
Véase también right(), center() y QTextStream manipulators.
QTextStream &Qt::lowercasebase(QTextStream &stream)
Llama a QTextStream::setNumberFlags(QTextStream::numberFlags() y ~QTextStream::UppercaseBase) en stream y devuelve stream.
Véase también uppercasebase(), lowercasedigits() y QTextStream manipulators.
QTextStream &Qt::lowercasedigits(QTextStream &stream)
Llama a QTextStream::setNumberFlags(QTextStream::numberFlags() & ~QTextStream::UppercaseDigits) en stream y devuelve stream.
Véase también uppercasedigits(), lowercasebase() y QTextStream manipulators.
QTextStream &Qt::noforcepoint(QTextStream &stream)
Llama a QTextStream::setNumberFlags(QTextStream::numberFlags() y ~QTextStream::ForcePoint) en stream y devuelve stream.
Véase también forcepoint(), noforcesign(), noshowbase() y QTextStream manipulators.
QTextStream &Qt::noforcesign(QTextStream &stream)
Llama a QTextStream::setNumberFlags(QTextStream::numberFlags() y ~QTextStream::ForceSign) en stream y devuelve stream.
Véase también forcesign(), noforcepoint(), noshowbase() y QTextStream manipulators.
QTextStream &Qt::noshowbase(QTextStream &stream)
Llama a QTextStream::setNumberFlags(QTextStream::numberFlags() y ~QTextStream::ShowBase) en stream y devuelve stream.
Véase también showbase(), noforcesign(), noforcepoint() y QTextStream manipulators.
QTextStream &Qt::oct(QTextStream &stream)
Llama a ` QTextStream::setIntegerBase(8)` en ` stream ` y devuelve ` stream`.
Véase también bin(), dec(), hex() y QTextStream manipulators.
QTextStream &Qt::reset(QTextStream &stream)
Llama a ` QTextStream::reset()` en ` stream ` y devuelve ` stream`.
Véase también flush() y QTextStream manipulators.
QTextStream &Qt::right(QTextStream &stream)
Llama a ` QTextStream::setFieldAlignment` (QTextStream::AlignRight) en ` stream ` y devuelve ` stream`.
Véase también left(), center() y QTextStream manipulators.
QTextStream &Qt::scientific(QTextStream &stream)
Llama a ` QTextStream::setRealNumberNotation` (QTextStream::ScientificNotation) en ` stream ` y devuelve ` stream`.
Véase también fixed() y QTextStream manipulators.
QTextStream &Qt::showbase(QTextStream &stream)
Llama a QTextStream::setNumberFlags(QTextStream::numberFlags() | QTextStream::ShowBase) en stream y devuelve stream.
Véase también noshowbase(), forcesign(), forcepoint() y QTextStream manipulators.
QTextStream &Qt::uppercasebase(QTextStream &stream)
Llama a QTextStream::setNumberFlags(QTextStream::numberFlags() | QTextStream::UppercaseBase) en stream y devuelve stream.
Véase también lowercasebase(), uppercasedigits() y QTextStream manipulators.
QTextStream &Qt::uppercasedigits(QTextStream &stream)
Llama a QTextStream::setNumberFlags(QTextStream::numberFlags() | QTextStream::UppercaseDigits) en stream y devuelve stream.
Véase también lowercasedigits(), uppercasebase() y QTextStream manipulators.
QTextStream &Qt::ws(QTextStream &stream)
Llama a ` skipWhiteSpace()` en ` stream ` y devuelve ` stream`.
Véase también QTextStream manipulators.
[constexpr noexcept] QKeyCombination operator|(Qt::Modifier modifier, Qt::Key key)
[constexpr noexcept] QKeyCombination operator|(Qt::KeyboardModifier modifier, Qt::Key key)
[constexpr noexcept] QKeyCombination operator|(Qt::Key key, Qt::Modifier modifier)
[constexpr noexcept] QKeyCombination operator|(Qt::Key key, Qt::KeyboardModifier modifier)
Devuelve un objeto ` QKeyCombination ` que representa la combinación de ` key ` con el modificador ` modifier`.
[constexpr noexcept] QKeyCombination operator|(Qt::Modifiers modifiers, Qt::Key key)
[constexpr noexcept] QKeyCombination operator|(Qt::KeyboardModifiers modifiers, Qt::Key key)
[constexpr noexcept] QKeyCombination operator|(Qt::Key key, Qt::Modifiers modifiers)
[constexpr noexcept] QKeyCombination operator|(Qt::Key key, Qt::KeyboardModifiers modifiers)
Devuelve un objeto ` QKeyCombination ` que representa la combinación de ` key ` con los modificadores ` modifiers`.
© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.
El cursor de flecha estándar.
Una flecha que apunta hacia arriba, hacia la parte superior de la pantalla.
Un cursor en forma de cruz, que suele utilizarse para ayudar al usuario a seleccionar con precisión un punto de la pantalla.
Un cursor en forma de reloj de arena o de reloj, que suele aparecer durante operaciones que impiden al usuario interactuar con la aplicación.
Un cursor en forma de carrete o de barra, que indica que un control puede aceptar y mostrar texto introducido.
Un cursor utilizado para elementos que sirven para cambiar el tamaño vertical de las ventanas de nivel superior.
Un cursor utilizado para elementos que sirven para cambiar el tamaño horizontal de las ventanas de nivel superior.
Un cursor utilizado para elementos que sirven para cambiar el tamaño en diagonal de las ventanas de nivel superior en sus esquinas superior derecha e inferior izquierda.
Un cursor utilizado para elementos que sirven para cambiar el tamaño en diagonal de ventanas de nivel superior por sus esquinas superior izquierda e inferior derecha.
Un cursor utilizado para elementos que sirven para cambiar el tamaño de las ventanas de nivel superior en cualquier dirección.
Un cursor utilizado para divisores verticales, que indica que se puede arrastrar un controlador horizontalmente para ajustar el uso del espacio disponible.
Un cursor utilizado para divisores horizontales, que indica que se puede arrastrar un controlador verticalmente para ajustar el uso del espacio disponible.
Un cursor en forma de mano que suele utilizarse para elementos en los que se puede hacer clic, como los hipervínculos.
Un cursor de círculo tachado, que se utiliza normalmente durante las operaciones de arrastrar y soltar para indicar que el contenido arrastrado no se puede soltar en determinados widgets o dentro de ciertas regiones.
Un cursor que representa una mano abierta, que se utiliza habitualmente para indicar que el área situada debajo del cursor es la parte visible de un lienzo en la que el usuario puede hacer clic y arrastrar para desplazarse.
Un cursor que representa una mano cerrada, que suele utilizarse para indicar que se está realizando una operación de arrastre que implica desplazamiento.
Una flecha con un signo de interrogación, que suele utilizarse para indicar la presencia de la ayuda «¿Qué es esto?» para un widget.
Un cursor en forma de reloj de arena o de reloj, que suele aparecer durante operaciones que permiten al usuario interactuar con la aplicación mientras se realizan en segundo plano.










