Create dynamic basemap gallery

// [WriteFile Name=CreateDynamicBasemapGallery, Category=Maps]
// [Legal]
// Copyright 2024 Esri.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// [Legal]

// sample headers
#include "BasemapStyleListModel.h"

// ArcGIS Maps SDK headers
#include "BasemapStyleInfo.h"

using namespace Esri::ArcGISRuntime;

BasemapStyleListModel::BasemapStyleListModel(QObject* parent /* = nullptr */)
    : QAbstractListModel(parent){}

QHash<int, QByteArray> BasemapStyleListModel::roleNames() const {
    QHash<int, QByteArray> roles;
    roles[StyleNameRole] = "styleName";
    roles[PreviewImageUrlRole] = "previewImageUrl";
    return roles;
}

QVariant BasemapStyleListModel::data(const QModelIndex& index, int role) const
{
    bool modelIndexIsOutOfBounds = index.row() >= m_previews.size();
    if (!index.isValid() || modelIndexIsOutOfBounds)
    {
        return QVariant();
    }

    switch(role)
    {
    case StyleNameRole:
        return m_previews[index.row()]->styleName();
    case PreviewImageUrlRole:
        return m_previews[index.row()]->thumbnailUrl();
    default:
        return QVariant();
    }
}

int BasemapStyleListModel::rowCount(const QModelIndex& parent) const
{
    Q_UNUSED(parent)
    return m_previews.size();
}

void BasemapStyleListModel::insertItemsIntoGallery(const QList<BasemapStyleInfo*> infos)
{
    beginResetModel();
    m_previews.clear();
    for (auto index = 0; index < infos.size(); ++index)
    {
        m_previews.insert(index, infos.at(index));
        connect(m_previews.at(index), &BasemapStyleInfo::thumbnailUrlChanged, this, [this, index]()
        {
            QModelIndex modelIndex = createIndex(index, 0);
            emit dataChanged(modelIndex, modelIndex);
        });
    }
    endResetModel();
}

// [WriteFile Name=CreateDynamicBasemapGallery, Category=Maps]
// [Legal]
// Copyright 2024 Esri.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// [Legal]

#ifndef BASEMAPSTYLELISTMODEL_H
#define BASEMAPSTYLELISTMODEL_H

// Qt headers
#include <QAbstractListModel>
#include <QObject>
#include <QUrl>

namespace Esri::ArcGISRuntime {
class BasemapStyleInfo;
}

class BasemapStyleListModel : public QAbstractListModel
{
    Q_OBJECT

public:
    enum previewRoles {
        StyleNameRole = Qt::UserRole + 1,
        PreviewImageUrlRole
    };

    BasemapStyleListModel(QObject* parent = nullptr);

    QHash<int, QByteArray> roleNames() const override;
    QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const override;
    int rowCount(const QModelIndex& parent = QModelIndex()) const override;
    void insertItemsIntoGallery(const QList<Esri::ArcGISRuntime::BasemapStyleInfo*> infos);

private:
    QList<const Esri::ArcGISRuntime::BasemapStyleInfo*> m_previews;
};

#endif // BASEMAPSTYLELISTMODEL_H

// [WriteFile Name=CreateDynamicBasemapGallery, Category=Maps]
// [Legal]
// Copyright 2024 Esri.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// [Legal]

#ifdef PCH_BUILD
#include "pch.hpp"
#endif // PCH_BUILD

// sample headers
#include "BasemapStyleListModel.h"
#include "CreateDynamicBasemapGallery.h"

// ArcGIS Maps SDK headers
#include "Basemap.h"
#include "BasemapStyleInfo.h"
#include "BasemapStyleLanguageInfo.h"
#include "BasemapStyleParameters.h"
#include "BasemapStylesService.h"
#include "BasemapStylesServiceInfo.h"
#include "Error.h"
#include "Map.h"
#include "MapQuickView.h"
#include "MapTypes.h"
#include "Viewpoint.h"
#include "Worldview.h"

// Qt headers
#include <QFuture>

using namespace Esri::ArcGISRuntime;

namespace
{
QMap<QString, BasemapStyleLanguageStrategy> languageStrategyNameToEnumMap{
    {"Default", BasemapStyleLanguageStrategy::Default},
    {"Global", BasemapStyleLanguageStrategy::Global},
    {"Local", BasemapStyleLanguageStrategy::Local},
    {"Application Locale", BasemapStyleLanguageStrategy::ApplicationLocale}
};
}

CreateDynamicBasemapGallery::CreateDynamicBasemapGallery(
    QObject* parent /* = nullptr */)
    : QObject(parent),
    m_map(new Map(BasemapStyle::ArcGISNavigation, this)),
    m_gallery(new BasemapStyleListModel(this))
{
    BasemapStylesService* service = new BasemapStylesService(this);

    connect(service, &BasemapStylesService::doneLoading, this, [this, service](const Error& /*error*/){
        if (service->loadStatus() != LoadStatus::Loaded)
        {
            return;
        }

        m_styleInfos = service->info()->stylesInfo();
        createGallery();
        updateSelectedStyle("ArcGIS Navigation");
    });

    service->load();
}

CreateDynamicBasemapGallery::~CreateDynamicBasemapGallery()
{}

void CreateDynamicBasemapGallery::init()
{
    // Register the map view for QML
    qmlRegisterType<MapQuickView>("Esri.Samples", 1, 0, "MapView");
    qmlRegisterType<CreateDynamicBasemapGallery>("Esri.Samples",
                                                 1,
                                                 0,
                                                 "CreateDynamicBasemapGallerySample");
}

// -------------------------------------------------- //
//                         Methods                    //
// -------------------------------------------------- //

void CreateDynamicBasemapGallery::createGallery()
{
    m_gallery->insertItemsIntoGallery(m_styleInfos);
    emit galleryChanged();
}

void CreateDynamicBasemapGallery::updateSelectedStyle(const QString& nameOfSelectedStyle)
{
    const auto iteratorToInfoForSelectedStyle = std::find_if(m_styleInfos.begin(),
                                                             m_styleInfos.end(),
                                                             [nameOfSelectedStyle](const BasemapStyleInfo* info){
                                                                 return info->styleName().compare(nameOfSelectedStyle, Qt::CaseInsensitive) == 0;
                                                             });

    if (iteratorToInfoForSelectedStyle != m_styleInfos.end())
    {
        m_selectedStyle = *iteratorToInfoForSelectedStyle;
        emit selectedStyleChanged();

        updateLanguageStrategiesList();
        updateLanguagesList();
        updateWorldviewsList();
    }
}

void CreateDynamicBasemapGallery::updateLanguageStrategiesList()
{
    m_languageStrategies.clear();
    if (m_selectedStyle->languageStrategies().isEmpty())
    {
        emit languageStrategiesChanged();
        return;
    }

    m_languageStrategies.append("None"); // Add "None" to allow the user to unset this parameter in the UI.
    for(const BasemapStyleLanguageStrategy& strategy : m_selectedStyle->languageStrategies())
    {
        QString displayName = languageStrategyNameToEnumMap.key(strategy);
        if (displayName.isEmpty())
        {
            continue;
        }
        m_languageStrategies.append(displayName);
    }

    emit languageStrategiesChanged();
}

void CreateDynamicBasemapGallery::updateLanguagesList()
{
    m_languages.clear();
    if (m_selectedStyle->languages().isEmpty())
    {
        emit languagesChanged();
        return;
    }

    m_languages.append("None"); // Add "None" to allow the user to unset this parameter in the UI.
    for (const BasemapStyleLanguageInfo* info : m_selectedStyle->languages())
    {
        m_languages.append(info->displayName());
    }

    emit languagesChanged();
}

void CreateDynamicBasemapGallery::updateWorldviewsList()
{
    m_worldviews.clear();
    if (m_selectedStyle->worldviews().isEmpty())
    {
        emit worldviewsChanged();
        return;
    }

    m_worldviews.append("None"); // Add "None" to allow the user to unset this parameter in the UI.
    for(const Worldview* worldview : m_selectedStyle->worldviews())
    {
        m_worldviews.append(worldview->displayName());
    }

    emit worldviewsChanged();
}

void CreateDynamicBasemapGallery::loadBasemap(const QString& selectedStrategy,
                                              const QString& selectedLanguage,
                                              const QString& selectedWorldview)
{
    if (!m_selectedStyle)
    {
        return;
    }

    BasemapStyleParameters* customisationParameters = new BasemapStyleParameters(this);

    if (!selectedStrategy.isEmpty() && selectedStrategy != "None")
    {
        customisationParameters->setLanguageStrategy(languageStrategyNameToEnumMap[selectedStrategy]);
    }

    if (!selectedLanguage.isEmpty() && selectedLanguage != "None")
    {
        const QList<BasemapStyleLanguageInfo*> specificLanguages = m_selectedStyle->languages();

        const auto iteratorToLanguageInfoForSelectedLanguage = std::find_if(specificLanguages.begin(),
                                                                            specificLanguages.end(),
                                                                            [selectedLanguage](const BasemapStyleLanguageInfo* info)
                                                                            {
                                                                                return info->displayName().compare(selectedLanguage, Qt::CaseInsensitive) == 0;
                                                                            });

        if (iteratorToLanguageInfoForSelectedLanguage != specificLanguages.end())
        {
            const BasemapStyleLanguageInfo* languageInfo = *iteratorToLanguageInfoForSelectedLanguage;
            const QString code = languageInfo->languageCode();
            customisationParameters->setSpecificLanguage(code);
        }
    }

    if (!selectedWorldview.isEmpty() && selectedWorldview != "None")
    {
        const QList<Worldview*> worldviews = m_selectedStyle->worldviews();

        const auto iteratorToSelectedWorldview = std::find_if(worldviews.begin(), worldviews.end(), [selectedWorldview](const Worldview* view)
                                                              {
                                                                  return view->displayName().compare(selectedWorldview, Qt::CaseInsensitive) == 0;
                                                              });

        if (iteratorToSelectedWorldview != worldviews.end())
        {
            customisationParameters->setWorldview(*iteratorToSelectedWorldview);
        }
    }

    Basemap* newBasemap = new Basemap(m_selectedStyle->style(), customisationParameters, this);
    const Viewpoint currentVewpoint = m_mapView->currentViewpoint(ViewpointType::CenterAndScale);
    m_mapView->map()->setBasemap(newBasemap);
    m_mapView->setViewpointAsync(currentVewpoint);
}

// -------------------------------------------------- //
//             Property getters and setters           //
// -------------------------------------------------- //

MapQuickView* CreateDynamicBasemapGallery::mapView() const
{
    return m_mapView;
}

// Set the view (created in QML)
void CreateDynamicBasemapGallery::setMapView(MapQuickView* mapView)
{
    if (!mapView || mapView == m_mapView)
    {
        return;
    }

    m_mapView = mapView;
    m_mapView->setMap(m_map);
    m_mapView->setViewpointAsync(Viewpoint{52.3433, -1.5796, 2500000});

    emit mapViewChanged();
}

QAbstractListModel* CreateDynamicBasemapGallery::gallery() const
{
    return m_gallery;
}

const QStringList& CreateDynamicBasemapGallery::languageStrategies() const
{
    return m_languageStrategies;
}

const QStringList& CreateDynamicBasemapGallery::languages() const
{
    return m_languages;
}

const QStringList& CreateDynamicBasemapGallery::worldviews() const
{
    return m_worldviews;
}

int CreateDynamicBasemapGallery::indexOfSelectedStyle() const
{
    return static_cast<int>(m_styleInfos.indexOf(m_selectedStyle));
}

// [WriteFile Name=CreateDynamicBasemapGallery, Category=Maps]
// [Legal]
// Copyright 2024 Esri.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// [Legal]

#ifndef CREATEDYNAMICBASEMAPGALLERY_H
#define CREATEDYNAMICBASEMAPGALLERY_H

// Qt headers
#include <QAbstractListModel>
#include <QMap>
#include <QObject>
#include <QUrl>

Q_MOC_INCLUDE("MapQuickView.h")

class BasemapStyleListModel;
class QAbstractListModel;

namespace Esri::ArcGISRuntime {
enum class BasemapStyleLanguageStrategy;
class BasemapStyleInfo;
class Map;
class MapQuickView;
} // namespace Esri::ArcGISRuntime

class CreateDynamicBasemapGallery : public QObject
{
    Q_OBJECT

    Q_PROPERTY(Esri::ArcGISRuntime::MapQuickView* mapView READ mapView WRITE setMapView NOTIFY
                   mapViewChanged)
    Q_PROPERTY(QAbstractListModel* gallery READ gallery NOTIFY galleryChanged)
    Q_PROPERTY(QStringList languageStrategies READ languageStrategies NOTIFY languageStrategiesChanged)
    Q_PROPERTY(QStringList languages READ languages NOTIFY languagesChanged)
    Q_PROPERTY(QStringList worldviews READ worldviews NOTIFY worldviewsChanged)
    Q_PROPERTY(int indexOfSelectedStyle READ indexOfSelectedStyle NOTIFY selectedStyleChanged)

public:
    explicit CreateDynamicBasemapGallery(QObject* parent = nullptr);
    ~CreateDynamicBasemapGallery() override;

    static void init();

    Esri::ArcGISRuntime::MapQuickView* mapView() const;
    void setMapView(Esri::ArcGISRuntime::MapQuickView* mapView);
    QAbstractListModel* gallery() const;
    const QStringList& languageStrategies() const;
    const QStringList& languages() const;
    const QStringList& worldviews() const;
    int indexOfSelectedStyle() const;

    Q_INVOKABLE void updateSelectedStyle(const QString& styleName);
    Q_INVOKABLE void loadBasemap(const QString& selectedStrategy, const QString& selectedLanguage, const QString& selectedWorldview);

signals:
    void mapViewChanged();
    void selectedStyleChanged();
    void galleryChanged();
    void languageStrategiesChanged();
    void languagesChanged();
    void worldviewsChanged();

private:
    void createGallery();
    void updateLanguageStrategiesList();
    void updateLanguagesList();
    void updateWorldviewsList();

    Esri::ArcGISRuntime::Map* m_map = nullptr;
    Esri::ArcGISRuntime::MapQuickView* m_mapView = nullptr;
    QList<Esri::ArcGISRuntime::BasemapStyleInfo*> m_styleInfos;
    BasemapStyleListModel* m_gallery = nullptr;
    Esri::ArcGISRuntime::BasemapStyleInfo* m_selectedStyle = nullptr;
    QStringList m_languageStrategies;
    QStringList m_languages;
    QStringList m_worldviews;
};

#endif // CREATEDYNAMICBASEMAPGALLERY_H

// [WriteFile Name=CreateDynamicBasemapGallery, Category=Maps]
// [Legal]
// Copyright 2024 Esri.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// [Legal]

import QtQuick
import QtQuick.Controls
import QtQuick.Controls.Material
import QtQuick.Layouts
import Esri.Samples

Item {
    property real flowCellWidth: 200

    // Create MapQuickView here, and create its Map etc. in C++ code
    MapView {
        id: view
        anchors.fill: parent
        // set focus to enable keyboard navigation
        focus: true

        RoundButton {
            x: 10
            y: 10
            icon.name: "grid-24"
            icon.source: "grid-24.svg"
            onClicked: popup.open()
            }

            Popup {
                id: popup
                x: parent.width * 0.1
                y: parent.height * 0.1
                width: parent.width * 0.8
                height: parent.height * 0.8
                modal: true
                focus: true
                closePolicy: Popup.CloseOnEscape | Popup.CloseOnPressOutside

                ColumnLayout {
                    anchors.fill: parent
                    clip: true

                    GridView {
                        id: basemapView
                        Layout.alignment: Qt.AlignHCenter
                        Layout.fillWidth: false
                        Layout.fillHeight: true
                        implicitWidth: {
                            var numCellsInPopup_dbl = popup.width / basemapView.cellWidth;
                            var numCellsInPopup_int = Math.trunc(numCellsInPopup_dbl);
                            return Math.max(1, numCellsInPopup_int) * basemapView.cellWidth;
                        }
                        clip: true
                        model: model.gallery
                        currentIndex: model.indexOfSelectedStyle;
                        cellWidth: 200
                        cellHeight: 160
                        highlight: Rectangle {
                            width: basemapView.cellWidth;
                            height: basemapView.cellHeight
                            color: "lightsteelblue";
                            anchors.fill: basemapView.currentItem
                        }
                        highlightFollowsCurrentItem: false;

                        delegate: ItemDelegate {
                            id: basemapDelegate
                            width: basemapView.cellWidth
                            height: basemapView.cellHeight
                            required property string styleName
                            required property string previewImageUrl
                            onClicked: {
                                model.updateSelectedStyle(styleName);
                            }
                            clip: true
                            Column {
                                spacing: 5
                                padding: 10
                                Text {
                                    font.bold: true
                                    font.pixelSize: 12
                                    text: styleName + ":"
                                }
                                Image {
                                    source: previewImageUrl
                                    fillMode: Image.PreserveAspectFit
                                    width: basemapView.cellWidth - 25
                                }
                            }
                        }
                    }

                    Flow {
                        id: flow
                        Layout.fillWidth: false
                        Layout.alignment: Qt.AlignHCenter
                        Layout.preferredWidth: calculateFlowLayoutWidth();
                        spacing: 10

                        ColumnLayout {
                            Text {
                                Layout.preferredHeight: 15
                                font.underline: true
                                text: "Language Strategy:"
                            }
                            ComboBox {
                                id: languageStrategyOptions
                                Layout.preferredHeight: 30
                                Layout.preferredWidth: flowCellWidth
                                model: model.languageStrategies
                                enabled: model.languageStrategies.length !== 0
                            }
                        }
                        ColumnLayout {
                            Text {
                                Layout.preferredHeight: 15
                                font.underline: true
                                text: "Language:"
                            }
                            ComboBox {
                                id: languages
                                Layout.preferredHeight: 30
                                Layout.preferredWidth: flowCellWidth
                                model: model.languages
                                enabled: model.languages.length !== 0
                            }
                        }
                        ColumnLayout {
                            Text {
                                Layout.preferredHeight: 15
                                font.underline: true
                                text: "Worldview:"
                            }
                            ComboBox {
                                id: worldviews
                                Layout.preferredHeight: 30
                                Layout.preferredWidth: flowCellWidth
                                model: model.worldviews
                                enabled: model.worldviews.length !== 0
                            }
                        }
                        RowLayout {
                            width: flowCellWidth
                            height: 45
                            Button {
                                Layout.alignment: Qt.AlignCenter
                                text: "Load"
                                Layout.preferredHeight: 40
                                Layout.preferredWidth: 80
                                onPressed: {
                                    model.loadBasemap(
                                               languageStrategyOptions.currentText,
                                               languages.currentText,
                                               worldviews.currentText);
                                    popup.close();
                                }
                            }
                        }
                    }
                }
            }
        }

    // Declare the C++ instance which creates the map etc. and supply the view
    CreateDynamicBasemapGallerySample {
        id: model
        mapView: view
    }

    function calculateFlowLayoutWidth() {
        var widthOfMargins = 2 * flow.spacing;
        var numHorizontalInputs_dbl = (popup.width - widthOfMargins) / (flowCellWidth + flow.spacing);
        var numHorizontalInputs_int = Math.trunc(numHorizontalInputs_dbl);
        var widthOfInputElements = Math.max(1, numHorizontalInputs_int) * flowCellWidth;
        var widthOfSpacing = ((Math.max(1, numHorizontalInputs_int) + 2) * flow.spacing);
        return widthOfInputElements + widthOfSpacing;
    }
}

// [Legal]
// Copyright 2024 Esri.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// [Legal]

// sample headers
#include "CreateDynamicBasemapGallery.h"

// ArcGIS Maps SDK headers
#include "ArcGISRuntimeEnvironment.h"

// Qt headers
#include <QCommandLineParser>
#include <QDir>
#include <QGuiApplication>
#include <QQmlApplicationEngine>

// Platform specific headers
#ifdef Q_OS_WIN
#include <Windows.h>
#endif

int main(int argc, char *argv[])
{
    Esri::ArcGISRuntime::ArcGISRuntimeEnvironment::setUseLegacyAuthentication(false);
    QGuiApplication app(argc, argv);
    app.setApplicationName(QString("CreateDynamicBasemapGallery"));

  // Use of ArcGIS location services, such as basemap styles, geocoding, and routing services,
  // requires an access token. For more information see
  // https://links.esri.com/arcgis-runtime-security-auth.

  // The following methods grant an access token:

  // 1. User authentication: Grants a temporary access token associated with a user's ArcGIS account.
  // To generate a token, a user logs in to the app with an ArcGIS account that is part of an
  // organization in ArcGIS Online or ArcGIS Enterprise.

  // 2. API key authentication: Get a long-lived access token that gives your application access to
  // ArcGIS location services. Go to the tutorial at https://links.esri.com/create-an-api-key.
  // Copy the API Key access token.

  const QString accessToken = QString("");

  if (accessToken.isEmpty())
  {
      qWarning() << "Use of ArcGIS location services, such as the basemap styles service, requires" <<
                    "you to authenticate with an ArcGIS account or set the API Key property.";
  }
  else
  {
      Esri::ArcGISRuntime::ArcGISRuntimeEnvironment::setApiKey(accessToken);
  }

    // Initialize the sample
    CreateDynamicBasemapGallery::init();

    // Initialize application view
    QQmlApplicationEngine engine;
    // Add the import Path
    engine.addImportPath(QDir(QCoreApplication::applicationDirPath()).filePath("qml"));

#ifdef ARCGIS_RUNTIME_IMPORT_PATH_2
    engine.addImportPath(ARCGIS_RUNTIME_IMPORT_PATH_2);
#endif

    // Set the source
    engine.load(QUrl("qrc:/Samples/Maps/CreateDynamicBasemapGallery/main.qml"));

    return app.exec();
}

// Copyright 2024 Esri.

// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0

// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

import QtQuick.Controls
import Esri.Samples

ApplicationWindow {
    visible: true
    width: 800
    height: 600

    CreateDynamicBasemapGallery {
        anchors.fill: parent
    }
}