include /etc/nginx/sites-enabled/*;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
user root;   #pour dire qui a le droit d'utiliser le script
worker_processes  1;

events {
    worker_connections  1024;
}

http {
    include       mime.types;
    default_type  application/octet-stream;

    sendfile        on;
    keepalive_timeout  65;

    include /etc/nginx/conf.d/*.conf;
    include /etc/nginx/sites-enabled/*; #pour inclure mes fichiers de configuration propres à chacun de mes sites.
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
server {
    listen 80;
    server_name monsupersite.fr *.monsupersite.fr; #mettez ici tous les liens devant pointer vers votre site

location / {
               proxy_pass http://127.0.0.1:8000/;
               proxy_read_timeout 300;
               proxy_redirect off;
               proxy_buffering off;
               proxy_store off;
               proxy_set_header Host $host;
               proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
     }
 
     location /static/ {
                alias /home/monuser/www/staticFiles/; #le dossier /home/monuser/www correspond au dossier dans lequel vous aurez mis votre projet, c'est à dire tout ce qui se trouve au même niveau que manage.py
           }
}

1
2
sudo /etc/init.d/nginx restart
gunicorn jiyuu.wsgi:application --bind=127.0.0.1:8000 --daemon

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <QGuiApplication>
#include <QQmlApplicationEngine>
 
int main(int argc, char *argv[])
{
    QGuiApplication app(argc, argv);
    QQmlApplicationEngine engine;
 
    app.setOrganizationName("JiyuuOnDVP");
    app.setApplicationName("TestSettings");
 
    engine.load(QUrl(QStringLiteral("qrc:/main.qml")));
 
    return app.exec();
}

1
2
app.setOrganizationName("JiyuuOnDVP");
app.setApplicationName("TestSettings");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
import sys, os
 
from PyQt5.QtGui import QGuiApplication
from PyQt5.QtQml import QQmlApplicationEngine
 
 
if __name__ == '__main__':
 
    app = QGuiApplication(sys.argv)
    engine = QQmlApplicationEngine()
 
    app.setOrganizationName("JiyuuOnDVP");
    app.setApplicationName("TestSettings");
 
 
    context = engine.rootContext()
    engine.load('./main.qml')
    sys.exit(app.exec_())

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import QtQuick 2.5
import QtQuick.Window 2.2
import Qt.labs.settings 1.0
 
Window {
    visible: true
    title: qsTr('Test Settings')
 
    Settings {
        category: "Category_1"
 
        property string value1: "ma première entrée"
 
    }
}

winecfg

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
import QtQuick 2.5
import QtQuick.Window 2.2
import QtQuick.Controls 1.4
import QtQuick.Layouts 1.2
 
 
Window {
    visible: true
    width: 800; height: 500
    x: 100 ; y: 100
    title: "Create curve with QML"
 
 
    Rectangle{
        id: root
        anchors.fill: parent
 
        ColumnLayout {
            id: grid
            anchors.fill: parent
 
 
            RowLayout {
                id: control
                Layout.fillWidth: true
                implicitHeight: 25
                Button {
                    text: "Trace"
                }
 
                Button {
                    text: "Efface"
                }
 
                Slider {
                    id: slider
                    value: 0
                    maximumValue: 20
                }
 
                Item {
                    Layout.fillWidth: true
                }
 
                Label {
                    id: posiX
                }
 
                Label {
                    id: posiY
                }
 
                Label {
                    id: posiX2
                }
            }
 
            Rectangle {
                id: area
                Layout.fillHeight: true
                Layout.fillWidth: true
                color: "lightgray"
                Canvas {
                    id: canvas
                    anchors.fill: parent
                    transform: Rotation { origin.x: area.x; origin.y: area.height/2; angle: 180; axis { x: 1; y: 0; z: 0 }}
                    property int origX: 0
                    property int origY: 0
                    property int maxX: width - origX
                    property int maxY: height - origY
 
                    property alias pointCurve: pointCurve
 
                    /* c'est ici que ça commence à devenir intéressant. Comme précédemment nous allons créer au démarrage de l'application nos axes, mais nous n'irons pas plus loin.*/
 
                    onPaint: {
                        getContext("2d")
 
/* getContext("2d") est nécessaire pour indiquer dans quel type de context nous nous trouvons. 
Ici on déclare donc un Context2D (http://doc.qt.io/qt-5/qml-qtquick-context2d-members.html) qui a notamment deux méthodes qui nous intéresseront tout  particulièrement :
   - beginPath()
   - closePath()
 
Entre ces deux méthodes, vous pouvez créer comme bon vous semble différents chemins et y appliquer un style unique (couleur, épaisseur du trait...) .
Pour appliquer d'autres styles il faudra redéclarer un nouveau Path (chemin en anglais).*/
 
                        /* Trace Axes */
                        context.beginPath()
                        context.lineWidth = 2
                        context.moveTo(origX, origY)  // permet de se déplacer sans tracer de points
                        context.lineTo(maxX, origY)    // permet de tracer une ligne
                        context.moveTo(origX, origY)
                        context.lineTo(origX, maxY)
                        context.strokeStyle = Qt.rgba(0,0,0);
                        context.stroke()
                        context.closePath()
                    }
 
                    ListModel{id: pointCurve}
 
 
                }
            }
        }
    }
}

1
2
3
4
5
6
7
8
9
Button {
    text: "Trace"
    onClicked: {
        for (var i=0; i<=20; i++){
            pointCurve.append({"x":i*20, "y":Math.pow(i,2)})
        }
         canvas.traceCurve() // nous verrons cette fonction un peu plus bas.
    }
}

1
2
3
4
5
6
7
Button {
    text: "Efface"
    onClicked: {
        slider.value = 0
        canvas.clear() // Comme pour canvas.traceCurve() nous verrons bientôt cette fonction.
    }
}

1
2
3
4
5
6
7
8
9
Slider {
    id: slider
    value: 0
    maximumValue: 20
    onValueChanged: {
        if (value !== 0)canvas.point(root.valueX*20, Math.pow(root.valueX,2))
        canvas.traceCurve()
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
function traceCurve() {
    if (context){
        context.beginPath()                           // comme précédemment nous créons un nouveau Path
        context.lineWidth = 1
        for (var i = 0; i < pointCurve.count; i++) {  // Pour chaque élément de notre ListModel, nous créons une nouvelle ligne
           var posiX = origX + pointCurve.get(i).x
           var posiY = origY + pointCurve.get(i).y
           context.lineTo(posiX, posiY)
       }
       context.moveTo(origX, origY)
       context.strokeStyle = Qt.rgba(0,0,1);
       context.stroke()                               // Nous appliquons le style voulu
       context.closePath()                            // Nous fermons notre chemin
    }
 
requestPaint()                                        // et nous lançons la requête de rendu

1
2
3
4
5
6
7
function clear(){
    if (context){
        pointCurve.clear()
        context.reset()
        requestPaint()
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
import QtQuick 2.5
import QtQuick.Window 2.2
import QtQuick.Controls 1.4
import QtQuick.Layouts 1.2
 
 
Window {
    visible: true
    width: 800; height: 500
    x: 100 ; y: 100
    title: "Create curve with QML"
 
 
    Rectangle{
        id: root
        anchors.fill: parent
 
        property alias valueX: slider.value
 
        ColumnLayout {
            id: grid
            anchors.fill: parent
 
 
            RowLayout {
                id: control
                Layout.fillWidth: true
                implicitHeight: 25
                Button {
                    text: "Trace"
                    onClicked: {
                        for (var i=0; i<=20; i++){
                            pointCurve.append({"x":i*20, "y":Math.pow(i,2)})
                        }
                        canvas.traceCurve()
                    }
                }
                Button {
                    text: "Efface"
                    onClicked: {
                        slider.value = 0
                        canvas.clear()
                    }
                }
                Slider {
                    id: slider
                    value: 0
                    maximumValue: 20
                    onValueChanged: {
                        if (value !== 0)canvas.point(root.valueX*20, Math.pow(root.valueX,2))
                        canvas.traceCurve()
                    }
                }
                Item {
                    Layout.fillWidth: true
                }
 
                Label {
                    id: posiX
                    text: "x : " + (root.valueX*20).toFixed(2)
                }
                Label {
                    id: posiY
                    text: "y : " + Math.pow(root.valueX,2).toFixed(2)
                }
                Label {
                    id: posiX2
                }
            }
 
            Rectangle {
                id: area
                Layout.fillHeight: true
                Layout.fillWidth: true
                color: "lightgray"
                Canvas {
                    id: canvas
                    anchors.fill: parent
                    transform: Rotation { origin.x: area.x; origin.y: area.height/2; angle: 180; axis { x: 1; y: 0; z: 0 }}
                    property int origX: 0
                    property int origY: 0
                    property int maxX: width - origX
                    property int maxY: height - origY
 
                    property alias pointCurve: pointCurve
 
 
 
                    function clear(){
                        if (context){
                            pointCurve.clear()
                            context.reset()
                            requestPaint()
                        }
                    }
 
                    function point(q, h){
                        context.reset()
                        context.beginPath()
                        context.lineWidth = 1
                        context.moveTo(origX, h+origY)
                        context.lineTo(maxX, h+origY)
                        context.moveTo(q+origX, origY)
                        context.lineTo(q+origX, maxY)
                        context.strokeStyle = Qt.rgba(1,0,0);
                        context.stroke()
                        context.closePath()
                        requestPaint()
                    }
 
                    function traceCurve() {
                        if (context){
                            context.beginPath()
                            context.lineWidth = 1
                            for (var i = 0; i < pointCurve.count; i++) {
                                var posiX = origX + pointCurve.get(i).x
                                var posiY = origY + pointCurve.get(i).y
                                context.lineTo(posiX, posiY)
                            }
                            context.moveTo(origX, origY)
                            context.strokeStyle = Qt.rgba(0,0,1);
                            context.stroke()
                            context.closePath()
                        }
 
                        requestPaint()
                    }
 
                    onPaint: {
                        getContext("2d")
 
                        /* Trace Axes */
                        context.beginPath()
                        context.lineWidth = 2
                        context.moveTo(origX, origY)
                        context.lineTo(maxX, origY)
                        context.moveTo(origX, origY)
                        context.lineTo(origX, maxY)
                        context.strokeStyle = Qt.rgba(0,0,0);
                        context.stroke()
                        context.closePath()
                    }
 
                    ListModel{id: pointCurve}
                }
            }
        }
    }
}

1
2
3
4
5
6
7
8
import QtQuick 2.5
import QtWebEngine 1.0
 
WebEngineView {
    width: 800
    height: 600
    url: "http://www.developpez.net/forums/blogs/135545-jiyuu/"
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import QtQuick 2.5
import QtWebEngine 1.0
 
WebEngineView {
    id: webview
    property string viewer    // chemin absolu pointant vers notre fichier viewer.html dernièrement téléchargé.
    property string pathPdf  // chemin absolu pointant vers le document pdf à afficher.
 
    // le code ci-dessous permettra d'afficher une page blanche si au moins l'un des deux chemins n'est pas renseigné
   url: if (viewer && pathPdf)
         {
             viewer + "?file=" + pathPdf
         }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
import QtQuick 2.5
import QtQuick.Controls 1.4
 
ApplicationWindow {
    visible: true
    width: 640
    height: 480
    title: qsTr("Hello World")
 
    menuBar: MenuBar {
        Menu {
            title: qsTr("File")
            MenuItem {
                text: qsTr("&Open")
                onTriggered: console.log("Open action triggered");
            }
            MenuItem {
                text: qsTr("Exit")
                onTriggered: Qt.quit();
            }
        }
    }
 
    Label {
        id: label
        text: qsTr("Hello World")
        x: 5 ; y: 5
        width: parent.width
        height: 50
    }
    Button{
        x: 5 ; y: 100
        text: qsTr("Click here")
        onClicked: label.text = comCpp.txt()  // les lignes qui suivent expliquent ce qu'est comCpp.txt()
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <QGuiApplication>
#include <QQmlApplicationEngine>
#include <QQmlContext>  // nécessaire pour dialoguer entre le code C++ et le code QML
#include <comcpp.h>  // correspond à une classe que nous allons construire ensuite.
 
int main(int argc, char *argv[])
{
    QGuiApplication app(argc, argv);
    ComCpp compCpp; 
 
    QQmlApplicationEngine engine;
    engine.rootContext()->setContextProperty("comCpp", &compCpp); // nous passons ensuite notre object comCpp comme contextProperty dans notre QML. C'est ainsi que nous pourrons l'utiliser.
    engine.load(QUrl(QStringLiteral("qrc:/main.qml")));
 
    return app.exec();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#ifndef COMCPP_H
#define COMCPP_H
 
#include <QString>
#include <QObject>
 
 
class ComCpp : public QObject  // IMPORTANT : pour être utilisable dans le code QML, votre classe doit dériver de QObject ou QQuickItem.
{
    Q_OBJECT
public:
    explicit ComCpp(QObject *parent = 0);
 
signals:
 
public slots:
    QString txt();
};
 
#endif // COMCPP_H

1
2
3
4
5
6
7
8
9
10
11
#include "comcpp.h"
 
ComCpp::ComCpp(QObject *parent) : QObject(parent)
{
 
}
 
QString ComCpp::txt(){
    QString r = "You have clicked on QML Button";
    return r;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
import QtQuick 2.4
import QtQuick.Controls 1.3
 
Rectangle {
    width: 800
    height: 300
 
    property string testText: "Ceci est un TEST de Text"
    property string testLabel: "Ceci est un TEST de Label"
 
    Text{
        id: txt
        anchors.horizontalCenter: parent.horizontalCenter
        anchors.top: parent.top
        text: testText
 
    }
    Label{
        id: label
        anchors.horizontalCenter: parent.horizontalCenter
        anchors.top: txt.bottom
        text: testLabel
    }
    Rectangle{
        id: rect
        anchors.horizontalCenter: parent.horizontalCenter
        anchors.top: label.bottom
        height: 30; width: 30
    }
 
    Row{
        id: row
        anchors.horizontalCenter: parent.horizontalCenter
        anchors.top: rect.bottom
        spacing: 100
 
        Text{
            text: "Détail composant Text :
Style : " +txt.style +"
Font : " + txt.font.family+"
Color : "+txt.color+"
Gras : "+txt.font.bold+"
Pixel : "+txt.font.pixelSize+"
Size : "+txt.font.pointSize+"
Render : "+txt.renderType+"
Format : "+txt.textFormat+"
Antialising : "+txt.antialiasing
 
        }
        Label{
            text: "Détail composant Label :
Style : " +label.style +"
Font : " + label.font.family+"
Color : "+label.color+"
Gras : "+label.font.bold+"
Pixel : "+label.font.pixelSize+"
Size : "+label.font.pointSize+"
Render : "+label.renderType+"
Format : "+label.textFormat+"
Antialising : "+label.antialiasing
        }
    }
            Rectangle{
                id: rect1
                anchors.horizontalCenter: parent.horizontalCenter
                anchors.top: row.bottom
                height: 30; width: 30
            }
            Text{
                id: txt1
                anchors.horizontalCenter: parent.horizontalCenter
                anchors.top: rect1.bottom
                text: testText + " modifié"
                renderType: Text.NativeRendering
            }
 
            Label{
                id: label1
                anchors.horizontalCenter: parent.horizontalCenter
                anchors.top: txt1.bottom
                text: testLabel
            }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
import QtQuick 2.4
import QtMultimedia 5.0
import QtQuick.Controls 1.3
import QtQuick.Layouts 1.1  // Histoire de placer facilement mes composants.
 
ApplicationWindow {
    width : 800
    height : 600
    GridLayout {
        id: grid
        anchors.fill: parent
        columns :2
        Button {
            text: "Lancer la musique"
            onClicked: playMusic.play()
            Layout.fillWidth: true
        }
        Button {
            text: "Lancer le Film"
            onClicked: video.play()
            Layout.fillWidth: true
        }
 
        Video {
            id: video
            source: "/home/charlie/Movies/Taken.avi"
            Layout.fillHeight: true
            Layout.fillWidth: true
            Layout.columnSpan: grid.columns
 
            // au cas où l'on souhaite lancer la vidéo en cliquant sur l'espace réservé à sa lecture.
            MouseArea {
                anchors.fill: parent
                onClicked: {
                    video.play()
                }
            }
        }
 
        Audio {
            id: playMusic
            source: "cosmo.mp3"
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
import sys, platform
from PyQt5.QtWidgets import QApplication
from PyQt5.QtQml import QQmlApplicationEngine, QQmlComponent
 
 
if __name__ == "__main__":
    app = QApplication(sys.argv)
    engine = QQmlApplicationEngine()
    engine.load('test.qml')
    win = engine.rootObjects()[0]
    win.show()
    sys.exit(app.exec())

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <QApplication>
#include <QQmlApplicationEngine>
#include <QQmlContext>
 
 
int main(int argc, char *argv[])
{
    QApplication app(argc, argv);
 
    QQmlApplicationEngine engine;
    engine.load(QUrl(QStringLiteral("qrc:/test.qml")));
 
    return app.exec();
 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import QtQuick 2.4
import QtQuick.Controls 1.3
import QtQuick.Dialogs 1.2
 
Dialog {
    id: dateDialog
    width : 400
    height : 350
    visible: true
    title: "Sélectionner une date"
    standardButtons: StandardButton.Ok | StandardButton.Cancel
 
    onAccepted: console.log("Date sélectionnée : ",Qt.formatDate(calendar.selectedDate, "dd/MM/yyyy"))
 
    Calendar {
        id: calendar
        weekNumbersVisible: true
        width : 375
        height : 295
        onDoubleClicked: dateDialog.click(StandardButton.Ok)
 
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
import QtQuick 2.4
import QtQuick.Controls 1.3
import QtQuick.Window 2.2
 
Window {
    id: view
    height : 200
    width : 300
    x: 100
    y: 100
 
 
    Label {
        text: "test"
        MouseArea {
            id: mouseArea
            anchors.fill: parent
            acceptedButtons: Qt.LeftButton | Qt.RightButton
            onClicked: {
                if (mouse.button === Qt.RightButton){
                    contextMenu.visible = true
                    contextMenu.y = view.y + mouseY
                    contextMenu.x = view.x + mouseX + 15
 
                }
            }
        }
    }
    Window {
        id: contextMenu
        visible: false
        height: 100
        width: 150
        flags: Qt.FramelessWindowHint
        color: "lightgray"
 
        MouseArea {
            anchors.fill: parent
            hoverEnabled: true
            onExited: contextMenu.visible = false
        }
 
        Column{
            anchors.fill: parent
 
            Label {
                text: "Action 1"
                MouseArea {
                    anchors.fill: parent
                    onClicked : {
                        console.log("Vous avez cliqué sur Action 1")
                        contextMenu.visible = false
                    }
                }
            }
            Label {
                text: "Action 2"
                MouseArea {
                    anchors.fill: parent
                    onClicked : {
                        console.log("Vous avez cliqué sur Action 2")
                        contextMenu.visible = false
                    }
                }
            }
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
import QtQuick 2.4
import QtQuick.LocalStorage 2.0
 
Item {
    /*Propriété de l'item à rensigner */
    property var db : getDatabase("QQmlExampleDB", "1.0", "The Example QML SQL!", 1000000)
    property string dbTable : "Greeting"
 
 
 
 
    /* Exemple de codes  */
    function printResult(result){
        for(var key in result){
            var dic = result[key]
            console.log(key, dic.salutee, dic.salutation)
        }
 
    }
 
    Component.onCompleted: {
        createTable('salutation TEXT, salutee TEXT')
        insertValueByCol({"salutee":"Bob", "salutation":"hello"})
        insertValueByCol({"salutee":"Bob", "salutation":"hello"})
        insertValue(["hello","Toto"])
        insertValue(["salut","Jiyuu"])
        var newData = getAll()
        var newData2 = filter("salutation = 'hello'")
        printResult(newData2)
    }
 
 
 
    /* Fonctions internes */
    function getDatabase(name, version, descriptif, taille) {
         return LocalStorage.openDatabaseSync(name, version , descriptif, taille);
    }
 
    function createTable(dbQuery) {
        db.transaction(
            function(tx) {
                tx.executeSql('CREATE TABLE IF NOT EXISTS ' +dbTable+ ' ('+dbQuery+')');
            }
        )
    }
 
    function insertValueByCol(dbDict) {
        var dbColumn = []
        var dbValue = []
        var nbVal = ''
 
        for(var key in dbDict) {
            dbColumn.push(key)
            dbValue.push(dbDict[key])
            nbVal += '?,'
        }
 
        nbVal = nbVal.substring(0, nbVal.length - 1);
        db.transaction(
            function(tx) {
                tx.executeSql('INSERT INTO ' +dbTable+'('+dbColumn+')'+ ' VALUES('+nbVal+')', dbValue);
            }
        )
    }
 
    function insertValue(dbValue) {
        var nbVal = ''
        for(var i in dbValue) {
            nbVal += '?,'
        }
        nbVal = nbVal.substring(0, nbVal.length - 1);
        db.transaction(
            function(tx) {
                tx.executeSql('INSERT INTO ' +dbTable+ ' VALUES('+nbVal+')', dbValue);
            }
        )
    }
 
    function getAll() {
        var result
        db.transaction(
            function(tx) {
                var rs = tx.executeSql('SELECT * FROM '+dbTable);
                var info = tx.executeSql('PRAGMA table_info('+dbTable+') ')
                var col = []
                var r = []
                for(var column = 0; column < info.rows.length; column++) {
                    col.push(info.rows.item(column).name)
                }
 
 
                for(var i = 0; i < rs.rows.length; i++){
                    var dic = {}
                    for(var key in col) {
                        var keyDic = col[key]
                        var valueDic = rs.rows.item(i)[keyDic]
                        dic[keyDic] = valueDic
                    }
                    r.push(dic)
                }
                result = r
            }
        )
        return result
    }
    function filter(query) {
        var result
        db.transaction(
            function(tx) {
                var rs = tx.executeSql('SELECT * FROM '+dbTable+' WHERE '+query);
                var info = tx.executeSql('PRAGMA table_info('+dbTable+') ')
                var col = []
                var r = []
                for(var column = 0; column < info.rows.length; column++) {
                    col.push(info.rows.item(column).name)
                }
 
 
                for(var i = 0; i < rs.rows.length; i++){
                    var dic = {}
                    for(var key in col) {
                        var keyDic = col[key]
                        var valueDic = rs.rows.item(i)[keyDic]
                        dic[keyDic] = valueDic
                    }
                    r.push(dic)
                }
                result = r
            }
        )
        return result
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
import QtQuick 2.4
 
Canvas {
    width: 500; height: 500
    contextType: "2d"
    transform: Rotation { origin.x: 0; origin.y: height/2; angle: 180; axis { x: 1; y: 0; z: 0 }}
 
    Path {
        id: myCurve1
        startX: 20; startY: 120
        PathCurve { x: 40; y: 116 }
        PathCurve { x: 60; y: 112 }
        PathCurve { x: 80; y: 104 }
        PathCurve { x: 100; y: 96 }
        PathCurve { x: 120; y: 86 }
        PathCurve { x: 140; y: 76 }
        PathCurve { x: 160; y: 60 }
        PathCurve { x: 180; y: 44 }
        PathCurve { x: 200; y: 20 }
    }
 
    Path {
        id: myCurve2
        startX: 20; startY: 120
        PathCurve { x: 75; y: 75 }
        PathCurve { x: 200; y: 150 }
        PathCurve { x: 325; y: 25 }
        PathCurve { x: 400; y: 100 }
    }
 
    Path {
        id: myAxis
        startX: 20; startY: 20
        PathLine { x: 20 ; y: 300 }
        PathLine { x: 20 ; y: 20 }
        PathLine { x: 450 ; y: 20 }
        PathLine { x: 20 ; y: 20 }
    }
 
    onPaint: {
        context.strokeStyle = Qt.rgba(0,0,1);
        context.path = myAxis;
        context.stroke();
 
        context.strokeStyle = Qt.rgba(1,0,0);
        context.path = myCurve1;
        context.stroke();
 
        context.strokeStyle = Qt.rgba(0,1,0);
        context.path = myCurve2;
        context.stroke();
        }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
import sys
from PyQt5.QtCore import QObject, QUrl, pyqtSlot, QVariant
from PyQt5.QtWidgets import QApplication
from PyQt5.QtQuick import QQuickView
from PyQt5.QtQml import QQmlApplicationEngine
 
 
class MainApp(QObject):
    def __init__(self, parent=None):
        super(MainApp, self).__init__(parent)
 
        self.win = parent
        self.win.findChild(QObject,"myButton").clicked.connect(self.test3)
 
 
    @pyqtSlot(QVariant)
    def test(self, ctx):
        txt = "Test by contextProperty"
        ctx.setContextProperty("retour", txt)
 
        return 0
 
 
    @pyqtSlot(result=QVariant)
    def test2(self):
 
        return 'Test by direct call'
 
 
    def test3(self):
        txt = self.win.findChild(QObject, "myTextField")
        txt.setProperty("text", "Test by name")
 
        return 0
 
 
 
if __name__ == "__main__":
    app = QApplication(sys.argv)
 
    engine = QQmlApplicationEngine()
    ctx = engine.rootContext()
 
    txt = "Test by ContextProperty"
    ctx.setContextProperty("titreBtn", txt)
    ctx.setContextProperty("ctx", ctx)
 
    engine.load('gui.qml')
    win = engine.rootObjects()[0]
 
    _MainApp = MainApp(win)
    ctx.setContextProperty("py_MainApp", _MainApp)
 
    win.showMaximized()
 
    sys.exit(app.exec_())

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
import QtQuick 2.4
import QtQuick.Controls 1.3
import QtQuick.Window 2.2
import QtQuick.Dialogs 1.2
import QtQuick.Layouts 1.1
 
 
ApplicationWindow {
    title: qsTr("Test")
    width: 640
    height: 480
 
    menuBar: MenuBar {
        Menu {
            title: qsTr("&File")
            MenuItem {
                text: qsTr("&Open")
                onTriggered: messageDialog.show(qsTr("Open action triggered"));
            }
            MenuItem {
                text: qsTr("E&xit")
                onTriggered: Qt.quit();
            }
        }
    }
 
    GridLayout {
        id : grid
        columns : 6
        columnSpacing: 5
        anchors.fill: parent
        anchors.margins: 10
 
        RowLayout {
            id : nav
            Layout.fillWidth: true
            Layout.columnSpan: grid.columns
 
            TextField{
                id : txt
                objectName: "myTextField"
                Layout.fillWidth: true
            }
            Button{
                objectName: "myButton"
                text : "Test byName"
            }
            Button{
                text : titreBtn
                onClicked: {
                    py_MainApp.test(ctx)
                    txt.text = retour
                }
            }
            Button{
                text : "Test de retour"
                onClicked: txt.text = py_MainApp.test2()
            }
        }
 
        TextArea{
            id: result
            Layout.fillWidth: true
            Layout.fillHeight: true
            Layout.columnSpan: grid.columns
        }
   }
 
 
   MessageDialog {
        id: messageDialog
        title: qsTr("May I have your attention, please?")
 
        function show(caption) {
            messageDialog.text = caption;
            messageDialog.open();
        }
    }
}