initial commit

Ferenc Szontágh

2024-02-03 875477e097c353a368b5fbf5b5f048c956fc4743

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
#ifndef __SD_GUI_QUEUE_MANAGER 
#define __SD_GUI_QUEUE_MANAGER 
 
#include <map> 
#include <chrono> 
#include <nlohmann/json.hpp> 
 
#include "utils.hpp" 
 
#include <wx/event.h> 
#include <wx/window.h> 
 
namespace QM 
{ 
    enum QueueStatus 
    { 
        PENDING, 
        RUNNING, 
        PAUSED, 
        FAILED 
    }; 
    inline const char *QueueStatus_str[] = { 
        "pending", 
        "running", 
        "paused", 
        "failed"}; 
 
    enum QueueEvents 
    { 
        ITEM_DELETED, 
        ITEM_ADDED, 
        ITEM_STATUS_CHANGED, 
        ITEM_UPDATED 
    }; 
    struct QueueItem 
    { 
        QueueItem() = default; 
        QueueItem(const QueueItem &other) 
            : id(other.id), created_at(other.created_at), updated_at(other.updated_at), 
              finished_at(other.finished_at), params(other.params), status(other.status) {} 
 
        QueueItem &operator=(const QueueItem &other) 
        { 
            if (this != &other) 
            { 
                id = other.id; 
                created_at = other.created_at; 
                updated_at = other.updated_at; 
                finished_at = other.finished_at; 
                // Másolatot készítünk a params referenciáról 
                // Ha a params referenciához tartozó SDParams objektum módosulna, 
                // akkor ebben az esetben másolatban marad az eredeti QueueItem-ben 
                params = other.params; 
                status = other.status; 
            } 
            return *this; 
        } 
        int id, created_at, updated_at, finished_at; 
        sd_gui_utils::SDParams params; 
        QM::QueueStatus status = QM::QueueStatus::PENDING; 
    }; 
 
    inline void to_json(nlohmann::json &j, const QueueItem &p) 
    { 
        j = nlohmann::json{ 
            {"id", p.id}, 
            {"created_at", p.created_at}, 
            {"updated_at", p.updated_at}, 
            {"finished_at", p.finished_at}, 
            //   {"params", p.params}, 
            {"status", (int)p.status}}; 
    } 
 
    inline void from_json(const nlohmann::json &j, QueueItem &p) 
    { 
        j.at("id").get_to(p.id); 
        j.at("created_at").get_to(p.created_at); 
        j.at("updated_at").get_to(p.updated_at); 
        j.at("finished_at").get_to(p.finished_at); 
        //  j.at("params").get_to(p.params); 
        p.status = j.at("status").get<QM::QueueStatus>(); 
    } 
 
    class QueueManager 
    { 
    public: 
        QueueManager(wxEvtHandler *eventHandler, std::string jobsdir); 
        int AddItem(QM::QueueItem item); 
        int AddItem(sd_gui_utils::SDParams *params); 
        int AddItem(sd_gui_utils::SDParams params); 
        QM::QueueItem GetItem(int id); 
        QM::QueueItem GetItem(QM::QueueItem item); 
        const std::map<int, QM::QueueItem> getList(); 
        int Duplicate(QM::QueueItem item); 
        int Duplicate(int id); 
        void SetStatus(QM::QueueStatus status, int id); 
        void PauseAll(); 
        void SendEventToMainWindow(QM::QueueEvents eventType, QM::QueueItem item = QM::QueueItem()); 
        void OnThreadMessage(wxThreadEvent &e); 
 
    private: 
        int GetCurrentUnixTimestamp(); 
        std::string jobsDir; 
        // thread events handler, toupdate main window data table 
        void onItemAdded(QM::QueueItem item); 
        void LodJobsFromFile(); 
        void SaveJobsToFile(); 
 
        wxEvtHandler *eventHandler; 
        wxWindow *parent; 
        std::map<int, QM::QueueItem> QueueList; 
    }; 
 
}; 
 
#endif