You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
329 lines
10 KiB
329 lines
10 KiB
/****************************************************************************
|
|
**
|
|
** Copyright (C) 2016 The Qt Company Ltd.
|
|
** Contact: https://www.qt.io/licensing/
|
|
**
|
|
** This file is part of the Qt Quick Controls module of the Qt Toolkit.
|
|
**
|
|
** $QT_BEGIN_LICENSE:LGPL$
|
|
** Commercial License Usage
|
|
** Licensees holding valid commercial Qt licenses may use this file in
|
|
** accordance with the commercial license agreement provided with the
|
|
** Software or, alternatively, in accordance with the terms contained in
|
|
** a written agreement between you and The Qt Company. For licensing terms
|
|
** and conditions see https://www.qt.io/terms-conditions. For further
|
|
** information use the contact form at https://www.qt.io/contact-us.
|
|
**
|
|
** GNU Lesser General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU Lesser
|
|
** General Public License version 3 as published by the Free Software
|
|
** Foundation and appearing in the file LICENSE.LGPL3 included in the
|
|
** packaging of this file. Please review the following information to
|
|
** ensure the GNU Lesser General Public License version 3 requirements
|
|
** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
|
|
**
|
|
** GNU General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU
|
|
** General Public License version 2.0 or (at your option) the GNU General
|
|
** Public license version 3 or any later version approved by the KDE Free
|
|
** Qt Foundation. The licenses are as published by the Free Software
|
|
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
|
|
** included in the packaging of this file. Please review the following
|
|
** information to ensure the GNU General Public License requirements will
|
|
** be met: https://www.gnu.org/licenses/gpl-2.0.html and
|
|
** https://www.gnu.org/licenses/gpl-3.0.html.
|
|
**
|
|
** $QT_END_LICENSE$
|
|
**
|
|
****************************************************************************/
|
|
|
|
import QtQuick 2.2
|
|
import QtQuick.Controls 1.2
|
|
import QtQuick.Controls.Private 1.0
|
|
|
|
/*!
|
|
\qmltype TabView
|
|
\inqmlmodule QtQuick.Controls
|
|
\since 5.1
|
|
\ingroup views
|
|
\ingroup controls
|
|
\brief A control that allows the user to select one of multiple stacked items.
|
|
|
|
\image tabview.png
|
|
|
|
TabView provides tab-based navigation model for your application.
|
|
For example, the following snippet uses tabs to present rectangles of
|
|
different color on each tab page:
|
|
|
|
\qml
|
|
TabView {
|
|
Tab {
|
|
title: "Red"
|
|
Rectangle { color: "red" }
|
|
}
|
|
Tab {
|
|
title: "Blue"
|
|
Rectangle { color: "blue" }
|
|
}
|
|
Tab {
|
|
title: "Green"
|
|
Rectangle { color: "green" }
|
|
}
|
|
}
|
|
\endqml
|
|
|
|
\note You can create a custom appearance for a TabView by
|
|
assigning a \l {TabViewStyle}.
|
|
|
|
\l Tab represents the content of a tab in a TabView.
|
|
*/
|
|
|
|
FocusScope {
|
|
id: root
|
|
|
|
implicitWidth: 240
|
|
implicitHeight: 150
|
|
|
|
/*! The current tab index */
|
|
property int currentIndex: 0
|
|
|
|
/*! The current tab count */
|
|
readonly property int count: __tabs.count
|
|
|
|
/*! The visibility of the tab frame around contents */
|
|
property bool frameVisible: true
|
|
|
|
/*! The visibility of the tab bar */
|
|
property bool tabsVisible: true
|
|
|
|
/*!
|
|
\qmlproperty enumeration TabView::tabPosition
|
|
|
|
\list
|
|
\li Qt.TopEdge (default)
|
|
\li Qt.BottomEdge
|
|
\endlist
|
|
*/
|
|
property int tabPosition: Qt.TopEdge
|
|
|
|
/*!
|
|
\qmlproperty Item TabView::contentItem
|
|
\since QtQuick.Controls 1.3
|
|
|
|
This property holds the content item of the tab view.
|
|
|
|
Tabs declared as children of a TabView are automatically parented to the TabView's contentItem.
|
|
*/
|
|
readonly property alias contentItem: stack
|
|
|
|
/*! \internal */
|
|
default property alias data: stack.data
|
|
|
|
/*!
|
|
\qmlmethod Tab TabView::addTab(string title, Component component)
|
|
|
|
Adds a new tab with the given \a title and an optional \a component.
|
|
|
|
Returns the newly added tab.
|
|
*/
|
|
function addTab(title, component) {
|
|
return insertTab(__tabs.count, title, component)
|
|
}
|
|
|
|
/*!
|
|
\qmlmethod Tab TabView::insertTab(int index, string title, Component component)
|
|
|
|
Inserts a new tab at \a index, with the given \a title and
|
|
an optional \a component.
|
|
|
|
Returns the newly added tab.
|
|
*/
|
|
function insertTab(index, title, component) {
|
|
var tab = tabcomp.createObject()
|
|
tab.sourceComponent = component
|
|
tab.title = title
|
|
// insert at appropriate index first, then set the parent to
|
|
// avoid onChildrenChanged appending it to the end of the list
|
|
__tabs.insert(index, {tab: tab})
|
|
tab.__inserted = true
|
|
tab.parent = stack
|
|
__didInsertIndex(index)
|
|
__setOpacities()
|
|
return tab
|
|
}
|
|
|
|
/*! \qmlmethod void TabView::removeTab(int index)
|
|
Removes and destroys a tab at the given \a index. */
|
|
function removeTab(index) {
|
|
var tab = __tabs.get(index).tab
|
|
__willRemoveIndex(index)
|
|
__tabs.remove(index, 1)
|
|
tab.destroy()
|
|
__setOpacities()
|
|
}
|
|
|
|
/*! \qmlmethod void TabView::moveTab(int from, int to)
|
|
Moves a tab \a from index \a to another. */
|
|
function moveTab(from, to) {
|
|
__tabs.move(from, to, 1)
|
|
|
|
if (currentIndex == from) {
|
|
currentIndex = to
|
|
} else {
|
|
var start = Math.min(from, to)
|
|
var end = Math.max(from, to)
|
|
if (currentIndex >= start && currentIndex <= end) {
|
|
if (from < to)
|
|
--currentIndex
|
|
else
|
|
++currentIndex
|
|
}
|
|
}
|
|
}
|
|
|
|
/*! \qmlmethod Tab TabView::getTab(int index)
|
|
Returns the \l Tab item at \a index. */
|
|
function getTab(index) {
|
|
var data = __tabs.get(index)
|
|
return data && data.tab
|
|
}
|
|
|
|
/*! \internal */
|
|
property ListModel __tabs: ListModel { }
|
|
|
|
/*! \internal */
|
|
property Component style: Settings.styleComponent(Settings.style, "TabViewStyle.qml", root)
|
|
|
|
/*! \internal */
|
|
property var __styleItem: loader.item
|
|
|
|
onCurrentIndexChanged: __setOpacities()
|
|
|
|
/*! \internal */
|
|
function __willRemoveIndex(index) {
|
|
// Make sure currentIndex will points to the same tab after the removal.
|
|
// Also activate the next index if the current index is being removed,
|
|
// except when it's both the current and last index.
|
|
if (count > 1 && (currentIndex > index || currentIndex == count -1))
|
|
--currentIndex
|
|
}
|
|
function __didInsertIndex(index) {
|
|
// Make sure currentIndex points to the same tab as before the insertion.
|
|
if (count > 1 && currentIndex >= index)
|
|
currentIndex++
|
|
}
|
|
|
|
function __setOpacities() {
|
|
for (var i = 0; i < __tabs.count; ++i) {
|
|
var child = __tabs.get(i).tab
|
|
child.visible = (i == currentIndex ? true : false)
|
|
}
|
|
}
|
|
|
|
activeFocusOnTab: false
|
|
|
|
Component {
|
|
id: tabcomp
|
|
Tab {}
|
|
}
|
|
|
|
TabBar {
|
|
id: tabbarItem
|
|
objectName: "tabbar"
|
|
tabView: root
|
|
style: loader.item
|
|
anchors.top: parent.top
|
|
anchors.left: root.left
|
|
anchors.right: root.right
|
|
}
|
|
|
|
Loader {
|
|
id: loader
|
|
z: tabbarItem.z - 1
|
|
sourceComponent: style
|
|
property var __control: root
|
|
}
|
|
|
|
Loader {
|
|
id: frameLoader
|
|
z: tabbarItem.z - 1
|
|
|
|
anchors.fill: parent
|
|
anchors.topMargin: tabPosition === Qt.TopEdge && tabbarItem && tabsVisible ? Math.max(0, tabbarItem.height - baseOverlap) : 0
|
|
anchors.bottomMargin: tabPosition === Qt.BottomEdge && tabbarItem && tabsVisible ? Math.max(0, tabbarItem.height -baseOverlap) : 0
|
|
sourceComponent: frameVisible && loader.item ? loader.item.frame : null
|
|
|
|
property int baseOverlap: __styleItem ? __styleItem.frameOverlap : 0
|
|
|
|
Item {
|
|
id: stack
|
|
|
|
anchors.fill: parent
|
|
anchors.margins: (frameVisible ? frameWidth : 0)
|
|
anchors.topMargin: anchors.margins + (style =="mac" ? 6 : 0)
|
|
anchors.bottomMargin: anchors.margins
|
|
|
|
property int frameWidth
|
|
property string style
|
|
property bool completed: false
|
|
|
|
Component.onCompleted: {
|
|
addTabs(stack.children)
|
|
completed = true
|
|
}
|
|
|
|
onChildrenChanged: {
|
|
if (completed)
|
|
stack.addTabs(stack.children)
|
|
}
|
|
|
|
function addTabs(tabs) {
|
|
var tabAdded = false
|
|
for (var i = 0 ; i < tabs.length ; ++i) {
|
|
var tab = tabs[i]
|
|
if (!tab.__inserted && tab.Accessible.role === Accessible.LayeredPane) {
|
|
tab.__inserted = true
|
|
// reparent tabs created dynamically by createObject(tabView)
|
|
tab.parent = stack
|
|
// a dynamically added tab should also get automatically removed when destructed
|
|
if (completed)
|
|
tab.Component.onDestruction.connect(stack.onDynamicTabDestroyed.bind(tab))
|
|
__tabs.append({tab: tab})
|
|
tabAdded = true
|
|
}
|
|
}
|
|
if (tabAdded)
|
|
__setOpacities()
|
|
}
|
|
|
|
function onDynamicTabDestroyed() {
|
|
for (var i = 0; i < __tabs.count; ++i) {
|
|
if (__tabs.get(i).tab === this) {
|
|
__willRemoveIndex(i)
|
|
__tabs.remove(i, 1)
|
|
__setOpacities()
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
onLoaded: { item.z = -1 }
|
|
}
|
|
|
|
onChildrenChanged: stack.addTabs(root.children)
|
|
|
|
states: [
|
|
State {
|
|
name: "Bottom"
|
|
when: tabPosition === Qt.BottomEdge && tabbarItem != undefined
|
|
PropertyChanges {
|
|
target: tabbarItem
|
|
anchors.topMargin: -frameLoader.baseOverlap
|
|
}
|
|
AnchorChanges {
|
|
target: tabbarItem
|
|
anchors.top: frameLoader.bottom
|
|
}
|
|
}
|
|
]
|
|
}
|
|
|