7¤0ìl1DVB¨2ã0333333333ä§øhK½S’D”o;…”}L3ãÌ`ß�þOyè·_ˆah€Ùð"ø¶º»â5k&*s  äi8*šŸ€ ‡#2(“H£‘X,Ã@
£(
b ˆÂ(EZ4   DÚ[TÈ                     WithDebInfo"
set_property(TARGET Qt6::Designer APPASE)
get_target_property(_qt_imported_soname Qt6::AKE_CURRENT_LIST_DIR}/Qt6QQuickWidgetPluginDependeEALPATH)

if (NOT QT_NO_CREATE_TARGETS)
    # Findun ####
####### The input file was QtPluginConfig.DALONE_PARTS
    AND NOT QT_BUILD_STANDALONE_TESTSle_inclusion(_targets_not_defined "Designer;DesignPREFIX}/plugins/designer/libqquickwidget.so"
  IMPependency_paths)
unset(__qt_Designer_target_deps)
nd_qt_dependencies("Designer" __qt_Designer_targetset(__qt_Designer_third_party_deps)

# Find Qt tooAME}_FIND_REQUIRED FALSE)

if(NOT Qt6_FOUND)
    ft_cmake_dir}" STREQUAL "")
    set(_qt_cmake_dir "GETS)
            string(APPEND Qt6Designer_NOT_FO(Qt6Designer_FOUND FALSE)
    if(NOT DEFINED Qt6DeISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6DesignerBuildIns
                            Qt6::Designer MODULELL_MODULES_FOUND_VIA_FIND_PACKAGE "Designer")
    ix)

    list(REMOVE_DUPLICATES Qt6Designer_INCLUDer${_priv      endif()
        list(APPEND Qt6Designer${_prndif()

    get_target_property(Qt6Designer_COMPILndif()

    get_target_property(Qt6Designer_DEFININCLUDE_DIRECTORIES)
    if(NOT _Qt6Designer_OWN_INdditionalTargetInfo.cmake"
        OPTIONAL)
    icy_debugging(Designer
        __qt_Designer_pkg ${SAGE "The following import other
# export set exist.
unset(${Che targets which have been exported in some other
files "${CMAKE_CURRENT_LIST_DIR}/Qt6DesignerTargetQt6::CorePrivate;Qt6::GuiPrivate;Qt6::WidgetsPrivaigner/6.8.3>;\$<\$<BOOL:\$<TARGET_PROPERTY:Qt6::Deon "6.8.3"
  _qt_private_module_target_name "DesigPORT_PREFIX}/metatypes/qt6designer_release_metatypNER_LIB"
  INTERFACE_COMPILE_OPTIONS "-fPIC"
  INTt(_IMPORT_PREFIX "/usr/lib/cmake/Qt6Designer")
endVERSION_LESS "3.1.0")
  BSD-3-Clause

include_guard(DIRECTORY)


# DistribTools_FOUND FALSE)
    if(NOT DEFINED Qt6UiTools_N   include("${CMAKE_CURRENT_LIST_DIR}/Qt6UiToolsVe    endif()

    if(NOT "UiTools" IN_LIXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6UiToolsPluginse_suffix)

    list(REMOVE_DUPLICATES Qt6UiTools_IRFACE_COMPILE_DEFINITIONS)
    if(NOT Qt6UiTools_CUiTools_DEFINITIONS
                        Qt6::U(Qt6UiTools_LIBRARIES "Qt6::UiTools")

   effort basis to facilitate porting.
    # Considerependency_debugging(UiTools
        __qt_UiTools_p_import_prefix "${_import_prefix}" REALPATH)

# Exilename_component(_realOrig "/usr/lib/cmake/Qt6UiTion.
set(CMAKE_IMPORT_FILE_VERSION)
# NK_DEPENDENT_LIBRARIES_RELEASE "Qt6::OpenGL"
  IMPLE_VERSION 1)

# Import target "Qt6::UiTools" for _location_default)
unset(_qt_imported_soname)
unse PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES_RELWITthDebInfo"
set_property(TARGET Qt6::UiTools APPENDarget_property(_qt_imported_link_dependencies Qt6:le_inclusion(_targets_not_defined "UiTools;UiTools"6.8.3"
  _qt_public_module_target_name "UiTools"
onfig_module_name "uitools_private"
  _qt_is_privaROPERTIES
  INTERFACE_INCLUDE_DIRECTORIES "\$<\$<Bn "6.8.3"
  _qt_private_module_target_name "UiToolre;Qt6::Gui;Qt6::Widgets;Qt6::OpenGLWidgets"
  INT)
endif()

# Create imported target Qt6::UiTools
ae;Gui;Widgets;UiPlugin;OpenGLWidgets;OpenGL")
set(et(__qt_UiTools_target_deps "Qt6Core\;6.8.3;Qt6Guird_party_deps example: "ICU\\;FALSE\\;1.0\\;i18n ued by the includer of the Dependencies file.
set($t6 is found before anything else.
set(Qt6UiTools_Fcation)
    set_property(TARGET Qt6::lupdate-pro PNFIGURATION})

# Import target "Qt6::lupdate-pro" lWithDebInfo"
set_property(TARGET Qt6::lupdate APPinSizeRel"
set_property(TARGET Qt6::lrelease-pro Aproperty(_qt_imported_location Qt6::lrelease-pro IthDebInfo"
set_property(TARGET Qt6::lrelease APPENthDebInfo"
set_property(TARGET Qt6::lprodump APPEN}")
endif()

# Import target "Qt6::lconvert" for cmation for Qt6LinguistTools
if(NOTlease"
set_property(TARGET Qt6::lupdate-pro APPENDlrelease-pro" )

# Import target "Qt6::lupdate" fo6::lrelease "${_IMPORT_PREFIX}/bin/lrelease" )

# RELEASE "${_IMPORT_PREFIX}/libexec/lprodump"
  )

lconvert" )

# Import target "Qt6::lprodump" for cget import file for configuration "Release".
#----      set_target_properties(Qt::${__qt_tool}
     properties to find one that contains a path.
     D content "  ]
}
")
file(WRITE "${OUT_FILE}" "${cosources_exclusions}
    }")
        if(i LESS lupd    SOURCES ${absolute_subproject${i}_sources}
   json_array("${absolute_include_paths}" json_includ root
foreach(path_var IN LISTS path_variables)
  oject_count GREATER 0)
    foreach(i RANGE 1 ${lupf()
    list_to_json_array("${sources}" result)
  AUTOGEN_DIR)
    set(multi_value_options SOURCES)
  -> .../src/foo.ui
function(filter_files_in_direc files from SOURCES that are in EXCLUDED_DIR.
#   ut_var.
#    filter_nonexistent_files(existing_filion(list_to_json_array srcList jsonList)
    set(qscript mode with the following variables set:
#
# g
                "${no_value_options}" "${single_  message(FATAL_ERROR "qt_add_lrelease() is o     set(${arg_QM_FILES_OUTPUT_VARIABLE} ${${arg_QAULT_MAJOR_VERSION EQUAL 6)
            qt6_colleciles}" "${${_qm_files}}" PARENT_SCOPE)
    endfuncUAL 5)
            qt5_create_translation("${_qm_f     list(APPEND accumulated_out_targets ${out_tar   set(scope_args TARGET_DIRECTORY ${targets})
   _ide
    # doesn't cause an error at generation ti OPTIONS "${arg_LRELEASE_OPTIONS}"
        __QT_INIES}"
        OPTIONS "${arg_LUPDATE_OPTIONS}"
   chedule this command to be called at the end of th  # The project-level CMakeLists.txt might miss a olute.
            # Relative paths are consideredgs} ${multiValueArgs})
            set(path_variab       list(APPEND forwarded_args ${keyword})
     # Predict the names of generated .qm files.
     ations cannot defer function calls with this CMakelations is not supported with "
                "OARIABLE}" ${arg_PLURALS_TS_FILE} ${arg_TS_FILES} P   set(source_lang ${QT_I18N_SOURCE_LANGUAGE})
   Default the source language to "en" in case the us
    # Determine the .ts file paths if necessary. not be specified "
            "together with RESOArgs}" ${ARGN})

    set(targets "${arg_TARGETS}")        LRELEASE_TARGET
        TS_FILE_DIR
      
        IMMEDIATE_CALL
        NO_GENERATE_PLURAL         add_dependencies(${legacy_target} ${lreleurce_files_properties("${qm}" ${scope_args} PROPERal_process_resource, to avoid the Xcode issue of n{CMAKE_COMMAND}" -E make_directory "${qm_dir}"
   _wrapper_script_path(tool_wrapper)
    set(lreleas   set(n 1)
        while(TARGET "${lrelease_targe Support the old command signature that takes one      string(PREPEND qm "${default_out_dir}/")
    ernal_generated_qm_file_path out_var ts_file defaule path to the .qm file that will be generated fro ${ts_file}
            OUTPUT_STRIP_TRAILING_WHITernal_add_phony_target(${QT_GLOBAL_LUPDATE_TARGET}${_Qt6_LINGUIST_TOOLS_DIR}/GenerateLUpdateProject.     $<TARGET_FILE:${QT_CMAKE_EXPORT_NAMESPACE}::ldate_project_cmake}" CONTENT "${content}")

    _q},AUTOGEN_BUILD_DIR>")
        set(default_autogenNSLATION>")
        set(autogen_build_dir_genex "$TY GENERATOR_IS_MULTI_CONFIG)
    if(multi_config)    _qt_internal_ensure_ts_file(TS_FILE "${plurals(LENGTH targets targets_length)

    if(arg_INCLUDet "${lupdate_target_orig}${n}")
            math(  list(POP_FRONT arg_UNPARSED_ARGUMENTS target)
  eValueArgs
        PLURALS_TS_FILE
        LUPDATE   _qt_i18n_translated_language)
    if("${languag"1.0" encoding="utf-8"?>
<!--
Run the update_transt, write an initial .ts file that can be read by lnction(_qt_internal_guess_language_from_ts_file_nahs in the unparsed arguments absolute and stores t)
                list(APPEND result ${target})
  bout
                # QT_EXCLUDE_FROM_TRANSLATION   set(result "")
    get_property(excluded DIRECTbs_FILE} -qm ${qm}
            DEPENDS ${qm_dep} Vget_source_file_property(output_location ${_abs_FItion(qt6_add_translation _qm_files)
    set(option       add_custom_command(OUTPUT ${stamp_file}
   le_srcs "-I${_pro_include}\n${_lst_file_srcs}")
  ectory_contents CONFIGURE_DEPENDS ${_directory_glo  set(_ts_lst_file "${CMAKE_CURRENT_BINARY_DIR}${CXISTS "${stamp_file_dir}")
        file(MAKE_DIREC   get_filename_component(_abs_FILE ${_file} ABSOLUPDATE_UNPARSED_ARGUMENTS})
    set(_lupdate_optioptions)
    set(oneValueArgs)
    set(multiValueArarty_deps "")
_qt_internal_find_third_party_dependlude("${CMAKE_CURRENT_LIST_DIR}/Qt6LinguistToolsCoiles "${CMAKE_CURRENT_LIST_DIR}/Qt6LinguistToolsTa_executable(Qt6::lupdate-pro IMPORTm_spdx_id "SPDXRef-Package-qttools-qt-tool-lupdatePDXRef-Package-qttools-qt-tool-lrelease-pro"
  _qtD)

set_target_properties(Qt6::lrelease-pro PROPERPORTED)

set_target_properties(Qt6::lrelease PROPEPORTED)

set_target_properties(Qt6::lprodump PROPEies(Qt6::lconvert PROPERported target Qt6::lconvert
add_executable(Qt6::lc:lrelease-pro Qt6::lupdate Qt6::lupdate-pro)
  lis_target IN ITEMS Qt6::lconvert Qt6::lprodump Qt6::::lupdate-pro)
endif()
set(Qt6LinguistTools_TARGETrnal_promote_target_to_global(Qt6::lrelease)
endifa_cmake_include Qt6LinguistToolsMacros.cmake)
     DEFINED "Qt6LinguistTools_FOUND")
    set("Qt6Lin...3.21)

include(CMakeFindDependencyMacro)

# Finonent(_realOrig "/usr/lib/cmake/Qt6LinguistTools" rmat(Format f)  { m_format = f; }
    Format formafndef ORDERDIALOG_P_H
#define ORDERDIALOG_P_H

#innternal

QT_END_NAMESPACE

#endif // WIDGETDATABAS                   const QString &baseClassName,
 rs for 'New Form' wizards: Set a fixed size on a X   void remove(int index);


    void grabDefaultPication  includeSpecification(QString includeFile)
    uint m_compat: 1;
    uint m_container: 1;
  BaseItemInterface *item);

    QString baseClassNaltPropertyValues(const QList<QVariant> &list) overtring &group) override;

    QString toolTip() con QDESIGNER_SHARED_EXPORT WidgetDataBaseItem: publitractwidgetdatabase.h>

#include <QtGui/qicon.h>
#tual ~QTextBuilder();

    virtual QVariant loadTee QFormInternal
{
#endif

class DomProperty;
classIGNERPROPERTYEDITOR_H
// Copyright (C) 2020 The Qt has not changed
     * (as opposed to setObject() bool enableSubPropertyHandling);
    void resetPr= {});

    // A pair <ValidationMode, bool isTran
#include <QtDesigner/abstractpropertyeditor.h>

Qiid, mgr);
    mgr->registerExtensions(factory, iiject = checkObject(qObject);
    if (!object)
    actory<ExtensionInterface, Object, Extension>::Extnience for registering the extension. Do not use fon for an object type.
template <class ExtensionIntion;
    int m_currentIndex = 0;
    QLineEdit *mn(bool selectAction);
    void movePrevious(bool cActionDragCheck checkAction(QAction *action) constseEvent *event);
    bool handleMouseReleaseEvent(d deleteMenu();
    void slotRemoveMenuBar();

proid moveRight(bool ctrl = false);
    void moveUp()nerActionProviderExtension;

class QLineEdit;
clas QDESIGNER_MENUBAR_H
#define QDESIGNER_MENUBAR_H


    QT_PREPEND_NAMESPACE(Ui)::PluginDialog ui;
  g &itemName);
    QTreeWidgetItem* setPluginItem(Q/ We mean it.
//

#include "ui_plugindialog.h"

QTDataBaseItemInterface *> promotionBaseClasses() co                  const QString &includeFile,
    IGNERPROMOTION_H
#define QDESIGNERPROMOTION_H

#inSheet *sheet);

    FormWindowBasePrivate *m_d;
};nslations(bool v);

    bool connectSlotsByName() 
        CRLFLineTerminator,
        NativeLineTerySheet *sheet, int index);
    void addReloadablePfindContainer(QWidget *w, bool excludeLayout) consDItemInterface*> &item_list, QWidget *target,
    esignerGrid(const Grid& grid);

    // Overwrite tdVisible() const;

    ResourceFileSaveMode resour   enum HighlightMode  { Restore, Highlight };

  
class QEditorFormBuilder;
class DeviceProfile;
cl  { setFrameShape(orient == Qt::Horizontal ? HLineoid setOrientation(Qt::Orientation orient)
    { simumSizeHint().expandedTo(QSize(16, 16)); }

proteidget(QDesignerFormWindowInterface* formWindow, QWd.
//
// We mean it.
//

#ifndef QDESIGNER_WIDGET_onSelectionList = QList<QPointer<QWidget> >;
    P};
    PromotionState createPromotionActions(QDesi*fw, unsigned flags, QMenu *menu);
    void addActon *>;

    enum AddFlags { LeadingSeparator = 1, ontext menus and handling promotion actions.

clased.
//
// We mean it.
//

#ifndef PROMOTIONTASKMEN no concept of 'stored')
    static bool checkPropverride;

    // Check whether the property is to ertPage;
    QAction *m_actionInsertPageAfter;
   add a menu on a tackedWidget
    static QMenu *addtFilter : public QStackedWidgetPreviewEventFilter
bool v) { m_buttonToolTipEnabled = v; }
    bool bMenu;
}

// Event filter to be installed on a QStaR_STACKEDBOX_H
#define QDESIGNER_STACKEDBOX_H

#in.m_snapY == rhs.m_snapY
            && lhs.m_deltaid setDeltaX(int dx)        { m_deltaX = dx; }

  id setSnapX(bool snap)      { m_snapX = snap; }

 gner grid which is able to serialize to QVariantMaal

QT_END_NAMESPACE

#endif // DEVICEPROFILE_H
//get: Change only inherited font
         * sub proc void systemResolution(int *dpiX, int *dpiY);
     // Default font size of the embedded system
    ), dpi and
 * style of the form. This class represared_global_p.h"

#include <QtCore/qcompare.h>
#in       const DeviceProfile &deviceProfile = Devicee *m_pixmapCache;
    DesignerIconCache *m_iconCact QString &qrcPath);

    void applyProperties(QObt QString &name) override;
    bool addItem(DomWidr::createDom;
    using QFormBuilder::create;

   to be embedded into a main window.
    static QWidnience that pops up message boxes in case of failu   // Create a preview widget (for integrations) o system settings to its toplevel window. */

classR_FORMBUILDER_H
#define QDESIGNER_FORMBUILDER_H

#mand
{
public:
    DeleteConnectionsCommand(Connecpublic CETypes
{
public:
   explicit  CECommand(Corrently editing
    ConnectionList m_con_list;
   nectionAt(const QPoint &pos) const;
    EndPoint eonnection();

    void findObjectsUnderMouse(consturn m_con_list; }
    const ConnectionSet &selectit *e) override;
    void keyPressEvent(QKeyEvent *seEvent *e) override;
    void mousePressEvent(QMor_internal::Connection *con);
    void widgetActivtring &obj_name);

    QUndoStack *undoStack() con<QWidget> &background() const { return m_bg_widgetet_rect;
    bool m_visible;

    void setSource(Qsource_label_pm : m_target_label_pm; }

    Connec

    QPoint endPointPos(EndPoint::Type type) consnection(ConnectionEdit *edit, QObject *source, QObrator == (const EndPoint &other) const { return conection *>;
    using ConnectionSet = QHash<Connecfndef CONNECTIONEDIT_H
#define CONNECTIONEDIT_H

#m *item = layout->itemAt(index)) {
        if (iteidgets; }
    QLayout *createLayout(int type);
   ed off when
      * morphing */
    bool reparentL                        QWidget *layoutBase, Layouernal {
class QDESIGNER_SHARED_EXPORT Layout : pubmean it.
//

#ifndef LAYOUT_H
#define LAYOUT_H

#i_actionPaste;
#endif
    QAction *m_actionSelectAlindow, const ActionList &);
#endif

    void resto menu for item or global menu if item == 0.
    voction *item, int column = -1);
    void editCurrentring &filter);
    void mainContainerChanged();
 on *actionDelete() const;

    QString filter() co
class QDESIGNER_SHARED_EXPORT ActionEditor: publih"
#include <QtDesigner/abstractactioneditor.h>

#SPACE

Q_DECLARE_METATYPE(qdesigner_internal::Sele QString className;
        QString signature;
   
namespace Ui { class SelectSignalDialog; }

namesCTSIGNALDIALOG_H
#define SELECTSIGNALDIALOG_H

#inted:
    void highlightBlock(const QString&) overrstruct CssHighlightColors
{
    QColor selector;
 lateFormAction;
    QAction *m_separator2;
    Q
    QAction *preferredEditAction(QWidget *w, QDes// pops up a dialog in which the user can specify ifndef FORMLAYOUTMENU
#define FORMLAYOUTMENU

//
/ItemPixmap();

    // Pixmap cache (item, profile Item *&selectedItemFound);
    void loadFrom(const
    QPixmap formPreviewPixmap(QIODevice &file, coentTemplate(QString *errorMessage = nullptr) overrNewFormWidget() override;

    bool hasCurrentTempis header file may change from version to
// versiidget* w);
    QDESIGNER_SHARED_EXPORT QString prolots:
    void slotDestroyed(QObject *object);

prc:
    explicit MetaDataBase(QDesi m_fakeSlots;
    QStringList m_fakeSignals;
};

c(bool b) override;

    QString customClassName() #ifndef METADATABASE_H
#define METADATABASE_H

#in  void setGrid(const Grid &g);
    Grid grid() conss Grid;

namespace Ui {
    class GridPanel;
}

cize sizeHint(const QStyleOptionViewItem &opt, consifndef SHEET_DELEGATE_H
#define SHEET_DELEGATE_H

nFactory<QDesignerTaskMenuExtension, QWidget, QDesveStatusBar();
    void containerFakeMethods();
  ction of the object inspector. */
    QObjectList Qt::TextFormat desiredFormat);

    QAction *creatnum PropertyMode { CurrentWidgetMode, MultiSelectiIGNER_TASKMENU_H
#define QDESIGNER_TASKMENU_H

#inonst QString &path);
    void registerPlugin(const

    CustomWidgetList registeredCustomWidgets() cid setPluginPaths(const QStringList &plugin_paths)e *core);
    explicit QDesignerPluginManager(consst;
    // Optional. The name to be used in the wiring &pluginPath = QString());

    enum ParseResuype: validation mode and translatable flag.
    usean it.
//

#ifndef PLUGINMANAGER_H
#define PLUGINal const QDesignerMetaObjectInterface* metaObject(erface *userProperty() const  = 0;
};

// To be ob) const = 0;
    virtual int enumeratorOffset() coInterface)

    QDesignerMetaObjectInterface();
  nerMetaMethodInterface();

    enum MethodType { M
    virtual QVariant read(const QObject *object)  virtual const QDesignerMetaEnumInterface *enumeranerMetaPropertyInterface)

    enum Kind { EnumKining &keys) const = 0;
    virtual QString name() cTRACTMETAOBJECT_H
#define ABSTRACTMETAOBJECT_H

#it (qApp) is active
    QStyle *m_currentStyle;
     void loadPlugins();
    void activeFormWindowChaeturn whether object was created by the factory fo &styleName);

    /* Return a cached style matchiget *createWidget(const QString &className, QWidQ_OBJECT
public:
    explicit WidgetFactory(QDesigfndef WIDGETFACTORY_H
#define WIDGETFACTORY_H

#inNAMESPACE

#endif // ABSTRACTDIALOGGUI_H



// Coping &caption = QString(), const QString &dir = QStptions = {})= 0;
    virtual QString getOpenImageFly)= 0;
    virtual QString getOpenFileName(QWidgeString &text, const QString &informativeText,
          const QString &title, const QString &text, QionMismatchMessage, ResourceLoadFailureMessage,
  STRACTDIALOGGUI_H
#define ABSTRACTDIALOGGUI_H

#innment m_oldAlignment;
    QWidget *m_widget;
};

} bool init(QWidget *w, Qt::Alignment alignment);

t *w, int oldType, int newType);

    BreakLayoutC type of a managed layout on a widget (including
 IGNER_COMMAND2_H
#define QDESIGNER_COMMAND2_H

#in *resourceSet, bool resourceSetChanged); // resourtring, QString> contents() const;
    // Find the rceSets() const;

    QtResourceSet *currentResour &path) const; // only for paths which are on loadtringList &paths, int *errorCount = nullptr, QStrirs on the list it is automatically added to
    //urceSetActivated();
    // otherwise only in case f QTRESOURCEMODEL_H
#define QTRESOURCEMODEL_H

#ining &old_name, const QString &new_name);
proteceBuddies(QDesignerFormWindowInterface *form,
     Gui/qundostack.h>

#include <QtCore/qpointer.h>

Qnumeration by name
template <class QObjectType, clenumerator();
}

// Convert key to value for enume<class EnumType>
inline EnumType enumKeysToValue(cnum &metaEnum,const char *key, const EnumType* = n}
    Qt::CheckState fakeCheckState() const       BarArea; }
    QGradient::Type fakeGradientType() rGroup() const { Q_ASSERT(0); return static_cast<Qnst     { Q_ASSERT(0); return Qt::Horizontal; }
  RTY(QPalette::ColorGroup colorGroup READ fakeColorPERTY(Qt::Orientation orientation READ fakeOrientaopertyToVariant(const DomProperty *property);
QDESe UILIBPROPERTIES_H

#include "uilib_global.h"

#ifaultFont(const QFont &font);

    void setText(corent = nullptr);
    ~PlainTextEditorDialog();

  m_widgetResizeBlocked = false;
    bool m_widgetZo(const QSize &s, bool *ptrToValid = nullptr) constventFilter(QObject *watched, QEvent *event);

publ void setWidgetZoomContextMenuEnabled(bool e);

  temAcceptDrops DESIGNABLE true SCRIPTABLE true)
  led change on to the embedded widget.
 * Provides D_EXPORT ZoomProxyWidget : public QGraphicsProxyWi void showContextMenu(const QPoint &globalPos);

pplementing menus) and qreal zoomFactor
     * in sOPERTY(bool zoomContextMenuEnabled READ isZoomCont  // Return a list of available zoom values.
    sqlist.h>

QT_BEGIN_NAMESPACE

class QGraphicsSceneesignerFormWindowManagerInterWe mean it.
//

#ifndef QDESIGNER_FORMWINDOMANAGERl

QT_END_NAMESPACE

#endif // SHARED_SETTINGS_H
/ Design
    DeviceProfile currentDeviceProfile() cool v);

    // Zoom in percent
    int zoom() cononst QSize &s);

    // Check with isCustomPreviewd &grid);

    QStringList formTemplatePaths() con "shared_enums_p.h"
#include "deviceprofile_p.h"

Object) const;

    private:
        mutable QHashDesignerIntrospectionInterface {
    public:
     .
//

#ifndef DESIGNERINTROSPECTION
#define DESIGNPORT QIcon createIconSet(QStringView name);
QDESIG>

QT_BEGIN_NAMESPACE

class QString;
class QIcon;arElementYear();

    inline int elementMonth() com Child {
        Width = 1,
        Height = 2
  tHeight(int a);
    inline bool hasElementHeight()     HorStretch = 4,
        VerStretch = 8
    };mentHorStretch();

    inline int elementVerStretcElementHSizeType();

    inline int elementVSizeTyeVSizeType(const QString &a) { m_attr_vSizeType = izeType() const { return m_has_attr_hSizeType; }
 ibuteCountry() const { return m_attr_country; }
  ributeLanguage() const { return m_attr_language; }y = 0;
    int m_width = 0;
    int m_height = 0;
ne int elementWidth() const { return m_width; }
  ISABLE_COPY_MOVE(DomRect)
public:
    DomRect() = id clearElementX();

    inline int elementY() con= 32,
        StrikeOut = 64,
        Antialiasingreturn m_fontWeight; }
    void setElementFontWeigelementHintingPreference() const { return m_hintinurn m_styleStrategy; }
    void setElementStyleStrerline; }
    void setElementUnderline(bool a);
  lementWeight();

    inline bool elementItalic() cmentFamily();

    inline int elementPointSize() c
        Inactive = 2,
        Disabled = 4
    };orGroup *elementDisabled() const { return m_disablCOPY_MOVE(DomPalette)
public:
    DomPalette() = dolorRole *> m_colorRole;
    QList<DomColor *> m_c m_attr_role;
    bool m_has_attr_role = falturn m_brush; }
    DomBrush *takeElementBrush();
_MOVE(DomColorRole)
public:
    DomColorRole() = dGradient() const { return m_gradient; }
    DomGraomColor *elementColor() const { return m_color; }
uteBrushStyle() const { return m_has_attr_brushSty_attr_spread = false;

    QString m_attr_coordinattr_startY = false;

    double m_attr_endX = 0.0;QList<DomGradientStop *> elementGradientStop() con; }

    inline bool hasAttributeCoordinateMode() attributeAngle() const { return m_attr_angle; }
  tributeRadius() const { return m_attr_radius; }
  tributeFocalX() const { return m_attr_focalX; }
  arAttributeCentralX() { m_has_attr_centralX = fals attributeEndY() const { return m_attr_endY; }
   ributeEndX() const { return m_has_attr_endX; }
   etAttributeStartX(double a) { m_attr_startX = a; mribute data
    double m_attr_position = 0.0;
    s_attr_position; }
    inline double attributePosi_red = 0;
    int m_green = 0;
    int m_blue = 0;return m_red; }
    void setElementRed(int a);
   ttributeAlpha() const { return m_attr_alpha; }
      // attribute data
    QString m_attr_name;
    DomSpacer)
public:
    DomSpacer() = de
        Widget = 128,
        Action = 256,
     m *> m_item;
    QList<DomLayout *> m_layout;
    etElementAddAction(const QList<DomActionRef *> &a)tion *> elementAction() const { return m_action; }
    inline QList<DomColumn *> elementColumn() conattr_native; }
    inline bool attributeNative() cid clearAttributeClass() { m_has_attr_class = fals:
    DomWidget() = default;
    ~DomWidget();

      void setElementItem(const QList<DomItem *> &a)_column; }
    inline void setAttributeColumn(int T DomItem {
    Q_DISABLE_COPY_MOVE(DomItem)
publi:
    DomColumn() = default;
    ~DomColumn();

  ayout *m_layout = nullptr;
    DomSpacer *m_spacercolumn = false;

    int m_attr_rowSpan = 0;
    b_widget; }
    DomWidget *takeElementWidget();
   AttributeAlignment() { m_has_attr_alignment = falsttr_colSpan; }
    inline int attributeColSpan() cne void clearAttributeRow() { m_has_attr_row = fal *> m_attribute;
    QList<DomLayoutItem *> m_ite m_attr_stretch;
    bool m_has_attr_stretch = faltItem *> elementItem() const { return m_item; }
  imumWidth() { m_has_attr_columnMinimumWidth = falseight() const { return m_attr_rowMinimumHeight; }
ributeColumnStretch() const { return m_attr_columnattr_rowStretch; }
    inline QString attributeRowng &a) { m_attr_class = a; m_has_attr_class = truesAttributeClass() const { return m_has_attr_class;    DomTabStops() = default;
    ~DomTabStops();

uteMargin() const { return m_has_attr_margin; }
  Spacing() const { return m_has_attr_spacing; }
   d setAttributeMargin(int a) { m_attr_margin = a; msetAttributeSpacing(int a) { m_attr_spacing = a; m      Extends = 2,
        Header = 4,
        SizrElementPropertyspecifications();

private:

    / void setElementPixmap(const QString &a);
   ageMethod();

    inline int elementContainer() co m_header; }
    DomHeader *takeElementHeader();
 String elementExtends() const { return m_extends; cation = false; }

private:
    QString m_text;

  accessors
    inline bool hasAttributeLocation() t *> elementCustomWidget() const { return m_customurn m_buttonGroup; }
    void setElementButtonG        Property = 1,
        Attribute = 2
    };mentAttribute(const QList<DomProperty *> &a);

prieturn m_has_attr_name; }
    inline QString attrib    // attribute accesen = 0;
    QList<DomProperty *> m_property;
    Q m_attribute; }
    void setElementAttribute(constm_attr_name; }
    inline void setAttributeName(coomAction {
    Q_DISABLE_COPY_MOVE(DomAction)
publroperty *> elementProperty() const { return m_prop*> &a);

    inline QList<DomActionGroup *> elemenblic:
    DomActionGroup() = default;
    ~DomActid(QXmlStreamReader &reader);
    void write(QXmlSt = 1
    };
};

class QDESIGNER_UILIB_EXPORT DomReine void clearAttributeName() { m_has_attr_name = pldecl;
    bool m_has_attr_impldecl = false;
};

urn m_has_attr_location; }
    inline QString attrXmlStreamWriter &writer, const QString &tagName = es();

    void read(QXmlStreamReader &reader);
  ullptr;

    enum Child {
        Author = 1,
    *m_widget = nullptr;
    DomLayoutDefault *m_layou  // child element data
    uint m_children = 0;
 e:
    // attribute data
    QString m_attr_versiourn m_slots; }
    DomSlots *takeElementSlots();
 sources();

    inline DomConnections *elementConnudes; }
    DomIncludes *takeElementIncludes();
  dgets();

    inline DomTabStops *elementTabStops(mLayoutFunction *a);
    inline bool hasElementLayurn m_children & Widget; }
    void clearElementWinst { return m_class; }
    void setElementClass(c

    // child element accessors
    inline QStrinint attributeStdsetdef() const { return m_attr_stdme = a; m_has_attr_connectslotsbyname = true; }
  _displayname = false; }

    inline bool hasAttribst QString &a) { m_attr_language = a; m_has_attr_linline void clearAttributeVersion() { m_has_attr_vpertyToolTip;
class DomStringPropertySpecification DomSpacer;
class DomColor;
class DomGradientStop;Includes;
class DomInclude;
class DomResources;
clER_UILIB_IMPORT Q_DECL_IMPORT

#if defined(QT_DESIdefine UI4_H

#include <qlist.h>
#include <qstring   Q_DECLARE_PRIVATE(QtResourceEditorDialog)
    QT
public:
    QtResourceModel *model() co QTRESOURCEEDITOR_H

#include <QtCore/qscopedpointnValue icon;
    };
    QHash<QWidget *, PageData>yCurrentTabWhatsThis, PropertyTabWidgetNone };

   to be saved. Returns false for the page
    // prkMenu;
};

// PropertySheet to handle the page proQMenu *popup);

    // Add context menu and returnbWidgetEventFilter();

    // Install helper on QT;
class QTabBar;
class QMenu;
class QAction;

nameace *m_dialogGui;
    SignaturePanel *m_slotPanel;gList &slotList, QStringList &signalList);


priva static void existingMethodsFromMemberSheet(QDesig // Edit fake methods of a promoted class stored i= nullptr, FocusMode m = FocusSlots);
    ~SignalSd slots are stored
//    in the meta database (pertView *m_listView;
    QToolButton *m_removeButtonvoid checkSignature(const QString &signature, bool
// Dialog data
struct SignalSlotDialogData {
    erMemberSheet;
class QListView;
class QToolButton;
QT_END_NAMESPACE

#endif // RITCHTEXTEDITOR_H
// ialog();
    void setDefaultFont(const QFont &fontRichTextEditor;

class QDESIGNER_SHARED_EXPORT RicgetParent, QObject *actionParent = nullptr) = 0;
}irtual FormBuilderClipboard paste(DomUI *ui, QWidg_actions;
};

// Base class for a form builder useQList<DomCustomWidget *> &custom_widget_list);
   s
    // the custom widgets to the widget database*object);
    static QString customWidgetScript(QD    // Query extensions for additional data
    stimpleResource : public QAbstractFormBuilder
{
publm ObjectNamingMode { CamelCase, Underscore };
}

Q, QTabWidget)
        PageContainer,
        // Mdng using literal "\n".
        ValidationMultiLineude "shared_global_p.h"

QT_BEGIN_NAMESPACE

namesString *m_promoteTo;
        QDesignerPromotionIntayedUpdateFromWidgetDatabase();
        // Return election &);
        void slotNewPromotedClass(con    const QString &promotableWidgetClassName = QSt

    // Dialog for editing promoted classes.
    ass(const PromotionParameters &, bool *ok);

    prCase() const    { return m_promotedHeaderLowerCas

class QTreeView;
class QPushButton;
class QItemS//

#ifndef PROMOTIONEDITORDIALOG_H
#define PROMOT::QDesignerPropertySheet;

    bool isEnabled(int oid setDocked(bool b);

    Qt::DockWidgetArea docDockWidgetArea DESIGNABLE true STORED false)
    QnProvider *m_iconProvider = nullptr;
};

}  // namidget *parent = nullptr, const QString &caption =  QString &filter = QString(), QString *selectedFilctedFilter = nullptr, QFileDialog::Options optionsdButton defaultButton = QMessageBox::NoButton) ove      QMessageBox::StandardButtons buttons = QMessrent, Message context, QMessageBox::Icon icon,
   ditorInterface *m_core;
    };
} //dex &index) const;
        ModelData modelData(coublic QStandardItemModel {
        Q_OBJECT

    p promoted widgets.
    class PromotionModel : publpertySheet>;

Q_DECLARE_OPERATORS_FOR_FLAGS(QDesigr)
{
    QDesignerPropertySheetFactory *factory = parent) const
{
    Object *object = qobject_cast<le inheritance. */

template <class Object, class bject *createPropertySheet(QObject *qObject, QObjeignerAbstractPropertySheetFactory: public QExtensiObject(const QObject *o);
    static PropertyType ropertyText
    };

    enum ObjectType { ObjectNotyLayoutFormAlignment,
                PropertyLayoutHorizontalSpacing,
                         PropertyLayoutObjectName,
    orInterface *formEditorForObject(QObject *o);

prot;
    void setIconCache(qdesigner_internal::Desigriant &value) override;

    bool isChanged(int inool reset(int index) override;

    bool isAttribu   class FormWindowBase;
}

classsigner/qextensionmanager.h>

#include <QtCore/qvar We mean it.
//

#ifndef QDESIGNER_PROPERTYSHEET_H   class PropertyLineEdit : public QLineEdit {
    {

    // A line edit with a special context menuQt::Vertical;
    bool m_interactive = true;
    /erride;
    void resizeEvent(QResizeEvent* e) overidget *parent = nullptr);

    QSize sizeHint() co)
    Q_PROPERTY(QSizePolicy::Policy sizeType READEND_NAMESPACE

#endif // HTMLHIGHLIGHTER_H
// Copy:
    QTextCharFormat m_formats[LastConstruct + 1]ter : public QSyntaxHighlighter
{
    Q_OBJECT

pur &other);
};
}

QT_END_NAMESPACE

#endif // PREVI               /*Disabled by default, <0 */
      s:
    void slotZoomChanged(int);

private:

    vPreview(const QDesignerFormWindowInterface *, consring &style, int deviceProfileIndex /*=-1*/, QStrilose button
        ApplicationModalPreview,
      configuration.

class PreviewManagerPrivate;

claData> m_d;
};

QDESIGNER_SHARED_EXPORT bool operatct od QApplication::setSyleSheet()).
    QString ass QAction;
class QActionGroup;
class QMenu;
classndef PREVIEWMANAGER_H
#define PREVIEWMANAGER_H

#ierMenu *menu, QAction *action, QObject *m_objectToet *m_menuParent;
    QWidget *m_associatedWidget;rride {  insertAction(); }
};

class MenuActionCom) override {  removeAction(); }
};

class RemoveAc   using ActionData = QList<ActionDataItem>;

privs (for example, removal of signals and slots
class_action;
};

// Note: This command must be executeidget *listWidget, const ListContents &oldItems, ctrategy {
        SetIconStrategy,
        ResetIccomparesEqual(const TreeWidgetContents &lhs,
     d:1;
        QList<ItemContents> m_children;

     methods to retrieve and apply for ChangeTreeConteQDESIGNER_SHARED_EXPORT ChangeTableContentsCommandlumnAddress, ItemData> m_items;

    friend QDESIGtd::pair<int, int>;

    TableWidgetContents();
  a structure representing the contents of a QTableW ListContents(const QTreeWidgetItem *item);
    QTes.isEmpty(); }

    QHash<int, QVariant> m_propert QListWidgetItem *item, bool editor);
    ItemDaterWidget, ContainerType ct, InsertionMode mode);

d
{

public:
    explicit DeleteContainerWidgetP override;

    QDesignerContainerExtension *contat;
};

class QDESIGNER_SHARED_EXPORT ContainerWidgPointer<QToolBar> m_toolBar;
};

class DockWidgetCainWindow *mainWindow, Qt::ToolBarArea area);

   inWindow;
    QPointer<QStatusBar> m_statusBar;
};enuBar> m_menuBar;
};

class CreateStatusBarCommanate:
    QPointer<QMainWindow> m_mainWindow;
    Qide;

    void init(QStackedWidget *stackedWidget)t m_oldIndex;
};

class DeleteStackedWidgetPageCom_page;
    QString m_label;
    QIcon m_icon;
};

                    int index, int newIndex);

   de;
};

class AddTabPageCommand: public TabWidgetC() override;

    void init(QTabWidget *tabWidget)   InsertBefore,
        InsertAfter
    };
    exass DeleteToolBoxPageCommand: public ToolBoxCommanremovePage();
    void addPage();

    QPointer<QTommand
{
public:
    explicit SimplifyLayoutComman// Reparent/Hide instances of QLayoutWidget.
     onState m_cursorSelectionState;
    bool m_setup;
etList &widgets, LayoutInfo::Type layoutType,
    ctionState)
public:
    CursorSelectionState();

 mand
{
public:
    using WidgetList = PromoteToCusSelection();
    WidgetPointerList m_widgets;
    ewTabOrder() const
    { return m_newTabOrder; }

t;
    QRect m_oldInfo;
    QRect m_newInfo;
};

cation(Operation op);

    QPointer<QWidget> m_widgHARED_EXPORT ChangeFormLayoutItemRoleCommand : pub int m_zOrderIndex;
    ManageWidgetCommandHelper ;
    ~DeleteWidgetCommand() override;

    enum Dn;
};

class QDESIGNER_SHARED_EXPORT DeleteWidgetCd its children for delete operations
class  QDESIGoid reorder(QWidget *widget) const override;
};

cformWindow);

    void init(QWidget *widget);

pro
{

public:
    explicit ChangeZOrderCommand(QDesi-1);

    void redo() override;
    void undo() ov
class QDESIGNER_SHARED_EXPORT InsertWidgetCommandlude <QtCore/qlist.h>
#include <QtCore/qmap.h>
#incommand_p.h"
#include "qdesigner_formwindowcommandDialog() override;

    QString selectedResource()T
public:
    explicit QtResourceViewDialog(QDesigd(bool enable);

    // Helpers for handling the dtring &key);

    bool isResourceEditingEnabled() ata;

class QDESIGNER_SHARED_EXPORT QtResourceView  void accept(QDragMoveEvent *event) const;
privationList &actionList() const { return m_actionList;& selected, const QItemSelection& deselected);
   bstractItemView::SelectionMode selectionMode() con.

class ActionView : public  QStackedWidget {
    void startDrag(Qt::DropActions supportedActions) , QAction *);
    void currentActionChanged(QActiolIndex &);

private:
    ActionModel *m_model;
};
 explicit ActionTreeView(ActionModel *model, QWidgace *m_core = nullptr;
};

// Internal class that *ps);

signals:
    void resourceImageDropped(cons

    QMimeData *mimeData(const QModelIndexList &i QModelIndex addAction(QAction *a);
    // remove QtGui/qicon.h>

QT_BEGIN_NAMESPACE

class QPixmap; it.
//

#ifndef ACTIONREPOSITORY_H
#define ACTIONsetButton = true);
    ~IconThemeEnumEditor() over);

signals:
    void edited(const QString &);

pue user input theme icon names and shows a preview ether a pixmap may be read
    enum CheckMode { CherIconCache *iconCache);
    void setPixmapCache(DResourceDialogPrivate> d_ptr;
    Q_DECLARE_PRIVATalue;
struct IconThemeEditorPrivate;

// Resource en be removed.
//
// We mean it.
//


#ifndef ICONtion() = 0;

public slots:
    virtual void mainCoidgetList managed;
    // Unmanaged widgets
    QWface;

namespace qdesigner_internal {

struct QDESor =(const PreviewConfigurationWidget &other);
};
rivate;
    PreviewConfigurationWidgetPrivate *m_i------ PreviewConfigurationWidget: Widget to edit void applyStyleSheet();

preSheetPropertyEditorDialog(QWidget *parent, QDesigd setOkButtonEnabled(bool v);

private:
    void iid slotContextMenuRequested(const QPoint &pos);
  ss QDESIGNER_SHARED_EXPORT StyleSheetEditorDialog idgets/qdialog.h>
#include <QtWidgets/qlabel.h>
#iteMode = UpdateAsYouType;
        PropertyLineEditonst QString &text);
        void selectAll();
   Mode);

    signals:
        void textChanged(consnst override;
        QSize minimumSizeHint () conertyValidationMode vm);

        UpdateMode update    // Stand-alone widget
            EmbeddingNon      Q_PROPERTY(QString text READ text WRITE setTt.
//

#ifndef TEXTPROPERTYEDITOR_H
#define TEXTPRManager *parent = nullptr);

protected:
    QObjecool signalMatchesSlot(const QString &signal, const   void setMemberGroup(int index, const QString &gR_MEMBERSHEET_H
#define QDESIGNER_MEMBERSHEET_H

#const QString &xml, bool insertFakeTopLevel, QStri          const QString &category = QString()) conox : public QDesignerWidgetBoxInterface
{
    nal {

// A widget box with a load mode that allowg formFileName() const;
    void setMimeType(constrorMessage);

    static bool showCodeDialog(constR_SHARED_EXPORT CodeDialog : public QDialog
{
    / Copyright (C) 2016 The Qt Company Ltd.
// SPDX-LToData;
};

using QToolBoxWidgetPropertySheetFacto                PropertyCurrentItemToolTip,  Prope;
    QAction *m_actionChangePageOrder;
    qdesigPalette::ColorRole role);

    bool eventFilter(QOoid install(QToolBox *toolbox);
    static QToolBoropertysheet_p.h"
#include "qdesigner_utils_p.h"
#   void paintEvent(QPaintEvent *e) override;

priv(int layoutMargin);

    int layoutRightMargin() crface *m_formWindow;
    LayoutHelper* m_helper;

return m_widget; }

    void setInsertMode(InsertMd:
    // figure out insertion position and mode fidLayout *, int row, int column);
    using QDesigQRect &area);
    static void createEmptyCells(QFont index) override;

    QWidgetList widgets(QLayo              { return m_helper; }

    // DecoratecorationExtension
{
    Q_OBJECT
    Q_INTERFACES*widgetWithManagedLayout, const QRect &restrictiondget(QLayout *lt, const QRect &info, QWidget *w) =nction.
class LayoutHelper {
protected:
    LayoutQVariant m_gridRowStretch;

    bool m_gridColumnSolicyChanged;
    QVariant m_fieldGrowthPolicy;
  yout);

    // Retrieve from /apply to sheet: A prowWrapPolicyProperty = 0x400, LabelAlignmentProper= 0x1,
        LeftMarginProperty = 0x2, TopMargindgets/qwidget.h>
#include <QtWidgets/qlayout.h>

Q
};
#ifdef QFORMINTERNAL_NAMESPACE
}
#endif

QT_ENe, QString>;
    QList<RoleNName> itemRoles;
    Q   using RoleNName = std::pair<Qt::ItemDataRole, Qatic constexpr auto titleAttribute = QLatin1StringoupHash m_buttonGroups;

    bool m_layoutWidget =static DomBrush *saveBrush(const QBrush &br);

   tic void clearGridLayoutColumnMinimumWidth(QGridLa   static bool setGridLayoutRowMinimumHeight(constgridLayoutColumnStretch(const QGridLayout *);
    *groups);

    using ButtonGroupEntry = std::pair<t *d);
    QString customWidgetAddPageMethod(const setParentWidget(const QPointer<QWidget> &w);

   d clear();

    DomUI *readUi(QIODevice *dev);
   ndif

class DomBrush;
class DomButtonGroups;
classQtCore/qpointer.h>
#include <QtCore/qstringlist.h>.  It exists purely as an
// implementation detailEdit *m_editor;
    bool m_dragging = false;
    iignerMenu *findActivatedMenu() const;

    QRect s   enum LeaveEditMode {
        Default = 0,
     textMenuEvent(QWidget *widget, QContextMenuEvent *idget, QMouseEvent *event);
    bool handleMousePr    void dragEnterEvent(QDragEnterEvent *event) ovaction);

    static void drawSelection(QPainter *ateSubmenuCommand;
    class ActionInsertionCommane <QtGui/qaction.h>
#include <QtGui/qpixmap.h>

#iction *m_subMenuAction = nullptr;
    QMenu *m_menface *fw, ActionList& al);
    void populate(QWidge MORPH_COMMAND_H

#include "shared_global_p.h"
#i  return false;

    if (widget == fw->mainContain }
    return value.toInt(ok);
}

inline bool isObinline int valueOf(const QVariant &value, bool *okt;
    const bool m_enabled;
};

// QPalette helpeonst QString &fileName, UicLanguage language,
    rFormWindowCommand *createTextPropertyCommand(cons_internal::PropertySheetFlagValue)
Q_DECLARE_METATeData &upRhs = rhs;
        return lhs.m_value == );
    QKeySequence::StandardKey standardKey() conrtySheetKeySequenceValue(const QKeySequence &valuelue == rhs.m_value && upLhs == upRhs;
    }
    Q_value;
};

// -------------- StringValue: Returnedtring(), const QString &comment = QString());

   opertySheetStringValue(const QString &value = QStrropertySheetTranslatableData &rhs) noexcept
    {
QString &disambiguation = QString(),
     etTranslatableData(bool translatable = true,
     plicit DesignerIconCache(DesignerPixmapCache *pixmoexcept;
    Q_DECLARE_EQUALITY_COMPARABLE(Propert    // Convenience accessors to get themed/unthemeempty path resets the pixmap

    uint mask() consoexcept;
    PropertySheetIconValue &operator=(con;
    }
    friend bool comparesEqual(const Properid setPath(const QString &path); // passing the emD_EXPORT PropertySheetPixmapValue
{
public:
    PrnerMetaEnum &me);
    PropertySheetEnumValue();

  QString &separator);
    DesignerMetaFlags() = devalue) const;
    QString messageParseFailed(constame + m_separator;
    target += key;
}

// ------found = it != m_keyToValueMap.end();
    if (ok)
 
}

template <class IntType>
void MetaEnum<IntType&key, SerializationMode sm, QString &target) consttring &scope() const     { return m_scope; }
    cialogButtonBox.StandardButton.Cancel").*/

/* ----re returned by the property sheet
 * as a pair of indowCommand;
class DesignerIconCache;
class FormWre/qvariant.h>
#include <QtCore/qshareddata.h>
#inQDesignerDnDItems &items, QDrag *drag);
    Qt::DrptEvent(QDropEvent *e) const;

    // Helper to aceration.
    static Qt::DropAction execDrag(const Widget *m_widget;
    QWidget *m_decoration;
    Qerride;

    DropType type() const override;

prot/abstractdnditem.h>

#include <QtCore/qpoint.h>
#ialler();
    ~QDesignerWidgetItemInstaller();

prist;
    bool subjectToStretch() const;

    const onst QLayout *layout, QWidget *w, Qt::Orientationsyout *containingLayout() const;

    inline QWidgeem : public QObject, public QWidgetItemV2  {
    Qfrom being slammed to size 0 if the widget has no rWidgetItem: A Layout Item that is used for non-cocore;
};

} // namespace qdesigner_internal

QT_ENitorCommand: public QUndoCommand
{

public:
    QDt API.  It exists for the convenience
// of Qt DesoutItemPosition(const QFormLayout *formLayout, intlaidoutWidgetType(core, widget) != NoLayout; }

  *core, const QWidget *w);
    // Examines the manat
    };

    static void deleteLayout(const QDesi/  -------------
//
// This file is not part of thionTaskMenu;
    QPoint m_startPosition;
};
} // nrivate slots:
    void slotRemoveSelectedAction(); extension
    QList<QAction *> contextMenuActionsstatic bool withinHandleArea(const QToolBar *tb, crnal {

class PromotionTaskMenu;

// Special eventNER_TOOLBAR_H

#include "shared_global_p.h"

#inclt;
    int m_dataOffset;
    quint32 m_overallFlagd(c); }
    void writeByteArray(const QByteArray &ing currentPath = QString(), bool listMode = false    friend class RCCFileInfo;
    void reset();
  turn m_failedResources; }

    int formatVersion() }
    int compressLevel() const { return m_compreparseCompressionAlgorithm(QStringView algo, QStrinose() const { return m_verbose; }

    void setIni   RCCResourceLibrary(quint8 formatVersion);
    ~om version to version without notice, or even be ral OR GPL-3.0-only WITH Qt-GPL-exception-1.0

//
/IGNER_SHARED_EXPORT QDesignerQSettings : public QD

//
//  W A R N I N G
//  -------------
//
// Thiual void adjustIndicator(const QPoint &pos, int invoid insertWidget(QWidget *widget, const QPair<intesignerLayoutDecorationExtension)

    enum InserttCore/qpair.h>

QT_BEGIN_NAMESPACE

class QPoint;
tring &workingDirectory);

private:
    QString m_rtual ~QDesignerExtraInfoExtension() = default;

 st;

    virtual QList<QAction*> taskActions() conlass QDESIGNER_SDK_EXPORT QDesignerTaskMenuExtensie *formWindow);
    void formWindowSettingsChangedual QPixmap createPreviewPixmap() const = 0;

Q_SIWindow() const = 0;

    virtual int formWindowCou    };
    Q_ENUM(ActionGroup)

    virtual QActioion,
        GridLayoutAction,
        FormLayoutA  enum Action
    {
#if QT_CONFIG(clipboard)
     .h>
#include <QtDesigner/abstractformwindow.h>

#itUiPlugin/qdesignerexportwidget.h> instead.
#elif ACTFORMWINDOWCURSOR_H
#include "abstractwidgetfactnst = 0;
    virtual int selectedWidgetCount() contPosition(int pos, MoveMode mode = MoveAnchor) = 0rmWindowCursorInterface)

    enum MoveOperation
 operty(int index) const = 0;
    virtual bool canAing; // FIXME: fool syncqt

class QDesignerDynamicof the Qt API.  It exists for the convenience
// oex) const = 0;
    virtual void setAttribute(int i    virtual int indexOf(const QString &name) constE

class QVariant;

class QDesignerPropertySheetExrtual QWidget* containerOfWidget(QWidget *w) const   explicit QDesignerWidgetFactoryInterface(QObjeclic Q_SLOTS:
    virtual void setFormWindow(QDesigECTINSPECTOR_H
#define ABSTRACTOBJECTINSPECTOR_H

esignerMetaDataBaseInterface: public QObject
{
   setTabOrder(const QList<QWidget*> &tabOrder) = 0;
ude <QtCore/qlist.h>
#include <QtCore/qhash.h>

QT   void createConnections(DomConnections *connectient) override;
    QActionGroup *create(DomActionGparentWidget) override;
    QWidget *create(DomWidf QFORMINTERNAL_NAMESPACE
namespace QFormInternal
Builder *abstractFormBuilder,const QMetaObject *meToolBarArea toolbarAreaFromDOMAttributes(const Dom
    DomColorGroup *saveColorGroup(const QPalette Property *saveText(const QString &attributeName, c void saveTableWidgetExtraInfo(QTableWidget *tablWeTreeWidgetExtraInfo(QTreeWidget *treeWidget, DomWString &propertyName, const QVariant &value);

   *saveConnections();
    virtual DomCustomWidgets **ui_parentLayout, DomWidget *ui_parentWidget);
   *ui_item, QLayoutItem *item, QLayout *layout);
   g &name);
    virtual QLayout *createLayout(const ies(QObject *o, const QList<DomProperty*> &propert  virtual void loadExtraInfo(DomWidget *ui_widget,rceBuilder;
class QTextBuilder;
class QFormBuildermLayout;
class DomLayoutItem;
class DomProperty;
cButtonGroup;
class QActionGroup;
class QComboBox;
rent);

    static QStringList defaultPluginPaths(DesignerActionEditorInterface *createActionEditor(ect *parent);
    static QDesignerWidgetBoxInterfaditorInterface;
class QDesignerObjectInspectorInteerface *core() const;

    bool isContainer(QObjecObject(QObject *object, bool resolveName = true) criant> defaultPropertyValues() const = 0;
};

clasustom) = 0;

    virtual QString pluginPath() constual void setToolTip(const QString &toolTip) = 0;
de <QtCore/qobject.h>
#include <QtCore/qlist.h>

QMESPACE
#endif // QDESIGNER_COMPONENTS_GLOBAL_H
#imEditorPluginInterface, "org.qt-project.Qt.Designeed() const = 0;
    virtual void initialize(QDesigTSETTINGS_P_H
#include "default_extensionfactory.h, const QVariant &defaultValue = QVariant()) constIGNER_SDK_EXPORT QDesignerSettingsInterface
{
publECLARE_INTERFACE(IFace, IId) \
template <> inline tension(QObject *object, const QString &iid) const<QtCore/qstring.h>
#include <QtCore/qobject.h>

QTcore, QWidget *parent = nullptr);

Q_SIGNALS:
    WFORMWIDGET_H
#define ABSTRACTNEWFORMWIDGET_H

#inBSTRACTFORMEDITOR_H

#include "propertysheet.h" //:
    explicit QDesignerResourceBrowserInterface(Q const = 0;
};
Q_DECLARE_EXTENSION_INTERFACE(QDesi  virtual void setVisible(int index, bool b) = 0;
tension)

    QDesignerMemberSheetExtension() = dedget.h>
#endif
#include "abstractformeditor.h" //   void activated(QWidget *widget);

    void chang    virtual void setGrid(const QPoint &grid) = 0;
l void clearSelection(bool changePropertyDisplay =ace *findFormWindow(QWidget *w);
    static QDesigignerFormWindowToolInterface *tool(int index) consoid setResourceSet(QtResourceSet *resourceSet) = 0oid setLayoutFunction(const QString &margin, const   virtual bool hasFeature(Feature f) const = 0;

arent = nullptr, Qt::WindowFlags flags = {});
    ic:
    enum FeatureFlag
    {
        EditFeaturer *extensionManager);

private:
    QScopedPointerances() const;

    static QIcon createIcon(const (QDesignerSettingsInterface *settingsManager);
   tBox);
    void setPropertyEditor(QDesignerProperttrospection() const;
    QDesignerDialogGuiInterfaer() const;

    QWidget *topLevel() const;
    QDlass QtResourceModel;
class QtGradientManager;

clidgetDataBaseInterface;
class QDesignerMetaDataBas*widget, QWidget *managedWidget, QEvent *event) = ;
class QWidget;
class QAction;
class DomUI;

clasnsionFactory *>;
    QHash<QString, FactoryList> m

    void registerExtensions(QAbstractExtensionFa_H

#include <QtDesigner/extension_global.h>
#inclsetPromotedClassIncludeFile(const QString &classNa                      QString *errorMessage) = 0;

class QDesignerWidgetDataBaseItemInterface;

clasifndef ABSTRACTPROMOTIONINTERFACE_H
#define ABSTRAcated. Please include <QtUiPlugin/customwidget.h> TED_HEADER_QtUiPlugin_QDesignerCustomWidgetInterfa void unmanageAction(QAction *action) = 0;

public<QtDesigner/sdk_global.h>

#include <QtWidgets/qwi  QDesignerOptionsPageInterface() = default;
    vTERN
#else
#  define QDESIGNER_UILIB_EXPORT QDESIGRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-onlytual QString uiExtension() const = 0;
};

Q_DECLARirtual bool isLanguageResource(const QString &pathow, QWidget *parentWidget) = 0;
    virtual QDesign be removed.
//
// We mean it.
//

#ifndef QDESIGesigner.  This header
// file may change from versclude "formbuilder.h"
#include "layoutdecoration.h_H
#define QT_QTDESIGNER_MODULE_H
#include <QtDesi);

protected:
    virtual QObject *createExtensioextensionManager() const;

private Q_SLOTS:
    voclude "abstractsettings.h" // IWYU pragma: export
Widgets(const QList<QDesignerDnDItemInterface*> &i0;

    virtual int widgetCount(int cat_idx) consttegoryList = QList<Category>;

    explicit QDesig_name; }
        void setName(const QString &aname   QSharedDataPointer<QDesignerWidgetBoxWidgetData public QWidget
{
    Q_OBJECT
public:
    class Q// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-Private> d;
};

QT_END_NAMESPACE

#endif // ABSTRAteSelection() override;
    void updateCustomWidgewserInterface *createResourceBrowser(QWidget *pare(Feature f) override;

    ResourceFileWatcherBeha

    QString headerSuffix() const override;
    vl void removeDynamicProperty(const QString &name) QStringList &parameterNames);
    void navigateToSVariant &value);
    void objectNameChanged(QDesigndowInterface *formWindow, QObject *object,
      tual ~QDesignerIntegrationInterface();

    QDesigrInterface *core, QObject *parent = nullptr);
    t;
class QWidget;

namespace qdesigner_internal {
_BEGIN_NAMESPACE

class QDesignerFormWindowInterfartual void setCurrentIndex(int index) = 0;

    vixtension
{
public:
    Q_DISABLE_COPY_MOVE(QDesignidget *widget() const = 0;
    virtual QWidget *de;

class QDESIGNER_SDK_EXPORT QDesignerDnDItemIntetPropertyValue(const QString &name, const QVariantclass QDesignerFormEditorInterface;
class QString;only WITH Qt-GPL-exception-1.0

#ifndef ABSTRACTPRclude <QtCore/qglobal.h>

QT_BEGIN_NAMESPACE

#defifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WICATCH_TYPE_GEN\
        template<typename... TypesEMPLATE_LIST_TEST_CASE_2(TestName, TestFunc, Name,, Name, Tags, Signature, __VA_ARGS__)
#else
    #d, ...)\
        INTERNAL_CATCH_EXPAND_VARGS( INTER CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
    #dName, decltype(get_wrapper<INTERNAAndTags{ Name " - " + std::string(tmpl_types[index             (void)expander{(Catch::AutoReg( Catch
                    using expander = int[];      CH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS       MPLATE_PRODUCT_TEST_CASE2(TestName, TestFuncName, efine INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, AL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
   (TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))Name(){\
                    int index = 0;       ATCH_MAKE_NAMESPACE(TestName){\
            INTERNFunction ), CATCH_INTERNAL_LINEINFO, Catch::String_SUPPRESSION \
        void TestName::test()
    #ERNAL_CATCH_TEST_CASE_METHOD2( Test /* NOLINT */ \
        CATCH_INTERNAL_STOP_WARNINr )( Catch::makeTestInvoker( &TestName ), CATCH ) \
        static void TestName(); \
        CATgs, Signature, __VA_ARGS__ )
    #else
        #de_S_T_ ) , ClassName, Name, Tags, typename T, __VA_EMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNSignature, __VA_ARGS__ ) )
    #endif

    #ifndef_E_S_T_F_U_N_C_ ), Name, Tags, typename TestType, E_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTE                                \
        }       , Name, Tags, Signature, ... )    \
        namesp_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( TestNGISTRATION( TestName, ... ) \
        static void er {
    void (C::*m_testAsMethod)();
public:
    ame C>
class TestInvokerAsMethod : public ITestInvplate <typename T>
    struct is_callable;

    teeclval<Args>()...))> static test(int);
        temPARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,IN_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTETTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__))
#def
#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestNaTCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ._NTTP_1, INTERNAL_CATCH_NTTP_0)( __VA_ARGS__))
#deH_NTTP_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNPARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,I INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) IN__VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INT_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTT_METHOD0)(TestName, ClassName, __VA_ARGS__)
#defiL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTER...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INT> { \
        void test();\
    }

#ECLARE_SIG_TEST_METHOD0(TestName, ClassName)
#defiTERNAL_LINEINFO, className, nameAndTags);\
    }

   }

#define INTERNAL_CATCH_NTTP_REGISTER_METHOD0
    void reg_test(TypeList<Type>, Catch::NameAndT_CATCH_DEFINE_SIG_TEST1(TestName, signature)\
    e...>::type; };

#define INTERNAL_CATCH_DECLARE_SI_PARENS(signature)>\
    struct rewrap<NttpTemplat_REMOVE_PARENS(signature)> class Container, templa_CATCH_NTTP_1(signature, ...)\
    template<INTERNpe>::type; };\
    \
    template<template <typenaypeList<Container>, List<elems...>> { using type =lass, typename>\
    struct convert;\
    \
    teypename...> class...> struct TemplateTypeList{};\
_6, _7, _8) INTERNAL_CATCH_REMOVE_PARENS(_0), INTEPARENS_8_ARG(_0, _1, _2, _3, _4, _5, _6, _7) INTER), INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_1, _2, _3, _CATCH_MAKE_TYPE_LISTS_FROM_TYPES(...)\
    CATCH_PAND1(INTERNAL_CATCH_DEF __VA_ARGS__)

#ifndef CATINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param))
#else
ERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) INTERNb, c) evaluates to f(x, a), f(x, b), f(x, c)
#defif(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, (peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )()
#define CATCH_DEFER(id) id CATCH_EMPTY()

#defiESSOR
#define INTERNAL_CATCH_EXPAND_VARGS(...) __V_LEVEL0(CATCH_RECURSION_LEVEL0(__VA_ARGS__)))
#defurn StringRef( rawChars, size );
    }
} // namespst_iterator begin() const { return m_start; }
    == 0;
        }
        constexpr auto size() consreturn m_start[index];
        }

    public: // n      explicit operator std::string() const {
    
    private:
        static constexpr char const*nst& testCase, IConfig const& config );
    bool m{
        virtual void invoke () const = 0;
      / end namespace Catch

#define CATCH_REGISTER_TAG_ operator+() const;
    };
    template<typename Tstream& os, SourceLineInfo const& info );

    // ult;

        bool empty() const noexcept { return       virtual ~NonCopyable();
    };

    struct  name, __LINE__ )
#endif

#include <iosfwd>
#incluFIG_COUNTER
#  define INTERNAL_CATCH_UNIQUE_NAME( se))
#define CATCH_CATCH_ANON(type) if ((false))
#UNUSED_TEMPLATE_WARNINGS
#elif defined(__clang__) CH_INTERNAL_SUPPRESS_UNUSED_WARNINGS
#endif
#if !dCONFIG_GLOBAL_NEXTAFTER
#endif

// Even if we do nfined(CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE) && !IG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NEW_CA#  define CATCH_CONFIG_CPP17_VARIANT
#endif

#if dd(CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING) && !deCONFIG_WINDOWS_SEH
#endif
// This is set by defaul8)
  #  endif // __has_include(<variant>) && definshow_bug.cgi?id=31852
         // fix should be inR_GREATER)
  #    include <cstddef>
  #    if defiCONFIG_CPP17_STRING_VIEW
  #endif

  // Check if orsion of Windows that is real time.
// This means cause __COUNTER__ is not properly
// handled by itCATCH_INTERNAL_CONFIG_POLYFILL_ISNAN
#endif

/////R

#if defined(_REENTRANT) || defined(_MSC_VER)
//_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
#    endif / workaround for __VA_ARGS__
// _MSVC_TRADITIONAL =& defined(_GLIBCXX_USE_C99) \
           && !defin///////
// Cygwin
#ifdef __CYGWIN__

// Required ft std::to_string
#if defined(__ANDROID__)
#    def)
    #define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNAnused-template\"" )

#endif // __clang__

////////TERNAL_SUPPRESS_GLOBALS_WARNINGS \
         _Pragmrary,
// without a matching initialization. In praCATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma(    define CATCH_CPP17_OR_GREATER
#  endif

#endifE_EXCEPTIONS : Are exceptions enabled?
// ********t catch_compiler_capabilities.h

// Detect a numbeS
#endif

// end catch_platform.h

#ifdef CATCH_IME_CHRONO_STRINGMAKER
#  endif
#endif

#if !definedPCHs
#if defined(CATCH_CONFIG_ALL_PARTS)
#  defineadded"
#       pragma clang diagnostic ignored "-WINCLUDED
// start catch.hpp


#define CATCH_VERSIOLICENSE_1_0.txt)
 */
#ifndef TWOBLUECUBES_SINGLE_I Qt Designer module
Version: 6.8.3
Libs: -L${libdigin
Description: Qt UiPlugin module
Version: 6.8.3ts Qt6OpenGLWidgets
prefix=/usr
exec_prefix=${prefefix}/lib
includedir=${prefix}/include

Name: Qt6 g_files "${CMAKE_CURRENT_LIST_DIR}/Qt6ToolsToolsTa IMPORTED)

set_target_properties(Qt6::qdoc PROPERES "${_IMPORT_PREFIX}/include"
  INTERFACE_QT_MAJODXRef-Package-qttools-qt-tool-qhelpgenerator"
  _qd target Qt6::qhelpgenerator
add_executable(Qt6::qIMPORT_PREFIX "/usr/lib/cmake/Qt6ToolsTools")
endierator Qt6::qtattributionsscanner Qt6::qdoc)
  lis8.3")
   message(FATAL_ERROR "CMake >= 2.8.3 requiget_to_global(Qt6::qhelpgenerator)
endif()

if(NOTude("${CMAKE_CURRENT_LIST_DIR}/Qt6ToolsToolsVersiolsToolsDependencies.cmake")
endif()

# If *Depende##
####### The input file was QtModuleToolsConfig.s_for_Qt6::qdoc "${_IMPORT_PREFIX}/bin/qdoc" )

# t_target_properties(Qt6::qtattributionsscanner PRO "${_IMPORT_PREFIX}/libexec/qhelpgenerator" )

# Id_tool_dependencies("ToolsTools" __qt_ToolsTools_tcies, which are other ModuleTools packages.
set(QtE_WARNING=TRUE")
    endif()

    # Mark version ated_objects_default)
unset(_qt_imported_clr)
unsetefault)
unset(_qt_imported_link_dependencies)
unseCONFIGURATION})

# Import target "Qt6::qdoc" for cet_property(_qt_imported_location Qt6::qdoc IMPORT_property(TARGET Qt6::qtattributionsscanner APPENDed_location_default Qt6::qtattributionsscanner IMP
    set_property(TARGET Qt6::qhelpgenerator PROPEty(_qt_imported_location Qt6::qhelpgenerator IMPOR                       Qt6::${__qt_tool} ${__qt_imh(__qt_tool qhelpgenerator;qtattributionsscanner;qle()
# to create a version-file which can be insta procedure did not complete successfully.
* The inROR "The imported target \"${_cmake_target}\" refe_file IN LISTS _cmake_config_files)
  include("${_"
  _qt_is_public_module "TRUE"
  _qt_module_has_hget Qt6::Linguist
add_library(Qt6::Linguist INTERF(_IMPORT_PREFIX "/usr/lib/cmake/Qt6Linguist")
endimake_expected_target IN ITEMS Qt6::Linguist)
  lise. This is how we disable the version check.
    sRSION STREQUAL PACKAGE_VERSION)
        set(QT_NO_lude("${CMAKE_CURRENT_LIST_DIR}/Qt6LinguistConfigVle_inclusion(_targets_not_defined "Linguist")

_qtdencies("Linguist" __qt_Linguist_target_deps
     et(__qt_Linguist_tool_deps "Qt6LinguistTools\;6.8.ckages}
    )
endif()


# note: _third_party_deps ult_path_for_qt_packages "")
endif()

# Don't propf()


# if the installed or the using project don'AGE_FIND_VERSION STREQUAL PACKAGE_VERSION)
      s_DIR}/Qt6LinguistTargets(Qt6Linguist_FOUND FALSE)
    if(NOT DEFINED Qt6Lilude("${CMAKE_CURRENT_LIST_DIR}/Qt6LinguistVersionnguist MODULELL_MODULES_FOUND_VIA_FIND_PACKAGE "Linguist")
    ONS)
    list(REMOVE_DUPLICATES Qt6Linguist_COMPILsuffix)
            list(APPEND Qt6Linguist_PRIVAT    endif()
        list(APPEND Qt6Linguist${_privinguist_INCLUDE_DIRS
        ${_Qt6Linguist_OWN_INndif()

    get_target_property(Qt6Linguist_DEFINI")
    endif()

    if(TARGET Qt6::LinguistPrivateATE Qt6Linguist) instead.
    set(Qt6Linguist_LIBRcy_debugging(Linguist
        __qt_Linguist_pkg ${ISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6LinguistDependear} "${_file}")
  if(NOT EXISTS "${_file}")
    meonent(_realOrig "/usr/lib/cmake/Qt6Linguist" REALPQT_LIB_CLANG_VERSION}/include\"" CACHE STRING "" Fng::WrapLibClang
            INTERFACE libclang
  enex "$<IF:${__qt_clang_genex_condition},clang-cppibClang IMPORTED INTERFACE)

        target_includ set(__wrap_lib_clang_non_release_configs ${configion_found FALSE)

# Need to explicitly handle the ackage_global_promotion(zstd::libzstd_shared)
enditarget for libzstd.
# Disable its global promotionibClang::WrapLibClang)
    set(WrapLibClang_FOUND eps "")
set(__qt_Tools_find_dependency_paths "${CMkage.
set(__qt_Tools_tool_deps "Qt6ToolsTools\;6.8
    find_dependency(Qt6 6.8.3
        PATHS
     (Qt6Tools_FOUND FALSE)

if("${_qt_cmake_dir}" STREND_MESSAGE
            "Target \"Qt6::Tools\" was  EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6ToolsBuildInget_type STREQUAL "INTERFACE_LIBRARY")
    T_ALL_MODULES_FOUND_VIA_FIND_PACKAGE "Tools")
    uffix)

    list(REMOVE_DUPLICATES Qt6Tools_INCLUDdep}_INCLUDE_DIRS})
        list(APPEND Qt6Tools${t6Tools_PRIVATE_INCLUDE_DIRS
        ${_Qt6Tools_O  endif()

    get_target_property(Qt6Tools_COMPIL  endif()

    get_target_property(Qt6Tools_DEFINIPRIVATE Qt6Tools) instead.
    set(Qt6Tools_LIBRARNOT QT_NO_CREATE_TARGETS AND Qt6Tools_FOUND)
    ipendency_debugging(Tools
        __qt_Tools_pkg ${#########################################

cmake_momponent(_realOrig "/usr/lib/cmake/Qt6Tools" REALP the version.
set(CMAKE_IMPORT_FILE_VERSION)
cmake same project but in a separate export set.

# Comke_import_check_xcframework_for_${_cmake_target}}"d files and verify that they actually exist
foreacerface_name "Tools"
  _qt_package_name "Qt6Tools"
vate_headers "TRUE"
  _qt_module_has_public_header}/include/QtTools;${_IMPORT_PREFIX}/include;\$<\$<ed target Qt6::Tools
add_library(Qt6::Tools INTERFet defined: ${_cmake_targets_not_defined_text}\n")(_cmake_expected_target IN ITEMS Qt6::Tools)
  lis----

# Commands may need to know the format versiO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE")
endiFIND_NAME} was requested but "
        "an incompa "Version range ${PACKAGE_FIND_VERSION_RANGE}")
  g needlessly if we know that we're doing an exact {CMAKE_CURRENT_LIST_DIR}/Qt6ToolsConfigV CMAKE_SIZEOF_VOID_P set, ignore it:
if("${CMAKE_S range
  if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQN_EXACT if the current version string and
# the retiple_inclusion(_targets_not_defined "Tools")

_qtN "${PACKAGE_VERSION} (${installedBits}bit)")
  seREQUAL "")
  return()
endif()

# check that the ine_file().

set(PACKAGE_VERSION "6.8.3")

if (PACKA)

unset(__qt_disable_package_version_check)
unsetND_VERSION}")
   compatible)
    if(PACKAGE_FIND_VERSION_RANGE)
        AND NOT ${CCMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT
      ndencies_default)
unset(_qt_imported_objects)
unserComponentsPrivate PROPERTY IMPORTED_SONAME "${_qt PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES_MINSIZmport target "Qt6::DesignerComponentsPrivate" for perty(TARGET Qt6::DesignerComponentsPrivate APPENDD_SONAME_${QT_DEFAULT_IMPORT_CONFIGURATION})
get_tported_location Qt6::DesignerComponentsPrivate IMPtargets are referenced, but are missing: ${${CMAKEvate" )
  if(NOT TARGET "${_target}" )
    set(${Ce_target}")
endforeach()
unset(_cmake_target)
unseferences the file
   \"${_cmake_file}\"
but this fle}")
endforeach()
unset(_cmake_config_file)
unsetas_private_headers "TRUE"
  _qt_module_include_namPERTY:QT_CONSUMES_METATYPES>>:${_IMPORT_PREFIX}/me_PREFIX}/include/QtDesignerComponents/6.8.3/QtDesibrary(Qt6::DesignerComponentsPrivate SHARED IMPORTute the installation prefix relative to this file.ady imported targets are added once more.
set(_ccmake_policy(PUSH)
cmake_policy(VERSION 3.1.0...4.ts.so.6.8.3"
  IMPORTED_SONAME_RELEASE "libQt6Desi(Qt6::DesignerComponentsPrivate PROPERTIES
  IMPORsPrivate_MODULE_DEPENDENCIES "Core;Designer;Gui;Wips example: "Qt6Core\;5.12.0;Qt6Gui\;5.12.0"
set(_     ${_qt_additional_packages_prefix_paths}
     t propagate REQUIRED so we don't immediately FATALse

# Make sure Qt6 is found before anything else.   "Target \"Qt6::DesignerComponentsPrivate\" was OT QT_NO_CREATE_VERSIONLESS_TARGETS)
        if(CMqt_module_plugin_types)
            foreach(_qt_moif()

    if(NOT "DesignerComponentsPrivate" IN_LIntsPrivate)
    qt_make_features_available(Qt6::DeDEFINITIONS
             ${Qt6${_module_dep}_COMPI6DesignerComponentsPrivate${_private_suffix}_PRIVAerComponentsPrivate_INCLUDE_DIRS
        ${_Qt6Des(NOT Qt6DesOWN_PRIVATE_INCLUDE_DIRS)
            set(_Qt6DesiesignerComponentsPrivate) instead.
    set(Qt6DesiR}/Qt6DesignerComponentsPrivateExtraProperties.cmaebugging(DesignerComponentsPrivate
        __qt_De...3.21)

include(CMakeFindDependencyMacro)

get_fPONENTS})
    if(NOT ${_NAME}_${comp}_FOUND)
     ilename_component(_realOrig "/usr/lib/cmake/Qt6Desion(_targets_not_defined "DesignerComponentsPrivat_defined}" Qt6)

unset(_targets_not_defined)
# ProcCatchGeneratorsPrivateTargets.cmake was not "
   ts.cmake")
        endif()
    endif()
else()

     get_target_property(_qt_module_plugin_types
    ERSIONED_FOUND_VIA_FIND_PACKAGE
            "Qt6::e )
        include("${CMAKE_CURRENT_LIST_DIR}/${e(_private_suffix)
          else()
            set(_private_suffix "")
  E_DEFINITIONS
                        Qt6::QNS)
             if(def MATCHES "^[A-Za-z_]")
          if(NOT _Qt6QDocCatchGeneratorsPrivate_OWN_PR INTERFACE_INCLUDE_DIRECTORIES)
    if(NOT _Qt6QDoCATED
    # Provide old style variables for includ  set("Qt6QDocCatchGeneratorsPrivate_FOUND" TRUE)
end

# Find required dependencies, if any.
if(EXISdif()
    endif()
  endforeach()
endmacro()

#####ed through a "/usr move"
# cros

get_filename_component(PACKAGE_PREFIX_DIR "${CMA and contained
   \"${CMAKE_CURRENT_LIST_FILE}\"
bake_target}")
      if(NOT EXISTS "${_cmake_file}"_config_file IN LISTS _cmake_config_files)
  incluENT_LIST_DIR}/Qt6QDocCatchGeneratorsPrivateTargets "qdoccatchgenerators_private"
  _qt_is_header_modIMPORT_PREFIX}/include/QtQDocCatchGenerators/6.8.3 INTERFACE IMPORTED)

set_target_properties(Qt6::Qusr/lib/cmake/Qt6QDocCatchGeneratorsPrivate")
endiT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH)
# Use ()
if(NOT _cmake_targets_defined STREQUAL "")
  stfined "${_cmake_expected_target}")
  endif()
endfodif()
if(CMAKE_VERSION VERSION_LESS "3.0.0")
   meon(_targets_not_defined "QDocCatchGeneratorsPrivatearching:
if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8")AL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PION_COMPATIBLE if the current version is >= requesa basic version file for the Config-mode of find_p)
unset(__qt_package_version_message_prefix)
unset was found: ${PACKAGE_VERSION}. You can pass "
   ed. You can silence this warning by passing "
    g.
    if(__qt_package_version_incompatible AND NO set(__qt_package_version_incompatible TRUE)
else(disable_package_version_check TRUE)
endif()

# ExtNO_CREATE_TARGETS being set to TRUE and thus "
   R}/Qt6QDocCatchConversionsPrivateVersionlessTarget{_qt_module_plugin_type}")
  ionsPrivate MODULE_PLUGIN_TYPES)
        if(_qt_morivatePlugins.cmake")
    endif()

    if(NOT "QDoonsPrivate)

    foreach(extra_cmake_include )
   E_DUPLICATES Qt6QDocCatchConversionsPrivate_INCLUD list(APPEND Qt6QDocCatchConversionsPrivate_PRIVAT_INCLUDE_DIRS})

    foreach(_module_dep ${_Qt6QDoed_defs)
    endif()

    get_target_property(Qt6QIONS "")
    else()
        set(updated_defs "")
 RGET Qt6::QDocCatchConversionsPrivatePrivate)
    includes, compile definitions, etc.
    # These vaDocCatchConversionsPrivate_FOUND")
    set("Qt6QDoME}_NOT_FOUND_MESSAGE)
endif()

# If *ConfigDepend   if(${_NAME}_FIND_REQUIRED_${comp})
    (_realCurr STREQUAL _realOrig)
  set(PACKAGE_PREFIny changes to this file will be overwritten by theormation for Qt6QDocCatchConversionsPrivate
if(NOTate")

_qt_internal_create_versionless_alias_targee version to be used. There is no guarantee the bu   endif()

    message(WARNING
        "${__qt_paTRUE. There is no guarantee "
            "the bui         "Package ${PACKAGE_FIND_NAME} with versioRSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE)
 to get results of regular version checking.
includke_file)
  unset("_cmake_import_check_files_for_${rget}}")
    foreach(_cmake_file IN LISTS "_cmake__${_cmake_target}
      OR NOT IS_DIRECTORY "${_cmonfiguration.
file(GLOB _cmake_config_files "${CMAder_module "TRUE"
  _qt_is_internal_library "TRUE"REFIX}/include/QtQDocCatchConversions/6.8.3>;\$<\$E_DIRECTORIES "${_IMPORT_PREFIX}/include/QtQDocCatCurr)
get_filename_component(_IMPORT_PREFIX "${_IMxt}\n")
endif()
unset(_cmake_targets_defined)
unseined)
  unset(_cmake_expected_targets)
  unset(CMAts "${_cmake_expected_target}")
  if(TARGET "${_cmake_policy(PUSH)
cmake_policy(VERSION 3.0.0...4.2)RSION "${PACKAGE_VERSION} (${installedBits}bit)")
  set(PACKAGE_VERSION_EXACT TRUE)
    endif()
  enPACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" onfig.cmake file.
#
# The created file sets PACKAG_defined}" Qt6)

unset(_targets_not_defined)
# ThiORTED_SONAME_RELEASE "libQt6Help.so.6"
  )

list(Aernal_find_qt_dependencies("Help" __qt_Help_target Qt tool package.
set(__qt_Help_tool_deps "")
_qt_ESSAGE which will be displayed by the includer of e_dir "${QT_TOOLCHAIN_RELOCATABLE_CMAKE_DIR}")
endimported_clr_default)
unset(_qt_imported_configs)
 PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES "${_qtt6::Help APPEND PROPERTY IMPORTED_CONFIGURATIONS Md_soname)
    set_property(TARGET Qt6::Help PROPERQt6::Help IMPORTED_LINK_DEPENDENT_LIBRARIES_${QT_DNED QT_DEFAULT_IMPORT_CONFIGURATION)
    set(QT_DE\"Qt6::Help\" was not found.")

        if(QT_NO_Ct
    if (Qt6BuildInternals_DIR AND
        EXISTS            if(NOT "${_qt_module_plugin_type}"
   le_target_type "Qt6::Help" TYPE)
    if(NOT _qt_moS Qt6Help_COMPILE_DEFINITIONS)
endif()

if (TARGET      list(APPEND Qt6Help${_private_suffix}_COMPIL$")
            set(_private_suffix "Private")
                    list(APPEND updated_defs "${def}"TIONS)
        set(Qt6Help_DEFINITIONS "")
    els best-effort basis to facilitate porting.
    # Co include("${CMAKE_CURRENT_LIST_DIR}/Qt6HelpAdditio")
    _qt_internal_suggest_dependency_debugging(Hponents _NAME)
  foreach(comp ${${_NAME)
  set(${_var} "${_file}")
  if(NOT EXISTS "${_fided from @PACKAGE_INIT@ by configure_package_confiEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "")
  retON_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX)))
    sn range
  if ((PACKAGE_FIND_VERSION_RANGE_MIN STREersion_file() as input file for configure_file()
#other imported targets which have
# been exported ERROR "The imported target \"${_cmake_target}\" reION VERSION_LESS "3.28"
      OR NOT DEFINED _cmak_document_namespace "https://qt.io/spdxdocs/qttoolrget_properties(Qt6::HelpPrivate PROPERTIES
  INTEols-qt-module-Help"
  _qt_sbom_spdx_relative_instametatypes.json>"
  MODULE_PLUGIN_TYPES "help"
  _qREFIX "")
endif()

# Create imported target Qt6::Hefix symbolic link such as /lib -> /usr/lib.
get_f_not_defined}")
  message(FATAL_ERROR "Some (but n_defined_text "${_cmake_targets_defined}")
  strinxpected_target IN ITEMS Qt6::Help Qt6::HelpPrivate-----
# Generated CMake target import file.
#-----RGETS AND NOT QT_SKIP_AUTO_PLUGIN_INCLUSION)
    _Distributions should probably change this default.K=TRUE to disable the version check and force the    unset(PACKAGE_VERSION_UNSUITABLE)

# If QT_REPONOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY)
     rdless if it's a Qt repo build or user project buiage_version_incompatible FALSE)
endif()

if(__qt_docCatchConversionsPrivate QDocCatchGeneratorsPriva
        "Use at your own risk. "
        "You canqt_package_version_message_prefix} of package ${PAe can
# disable the check if they need to.
elseif(epted as "
            "compatible because QT_NO_Pkage_version_check)
    # Don't show the warning n Allow to opt out of the version check.
if(QT_NO_Phe installed version has the same 32/64bit-ness ast(PACKAGE_VERSION_COMPATIBLE FALSE)
  else()
    sEATER PACKAGE_FIND_VERSION_MAX)
        OR (PACKAGe same and it sets
# PACKAGE_VERSION_COMPATIBLE ifLE}\"
but not all the files it references.
")
    to another location.
* An install or uninstall proables.
set(_IMPORT_PREFIX)

# Loop over all importrepo_document_path "sbom/qttools-6.8.3.spdx"
  _qtdepends_include "TRUE"
  _qt_package_name "Qt6QDocOL:\$<TARGET_PROPERTY:Qt6::QDocCatchPrivate,_qt_mod target Qt6::QDocCatchPrivate
add_library(Qt6::QDnstall prefix when loaded through a
# cross-pexport set were already defined.\nTargets Defined:_target)
if(_cmake_targets_defined STREQUAL _cmake"")
set(_cmake_expected_targets "")
foreach(_cmakeke >= 3.0.0 required")
endif()
cmake_policy(PUSH)
when already imported targets are
# added       "Possibly due to QT_NO_CREATE_TARGETS being  DEFINED Qt6QDocCatchPrivate_NOT_FOUND_MESSAGE)
  _LIST_DIR}/Qt6QDocCatchPrivateBuildInternals.cmake_plugin_type IN LISTS _qt_module_plugin_types)
   IR}/${extra_cmake_include}")
    endforeach()

      endforeach()
    unset(_private_suffix)

    li             ${Qt6${_module_dep}_DEFINITIONS})
   APPEND Qt6QDocCatchPrivate${_private_suffix}_INCLUDEFINITIONS)
    if(NOT Qt6QDocCatchPrivate_COMPIL  foreach(def IN LISTS  Qt6QDocCatchPrivate_DEFINI   set(_Qt6QDocCatchPrivate_OWN_INCLUDE_DIRS "")
    set(Qt6QDocCatchPrivate_LIBRARIES "Qt6::QDocCatIR}/Qt6QDocCatchPrivateAdditionalTargetInfo.cmake"hPrivate
        __qt_QDocCatchPrivate_pkg ${CMAKErenced by variable ${_var} does not exist !")
  enealOrig "/usr/lib/cmake/Qt6QDocCatchPrivate" REALP The input file was QtModuleConfig.cmake.in       e_inclusion(_targets_not_defined "QDocCatchPrivate# Additional target information for Qt6UiPlugin
ifersion was found: ${PACKAGE_VERSION}. You can passREPO_MODULE_VERSION is set, that means we are buil version ${PACKAGE_VERSION} was accepted as "
    LE_WARNING TRUE)
    endif()

    # Warn if versioke code begin

# Extra CMake code end

if((NOT PACS "Core;Gui;Widgets")
set(Qt6UiPlugin_FOUND TRUE)
Qt6Gui\;6.8.3;Qt6Widgets\;6.8.3")
set(__qt_UiPlugi  ${QT_BUILD_CMAKE_PREFIX_PATH}
            "${CMAROR, rather let the find_dependency calls
# set _N             "included to define the target.")
   ON VERSION_LESS 3.18 OR QT_USE_OLD_VERSION_LESS_TAND_VIA_FIND_PACKAGE
                    "${_qt_modmodule_target_type STREQUAL "INTERFACE_LIBRARY")
        list(APPEND QT_ALL_MODULES_VERSIONED_FOUND_T Qt6::UiPlugin)
    qt_make_features_available(Qtdule_dep}_PRIVATE_INCLUDE_DIRS})
        if(_privain_MODULE_DEPENDENCIES})
        if(_module_dep MAFINITIONS "${updated_defs}")
        unset(updatedndif()

    get_target_property(Qt6UiPlugin_DEFINIonsider using target_link_libraries(app PRIVATE Qt it in that case.
if(NOT DEFINED "Qt6UiPlugin_FOUN_component(_import_prefix "${_import_prefix}" REAL}_FIND_COMPONENTS})
    if(NOT ${_NAME}_${comp}_FOERROR "File or directory ${_file} referenced by vaAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE)

# Use gets)

# This file does not depend on other import not exist.  Possible reasons include:
* The file fig_files)

# Cleanup temporary variables.
set(_IMttools-6.8.3"
  _qt_sbom_spdx_repo_project_name_loERFACE_LINK_LIBRARIES "Qt6::Core;Qt6::Gui;Qt6::Wid:QT_PLUGIN_CLASS_NAME>>:QDESIGNER_EXPORT_WIDGETS>"onent(_realOrig "/usr/lib/cmake/Qt6UiPlugin" REALPargets)


# Compute the installation prefix relatited_targets)
  unset(_cmake_targets_defined)
  unst}")
    list(APPEND _cmake_targets_defined "${_cm)
endif()
# Generated by CMake

if("${CMAKE_MAJOR_AL "8")
  math(EXPR installedBits "8 * 8")
  set(PSION_COMPATIBLE TRUE)
  endif()
else()
  if(PACKAGsted version.
# The variable CVF_VERSION must be sile()
# to create a version-file which can be instorted from the same project but in a separate expoall procedure did not complete successfully.
* Theported files and verify that they actually exist
fon for each installed configuration.
file(GLOB _cmERFACE_STRING "QT_MAJOR_VERSION"
  INTERFACE_QT_MAEFIX}" PATH)
if(_IMPORT_PREFIX STREQUAL "/")
  sets file.
get_filename_component(_IMPORT_PREFIX "${C_FILE_VERSION)
  cmake_policy(POP)
  return()
endid_targets "${_cmake_expected_target}")
  if(TARGET_IMPORT_FILE_VERSION 1)

# Protect against multiplL_ERROR "CMake >= 3.1.0 required")
endif()
if(CMAK_VERSION 1)

# Import target "Qt6::Designer" for c build will succeed. "
        "Use at your own ri      "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disabrsion as compatible. This is how we disable the veect build.
    # Allow to opt out of warning.
    rsion found is not the exactly same.
    if(${CMAKrsion config file to get results of regular versionse-Identifier: BSD-3-Clause

# Include the basic 6::QQuickWidgetPlugin PROPERTY IMPORTED_LOCATION_MERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO)

if(_argets("${_targets_not_defined}" Qt6)

unset(_targersion_check_due_to_developer_build)
unset(__qt_paE_FIND_NAME} was requested but "
        "an incomQt repo. Show message that one can
# disable the cN_CHECK was set to TRUE. There is no guarantee "
 rning needlessly if we know that we're doing an ex_DIR}/Qt6DesignerConfigVersionImpl.cmake")

set(__ported_objects_default)
unset(_qt_imported_clr)
unET Qt6::Designer PROPERTY IMPORTED_LOCATION "${_qtTED_SONAME_MINSIZEREL "${_qt_imported_soname}")
enname)
    set_property(TARGET Qt6::Designer PROPERted_link_dependencies_default Qt6::Designer IMPORTAULT_IMPORT_CONFIGURATION RELEASE)
endif()
__qt_inequired dependencies, if any.
    if(EXISTS "${CMAON 3.16...3.21)

include(CMakeFindDependencyMacro)f()
endmacro()

macro(check_required_components _N by the next CMake run ####
####### The input fileS)
    # We're building a Qt repository.
    # Ski more.
_qt_internal_check_multiple_inclusion(_targrt_check_targets Qt6::QQuickWidgetPlugin )
list(AP------

# Commands may need to know the format verool_deps)

# note: target_deps example: "Qt6Core\;;i18n uc data;ZLIB\\;FALSE\\;\\;"
set(__qt_DesigneATH")
if(QT_DISABLE_NO_DEFAULT_PATH_IN_QT_PACKAGESf()
set(__qt_use_no_default_path_for_qt_packages "ness as the one which is currently searching:
if(NN_LESS PACKAGE_FIND_VERSION_MIN)
      OR ((PACKAGERSION_EXACT if the current version string and
# tfind_package().
# It is used by write_basic_packagLIST_DIR}/Qt6DesignerVersionlessAliasTargets.cmake   endif()

    # Load Module's BuildInternals sho                  IN_LIST QT_ALL_PLUGIN_TYPES_FOUNT_LIST_DIR}/Qt6DesignerPlugins.cmake")
        incDUPLICATES Qt6Designer_PRIVATE_INCLUDE_DIRS)
    lIONS
             ${Qt6${_module_dep}_DEFINITIONS}_dep MATCHES ".+Private$")
            set(_privatNITIONS)
             if(def MATCHES "^[A-Za-z_]")                       Qt6::DesignerPrivate INTERFriables are deprecated and only provided on a best
endif()

if (NOT QT_NO_CREATE_TARGETS AND Qt6DesigDependencies.cmake exists, the variable value wilimport_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH)
grealCurr)

macro(set_and_check _var _file)
  set($fig_file() #######
####### Any changes to this fil_NAME}_NOT_FOUND_MESSAGE_targets}")
  endif()
endiMESSAGE_targets)
foreach(_target "Qt6::UiPlugin" )e file was deleted, renamed, or moved to another l\" references the file
   \"${_cmake_file}\"
but tame_lowercase "qttools"
)

# Load information for 
  _qt_config_module_name "designer_private"
  _qtesigner,_qt_module_has_private_headers>>:>;\$<\$<Bm_spdx_id "SPDXRef-Package-qttools-qt-module-Desigude_name "QtDesigner"
  _qt_module_interface_name QT_DESIGNER_LIB"
  INTERFACE_COMPILE_OPTIONS "-fPI/Qt6Designer" REALPATH)
if(_realCurr STREQUAL _reats_defined_text}\nTargets not yet defined: ${_cmak (but not all) targets in this export set were alr ITEMS Qt6::Designer Qt6::DesignerPrivate)
  list(lready imported targets are added once more.
set(_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8)
   messdif()


# if the installed or the using project doSION_RANGE)
  # Package version must be in the reqstalled along a config.cmake file.
#
# The createdt_internal_include_plugin_packages(Designer)
endifTools_NOT_FOUND_MESSAGE
            "Target \"Qt6:als should any exist
    if (Qt6BuildInternals_DIRh()
            unset(_qt_module_plugin_type)
    N_LIST QT_ALL_MODULES_FOUND_VIA_FIND_PACKAGE)
    able(Qt6::UiTools)

    foreach(extra_cmake_includAPPEND Qt6UiTools${_private_suffix}_DEFINITIONS
              ${Qt6${_module_dep}_INCLUDE_DIRS})
        ${_Qt6UiTools_OWN_INCLUDE_DIRS})

    set(Qt6          list(APPEND updated_defs "-D${def}")
   roperty(_Qt6UiTools_OWN_PRIVATE_INCLUDE_DIRS
      OPTIONAL)

    # DEPRECATED
    # Provide old stylue will be defined there.
# Don't override it in code begin

# Extra cmake code end

# Find require_PREFIX_DIR "/usr")
endif()
unset(_realOrig)
unsetcross-prefix symbolic link such as /lib -> /usr/liier: BSD-3-Clause


####### Expanded from @PACKAGEy passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WAReif(QT_REPO_MODULE_VERSION AND __qt_pacwill succeed. You can silence this warning by passersion check is disabled regardless if it's a Qt r exact search, and the
    # version found is not isable_package_version_check FALSE)

# Allow to opORT_PREFIX}/lib/libQt6UiTools.so.6.8.3" )

# Comma-------
# Generated CMake target import file for carget_to_global_checked(Qt6::UiToolsPrivate)

unse)
endif()
if(_qt_imported_link_dependencies)
    sTHDEBINFO "${_qt_imported_link_dependencies}")
endARGET Qt6::UiTools PROPERTY IMPORTED_SONAME_RELWIT::UiTools IMPORTED_LINK_DEPENDENT_LIBRARIES_RELEASsPrivate")

_qt_internal_create_versionless_targetERSION_UNSUITABLE TRUE)
endif()
# Protect against ct don't have CMAKE_SIZEOF_VOID_P set, ignore it:
st be set before calling configure_file().

set(PA# This is a basic version file for the Config-mode# Commands beyond this point should not need to kn The installation package was faulty and contained_check_xcframework_for_${_cmake_target}
      OR NIST_DIR}/Qt6UiToolsTargets-*.cmake")
foreach(_cmakheaders>>:${_IMPORT_PREFIX}/include/QtUiTools/6.8.\$<\$<BOOL:\$<TARGET_PROPERTY:Qt6::UiTools,_qt_mode_has_headers "ON"
  _qt_module_has_private_headerTERFACE_COMPILE_DEFINITIONS "QT_UITOOLS_LIB"
  INT_realOrig)
  set(_IMPORT_PREFIX "/usr/lib/cmake/Qt
# Use original install prefix when loaded throughPLACE ";" ", " _cmake_targets_defined_text "${_cmarget IN ITEMS Qt6::UiTools Qt6::UiToolsPrivate)
  multiple inclusion, which would fail when already pendency_paths)

set(_Qt6UiTools_MODULE_DEPENDENCIAKE_CURRENT_LIST_DIR}/.." "${_qt_cmake_dir}")
_qt_"UiTools" __qt_UiTools_third_party_deps)
unset(__q.
set(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED FALported_soname_default)
unset(_qt_imported_link_depult}")
endif()

unset(_qt_imported_location)
unsetHDEBINFO "${_qt_imported_location}")
endif()

# Imfiguration
if(_qt_imported_location_default)
    stion Qt6::lupdate IMPORTED_LOCATION_RELEASE)
get_tTIONS MINSIZEREL)

if(_qt_imported_location)
    sease-pro" for configuration "RelWithDebInfo"
set_pt6::lrelease" for configuration "MinSizeRel"
set_p${_qt_imported_location_default}")
endif()
get_tartion}")
endif()

# Default configuration
if(_qt_imLOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION})

# ImATION_MINSIZEREL "${_qt_imported_location}")
endifget_property(_qt_imported_location_default Qt6::lcd to know the version.
set(CMAKE_IMPORT_FILE_VERSIION_RELEASE "${_IMPORT_PREFIX}/bin/lupdate"
  )

l )

# Import target "Qt6::lrelease-pro" for config_cmake_import_check_files_for_Qt6::lprodump "${_IMD PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_ta configuration "Release"
set_property(TARGET Qt6::           IMPORTED_LOCATION_RELWITHDEBINFO
      __qt_imported_location_config
                IMPO   set(PACKAGE_VERSION_COMPATIBLE TRUE)
    if(PACND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGthe requested version string are exactly the same tent "    {
      \"projectFile\": \"${lupdate_sub${json_sources},
  \"translations\": ${json_transl   list(APPEND absolute_${path_var} "${path}")
     list(REMOVE_DUPLICATES lupdate_${path_var})
    each()
endif()

# Remove duplicates in include patES})
    filter_unsuitable_lupdate_input(sources $path}" OR (relative_path MATCHES "^\\.\\."))
     s}" "${multi_value_options}"
    )

    set(result(qm|json)$")
    set("${out_var}" "${result}" PAREo.txt bar.cpp)
#    -> foo.txt (if foo.txt exists ERSION 3.16)

include("${IN_FILE}")

# Converts a rmat.
#
# This file is to be used in CMake script uments(PARSE_ARGV 0 arg
                "${no_valuons "")
            set(single_value_options
     e)
        if(QT_DEFAULT_MAJOR_VERSION EQUAL 6)
  source_targets() is only available in Qt 6.")
    ction()
    function(qt_add_translation _qm_files)_files}" ${ARGN})
        elseif(QT_DEFAULT_MAJOR_     get_target_property(target_binary_dir ${targe project called cmake_minimum_required(VERSION)
  6_add_lrelease is called from a subdirectory diffeTS_FILE})
    foreach(target IN LISTS targets)
   ts)
    endif()
    qt6_add_lupdate(
        SOURC       cmake_language(EVAL CODE
                "c a call to find_package(Qt6 COMPONENTS Core
      d to be relative to the current source dir.
              )
            set(ignored_variables
         endforeach()
                set("${arg_QM_FILE foreach(ts_file IN LISTS arg_TS_FILES arg_PLURALS   message(WARNING
                "qt6_add_transl an immediate call was not
    # requested.
    sets file paths in a user-specified variable.
    if{source_lang}" IN_LIST QT_I18N_TRANSLATED_LANGUAGETS_FILES "")
        foreach(lang IN LISTS QT_I18N(scope_args DIRECTORY ${PROJECT_SOURCE_DIR})
    eTPUT_VARIABLE AND DEFINED arg_OUTPUT_TARGETS)
    if()
    if(DEFINED arg_RESOURCE_PREFIX AND DEFINE_FILES
        TS_FILE_BASE
        PLURALS_TS_FILLE}" "${qm_files}" PARENT_SCOPE)
    endif()
endfu      set(QT_GLOBAL_LRELEASE_TARGET release_translERSION_GREATER_EQUAL "3.18")
            set(scope the build of the custom command
        # into an       if(NOT EXISTS "${ts_file}")
            _qtif(NOT "${arg___QT_INTERNAL_DEFAULT_QM_OUT_DIR}" S
            set(legacy_signature_used TRUE)
    arse_arguments(arg "${options}" "${oneValueArgs}"        QM_FILES_OUTPUT_VARIABLE)
    set(multiValuile} OUTPUT_LOCATION)
    if(output_location)
         set_property(TARGET "${target}" APPEND PROPERges_from_ts_files_in_targets targets ts_files)
       if(NOT DEFINED QT_GLOBAL_LUPDATE_TARGET)
     .cmake"
        ${prepare_native_ts_command}
     ${raw_plurals_ts_file}"
        )

        # FilteOMMAND
            "${tool_wrapper}"
            $ate_subproject${n}_include_paths \"${includePaths}ded "$<TARGET_PROPERTY:${target},QT_EXCLUDE_SOURCEoject_file \"${CMAKE_CURRENT_LIST_FILE}\")
set(lups_ts_file}")
    endif()

    set(lupdate_project_       qt_internal_make_paths_absolute(additionalIge(FATAL_ERROR "No SOURCE_TARGETS nor SOURCES were"${arg_SOURCES}" STREQUAL "")
        message(FATA       INCLUDE_DIRECTORIES
        OPTIONS)
    cmGE}" STREQUAL "")
        string(APPEND content " )

    if(EXISTS "${arg_TS_FILE}")
        return(ion()

# If the given TS_FILE does not exist, writ the language cannot be guessed, return the empty 
    _qt_internal_collect_translation_source_targetargets out_var)
    set(no_value_options "")
    ERSION_LESS "3.19" AND target_type STREQUAL "INTER${_qm_files}} PARENT_SCOPE)
endfunction()

functioqm")
        endif()

        if(_LRELEASE___QT_INt_location}/${FILE_NAME}.qm")
        else()
     __QT_INTERNAL_TIMESTAMP_FILES)

    cmake_parse_ar}
            COMMAND ${QT_CMAKE_EXPORT_NAMESPACE}      string(REPLACE "../" "__/" _ts_relative_pathtory_property(_inc_DIRS INCLUDE_DIRECTORIES)
      "${_lst_file_src}/" OUTPUT_VARIABLE _directory_glme ${_ts_file} NAME)
        if(_my_sources)
     
    foreach(_file ${_lupdate_files})
        get_s_list}")
        list(TRANSFORM _extensions_list ")
_qt_internal_find_tool_dependencies("LinguistTo_version_incompatible)
# Copyright (C) 2024 The Qtce the "
        "incompatible version to be used.ge_version_message_prefix "Version range ${PACKAGEBLE_WARNING=TRUE")
    endif()

    # Mark version       AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAQT_NO_PACKAGE_VERSION_CHECK)
    set(__qt_disable_ The Qt Company Ltd.
# SPDX-License-Identifier: BSif()
    endforeach()
  endif()
  unset(_cmake_fil_import_check_targets)
  if(CMAKE_VERSION VERSION_de("${_cmake_config_file}")
endforeach()
unset(_cmOR_VERSION "6"
  _qt_is_internal_target "TRUE"
  _e_installed_repo_document_path "sbom/qttools-6.8.3rties(Qt6::lupdate PROPERTIES
  COMPATIBLE_INTERFAm_spdx_repo_document_namespace "https://qt.io/spdxqttools"
)

# Create imported target Qt6::lrelease_MAJOR_VERSION"
  INTERFACE_INCLUDE_DIRECTORIES "$UE"
  _qt_package_version "6.8.3"
  _qt_sbom_spdx_Qt6::lconvert IMPORTED)

set_target_properties(Qt6ent(_realCurr "${_IMPORT_PREFIX}" REALPATH)
get_fi)
endif()
if(NOT _cmake_targets_defined STREQUAL "xpected_target}")
  else()
    list(APPEND _cmake__cmake_targets_not_defined "")
set(_cmake_expected(PUSH)
cmake_policy(VERSION 2.8.3...4.2)
#--------Tools_FOUND)
    __qt_internal_promote_target_to_g)
    if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS)
   guistToolsDependencies.cmake")
    include("${CMAK
        set(${_NAME}_FOUND FALSE)
      endif()
 ponent(_realCurr "${CMAKE_CURRENT_LIST_DIR}" REALP        ########

get_filename_component(PACKAGE_P