Column {
        id: objLeftColumn
 
        property int m_iLastButtonClicked: -1
        property int m_iCurrentButtonClicked: -1
 
        onM_iCurrentButtonClickedChanged: {
            if(m_iLastButtonClicked != -1) {
                objLeftColumn.children[m_iLastButtonClicked].m_bIsSelected = false
            }
            m_iLastButtonClicked = m_iCurrentButtonClicked
        }
 
        Repeater {
            id: objLeftColumnRepeater
 
            model: 5
 
            delegate: ABCD {
                id: objABCD
 
                m_mouseProperty.onClicked: {
                    if(m_bIsSelected) {
                        objLeftColumn.m_iCurrentButtonClicked = index
                    }
                    else {
                        objLeftColumn.m_iLastButtonClicked = -1
                        objLeftColumn.m_iCurrentButtonClicked = -1
                    }
                }
            }
        }
}

Column {
        id: objLeftColumn
 
        property int m_iLastButtonClicked: -1
        property int m_iCurrentButtonClicked: -1
 
        property alias m_delegate: objLeftColumnRepeater.delegate
 
        onM_iCurrentButtonClickedChanged: {
            if(m_iLastButtonClicked != -1) {
                objLeftColumn.children[m_iLastButtonClicked].m_bIsSelected = false
            }
            m_iLastButtonClicked = m_iCurrentButtonClicked
        }
 
        Repeater {
            id: objLeftColumnRepeater
 
            model: 5
            onItemAdded: {
            //state of item can be manipulated but want to
            //add behaviour to the item (like accessing a function through virtual mechanism in c++) eg:
            /*item {
                     m_mouseProperty.onClicked: {
                     //do something
                     }
               }*/
            }            
        }
}

Exclusive {
    m_delegate: ABCD
}
 
Exclusive {
    m_delegate: DEFG
}

#include <QObject>
 
    class QString;
    class QQuickView;
 
    class screenCapture : public QObject
    {
        Q_OBJECT
    public:    
        explicit screenCapture(QQuickView *parent = 0);
 
    public slots:
        void capture(QString const &path) const;
 
    private:
        QQuickView *currentView_;    
    };

screenCapture.cpp
 
    #include <QPixmap>
    #include <QQuickView>
    #include <QString>
 
    #include "screenCapture.hpp"
 
    screenCapture::screenCapture(QQuickView *currentView) :
        QObject(0), currentView_(currentView)
    {
    }
 
    void screenCapture::capture(QString const &path) const
    {
        QPixmap::grabWidget(currentView_).save(path);
    }

main.cpp
 
    #include <QGuiApplication>
    #include <QQuickPaintedItem>
    #include <QQuickView>
    #include <QQmlContext>
 
    #include "screenCapture.hpp"
 
    int main(int argc, char *argv[])
    {
        QGuiApplication app(argc, argv);
 
        qmlRegisterType<screenCapture>("Image", 1, 0, "ScreenCapture");
        qmlRegisterType<saveAbleImage>("Image", 1, 0, "SaveAbleImage");
 
        QQuickView view;
        view.setResizeMode(QQuickView::SizeRootObjectToView);
        view.setSource(QStringLiteral("/Users/Qt/program/experiment_apps_and_libs/funnyCamera/qml/funnyCamera/main.qml"));
        view.show();
 
        screenCapture screenClass(&view);
        view.rootContext()->setContextProperty("screenObject", &screenClass);
 
        return app.exec();
    }

main.qml
 
    import QtQuick 2.0
 
    Rectangle{
        id : root
        width : 1024
        height : 768    
 
        MouseArea{
            anchors.fill: root
 
            onClicked: {          
                console.log("save image")
                screenObject.capture("Pictures/saveTest.jpg")
            }
        }
    }

void screenCapture::capture(QString const &path) const
    {
        QImage img = currentView_->grabWindow();
        img.save(path);
    }

ListView {
                id: imageList
 
                property int selection: 0
 
                anchors.centerIn: parent
                width: 75
                height: 500
                spacing: 80
 
                FolderListModel {
                    id: imageFolderModel
                    showDirs: true
                    folder: "/opt/org.seadot.desktop/qml/Apps/"
                    nameFilters: [ "*.svg" ]
                }
 
                Component {
                    id: imageFileDelegate
 
                    Item {
                        Image{
                            id: launcherItem
                            width: 75
                            height: 75
                            sourceSize.width: 75
                            sourceSize.height: 75
                            source: "file:///opt/org.seadot.desktop/qml/Apps/"+fileName+"/icon.svg"
 
                            MouseArea {
                                anchors.fill: parent
 
                                onClicked: {
                                    imageList.selection = index;
                                    imageList.model.opacity = 0.5
                                }
                            }
                        }
                    }
                }
 
                model: imageFolderModel
                delegate: imageFileDelegate
            }

Rectangle
{
    width: 600; height: 400
    Row
    {
        id: myRow; spacing: 5; x: 50; y: 200
        Repeater
        {
            id: myRepeater; model: 10
            Rectangle
            {
                width: 100; height: 100;
                property int myIndex: index
                Image
                {
                    source: "../GrayPoint.png"
                }
                MouseArea
                {
                    id: mouseArea; anchors.fill: parent; hoverEnabled: true
                    onEntered:
                        updateUI( parent )
                }
            }
 
        }
    }
	function updateUI( theParent )
    {
        theParent.childAt( 0, 0 ).source = "../RedPoint.png"
    }
}

import QtQuick 2.0
 
Item{
    id:root
    height: 800; width: 144
 
    signal fullScreen()
    signal camera()
    signal photo()
 
    Column{
        id: toolBarColumn
 
        anchors.fill: root
        spacing: 10
 
        Rectangle{
 
            width: 144
            height: 70
            color: "blue"
 
            Text{
                text: "fullScreen"
            }
 
            MouseArea{
                anchors.fill: parent
 
                onClicked: {
                    fullScreen()
                }
            }
        }
 
        Rectangle{
 
            width: 144
            height: 70
            color: "blue"
 
            Text{
                text: "camera"
            }
 
            MouseArea{
                anchors.fill: parent
 
                onClicked: {
                    camera()
                }
            }
        }
 
        Rectangle{
 
            width: 144
            height: 70
            color: "blue"
 
            Text{
                text: "photo"
            }
 
            MouseArea{
                anchors.fill: parent
 
                onClicked: {
                    photo()
                }
            }
        }
    }
}

import QtQuick 2.0
import QtMultimedia 5.0
 
 
Rectangle{
    id: root
 
    width: 480
    height: 320
    color: "black"
    state: "PHOTO"
 
    property alias source: largeImage.source
 
    property var theID: largeImage
 
    QtObject{
        id: param
 
        property var theID: largeImage
    }
 
    Image{
        id : largeImage
        anchors.fill: parent
        cache: false
        fillMode: Image.PreserveAspectFit
        smooth: true
    }
 
    Camera{
        id: camera
    }
 
    VideoOutput {
        id: videoOutput
 
        anchors.fill: parent
        source: camera
    }
 
    states:[
        State {
            name: "PHOTO"
            StateChangeScript{
                script:{
                    camera.stop()
                    param.theID = largeImage
                }
            }
 
            PropertyChanges { target: largeImage; opacity: 1}
            PropertyChanges { target: videoOutput; opacity: 0}
        },
        State {
            name: "CAMERA"
            StateChangeScript{
                script:{
                    camera.captureMode = Camera.CaptureStillImage
                    camera.start()
                    param.theID = videoOutput
                }
            }
 
            PropertyChanges {target: largeImage; opacity: 0}
            PropertyChanges { target: videoOutput; opacity: 1}
        }
    ]
}

import QtQuick 2.0
 
Rectangle {
    id: root
 
    width: 800
    height: 480
 
    QtObject{
        id: param
 
        property string previousFullScreenState
    }
 
    ToolBarTest{
        id: toolBarTest
 
        onFullScreen: {
            param.previousFullScreenState = root.state
            root.state = "FULLSCREEN"
        }
 
        onPhoto: {
            root.state = "PHOTO"
        }
 
        onCamera: {
            root.state = "CAMERA"
        }
    }
 
    PhotoTest{
        id: photoTest
 
        anchors.left: toolBarTest.right
        width: parent.width - toolBarTest.width
 
        source: "/Users/yyyy/Downloads/1359170070532.jpg"
 
        MouseArea{
            anchors.fill: parent
 
            onClicked: {
                if(root.state == "FULLSCREEN"){
                    root.state = param.previousFullScreenState
                }
            }
        }
    }
 
    states: [
        State {
            name: "PHOTO"
 
            PropertyChanges { target: photoTest; state: "PHOTO"}
            PropertyChanges { target: toolBarTest; width: 144}
        },
        State {
            name: "CAMERA"
 
            PropertyChanges { target: photoTest; state: "CAMERA"}
            PropertyChanges { target: toolBarTest; width: 144}
        },
        State {
            name: "FULLSCREEN"
 
            PropertyChanges { target: toolBarTest; width: 0}
        }
    ]
}

Flickable {
        id: content
        clip: false
        anchors.fill: parent
        boundsBehavior: Flickable.StopAtBounds
 
        Loader {
            id: contentLoader
            anchors.centerIn: parent
        }
 
        MouseArea {
            anchors.fill: parent
            onClicked: {
                console.log("[veo] onClicked - capture triggered")
                cplusplusobject.process(contentLoader.item)                 <----------------- call to C++
            }
        }

void
Cplusplusobject::process(const QVariant &v)
{
    qDebug() << "[veo]" << __FUNCTION__;
    QQuickItem *item = qobject_cast<QQuickItem *>( v.value<QObject*>() );
    qDebug() << "Item dimensions:" << item->width() << item->height();
 
    item->dumpObjectInfo();
 
    QQuickWindow *window = item->window();
    QImage image = window->grabWindow();
...