onbcode/meos-2024
1
0
Fork 0
Code Issues 1 Pull Requests Wiki Activity
68721b1833
meos-2024/code/qf_editor.cpp
Erik Melin 403373fcc6 MeOS V4.0, RC1
2024-04-07 08:37:06 +02:00

797 lines
25 KiB
C++
Raw Blame History

/************************************************************************
MeOS - Orienteering Software
Copyright (C) 2009-2024 Melin Software HB
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
Melin Software HB - software@melin.nu - www.melin.nu
Eksoppsvägen 16, SE-75646 UPPSALA, Sweden
************************************************************************/
#include "stdafx.h"
#include "gdioutput.h"
#include "qf_editor.h"
#include "qualification_final.h"
#include "localizer.h"
#include "oClass.h"
#include "meosexception.h"
#include "TabBase.h"
QFEditor::QFEditor() {
emptyScheme();
}
QFEditor::~QFEditor() = default;
void QFEditor::emptyScheme() {
currentQF = make_shared<QualificationFinal>(0, 0);
data.clear();
data.resize(2, { 1, {} });
data[0].second.emplace_back(lang.tl("Kval"));
data[1].second.emplace_back(lang.tl("Final"));
numLevels = 2;
makeDirty(DirtyFlag::ClearDirty, DirtyFlag::ClearDirty);
}
void QFEditor::load(const shared_ptr<QualificationFinal>& qf) {
currentQF = make_shared<QualificationFinal>(*qf);
data.clear();
data.resize(currentQF->getNumLevels());
for (int j = 0; j < currentQF->getNumClasses(); j++) {
int level = currentQF->getLevel(j+1);
data.at(level).second.push_back(currentQF->getInstance(j));
data[level].first++;
}
numLevels = data.size();
}
void QFEditor::makeQF() {
vector<QFClass> linear;
for (int j = 0; j < numLevels; j++) {
for (int i = 0; i < data[j].first; i++) {
linear.push_back(data[j].second[i]);
linear.back().level = j;
}
}
currentQF->setClasses(linear);
}
void QFEditor::show(gdioutput& gdi) {
gdi.clearPage(false);
gdi.pushX();
gdi.fillRight();
gdi.addButton("CloseEditor", "Stäng").setHandler(this);
gdi.addButton("New", "Nytt").setHandler(this);
gdi.addButton("Load", "Ladda").setHandler(this);
gdi.addButton("Save", "Exportera").setHandler(this);
if (cls)
gdi.addButton("Use", L"Use in X#" + cls->getName()).setHandler(this);
gdi.popX();
updateActions(gdi);
gdi.fillDown();
gdi.dropLine(3);
gdi.addSelection("Levels", 100, 100, nullptr, L"Antal nivåer:").setHandler(this);
vector<pair<wstring, size_t>> levels;
for (int i = 2; i <= 10; i++)
levels.emplace_back(itow(i), i);
gdi.setItems("Levels", levels);
gdi.selectItemByData("Levels", numLevels);
gdi.autoGrow("Levels");
gdi.setRestorePoint("LevelView");
showLevels(gdi);
gdi.refresh();
}
void QFEditor::showLevels(gdioutput& gdi) const {
for (int level = 0; level < numLevels; level++) {
showLevel(gdi, level, data[level].first, data[level].second);
}
}
void QFEditor::showLevel(gdioutput& gdi, int level, size_t numRaces, const vector<QFClass>& classes) const {
const int cxBase = gdi.getCX();
int cy = gdi.getCY();
gdi.setRestorePoint("Level" + itos(level));
gdi.fillDown();
RECT rcR = { cxBase, cy, cxBase + gdi.scaleLength(400), cy + gdi.scaleLength(2) };
gdi.addRectangle(rcR, colorDarkBlue);
gdi.addString("", fontMediumPlus, "Nivå X#" + itos(level + 1));
string cKey = "NumCls" + itos(level);
gdi.addSelection(cKey, 100, 100, nullptr, L"Antal klasser:").setHandler(this).setExtra(level);
vector<pair<wstring, size_t>> levels;
for (int i = 1; i <= 32; i++)
levels.emplace_back(itow(i), i);
gdi.setItems(cKey, levels);
gdi.autoGrow(cKey.c_str());
gdi.selectItemByData(cKey, numRaces);
bool rankBased = classes.size() > 0 && classes[0].rankLevel;
if (level > 0) {
gdi.addCheckbox("Rank" + itos(level), "Klass efter ranking", nullptr, rankBased,
"Använd ranking istället för placering i kval för att placera kvalificerade löpare i klasser").setExtra(level).setHandler(this);
}
// auto rc = gdi.getDimensionSince("Level" + itos(level));
gdi.setCX(gdi.scaleLength(230));
const int cxCls = gdi.getCX();
int cx = cxCls;
gdi.fillDown();
cy += gdi.scaleLength(10);
const int w = gdi.scaleLength(24 * 10);
int ww, hh;
gdi.getTargetDimension(ww, hh);
ww = max(ww, gdi.scaleLength(500));
for (int i = 0; i < numRaces; i++) {
gdi.setCY(cy);
gdi.setCX(cx);
string CK = getKeyTag(level, i);
auto& ref = gdi.addInput("Name" + CK, classes[i].name.empty() ? wstring(L"???") : classes[i].name, 24, nullptr,
L"Klass X (namnsuffix):#" + itow(i + 1));
ref.setHandler(this).setExtra(code(level, i));
if (level > 0) {
gdi.addString("QInfo" + CK, 0, classes[i].getQualInfo());
gdi.addButton("Edit", "Redigera...").setHandler(this).setExtra(code(level, i));
}
cx += w;
if (cx + w > ww) {
cx = cxCls;
gdi.dropLine(2);
cy = gdi.getCY();
}
}
gdi.dropLine(3);
gdi.setCX(cxBase);
}
void QFEditor::loadQualificationView(gdioutput& gdi, const QFClass& cls, int cCode) {
gdi.clearPage(false);
gdi.fillDown();
gdi.addString("", boldLarge, L"Kvalificeringsregler för X#" + cls.name);
gdi.pushY();
gdi.setRestorePoint("X");
gdi.addListBox("Rules", 120, 150, nullptr, L"Regler").setExtra(cCode).setHandler(this);
gdi.setItems("Rules", getRules(cls));
gdi.addButton("RemoveRule", "Ta bort").setHandler(this).setExtra(cCode);
gdi.disableInput("RemoveRule");
gdi.popY();
gdi.dropLine();
auto rc = gdi.getDimensionSince("X");
gdi.setCX(rc.right + gdi.scaleLength(10));
rcRuleForm.left = gdi.getCX();
rcRuleForm.top = gdi.getCY();
gdi.dropLine(0.8);
gdi.setCX(rcRuleForm.left + gdi.scaleLength(10));
gdi.pushX();
gdi.fillDown();
gdi.addString("", fontMediumPlus, "Lägg till regler");
gdi.dropLine();
gdi.addSelection("RuleType", 200, 100).setHandler(this).setExtra(cCode);
vector<pair<wstring, size_t>> ruleType;
for (auto* type : { "Klass / placering", "Bästa tid", "Övriga okvalificerade"}) {
ruleType.emplace_back(lang.tl(type), ruleType.size());
}
gdi.setItems("RuleType", ruleType);
gdi.selectFirstItem("RuleType");
gdi.setRestorePoint("RuleType");
//other.emplace_back(lang.tl("Inga"), 0);
//gdi.addString("", gdiFonts::boldText, "Klass / placering");
addRuleClassPlace(cCode, gdi);
/*gdi.dropLine(2.5);
rcE.bottom = gdi.getCY();
rcE.right = gdi.getWidth();
gdi.addRectangle(rcE, GDICOLOR::colorLightCyan);
gdi.dropLine();
gdi.setCX(rcE.right - gdi.scaleLength(75));
gdi.setCY(gdi.getHeight());
gdi.addButton("Close", "Stäng").setHandler(this);
gdi.refresh();*/
}
void QFEditor::addRuleClassPlace(int cCode, gdioutput& gdi) {
pair<int, int> levelClass = decode(cCode);
gdi.addSelection("Classes", 150, 200, nullptr, L"Kvalklass:");
if (levelClass.first > 0 && levelClass.first < data.size()) {
vector<pair<wstring, size_t>> prevLevel;
for (int i = levelClass.first - 1; i >= 0; i--) {
auto& dLine = data[i];
for (int j = 0; j < dLine.first; j++)
prevLevel.emplace_back(dLine.second[j].name, code(i, j));
}
gdi.setItems("Classes", prevLevel);
gdi.autoGrow("Classes");
gdi.selectFirstItem("Classes");
}
gdi.fillRight();
gdi.addInput("Places", L"", 10, nullptr, L"Placeringar");
gdi.fillDown();
gdi.dropLine(0.9);
gdi.addButton("AddClassPlace", "Lägg till").setHandler(this).setExtra(cCode);
gdi.popX();
endAddRuleForm(gdi);
}
void QFEditor::addRuleTime(int cCode, gdioutput& gdi) {
gdi.dropLine();
gdi.addString("", gdiFonts::boldText, "Bästa tid");
gdi.addButton("AddBestTime", "Lägg till").setHandler(this).setExtra(cCode);
endAddRuleForm(gdi);
}
void QFEditor::addRuleOther(int cCode, gdioutput &gdi) {
// gdi.addString("", gdiFonts::boldText, "Övriga okvalificerade:");
gdi.pushX();
gdi.fillRight();
gdi.addSelection("Other", 100, 200).setExtra(cCode).setHandler(this);
vector<pair<wstring, size_t>> other;
other.emplace_back(lang.tl("Inga"), 0);
other.emplace_back(lang.tl("Alla"), 1);
other.emplace_back(lang.tl("N bästa"), 2);
other.emplace_back(lang.tl("Tidskval"), 3);
gdi.setItems("Other", other);
gdi.autoGrow("Other");
gdi.addButton("AddOther", "Lägg till").setHandler(this).setExtra(cCode);
gdi.popX();
gdi.dropLine(3);
QFClass& cls = getQFClass(cCode);
int toSel = 1;
if (cls.extraQualification == QFClass::ExtraQualType::All)
toSel = 1;
else if (cls.extraQualification == QFClass::ExtraQualType::NBest)
toSel = 2;
else if (cls.extraQualification == QFClass::ExtraQualType::TimeLimit)
toSel = 3;
gdi.selectItemByData("Other", toSel);
extraSelPosX = gdi.getCX();
extraSelPosY = gdi.getCY();
updateExtraField(gdi, cls, cCode);
gdi.setCY(extraSelPosY);
gdi.dropLine(3);
endAddRuleForm(gdi);
}
void QFEditor::endAddRuleForm(gdioutput &gdi) {
gdi.dropLine(2.5);
rcRuleForm.bottom = gdi.getCY();
rcRuleForm.right = gdi.getWidth();
gdi.addRectangle(rcRuleForm, GDICOLOR::colorLightCyan);
gdi.dropLine();
gdi.setCX(rcRuleForm.right - gdi.scaleLength(75));
gdi.setCY(gdi.getHeight());
gdi.addButton("Close", "Stäng").setHandler(this);
gdi.refresh();
}
void QFEditor::updateExtraField(gdioutput& gdi, const QFClass& cls, int code) {
int type = gdi.getSelectedItem("Other").first;
if (type == 2) {
wstring def = cls.extraQualification == QFClass::ExtraQualType::NBest ? itow(cls.extraQualData) : L"0";
if (!gdi.hasWidget("NBest"))
gdi.addInput(extraSelPosX, extraSelPosY, "NBest", def, 6).setHandler(this).setExtra(code);
else
gdi.setText("NBest", def)->setExtra(code);
}
else if (gdi.hasWidget("NBest"))
gdi.removeWidget("NBest");
if (type == 3) {
wstring def = cls.extraQualification == QFClass::ExtraQualType::TimeLimit ?
formatTimeMS(cls.extraQualData, false) : L"0:00";
if (!gdi.hasWidget("TimeLimit"))
gdi.addInput(extraSelPosX, extraSelPosY, "TimeLimit", def , 6).setHandler(this).setExtra(code);
else
gdi.setText("TimeLimit", def)->setExtra(code);
}
else if (gdi.hasWidget("TimeLimit"))
gdi.removeWidget("TimeLimit");
}
vector<pair<wstring, size_t>> QFEditor::getRules(const QFClass& cls) const {
vector<pair<wstring, size_t>> qf;
for (int j = 0; j < cls.qualificationMap.size(); j++) {
auto& q = cls.qualificationMap[j];
int qIx = q.first;
pair<int, int> ix = getLevelIndexFromLinear(qIx);
if (ix.first == -1)
qf.emplace_back(L"???", -1);
else {
qf.emplace_back(itow(j+1) + L": " + data[ix.first].second[ix.second].name + L" / " + itow(q.second), j);
}
}
int base = cls.qualificationMap.size() + 1;
for (int j = 0; j < cls.numTimeQualifications; j++) {
qf.emplace_back(itow(base++) + lang.tl(" Bästa tid"), 1000 + j);
}
if (cls.extraQualification == QFClass::ExtraQualType::All)
qf.emplace_back(itow(base++) + lang.tl(" Alla övriga"), 10000);
else if(cls.extraQualification == QFClass::ExtraQualType::NBest)
qf.emplace_back(itow(base++) + lang.tl(" X bästa#" + itos(cls.extraQualData) ), 10000);
else if (cls.extraQualification == QFClass::ExtraQualType::TimeLimit)
qf.emplace_back(itow(base++) + lang.tl(L" Tidskval: X#" + formatTimeMS(cls.extraQualData, false)), 10000);
return qf;
}
QFClass& QFEditor::getQFClass(int id) {
auto key = decode(id);
if (key.first < data.size() && key.second < data[key.first].second.size()) {
return data[key.first].second[key.second];
}
throw meosException("Internal error");
}
const QFClass& QFEditor::getQFClass(int id) const {
return const_cast<QFEditor*>(this)->getQFClass(id);
}
int QFEditor::getLinearIndex(int level, int ix) const {
int lx = 0;
for (int j = 0; j <= level; j++) {
if (j < level)
lx += data[j].first;
else
return lx + ix + 1; // One indexed
}
return -1;
}
pair<int, int> QFEditor::getLevelIndexFromLinear(int linearIndex) const {
int lx = 0;
for (int j = 0; j <= numLevels; j++) {
if (lx + data[j].first < linearIndex)
lx += data[j].first;
else {
return make_pair(j, linearIndex - lx - 1); // linearIndex is one indexed
}
}
return make_pair(-1, -1);
}
vector<pair<int, int>> QFEditor::getLevelIndex() const {
vector<pair<int, int>> out;
out.emplace_back(-1, -1);
for (int j = 0; j < numLevels; j++) {
for (int i = 0; i < data[j].first; i++)
out.emplace_back(j+1, i+1);
}
return out;
}
void QFEditor::updateLevelMap(const vector<pair<int, int>>& oldIndex) {
auto newIndex = getLevelIndex();
map<pair<int, int>, int> levelMap;
for (int j = 1; j < newIndex.size(); j++)
levelMap[newIndex[j]] = j;
for (auto& d : data) {
for (auto &dc : d.second) {
for (auto& clpPlace : dc.qualificationMap) {
if (clpPlace.first < oldIndex.size()) {
auto res = levelMap.find(oldIndex[clpPlace.first]);
if (res == levelMap.end())
clpPlace.first = -1;
else
clpPlace.first = res->second;
}
else {
clpPlace.first = -1;
}
}
auto it = remove_if(dc.qualificationMap.begin(), dc.qualificationMap.end(), [](auto v)->bool {return v.first == -1; });
dc.qualificationMap.erase(it, dc.qualificationMap.end());
}
}
}
QFClass& QFEditor::getQFClassFromIndex(int linearIndex) {
auto v = getLevelIndexFromLinear(linearIndex);
return data[v.first].second[v.second];
}
void QFEditor::handle(gdioutput& gdi, BaseInfo& info, GuiEventType type) {
if (type == GUI_TIMER) {
if (info.id == "Reload") {
gdi.restore("LevelView", false);
showLevels(gdi);
gdi.refresh();
}
}
else if (type == GUI_INPUTCHANGE) {
InputInfo& ii = dynamic_cast<InputInfo&>(info);
if (ii.id.substr(0, 4) == "Name") {
if (trim(ii.text).empty())
ii.setBgColor(GDICOLOR::colorLightRed);
else {
ii.setBgColor(GDICOLOR::colorDefault);
}
ii.refresh();
}
}
else if (type == GUI_INPUT) {
InputInfo& ii = dynamic_cast<InputInfo&>(info);
if (ii.id.substr(0, 4) == "Name") {
QFClass& cls = getQFClass(ii.getExtraInt());
wstring tt = trim(ii.text);
if (!tt.empty()) {
if (tt != cls.name && !(cls.name.empty() && tt == ii.getPreviousText())) {
cls.name = tt;
edit(gdi);
}
}
else {
gdi.setText(ii.id, ii.getPreviousText());
ii.setBgColor(GDICOLOR::colorDefault);
}
}
}
else if (type == GUI_BUTTON) {
ButtonInfo& bi = dynamic_cast<ButtonInfo&>(info);
if (bi.id == "AddClassPlace") {
wstring place = gdi.getText("Places");
vector<wstring> sPlace;
split(place, L" ;,", sPlace);
vector<int> iPlace;
for (auto& sp : sPlace) {
int p = _wtoi(sp.c_str());
if (p > 0)
iPlace.push_back(p);
}
if (iPlace.empty())
throw meosException("Ange vilka placeringar i kalssen som kvalificerar hit, t.ex. '1,3'");
pair<int, int> levelCls = decode(bi.getExtraInt());
QFClass& cls = getQFClass(bi.getExtraInt());
int codedTarget = gdi.getSelectedItem("Classes").first;
pair<int, int> levelClsTgt = decode(codedTarget);
int linearCode = getLinearIndex(levelClsTgt.first, levelClsTgt.second);
int level = levelCls.first;
wstring errInfo;
for (int place : iPlace) {
pair<int, int> codedClassPlace(linearCode, place);
bool add = true;
for (int j = 0; j < data.size(); j++) {
for (int i = 0; i < data[j].first; i++) {
auto& c = data[j].second[i];
if (count(c.qualificationMap.begin(), c.qualificationMap.end(), codedClassPlace)) {
wstring info = lang.tl(L"Placering X kvalificerar till Y#" + itow(place) + L"#" + c.name);
if (errInfo.empty())
errInfo = info;
else
errInfo = L"\n" + info;
add = false;
break;
}
}
}
if (add)
cls.qualificationMap.push_back(codedClassPlace);
// Clear from unused data
for (int j = 0; j < data.size(); j++) {
for (int i = data[j].first; i < data[j].second.size(); i++) {
auto& c = data[j].second[i];
if (!c.qualificationMap.empty())
c.qualificationMap.erase(remove(c.qualificationMap.begin(), c.qualificationMap.end(), codedClassPlace));
}
}
}
sort(cls.qualificationMap.begin(), cls.qualificationMap.end());
gdi.setItems("Rules", getRules(cls));
updateQInfo(cls);
gdi.setText("Places", L"", true);
if (!errInfo.empty()) {
gdi.alert(errInfo);
}
}
else if (bi.id == "AddBestTime") {
QFClass& cls = getQFClass(bi.getExtraInt());
cls.numTimeQualifications++;
gdi.setItems("Rules", getRules(cls));
updateQInfo(cls);
gdi.setText("Places", L"", true);
}
else if (bi.id == "AddOther") {
QFClass& cls = getQFClass(bi.getExtraInt());
ListBoxInfo lbi;
gdi.getSelectedItem("Other", lbi);
int tp = lbi.data;
if (tp == 0)
cls.extraQualification = QFClass::ExtraQualType::None;
else if (tp == 1)
cls.extraQualification = QFClass::ExtraQualType::All;
else if (tp == 2) {
cls.extraQualification = QFClass::ExtraQualType::NBest;
cls.extraQualData = max(_wtoi(gdi.getText("NBest").c_str()), 0);
}
else if (tp == 3) {
cls.extraQualification = QFClass::ExtraQualType::TimeLimit;
cls.extraQualData = convertAbsoluteTimeMS(gdi.getText("TimeLimit").c_str());
if (cls.extraQualData == NOTIME || cls.extraQualData < 0)
cls.extraQualData = 0;
}
gdi.setItems("Rules", getRules(cls));
updateQInfo(cls);
}
else if (bi.id == "RemoveRule") {
auto sel = gdi.getSelectedItem("Rules");
QFClass& cls = getQFClass(bi.getExtraInt());
if (sel.second) {
int id = sel.first;
if (id < 1000) {
cls.qualificationMap.erase(cls.qualificationMap.begin() + id);
}
else if (id < 10000 && cls.numTimeQualifications > 0)
cls.numTimeQualifications--;
else if (id == 10000)
cls.extraQualification = QFClass::ExtraQualType::None;
gdi.setItems("Rules", getRules(cls));
updateQInfo(getQFClass(bi.getExtraInt()));
gdi.disableInput("RemoveRule");
}
}
else if (bi.id.substr(0, 4) == "Rank") {
int level = bi.getExtraInt();
if (level < data.size()) {
edit(gdi);
bool rnk = gdi.isChecked(bi.id);
for (auto& d : data[level].second)
d.rankLevel = rnk;
}
else
throw meosException("Internal error");
}
else if (bi.id == "Edit") {
QFClass& qfc = getQFClass(bi.getExtraInt());
pair<int, int> LIX = decode(bi.getExtraInt());
infoTextTag = "QInfo" + getKeyTag(LIX.first, LIX.second);
infoTextGdi = &gdi;
gdioutput* qual_settings = getExtraWindow("qualification", true);
if (!qual_settings) {
qual_settings = createExtraWindow("qualification", L"Qualification", gdi.scaleLength(700), gdi.scaleLength(500), true);
loadQualificationView(*qual_settings, qfc, bi.getExtraInt());
}
}
else if (bi.id == "Close") {
gdioutput* qual_settings = getExtraWindow("qualification", false);
if (qual_settings) {
qual_settings->closeWindow();
infoTextGdi = nullptr;
}
}
else if (bi.id == "New" || bi.id == "CloseEditor") {
if (checkSave(gdi)) {
gdioutput* qual_settings = getExtraWindow("qualification", false);
if (qual_settings) {
qual_settings->closeWindow();
infoTextGdi = nullptr;
}
if (bi.id == "New") {
emptyScheme();
if (cls && cls->getQualificationFinal())
cls = nullptr; // Clear connection to class
show(gdi);
}
else {
gdi.getTabs().get(TClassTab)->loadPage(gdi);
return;
}
}
}
else if (bi.id == "Use") {
if (cls) {
use();
updateActions(gdi);
}
}
else if (bi.id == "Load") {
vector<pair<wstring, wstring>> ext;
ext.push_back(make_pair(L"Qualfication/Final", L"*.xml"));
wstring fileName = gdi.browseForOpen(ext, L"xml");
if (!fileName.empty()) {
auto newQF = make_shared<QualificationFinal>(0, 0);
newQF->importXML(fileName);
load(newQF);
makeDirty(QFEditor::DirtyFlag::MakeDirty, QFEditor::DirtyFlag::ClearDirty);
show(gdi);
}
}
else if (bi.id == "Save") {
if (save(gdi))
updateActions(gdi);
}
}
else if (type == GUI_LISTBOX) {
ListBoxInfo& lbi = dynamic_cast<ListBoxInfo&>(info);
if (lbi.id == "Levels") {
auto origiIndex = getLevelIndex();
numLevels = lbi.data;
if (numLevels > data.size()) {
data.resize(numLevels);
for (auto& d : data) {
if (d.first == 0) {
d.first = 1;
d.second.emplace_back(lang.tl("Klass"));
}
}
}
edit(gdi);
updateLevelMap(origiIndex);
gdi.addTimeoutMilli(25, "Reload", nullptr).setHandler(this);
gdioutput* qual_settings = getExtraWindow("qualification", false);
if (qual_settings)
qual_settings->closeWindow();
}
else if (lbi.id.substr(0, 6) == "NumCls") {
int numCls = lbi.data;
int level = lbi.getExtraInt();
if (level < data.size()) {
auto origiIndex = getLevelIndex();
wstring bn = lang.tl("Class");
bool rnk = false;
if (!data[level].second.empty()) {
bn = data[level].second.back().name;
rnk = data[level].second.front().rankLevel;
}
while (numCls >= data[level].second.size()) {
data[level].second.emplace_back(bn);
data[level].second.back().rankLevel = rnk;
}
data[level].first = numCls;
updateLevelMap(origiIndex);
}
else
throw meosException("Internal error");
edit(gdi);
gdi.addTimeoutMilli(25, "Reload", nullptr).setHandler(this);
gdioutput* qual_settings = getExtraWindow("qualification", false);
if (qual_settings)
qual_settings->closeWindow();
}
else if (lbi.id == "Rules") {
gdi.setInputStatus("RemoveRule", lbi.data != -1);
}
else if (lbi.id == "RuleType") {
int cCode = lbi.getExtraInt();
gdi.restoreNoUpdate("RuleType");
if (lbi.data == 0)
addRuleClassPlace(cCode, gdi);
else if (lbi.data == 1)
addRuleTime(cCode, gdi);
else if (lbi.data == 2)
addRuleOther(cCode, gdi);
}
else if (lbi.id == "Other") {
QFClass& cls = getQFClass(lbi.getExtraInt());
updateExtraField(gdi, cls, lbi.getExtraInt());
}
}
}
string QFEditor::getKeyTag(int level, int ix) {
return "L" + itos(level) + "C" + itos(ix);
}
void QFEditor::updateQInfo(const QFClass& cls) {
if (infoTextGdi) {
edit(*infoTextGdi);
infoTextGdi->setText(infoTextTag, lang.tl(cls.getQualInfo()), true);
}
}
bool QFEditor::checkSave(gdioutput& gdi) {
if (cls != nullptr && dirtyInt) {
auto ans = gdi.askCancel(L"Vill du uppdatera X med ändringarna?#" + cls->getName());
if (ans == gdioutput::AskAnswer::AnswerCancel)
return false;
else if (ans == gdioutput::AskAnswer::AnswerYes)
use();
}
else if (cls == nullptr && dirtyExt) {
auto ans = gdi.askCancel(L"Vill du spara ändringar?");
if (ans == gdioutput::AskAnswer::AnswerCancel)
return false;
else if (ans == gdioutput::AskAnswer::AnswerYes) {
if (!save(gdi))
return false;
}
}
return true;
}
void QFEditor::makeDirty(DirtyFlag inside, DirtyFlag outside) {
if (inside == DirtyFlag::ClearDirty)
dirtyInt = false;
else if (inside == DirtyFlag::MakeDirty)
dirtyInt = true;
if (outside == DirtyFlag::ClearDirty)
dirtyExt = false;
else if (outside == DirtyFlag::MakeDirty)
dirtyExt = true;
}
void QFEditor::edit(gdioutput& gdi) {
makeDirty(DirtyFlag::MakeDirty, DirtyFlag::MakeDirty);
updateActions(gdi);
}
void QFEditor::updateActions(gdioutput& gdi) {
gdi.setInputStatus("Use", dirtyInt, true);
gdi.setInputStatus("Save", dirtyExt);
}
void QFEditor::use() {
makeQF();
cls->loadQualificationFinalScheme(*currentQF);
cls->updateFinalClasses(0, true);
makeDirty(QFEditor::DirtyFlag::ClearDirty, QFEditor::DirtyFlag::NoTouch);
}
bool QFEditor::save(gdioutput& gdi) {
vector<pair<wstring, wstring>> ext;
ext.push_back(make_pair(L"Qualfication/Final", L"*.xml"));
int fx = 0;
wstring fileName = gdi.browseForSave(ext, L"xml", fx);
if (!fileName.empty()) {
makeQF();
currentQF->exportXML(fileName);
makeDirty(QFEditor::DirtyFlag::NoTouch, QFEditor::DirtyFlag::ClearDirty);
return true;
}
return false;
}
Reference in New Issue View Git Blame Copy Permalink