Check-in [e53db001e5]

Not logged in

Many hyperlinks are disabled.
Use anonymous login to enable hyperlinks.

Overview
Comment:Repository intialization. Please note that build documentation was added (How to build and clean RR in windows.docx). Enjoy!!!
Timelines: family | ancestors | descendants | both | trunk
Files: files | file ages | folders
SHA1:e53db001e544a93f596ba5b6caf712a486ff9633
User & Date: azadok 2013-12-08 18:04:51
Context
2013-12-08
18:23
Change test check-in: bd2758c5da user: azadok tags: trunk
18:04
Repository intialization. Please note that build documentation was added (How to build and clean RR in windows.docx). Enjoy!!! check-in: e53db001e5 user: azadok tags: trunk
2013-11-20
09:15
initial empty check-in check-in: e16d3ca361 user: sgershon tags: trunk
Changes
Hide Diffs Unified Diffs Ignore Whitespace Patch

Added RapidReporter2/CleanRRfiles.exe.

cannot compute difference between binary files

Added RapidReporter2/Flags.h.

























>
>
>
>
>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8
9
10
11
12
#ifndef AVI_H
#define AVI_H

class Flags
{
public:
    Flags() {}
    enum OpenCloseTag {OPEN,CLOSE};
    enum HtmlTags {html, head, title, SCRIPT, style, body, div, h1, input, table, th};
};

#endif // AVI_H

Added RapidReporter2/How to build and clean RR in windows.docx.

cannot compute difference between binary files

Added RapidReporter2/RR2.pro.



































































































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
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
#-------------------------------------------------
#
# Project created by QtCreator 2013-10-17T18:25:44
#
#-------------------------------------------------

QT       += core gui

greaterThan(QT_MAJOR_VERSION, 4): QT += widgets

TARGET = RR2
TEMPLATE = app


SOURCES += main.cpp\
        mainwindow.cpp \
    logger.cpp \
    cliparser.cpp \
    helpviewer.cpp \
    applauncher.cpp \
    csv2htmlconverter.cpp \
    htmlstring.cpp \
    uitempconnector.cpp \
    uiemulator.cpp \
    screenshot.cpp \
    test.cpp \
    a.cpp \
    session.cpp \
    note.cpp \
    convert_csv2html.cpp

HEADERS  += mainwindow.h \
    logger.h \
    cliparser.h \
    helpviewer.h \
    applauncher.h \
    csv2htmlconverter.h \
    htmlstring.h \
    uitempconnector.h \
    uiemulator.h \
    screenshot.h \
    test.h \
    a.h \
    Flags.h \
    session.h \
    note.h \
    convert_csv2html.h

FORMS    += mainwindow.ui

Added RapidReporter2/a.cpp.













>
>
>
>
>
>
1
2
3
4
5
6
#include "a.h"

a::a(QWidget *parent) :
    QWidget(parent)
{
}

Added RapidReporter2/a.h.





































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#ifndef A_H
#define A_H

#include <QWidget>

class a : public QWidget
{
    Q_OBJECT
public:
    explicit a(QWidget *parent = 0);

signals:

public slots:

};

#endif // A_H

Added RapidReporter2/applauncher.cpp.















































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include "applauncher.h"
#include "helpviewer.h"
#include "cliparser.h"
#include "csv2htmlconverter.h"

#include <QDebug>


AppLauncher::AppLauncher(int argc, char *argv[], QObject *parent) :
    QObject(parent)
{
    CliParser cliPraser;
//    HelpViewer helpViewer;
//    Csv2HtmlConverter csv2HtmlConverter;

//    connect(&cliPraser,SIGNAL(EmitShowHelp()),&helpViewer,SLOT(ShowHelp()));
//    connect(&cliPraser,SIGNAL(EmitConvertCsvToHtml(QString)),&csv2HtmlConverter,SLOT(Convert(QString)));

    cliPraser.ParseCliArgs(argc,argv);

    qDebug() << "message";

}

Added RapidReporter2/applauncher.h.





































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#ifndef APPLAUNCHER_H
#define APPLAUNCHER_H

#include <QObject>

class AppLauncher : public QObject
{
    Q_OBJECT
public:
    explicit AppLauncher(int argc, char *argv[],QObject *parent = 0);

signals:

public slots:

};

#endif // APPLAUNCHER_H

Added RapidReporter2/cliparser.cpp.





































































































































































































































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
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
#include "cliparser.h"
#include <QFile>
#include <QDebug>
#include <QDir>

QString const TO_HTML = "-tohtml";
QString const REPORT = "-report";
QString const CHANGE_TARGET_DIRECTORY = "-directory";
QStringList helpStrings;

CliParser::CliParser(QObject *parent) :
    QObject(parent)
{
    helpStrings << "/help" << "-help" << "/h" << "-h" << "/?" ;
}

void CliParser::ParseCliArgs(int argc, char *argv[])
{
    // Start the application with default settings
    if (1 == argc)
    {
        return;
    }

    QString firstArg = (QString)argv[1];

    // Parse help
    if (helpStrings.contains(firstArg,Qt::CaseInsensitive))
    {
        emit(CliParser::EmitShowHelp());
        return;
    }

    // Parse html convertion
    else if (firstArg == TO_HTML)
    {
        if (argc < 3)
        {
            qDebug() << "missing file name!\n";
        }
        else
        {
            // **** note:
            // The current dir is not the exe dir but the debug/release dir
            // todo - need to set the working dir to the exe dir
            // For debug:
            // QDir currentDir = QDir::current();
            // QString qd = currentDir.absolutePath();
            // QStringList sl =currentDir.entryList();
            // ****

            QString const csvFileName = (QString)argv[2];
            QFile csvFile(csvFileName);

            if (csvFile.exists()) {
               emit(CliParser::EmitConvertCsvToHtml(csvFileName));
            }
            else {
                qDebug() << csvFileName << " - There is no such file!!!\n";
                EmitLogMsg(csvFileName +" - There is no such file!!!\n" );
            }
        }
        return;
    }

    // Parse report generator
    else if (firstArg == REPORT)
    {
        emit(CliParser::EmitGenerateFullReport());
        return;
    }


    // Parse change directory
    else if (firstArg == CHANGE_TARGET_DIRECTORY){

        if (argc < 3)
        {
            qDebug() << "Missing target directory!\n";
            qDebug() << "RR2 will run using default directory.\n";
        }
        else
        {
            QString const newTargetDirPath = (QString)argv[2];

            if (!QDir(newTargetDirPath).exists())
            {
                qDebug() << "The target directory does not exist!\n";
                qDebug() << "RR2 will run using default directory.\n";

            }
            else
            {
                emit(CliParser::EmitChangeTargetDirectory(newTargetDirPath));
            }

            return;
        }
    }


    // Parse added columns to RR2
    else
    {
        QStringList addedColumnsList;
        for (int i = 1; i <= argc; ++i)
        {
            addedColumnsList << (QString)argv[i];
        }
        emit(CliParser::EmitStartRR2withExtraColumns(addedColumnsList));
        return;
    }

}

Added RapidReporter2/cliparser.h.



























































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
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
#ifndef CLIPARSER_H
#define CLIPARSER_H

#include <QObject>
#include <QString>
#include <QStringList>
#include <QFile>
#include <QDir>

class CliParser : public QObject
{
    Q_OBJECT
public:
    explicit CliParser(QObject *parent = 0);
    void ParseCliArgs(int argc, char *argv[]);

signals:
    void EmitShowHelp();
    void EmitConvertCsvToHtml(QString csvFileName);
    void EmitLogMsg(QString logMsg);
    void EmitGenerateFullReport();
    void EmitChangeTargetDirectory(QString newTargetDirPath);
    void EmitStartRR2withExtraColumns(QStringList addedColumnsList);

public slots:

};

#endif // CLIPARSER_H

Added RapidReporter2/constants.cpp.











>
>
>
>
>
1
2
3
4
5
#include "constants.h"

Constants::Constants()
{
}

Added RapidReporter2/constants.h.



























>
>
>
>
>
>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8
9
10
11
12
13
#ifndef CONSTANTS_H
#define CONSTANTS_H

#include <QString>

class Constants
{
public:
    static const QString HTML_OPEN;
    Constants();
};

#endif // CONSTANTS_H

Added RapidReporter2/convert_csv2html.cpp.

















































































































































































































































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
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
// note: to add new line in qt write out << endl and not \n

#include "convert_csv2html.h"
#include <QString>
#include <QDir>
#include <QFile>
#include <QTextStream>

using namespace std;


Convert_Csv2Html::Convert_Csv2Html(QString csvFileName, bool relativePath)
{

    csvFile = csvFileName;
    QString workingDir = QDir::currentPath();
    htmlFile = csvFileName.replace(".csv", ".htm");
    htmlFile = relativePath ? workingDir + htmlFile : htmlFile;

    QString t = "th";
    QString tableLine = "";
    QString noteImage = "";
    QString noteRtf = "";

    bool exDrRetry = false;

    do
    {
        try
        {
            // delete old html file - if exist
            //QFile.remove(htmlFile); // to do: to verify what happend when the file is (not) exist

            // create instance to html file
            QFile htmlfile(htmlFile);
            htmlfile.open(QIODevice::WriteOnly | QIODevice::Text);
            QTextStream out(&htmlfile);

            // fill html meta-data
            out << longstrings.a_html_header;
            out << longstrings.c_javascript;
            out << longstrings.d_style;
            out << longstrings.g_html_body1;
            out << "<h1>Session Report | Powered by <a href=\"http://testing.gershon.info/reporter/\">Rapid Reporter</a></h1><br />";
            out << longstrings.i_toggle_auto;
            out << longstrings.j_html_bodytable1;

            // write csv file data into html file

            // create instace to csv file to read
            QFile csvfile("/home/hamad/lesson11.txt");
            QTextStream in(&csvfile);

            // read the csv file
            while(!in.atEnd())
            {
                QString line = in.readLine();  // Some files have empty lines in it, we don't want to process these lines.
                noteImage = ""; noteRtf = "";  // We clean this variables in order not to carry the last ones from the last iteration

                if ("" == line) continue;

                QStringList thisLine = line.split(",");

                // Dealing with screenshot attachments (if they exist).
                if (thisLine.length() > 4)
                {
                    QFile File (workingDir + thisLine[4]);
                    if (File.exists())
                    {
                        noteImage = "<a href=\"" + thisLine[4] + "\" target=\"_blank\"><img src=\"" + thisLine[4] + "\"></a>";
                    }
                    else noteImage = thisLine[4];
                } noteImage += "&nbsp;";

                // Dealing with the RTF note attachments (if they exist).
                if(thisLine.length() > 5)
                {
                    QFile File (workingDir + thisLine[5]);
                    if (File.exists())
                    {
                        noteRtf = "<a href=\"" + thisLine[5] + "\" target=\"_blank\">" + thisLine[5] + "</a>";
                    }
                    else noteRtf = thisLine[5];
                } noteRtf += "&nbsp;";

                // table line
                tableLine =
                    "<tr class=\""+thisLine[2]+"\"> <"+t+">" + thisLine[0] +
                    "</"+t+"><"+t+">"+ thisLine[1] +
                    "</"+t+"><"+t+" class=\"notetype\">"+ thisLine[2] +
                    "</"+t+"><"+t+">"+ thisLine[3].replace("\"","") +
                    "</"+t+"><"+t+">"+ noteImage +
                    "</"+t+"><"+t+">"+ noteRtf +
                    "</"+t+"></tr>\n";

                // wrinting into the html file
                out << tableLine;
                t = "td";
            }

            out << longstrings.m_html_bodytable2;
            out << longstrings.p_html_footer;

            // close csv file
            csvfile.close();

            // close html the file
            htmlfile.close();
        }

        catch(int x)
        {
            // QT not supported exceptions - http://stackoverflow.com/questions/5548951/why-doesnt-qt-use-exception-handling
            // to add failure to the looger
            // exDrRetry = logger answer (yes\no)...
        }
    } while (exDrRetry);

    // to add succesfull to the logger
}

Added RapidReporter2/convert_csv2html.h.





















































































































































































































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
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
#ifndef CONVERT_CSV2HTML_H
#define CONVERT_CSV2HTML_H

#include <QString>

class htmlstrings
{
public:
    QString html_title;

    //  the letter at the beginning of the var name is to hint about their order
    QString a_html_header;
    QString c_javascript;
    QString d_style;
    QString g_html_body1;
    QString i_toggle_auto;
    QString j_html_bodytable1;
    QString m_html_bodytable2;
    QString p_html_footer;

    htmlstrings()
    {
        html_title = "Session Report";

        //****************************************/
        a_html_header = "<html>\n<head>\n";
        a_html_header.append("<meta http-equiv=""Content-Type"" content=""text/html; charset=utf-8"">""");
        a_html_header.append("<title>" + html_title + "</title>");

        //****************************************/
        c_javascript = "<SCRIPT>\n";
        c_javascript.append("<!--\n");
        c_javascript.append("<!--");
        c_javascript.append("function showRow(obj)\n");
        c_javascript.append("{\n");
        c_javascript.append("    var allTrs = document.getElementsByTagName(""tr"");\n");
        c_javascript.append("    var display2 = ""none"";\n");
        c_javascript.append("    if(true == obj.checked)\n");
        c_javascript.append("    {\n");
        c_javascript.append("        display2 = """";\n");
        c_javascript.append("    }\n");
        c_javascript.append("    for(var i=0; i < allTrs.length ; i++)\n");
        c_javascript.append("    {\n");
        c_javascript.append("        if(""autogenerated"" == allTrs[i].className)\n");
        c_javascript.append("        {\n");
        c_javascript.append("            allTrs[i].style.display = display2;\n");
        c_javascript.append("        }\n");
        c_javascript.append("    }\n");
        c_javascript.append("}\n");
        c_javascript.append("//-->\n");
        c_javascript.append("</SCRIPT>\n");

        //****************************************/
        d_style = "<style>\n";
        d_style.append("H1 {text-align: center;}");
        d_style.append("table {margin-left: auto; margin-right: auto;}");
        d_style.append("table tr img {width: 250px; resize-scale: showall;}");
        d_style.append("table tr.Session {font-weight: bold; background: #ffff99;}");
        d_style.append("table tr.Bug {background: #FF7878;}");
        d_style.append("table tr.Test {background: #FFFFE0;}");
        d_style.append("table tr.Note {background: #00FFFF;}");
        d_style.append("table tr.Setup {background: #E3E3E3;}");
        d_style.append("table tr.autogenerated {color: #C0C0C0; font-style: italic;}");
        d_style.append("table tr.autogenerated img {width: 100px; resize-scale: showall;}");
        d_style.append("table td.notetype {font-weight: bold;}");
        d_style.append("</style>");
        d_style.append("<link rel=""stylesheet"" type=""text/css"" href=""style.css"" />\n");

        //****************************************/
        g_html_body1 = "</head>\n<body>\n<div id=""allbody"">\n";

        //****************************************/
        i_toggle_auto = "<input type=""checkbox"" checked=""true"" id=""1"" onClick=""showRow(this)""/> Show autogenerated rows\n";

        //****************************************/
        j_html_bodytable1 = "<div id=""aroundtable"">\n<table border=""1"">\n";

        //****************************************/
        m_html_bodytable2 = "</table>\n</div>";

        //****************************************/
        p_html_footer = "</div>\n</body>\n</html>";
    }
}; // long html strings class


class Convert_Csv2Html
{


public:
    Convert_Csv2Html(QString csvFileName, bool relativePath);


private:
    QString csvFile;
    QString htmlFile;


    // long html strings:
    htmlstrings longstrings;
};



#endif // CONVERT_CSV2HTML_H

Added RapidReporter2/csv2htmlconverter.cpp.







































































































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
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
#include "csv2htmlconverter.h"
#include <QDebug>
#include <QRegExp>
#include "QString"

class QFile;
class QRegExp;
class QTextStream;

Csv2HtmlConverter::Csv2HtmlConverter(QString csvFilePath, QObject *parent) :
    QObject(parent)
{
    csvFile = new QFile(csvFilePath);
    QRegExp regexp("csv");
    QString htmlFileName = csvFile->fileName().replace(regexp,"htm");
    htmlFile = new QFile(htmlFileName);
}


void Csv2HtmlConverter::Convert(QString csvFileName)
{
    qDebug() <<"Converting: " << csvFileName <<  " to html\n";
}


void Csv2HtmlConverter::writeHtmlTag(Flags::HtmlTags tagName,
                                            Flags::OpenCloseTag openCloseTag)
{
    if (!htmlFile->open(QIODevice::WriteOnly | QIODevice::Text
                       | QIODevice::Append))
        return;

    QTextStream out(&(*htmlFile));
    QString closingTag = (openCloseTag == Flags::OPEN) ? "" : "/";

    //out <<startDate << " " <<  msg << endl ;

    switch (tagName) {
    case Flags::html:
        out << "<html" + closingTag + ">";

        break;
    default:
        break;
    }

    htmlFile->flush();
    htmlFile->close();
}


Added RapidReporter2/csv2htmlconverter.h.

























































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
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
#ifndef CSV2HTMLCONVERTER_H
#define CSV2HTMLCONVERTER_H

#include <QObject>
#include <QString>
#include <QFile>
#include "Flags.h"

class Csv2HtmlConverter : public QObject
{
    Q_OBJECT
public:
    QFile * csvFile;
    QFile * htmlFile;



    explicit Csv2HtmlConverter(QString csvFilePath, QObject *parent = 0);
    void writeHtmlTag(Flags::HtmlTags tagName, Flags::OpenCloseTag openCloseTag = Flags::OPEN);
    void static StartConvert();

signals:

public slots:
    void Convert(QString csvFileName);
};

#endif // CSV2HTMLCONVERTER_H

Added RapidReporter2/helpviewer.cpp.





































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include "helpviewer.h"
#include <QDebug>

HelpViewer::HelpViewer(QObject *parent) :
    QObject(parent)
{

}


void HelpViewer::ShowHelp()
{
//    QWidget helpWindow;
//    helpWindow.show();

    qDebug() << "I'm showing some help here!!\n";

}

Added RapidReporter2/helpviewer.h.







































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#ifndef HELPVIEWER_H
#define HELPVIEWER_H

#include <QObject>

class HelpViewer : public QObject
{
    Q_OBJECT
public:
    explicit HelpViewer(QObject *parent = 0);

signals:

public slots:
    void ShowHelp();

};

#endif // HELPVIEWER_H

Added RapidReporter2/htmlstring.cpp.















>
>
>
>
>
>
>
1
2
3
4
5
6
7
#include "htmlstring.h"

HtmlString::HtmlString(QObject *parent) :
    QObject(parent)
{

}

Added RapidReporter2/htmlstring.h.





































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#ifndef HTMLSTRING_H
#define HTMLSTRING_H

#include <QObject>

class HtmlString : public QObject
{
    Q_OBJECT
public:
    explicit HtmlString(QObject *parent = 0);

signals:

public slots:

};

#endif // HTMLSTRING_H

Added RapidReporter2/logger.cpp.



















































































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
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
#include "logger.h"

const QString Logger::LOG_FILE_NAME = QString("-_-");

Logger::Logger(QObject *parent) :
    QObject(parent)
{
    startDate = dateTimeGen.currentDateTime().toString();


   msgType = new QString [5];
   //msgType[f::INFO_MSG] = "[Error]";
   //msgType[MyEnum::INFO_MSG] = "[Info]";

}

void Logger::Record(QString msg)
{
    QFile logFile(LOG_FILE_NAME);

    if (!logFile.open(QIODevice::WriteOnly | QIODevice::Text
                       | QIODevice::Append))
        return;

    QTextStream out(&logFile);

    out <<startDate << " " <<  msg << endl ;
}


//void Logger::Record(QString msg, MyEnum myEnum)
//{
//    QFile logFile(LOG_FILE_NAME);

//    if (!logFile.open(QIODevice::WriteOnly | QIODevice::Text
//                       | QIODevice::Append))
//        return;

//    QTextStream out(&logFile);
//    out <<startDate << " " <<  msg << endl ;
//}

Added RapidReporter2/logger.h.













































































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
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
#ifndef LOGGER_H
#define LOGGER_H

#include <QObject>
#include <QString>
#include <QDir>
#include <QFile>
#include <QTextStream>
#include <QDateTime>
#include <string>

using namespace std;

class Logger : public QObject
{
    Q_OBJECT
    Q_ENUMS(f)
    static const QString LOG_FILE_NAME;
    QString startDate;
    QString currentDate;
    QDateTime dateTimeGen;
    QString * msgType;

public:
    explicit Logger(QObject *parent = 0);
    //void Record(QString msg, MyEnum myEnum);
    void Record(QString msg);

    enum f {ERR_MSG,INFO_MSG,Unknown};


signals:

public slots:

};

#endif // LOGGER_H

Added RapidReporter2/main.cpp.



























































































































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
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
#include <QApplication>
#include <QDebug>
#include <iostream>
#include <QString>
#include <logger.h>
#include <qlogging.h>
#include <QPixmap>
#include <QtWidgets>

#include "mainwindow.h"
#include "applauncher.h"
#include "uitempconnector.h"
#include "screenshot.h"
#include <QBitmap>
#include <QPixmap>
#include <QWidget>
#include "csv2htmlconverter.h"
#include "Flags.h"
#include "convert_csv2html.h"

//using namespace std;

class QProcess;


int main(int argc, char *argv[])
{
    //for later use
//    QString absoluteFilePath = QDir::currentPath();
//    QString exeFilePath = qApp->applicationDirPath();


//    QString static const INFO_MSG = " [INFO] ";
//    QString static const ERR_MSG = " [ERROR] ";

    //AppLauncher appLauncher(argc,argv);

    ///todo - add identation func
    ///
    ///

    QApplication app(argc, argv);

    QString path("C:\\Users\\azadok\\Google Drive\\QT_Apps\\build-RR2-Desktop_Qt_5_1_1_MinGW_32bit-Debug\\20131110_132124.csv");
            //;
    Convert_Csv2Html dd(path,false);

    //    QString wd = qApp->applicationDirPath();

//     Csv2HtmlConverter converter("20131110_132124.csv");
//     converter.writeHtmlTag(Flags::html,Flags::OPEN);

//    Screenshot s;
//    s.ShootScreenSlot();

    //UiTempConnector uiTempConnector;

    return app.exec();
}


Added RapidReporter2/mainwindow.cpp.





























>
>
>
>
>
>
>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include "mainwindow.h"
#include "ui_mainwindow.h"

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);
}

MainWindow::~MainWindow()
{
    delete ui;
}

Added RapidReporter2/mainwindow.h.













































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    explicit MainWindow(QWidget *parent = 0);
    ~MainWindow();

private:
    Ui::MainWindow *ui;
};

#endif // MAINWINDOW_H

Added RapidReporter2/mainwindow.ui.

















































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<ui version="4.0">
 <class>MainWindow</class>
 <widget class="QMainWindow" name="MainWindow" >
  <property name="geometry" >
   <rect>
    <x>0</x>
    <y>0</y>
    <width>400</width>
    <height>300</height>
   </rect>
  </property>
  <property name="windowTitle" >
   <string>MainWindow</string>
  </property>
  <widget class="QMenuBar" name="menuBar" />
  <widget class="QToolBar" name="mainToolBar" />
  <widget class="QWidget" name="centralWidget" />
  <widget class="QStatusBar" name="statusBar" />
 </widget>
 <layoutDefault spacing="6" margin="11" />
 <pixmapfunction></pixmapfunction>
 <resources/>
 <connections/>
</ui>

Added RapidReporter2/note.cpp.















































































































































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
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
#include "note.h"

Note::Note(QObject *parent) :
    QObject(parent)
{
   // currentUserType = 0;  // first type;  probably it's insert here by mistake
}

// User Types

void Note::SetUserTypes(QString types[], int size)
{
    UserTypesCount = size;
    UserTypes = new QString[UserTypesCount];

    for (int i = 0; i < UserTypesCount; i++)
        UserTypes[i] = types[i];
}

void Note::AddUserTypes(QString types[], int size)
{
    QString *tmp = new QString[UserTypesCount + size];
    for (int i = 0; i < UserTypesCount; i++)
        tmp[i] = UserTypes[i];
    for (int i = 0; i < size; i++)
        tmp[i + UserTypesCount] = types[i];
    UserTypesCount += size;
    delete[] tmp;
}

void Note::AddUserType(QString type)
{
    QString *tmp = new QString[UserTypesCount + 1];
    for (int i = 0; i < UserTypesCount; i++)
        tmp[i] = UserTypes[i];
    tmp[UserTypesCount] = type;
    UserTypesCount++;
    delete[] tmp;
}

// Extra Columns Section

void Note::SetExtraColumns(QString columns[], int size)
{
    ExtraColumnsCount = size;
    ExtraColumns = new QString[ExtraColumnsCount];

    for (int i = 0; i < ExtraColumnsCount; i++)
        ExtraColumns[i] = columns[i];
}

void Note::AddExtraColumns(QString columns[], int size)
{
    QString *tmp = new QString[ExtraColumnsCount + size];
    for (int i = 0; i < ExtraColumnsCount; i++)
        tmp[i] = ExtraColumns[i];
    for (int i = 0; i < size; i++)
        tmp[i + ExtraColumnsCount] = columns[i];
    ExtraColumnsCount += size;
    delete[] tmp;
}

void Note::AddExtraColumn(QString column)
{
    QString *tmp = new QString[ExtraColumnsCount + 1];
    for (int i = 0; i < ExtraColumnsCount; i++)
        tmp[i] = ExtraColumns[i];
    tmp[ExtraColumnsCount] = column;
    ExtraColumnsCount++;
    delete[] tmp;
}

Added RapidReporter2/note.h.



















































































































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
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
#ifndef NOTE_H
#define NOTE_H

#include <QObject>
#include <QString>

class Note : public QObject
{
    Q_OBJECT
public:
    explicit Note(QObject *parent = 0);

    // User Types Methods
    void SetUserTypes (QString types[], int size);
    void AddUserTypes (QString types[], int size);
    void AddUserType  (QString type);
    int getUserTypesCount() { return UserTypesCount; }

    // Extra Columns Methods
    void SetExtraColumns (QString columns[], int size);
    void AddExtraColumns (QString columns[], int size);
    void AddExtraColumn  (QString column);
    int getExtraColumnsCount() { return ExtraColumnsCount; }

    // Sets for defualt columns
    void setReporter (QString reporter) { Reporter = reporter;  }
    void setCharter  (QString charter)  { Charter = charter;    }
    void setContent  (QString content)  { Content = content;    }
    void setRTFnoteLink    (QString RTFlink)        { RTFnoteLink = RTFlink; }
    void setScreenshotLink (QString scrShootLink)   { ScreenshotLink = scrShootLink; }

    // Gets for defualt columns
    QString getReporter ()		 { return Reporter;      }
    QString getCharter  ()		 { return Charter;       }
    QString getContent  ()		 { return Content;       }
    QString getRTFnoteLink    () { return RTFnoteLink;   }
    QString getScreenshotLink () { return ScreenshotLink;}

signals:

public slots:

private:
    // Default columns
    QString Reporter, Charter, Content, RTFnoteLink, ScreenshotLink;

    // Extra columns (can added via the plugins
    QString *ExtraColumns;
    int ExtraColumnsCount;
    // need to add current variable - to know where we are now

    // User types can change via CMD
    QString *UserTypes;
    int UserTypesCount;
};

#endif // NOTE_H

Added RapidReporter2/screenshot.cpp.







































































































































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
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
#include "screenshot.h"
#include <QApplication>
#include <QtGui>

class QDateTime;
class QRegExp;


Screenshot::Screenshot(QObject *parent) :
    QObject(parent)
{

}

Screenshot::Screenshot(QString screenshotTargetPath, QObject *parent):
    QObject(parent),
    screenshotPath(screenshotTargetPath)
{

}


// Take a screenshot and emit a SIGNAL with the screenshot file absolute path
void Screenshot::ShootScreenSlot()
{    
    // Each QString is seperated to make debug easier
    QString currentWorkingDirectory = QDir::currentPath();
    QString screenshotFileName = ShootScreen();

    // Concatenate paths for cross OS
    QString fullPath = QDir::cleanPath(currentWorkingDirectory
                                       + QDir::separator()
                                       + screenshotFileName);

    // notify registered classes
    emit ScreenshotCaptured(fullPath);
}

QString Screenshot::ShootScreen()
{
    // Generage unique file name
    QString fileName = "RR2_"
            + QDateTime::currentDateTime().toString(Qt::SystemLocaleShortDate)
            + ".png";

    // Remove chars which disturb the save proccess
    QRegExp regexp("[' ' | '\' | '/' | ':']");
    fileName.replace(regexp,"_");

    // Take the screenshot and save it to the file
    screenshotPixmap = new QPixmap();
    QScreen *screen = QGuiApplication::primaryScreen();
    if (screen)
        *screenshotPixmap = screen->grabWindow(0);
    screenshotPixmap->save(fileName);
    screenshotPixmap->~QPixmap();

    // Return the filename for later use
    return fileName;
}

void Screenshot::setScreenshotPath(QString targetPath)
{
    screenshotPath = targetPath;
}


Added RapidReporter2/screenshot.h.









































































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
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
#ifndef SCREENSHOT_H
#define SCREENSHOT_H

#include <QWidget>
#include <QPixmap>
#include <QString>
#include <QObject>

class Screenshot : public QObject
{
    Q_OBJECT

public:

    explicit Screenshot(QObject *parent = 0);
    Screenshot(QString screenshotTargetPath, QObject *parent = 0);

    QString ShootScreen();
    void setScreenshotPath(QString targetPath);

    signals:

        void ScreenshotCaptured(QString screenshotPath);

    public slots:


        void ShootScreenSlot();

    private:

        QString screenshotPath;
        QPixmap * screenshotPixmap;
};

#endif // SCREENSHOT_H

Added RapidReporter2/session.cpp.

























































































































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
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
#include "session.h"
#include <QDebug>

Session::Session(QObject *parent) :
    QObject(parent)
{
    currentUserType = 0; // first user type
}


void Session::StartSession()
{
    qDebug() << "StartSession was called!\n";
}


void Session::CloseSession()
{
    qDebug() << "CloseSession was called!\n";
}

void Session::StartSessionSlot()
{
    StartSession();
}

void Session::CloseSessionSlot()
{
    CloseSession();
}

QString Session::getNextUserType(QString userTypes[], int count)
{
    QString ret;
    int index = (currentUserType + 1) % count;
    ret = userTypes[index];
    currentUserType = index;

    return ret;
}

QString Session::getPrevUserType(QString userTypes[], int count)
{
    QString ret;
    currentUserType--;
    if (currentUserType < 0) currentUserType = count - 1;
    ret = userTypes[currentUserType];
    return ret;
}

QString Session::getSpecificUserType(QString userTypes[], int &index, int count)
{
    // need to check this
    if (index < 0) throw "Index cannnot be smaller then zero";
    if (index >= count) throw "Index cannot be equal or high from user types count";

    currentUserType = index;
    return userTypes[currentUserType];
}

Added RapidReporter2/session.h.





















































































































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
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
#ifndef SESSION_H
#define SESSION_H

#include <QObject>
#include <QTimer>
#include <QDateTime>
#include <QString>
#include <QStringList>
#include "note.h"

class Session : public QObject
{
    Q_OBJECT

    // util members
    QString startTime;
    QDateTime dateTimeGenerator;
    QTimer sessionTimer;

    // Assaf - Remove seesion members. we have special class for BE - note.h,cpp.
    // Session members
    //QString charter;
    //QString tester;
    //QString sessionNote;
    //QStringList noteTypes;
    //enum sessionStartingStage { tester, charter, notes };

    // Assaf - add: to know where we are in the arrays
    int currentUserType;


    // file hendling members
    QString workingDir;
    QString sessionFile;
    QString sessionFileFull;


public:
    explicit Session(QObject *parent = 0);
    void StartSession();
    void CloseSession();
    void SaveToSessionNotes(QString note);
    void UpdateNotes(int type, QString note, QString screenshot, QString RTFNote);
    void UpdateNotes(QString type, QString note, QString screenshot = "", QString RTFNote = "");

    QString getNextUserType(QString userTypes[], int count);
    QString getPrevUserType(QString userTypes[], int count);
    QString getSpecificUserType (QString userTypes[], int &index,int count);

signals:

public slots:
    void StartSessionSlot();
    void CloseSessionSlot();

};

#endif // SESSION_H

Added RapidReporter2/test.cpp.













>
>
>
>
>
>
1
2
3
4
5
6
#include "test.h"

test::test(QObject *parent) :
    QObject(parent)
{
}

Added RapidReporter2/test.h.





































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#ifndef TEST_H
#define TEST_H

#include <QObject>

class test : public QObject
{
    Q_OBJECT
public:
    explicit test(QObject *parent = 0);

signals:

public slots:

};

#endif // TEST_H

Added RapidReporter2/ui_mainwindow.h.











































































































































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
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
/********************************************************************************
** Form generated from reading UI file 'mainwindow.ui'
**
** Created by: Qt User Interface Compiler version 5.1.1
**
** WARNING! All changes made in this file will be lost when recompiling UI file!
********************************************************************************/

#ifndef UI_MAINWINDOW_H
#define UI_MAINWINDOW_H

#include <QtCore/QVariant>
#include <QtWidgets/QAction>
#include <QtWidgets/QApplication>
#include <QtWidgets/QButtonGroup>
#include <QtWidgets/QHeaderView>
#include <QtWidgets/QMainWindow>
#include <QtWidgets/QMenuBar>
#include <QtWidgets/QStatusBar>
#include <QtWidgets/QToolBar>
#include <QtWidgets/QWidget>

QT_BEGIN_NAMESPACE

class Ui_MainWindow
{
public:
    QMenuBar *menuBar;
    QToolBar *mainToolBar;
    QWidget *centralWidget;
    QStatusBar *statusBar;

    void setupUi(QMainWindow *MainWindow)
    {
        if (MainWindow->objectName().isEmpty())
            MainWindow->setObjectName(QStringLiteral("MainWindow"));
        MainWindow->resize(400, 300);
        menuBar = new QMenuBar(MainWindow);
        menuBar->setObjectName(QStringLiteral("menuBar"));
        MainWindow->setMenuBar(menuBar);
        mainToolBar = new QToolBar(MainWindow);
        mainToolBar->setObjectName(QStringLiteral("mainToolBar"));
        MainWindow->addToolBar(mainToolBar);
        centralWidget = new QWidget(MainWindow);
        centralWidget->setObjectName(QStringLiteral("centralWidget"));
        MainWindow->setCentralWidget(centralWidget);
        statusBar = new QStatusBar(MainWindow);
        statusBar->setObjectName(QStringLiteral("statusBar"));
        MainWindow->setStatusBar(statusBar);

        retranslateUi(MainWindow);

        QMetaObject::connectSlotsByName(MainWindow);
    } // setupUi

    void retranslateUi(QMainWindow *MainWindow)
    {
        MainWindow->setWindowTitle(QApplication::translate("MainWindow", "MainWindow", 0));
    } // retranslateUi

};

namespace Ui {
    class MainWindow: public Ui_MainWindow {};
} // namespace Ui

QT_END_NAMESPACE

#endif // UI_MAINWINDOW_H

Added RapidReporter2/uiemulator.cpp.



































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include "uiemulator.h"

UiEmulator::UiEmulator(QObject *parent) :
    QObject(parent)
{
}


void UiEmulator::UiStartSession()
{
    EmitUiStartSession();
}

void UiEmulator::UiCloseSession()
{
    EmitUiCloseSession();
}

Added RapidReporter2/uiemulator.h.















































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#ifndef UIEMULATOR_H
#define UIEMULATOR_H

#include <QObject>

class UiEmulator : public QObject
{
    Q_OBJECT
public:
    explicit UiEmulator(QObject *parent = 0);

    void UiStartSession();
    void UiCloseSession();

signals:
    void EmitUiStartSession();
    void EmitUiCloseSession();

public slots:

};

#endif // UIEMULATOR_H

Added RapidReporter2/uitempconnector.cpp.

























































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
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
#include "uitempconnector.h"
#include "uiemulator.h"
#include "session.h"
#include "screenshot.h"
#include <QDir>
#include <QString>


UiTempConnector::UiTempConnector(QObject *parent) :
    QObject(parent)
{

    Session session;
    UiEmulator uiEmulator;
    QString const currentDirPath = QDir::current().absolutePath();
    //Screenshot screenshot(currentDirPath);
//    Screenshot screenshot;


//    connect(&uiEmulator,SIGNAL(EmitUiStartSession()),&screenshot,SLOT(ShootScreenSlot()));
//    connect(&screenshot,SIGNAL(ScreenshotCaptured()),&session,SLOT(ScreenshotCupturedSlot(QString)));
//    connect(&uiEmulator,SIGNAL(EmitUiStartSession()),&session,SLOT(StartSessionSlot()));
//    connect(&uiEmulator,SIGNAL(EmitUiCloseSession()),&session,SLOT(CloseSessionSlot()));


//    uiEmulator.UiStartSession();
//    uiEmulator.UiCloseSession();
}

Added RapidReporter2/uitempconnector.h.





































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#ifndef UITEMPCONNECTOR_H
#define UITEMPCONNECTOR_H

#include <QObject>

class UiTempConnector : public QObject
{
    Q_OBJECT
public:
    explicit UiTempConnector(QObject *parent = 0);

signals:

public slots:

};

#endif // UITEMPCONNECTOR_H