911 lines
27 KiB
C++
911 lines
27 KiB
C++
#include "courtroom.h"
|
|
#include "options.h"
|
|
|
|
void Courtroom::initialize_evidence()
|
|
{
|
|
ui_evidence = new AOImage(ao_app, this);
|
|
ui_evidence->setObjectName("ui_evidence");
|
|
|
|
// ui_evidence_name = new QLabel(ui_evidence);
|
|
ui_evidence_name = new QLineEdit(ui_evidence);
|
|
ui_evidence_name_filter = new AOLineEditFilter();
|
|
ui_evidence_name->installEventFilter(ui_evidence_name_filter);
|
|
ui_evidence_name->setAlignment(Qt::AlignCenter);
|
|
ui_evidence_name->setFrame(false);
|
|
ui_evidence_name->setObjectName("ui_evidence_name");
|
|
ui_evidence_name->setReadOnly(true);
|
|
|
|
ui_evidence_buttons = new QWidget(ui_evidence);
|
|
ui_evidence_buttons->setObjectName("ui_evidence_buttons");
|
|
|
|
ui_evidence_left = new AOButton(ao_app, ui_evidence);
|
|
ui_evidence_left->setObjectName("ui_evidence_left");
|
|
ui_evidence_right = new AOButton(ao_app, ui_evidence);
|
|
ui_evidence_right->setObjectName("ui_evidence_right");
|
|
ui_evidence_present = new AOButton(ao_app, ui_evidence);
|
|
ui_evidence_present->setToolTip(tr("Present this piece of evidence to "
|
|
"everyone on your next spoken message"));
|
|
ui_evidence_present->setObjectName("ui_evidence_present");
|
|
|
|
ui_evidence_switch = new AOButton(ao_app, ui_evidence);
|
|
ui_evidence_switch->setObjectName("ui_evidence_switch");
|
|
ui_evidence_transfer = new AOButton(ao_app, ui_evidence);
|
|
ui_evidence_transfer->setObjectName("ui_evidence_transfer");
|
|
|
|
ui_evidence_save = new AOButton(ao_app, ui_evidence);
|
|
ui_evidence_save->setToolTip(tr("Save evidence to an .ini file."));
|
|
ui_evidence_save->setObjectName("ui_evidence_save");
|
|
ui_evidence_load = new AOButton(ao_app, ui_evidence);
|
|
ui_evidence_load->setToolTip(tr("Load evidence from an .ini file."));
|
|
ui_evidence_load->setObjectName("ui_evidence_load");
|
|
|
|
ui_evidence_overlay = new AOImage(ao_app, ui_evidence);
|
|
ui_evidence_overlay->setObjectName("ui_evidence_overlay");
|
|
|
|
ui_evidence_delete = new AOButton(ao_app, ui_evidence_overlay);
|
|
ui_evidence_delete->setToolTip(tr("Destroy this piece of evidence"));
|
|
ui_evidence_delete->setObjectName("ui_evidence_delete");
|
|
ui_evidence_image_name = new QLineEdit(ui_evidence_overlay);
|
|
ui_evidence_image_name_filter = new AOLineEditFilter();
|
|
ui_evidence_image_name->installEventFilter(ui_evidence_image_name_filter);
|
|
ui_evidence_image_name->setObjectName("ui_evidence_image_name");
|
|
ui_evidence_image_button = new AOButton(ao_app, ui_evidence_overlay);
|
|
ui_evidence_image_button->setText(tr("Choose.."));
|
|
ui_evidence_image_button->setObjectName("ui_evidence_image_button");
|
|
ui_evidence_x = new AOButton(ao_app, ui_evidence_overlay);
|
|
ui_evidence_x->setToolTip(tr("Close the evidence display/editing overlay.\n"
|
|
"You will be prompted if there's any unsaved changes."));
|
|
ui_evidence_x->setObjectName("ui_evidence_x");
|
|
ui_evidence_ok = new AOButton(ao_app, ui_evidence_overlay);
|
|
ui_evidence_ok->setToolTip(tr("Save any changes made to this piece of "
|
|
"evidence and send them to server."));
|
|
ui_evidence_ok->setObjectName("ui_evidence_ok");
|
|
|
|
ui_evidence_description = new QPlainTextEdit(ui_evidence_overlay);
|
|
ui_evidence_description->setFrameStyle(QFrame::NoFrame);
|
|
ui_evidence_description->setToolTip(tr("Click to edit. Press [X] to update your changes."));
|
|
ui_evidence_description->setObjectName("ui_evidence_description");
|
|
|
|
connect(ui_evidence_name, &QLineEdit::returnPressed, this, &Courtroom::on_evidence_name_edited);
|
|
connect(ui_evidence_left, &AOButton::clicked, this, &Courtroom::on_evidence_left_clicked);
|
|
connect(ui_evidence_right, &AOButton::clicked, this, &Courtroom::on_evidence_right_clicked);
|
|
connect(ui_evidence_present, &AOButton::clicked, this, &Courtroom::on_evidence_present_clicked);
|
|
connect(ui_evidence_switch, &AOButton::clicked, this, &Courtroom::on_evidence_switch_clicked);
|
|
connect(ui_evidence_transfer, &AOButton::clicked, this, &Courtroom::on_evidence_transfer_clicked);
|
|
connect(ui_evidence_save, &AOButton::clicked, this, &Courtroom::on_evidence_save_clicked);
|
|
connect(ui_evidence_load, &AOButton::clicked, this, &Courtroom::on_evidence_load_clicked);
|
|
|
|
connect(ui_evidence_delete, &AOButton::clicked, this, &Courtroom::on_evidence_delete_clicked);
|
|
connect(ui_evidence_image_name, &QLineEdit::returnPressed, this, &Courtroom::on_evidence_image_name_edited);
|
|
connect(ui_evidence_image_button, &AOButton::clicked, this, &Courtroom::on_evidence_image_button_clicked);
|
|
connect(ui_evidence_x, &AOButton::clicked, this, &Courtroom::on_evidence_x_clicked);
|
|
connect(ui_evidence_ok, &AOButton::clicked, this, &Courtroom::on_evidence_ok_clicked);
|
|
|
|
connect(ui_evidence_name, &QLineEdit::textChanged, this, &Courtroom::on_evidence_edited);
|
|
connect(ui_evidence_image_name, &QLineEdit::textChanged, this, &Courtroom::on_evidence_edited);
|
|
connect(ui_evidence_description, &QPlainTextEdit::textChanged, this, &Courtroom::on_evidence_edited);
|
|
|
|
ui_evidence->hide();
|
|
evidence_load("inventories/autosave.ini");
|
|
}
|
|
|
|
void Courtroom::refresh_evidence()
|
|
{
|
|
set_font(ui_evidence_name, "", "evidence_name");
|
|
set_font(ui_evidence_image_name, "", "evidence_image_name");
|
|
set_font(ui_evidence_description, "", "evidence_description");
|
|
|
|
// Should properly refresh the evidence list
|
|
qDeleteAll(ui_evidence_list.begin(), ui_evidence_list.end());
|
|
ui_evidence_list.clear();
|
|
|
|
set_size_and_pos(ui_evidence_button, "evidence_button");
|
|
ui_evidence_button->setImage("evidence_button");
|
|
ui_evidence_button->setToolTip(tr("Bring up the Evidence screen."));
|
|
|
|
set_size_and_pos(ui_evidence, "evidence_background");
|
|
if (current_evidence_global)
|
|
{
|
|
ui_evidence->setImage("evidence_background");
|
|
}
|
|
else
|
|
{
|
|
ui_evidence->setImage("evidence_background_private");
|
|
}
|
|
|
|
set_size_and_pos(ui_evidence_name, "evidence_name");
|
|
|
|
set_size_and_pos(ui_evidence_buttons, "evidence_buttons");
|
|
|
|
set_size_and_pos(ui_evidence_left, "evidence_left");
|
|
ui_evidence_left->setImage("arrow_left");
|
|
|
|
set_size_and_pos(ui_evidence_right, "evidence_right");
|
|
ui_evidence_right->setImage("arrow_right");
|
|
|
|
set_size_and_pos(ui_evidence_present, "evidence_present");
|
|
ui_evidence_present->setImage("present");
|
|
|
|
set_size_and_pos(ui_evidence_overlay, "evidence_overlay");
|
|
if (current_evidence_global)
|
|
{
|
|
ui_evidence_overlay->setImage("evidence_overlay");
|
|
}
|
|
else
|
|
{
|
|
ui_evidence_overlay->setImage("evidence_overlay_private");
|
|
}
|
|
|
|
set_size_and_pos(ui_evidence_delete, "evidence_delete");
|
|
ui_evidence_delete->setImage("evidence_delete");
|
|
|
|
set_size_and_pos(ui_evidence_image_name, "evidence_image_name");
|
|
|
|
set_size_and_pos(ui_evidence_image_button, "evidence_image_button");
|
|
|
|
set_size_and_pos(ui_evidence_x, "evidence_x");
|
|
ui_evidence_x->setImage("evidence_x");
|
|
|
|
set_size_and_pos(ui_evidence_ok, "evidence_ok");
|
|
ui_evidence_ok->setImage("evidence_ok");
|
|
|
|
set_size_and_pos(ui_evidence_switch, "evidence_switch");
|
|
if (current_evidence_global)
|
|
{
|
|
ui_evidence_switch->setImage("evidence_global");
|
|
ui_evidence_switch->setToolTip(tr("Switch evidence to private inventory."));
|
|
}
|
|
else
|
|
{
|
|
ui_evidence_switch->setImage("evidence_private");
|
|
ui_evidence_switch->setToolTip(tr("Switch evidence to global inventory."));
|
|
}
|
|
|
|
set_size_and_pos(ui_evidence_transfer, "evidence_transfer");
|
|
if (current_evidence_global)
|
|
{
|
|
ui_evidence_transfer->setImage("evidence_transfer");
|
|
ui_evidence_transfer->setToolTip(tr("Transfer evidence to private inventory."));
|
|
}
|
|
else
|
|
{
|
|
ui_evidence_transfer->setImage("evidence_transfer_private");
|
|
ui_evidence_transfer->setToolTip(tr("Transfer evidence to global inventory."));
|
|
}
|
|
|
|
set_size_and_pos(ui_evidence_save, "evidence_save");
|
|
ui_evidence_save->setImage("evidence_save");
|
|
if (current_evidence_global)
|
|
{
|
|
ui_evidence_save->hide();
|
|
}
|
|
else
|
|
{
|
|
ui_evidence_save->show();
|
|
}
|
|
|
|
set_size_and_pos(ui_evidence_load, "evidence_load");
|
|
ui_evidence_load->setImage("evidence_load");
|
|
if (current_evidence_global)
|
|
{
|
|
ui_evidence_load->hide();
|
|
}
|
|
else
|
|
{
|
|
ui_evidence_load->show();
|
|
}
|
|
|
|
set_size_and_pos(ui_evidence_description, "evidence_description");
|
|
|
|
QPoint f_spacing = ao_app->get_button_spacing("evidence_button_spacing", "courtroom_design.ini");
|
|
QPoint p_point = ao_app->get_button_spacing("evidence_button_size", "courtroom_design.ini");
|
|
|
|
const int button_width = p_point.x();
|
|
int x_spacing = f_spacing.x();
|
|
int x_mod_count = 0;
|
|
|
|
const int button_height = p_point.y();
|
|
int y_spacing = f_spacing.y();
|
|
int y_mod_count = 0;
|
|
|
|
evidence_columns = ((ui_evidence_buttons->width() - button_width) / qMax(1, x_spacing + button_width)) + 1;
|
|
evidence_rows = ((ui_evidence_buttons->height() - button_height) / qMax(1, y_spacing + button_height)) + 1;
|
|
|
|
max_evidence_on_page = evidence_columns * evidence_rows;
|
|
|
|
for (int i = 0; i < max_evidence_on_page; ++i)
|
|
{
|
|
int x_pos = (button_width + x_spacing) * x_mod_count;
|
|
int y_pos = (button_height + y_spacing) * y_mod_count;
|
|
|
|
AOEvidenceButton *f_evidence = new AOEvidenceButton(i, button_width, button_height, ao_app, ui_evidence_buttons);
|
|
ui_evidence_list.append(f_evidence);
|
|
f_evidence->move(x_pos, y_pos);
|
|
|
|
connect(f_evidence, &AOEvidenceButton::evidenceClicked, this, &Courtroom::on_evidence_clicked);
|
|
connect(f_evidence, &AOEvidenceButton::evidenceDoubleClicked, this, &Courtroom::on_evidence_double_clicked);
|
|
connect(f_evidence, &AOEvidenceButton::mouseoverUpdated, this, &Courtroom::on_evidence_hover);
|
|
|
|
++x_mod_count;
|
|
|
|
if (x_mod_count == evidence_columns)
|
|
{
|
|
++y_mod_count;
|
|
x_mod_count = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
void Courtroom::set_evidence_list(QVector<EvidenceItem> &p_evi_list)
|
|
{
|
|
global_evidence_list = p_evi_list;
|
|
if (!current_evidence_global)
|
|
{
|
|
return; // We're on private evidence editing, wait for user to do their
|
|
// thing
|
|
}
|
|
|
|
QVector<EvidenceItem> old_list = local_evidence_list;
|
|
local_evidence_list.clear();
|
|
local_evidence_list = p_evi_list;
|
|
|
|
set_evidence_page();
|
|
|
|
if (ui_evidence_overlay->isVisible()) // Update the currently edited evidence for this user
|
|
{
|
|
int p_id = current_evidence - (max_evidence_on_page * current_evidence_page);
|
|
if (current_evidence >= local_evidence_list.size())
|
|
{
|
|
evidence_close();
|
|
ui_evidence_name->setText("");
|
|
}
|
|
else if (ui_evidence_ok->isHidden()) // We haven't clicked to edit it or anything
|
|
{
|
|
on_evidence_double_clicked(p_id);
|
|
}
|
|
// Todo: make a function that compares two pieces of evidence for any
|
|
// differences
|
|
else if (compare_evidence_changed(old_list.at(current_evidence), local_evidence_list.at(current_evidence)))
|
|
{
|
|
QMessageBox *msgBox = new QMessageBox;
|
|
|
|
msgBox->setAttribute(Qt::WA_DeleteOnClose);
|
|
msgBox->setText(tr("The piece of evidence you've been editing has changed."));
|
|
msgBox->setInformativeText(tr("Do you wish to keep your changes?"));
|
|
msgBox->setDetailedText(tr("Name: %1\n"
|
|
"Image: %2\n"
|
|
"Description:\n%3")
|
|
.arg(local_evidence_list.at(current_evidence).name, local_evidence_list.at(current_evidence).image, local_evidence_list.at(current_evidence).description));
|
|
msgBox->setStandardButtons(QMessageBox::Yes | QMessageBox::No);
|
|
msgBox->setDefaultButton(QMessageBox::LastButton);
|
|
// msgBox->setWindowModality(Qt::NonModal);
|
|
int ret = msgBox->exec();
|
|
switch (ret)
|
|
{
|
|
case QMessageBox::Yes:
|
|
// "Keep changes"
|
|
ui_evidence_ok->hide();
|
|
break;
|
|
case QMessageBox::No:
|
|
// "Discard changes and keep theirs"
|
|
on_evidence_double_clicked(p_id);
|
|
break;
|
|
default:
|
|
// should never be reached
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void Courtroom::set_evidence_page()
|
|
{
|
|
int total_evidence = local_evidence_list.size();
|
|
|
|
ui_evidence_left->hide();
|
|
ui_evidence_right->hide();
|
|
|
|
for (AOEvidenceButton *i_button : std::as_const(ui_evidence_list))
|
|
{
|
|
i_button->hide();
|
|
}
|
|
|
|
// to account for the "add evidence" button
|
|
++total_evidence;
|
|
|
|
int total_pages = total_evidence / max_evidence_on_page;
|
|
int evidence_on_page = 0;
|
|
|
|
if ((total_evidence % max_evidence_on_page) != 0)
|
|
{
|
|
++total_pages;
|
|
// i. e. not on the last page
|
|
if (total_pages > current_evidence_page + 1)
|
|
{
|
|
evidence_on_page = max_evidence_on_page;
|
|
}
|
|
else
|
|
{
|
|
evidence_on_page = total_evidence % max_evidence_on_page;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
evidence_on_page = max_evidence_on_page;
|
|
}
|
|
|
|
if (total_pages > current_evidence_page + 1)
|
|
{
|
|
ui_evidence_right->show();
|
|
}
|
|
|
|
if (current_evidence_page > 0)
|
|
{
|
|
ui_evidence_left->show();
|
|
}
|
|
|
|
for (int n_evidence_button = 0; n_evidence_button < evidence_on_page; ++n_evidence_button)
|
|
{
|
|
int n_real_evidence = n_evidence_button + current_evidence_page * max_evidence_on_page;
|
|
AOEvidenceButton *f_evidence_button = ui_evidence_list.at(n_evidence_button);
|
|
|
|
f_evidence_button->setSelected(false);
|
|
f_evidence_button->setToolTip("");
|
|
if (n_real_evidence == (total_evidence - 1))
|
|
{
|
|
f_evidence_button->setThemeImage("addevidence.png");
|
|
}
|
|
else if (n_real_evidence < (total_evidence - 1))
|
|
{
|
|
f_evidence_button->setImage(local_evidence_list.at(n_real_evidence).image);
|
|
|
|
if (n_real_evidence == current_evidence)
|
|
{
|
|
f_evidence_button->setSelected(true);
|
|
}
|
|
|
|
f_evidence_button->setToolTip(QString::number(n_real_evidence + 1) + ": " + local_evidence_list.at(n_real_evidence).name);
|
|
}
|
|
else
|
|
{
|
|
f_evidence_button->setImage("");
|
|
}
|
|
|
|
f_evidence_button->show();
|
|
}
|
|
}
|
|
|
|
void Courtroom::show_evidence(int f_real_id)
|
|
{
|
|
// Make sure we're in the global evidence list
|
|
evidence_switch(true);
|
|
// Set the evidence page properly
|
|
current_evidence_page = f_real_id / max_evidence_on_page;
|
|
set_evidence_page();
|
|
// Display the target evidence using the local ID
|
|
int p_id = f_real_id - (max_evidence_on_page * current_evidence_page);
|
|
on_evidence_double_clicked(p_id);
|
|
}
|
|
|
|
void Courtroom::on_evidence_name_edited()
|
|
{
|
|
if (current_evidence >= local_evidence_list.size())
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
void Courtroom::on_evidence_image_name_edited()
|
|
{
|
|
if (current_evidence >= local_evidence_list.size())
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
void Courtroom::on_evidence_image_button_clicked()
|
|
{
|
|
QDir dir(get_base_path() + "/evidence/");
|
|
QFileDialog dialog(this);
|
|
dialog.setFileMode(QFileDialog::ExistingFile);
|
|
dialog.setNameFilter(tr("Images (*.png)"));
|
|
dialog.setViewMode(QFileDialog::List);
|
|
dialog.setDirectory(dir);
|
|
|
|
QStringList filenames;
|
|
|
|
if (dialog.exec())
|
|
{
|
|
filenames = dialog.selectedFiles();
|
|
}
|
|
|
|
if (filenames.size() != 1)
|
|
{
|
|
return;
|
|
}
|
|
|
|
QString filename = filenames.at(0);
|
|
QStringList bases = Options::getInstance().mountPaths();
|
|
bases.prepend(get_base_path());
|
|
for (const QString &base : bases)
|
|
{
|
|
QDir baseDir(base);
|
|
if (filename.startsWith(baseDir.absolutePath() + "/"))
|
|
{
|
|
dir.setPath(baseDir.absolutePath() + "/evidence");
|
|
break;
|
|
}
|
|
}
|
|
filename = dir.relativeFilePath(filename);
|
|
ui_evidence_image_name->setText(filename);
|
|
on_evidence_image_name_edited();
|
|
}
|
|
|
|
void Courtroom::on_evidence_clicked(int p_id)
|
|
{
|
|
int f_real_id = p_id + max_evidence_on_page * current_evidence_page;
|
|
|
|
if (f_real_id == local_evidence_list.size())
|
|
{
|
|
if (current_evidence_global)
|
|
{
|
|
ao_app->send_server_packet(AOPacket("PE", {"<name>", "<description>", "empty.png"}));
|
|
}
|
|
else
|
|
{
|
|
EvidenceItem f_evi;
|
|
f_evi.name = "<name>";
|
|
f_evi.description = "<description>";
|
|
f_evi.image = "empty.png";
|
|
|
|
local_evidence_list.append(f_evi);
|
|
private_evidence_list = local_evidence_list;
|
|
set_evidence_page();
|
|
}
|
|
return;
|
|
}
|
|
else if (f_real_id > local_evidence_list.size())
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (!Options::getInstance().evidenceDoubleClickEdit())
|
|
{
|
|
on_evidence_double_clicked(p_id);
|
|
return;
|
|
}
|
|
|
|
if (ui_evidence_overlay->isVisible())
|
|
{
|
|
return;
|
|
}
|
|
|
|
ui_evidence_name->setText(local_evidence_list.at(f_real_id).name);
|
|
for (AOEvidenceButton *i_button : std::as_const(ui_evidence_list))
|
|
{
|
|
i_button->setSelected(false);
|
|
}
|
|
|
|
ui_evidence_list.at(p_id)->setSelected(true);
|
|
current_evidence = f_real_id;
|
|
}
|
|
|
|
void Courtroom::on_evidence_double_clicked(int p_id)
|
|
{
|
|
int f_real_id = p_id + max_evidence_on_page * current_evidence_page;
|
|
|
|
if (f_real_id >= local_evidence_list.size())
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (ui_evidence_overlay->isVisible())
|
|
{
|
|
if (!on_evidence_x_clicked())
|
|
{
|
|
// We're told not to switch over to the other evidence ("cancel" clicked)
|
|
return;
|
|
}
|
|
}
|
|
|
|
for (AOEvidenceButton *i_button : std::as_const(ui_evidence_list))
|
|
{
|
|
i_button->setSelected(false);
|
|
}
|
|
|
|
// We have to check if the ID is on the currently displayed page.
|
|
// This is because SOMEONE allowed the switching of pages while evidence is still being edited.
|
|
if (p_id < ui_evidence_list.count())
|
|
{
|
|
ui_evidence_list.at(p_id)->setSelected(true);
|
|
}
|
|
current_evidence = f_real_id;
|
|
|
|
EvidenceItem f_evi = local_evidence_list.at(f_real_id);
|
|
|
|
ui_evidence_description->clear();
|
|
ui_evidence_description->appendPlainText(f_evi.description);
|
|
ui_evidence_description->setReadOnly(false);
|
|
ui_evidence_description->setToolTip(tr("Click to edit..."));
|
|
ui_evidence_description->moveCursor(QTextCursor::Start);
|
|
|
|
ui_evidence_name->setText(f_evi.name);
|
|
ui_evidence_name->setReadOnly(false);
|
|
ui_evidence_name->setToolTip(tr("Click to edit..."));
|
|
|
|
ui_evidence_image_name->setText(f_evi.image);
|
|
ui_evidence_image_name->setReadOnly(false);
|
|
ui_evidence_image_name->setToolTip(tr("Click to edit..."));
|
|
|
|
ui_evidence->show();
|
|
ui_evidence_overlay->show();
|
|
ui_evidence_ok->hide();
|
|
}
|
|
|
|
void Courtroom::on_evidence_hover(int p_id, bool p_state)
|
|
{
|
|
if (ui_evidence_overlay->isVisible())
|
|
{
|
|
// Ignore hovering behavior if we're in the process of viewing a piece of evidence
|
|
return;
|
|
}
|
|
|
|
int final_id = p_id + max_evidence_on_page * current_evidence_page;
|
|
|
|
if (p_state)
|
|
{
|
|
if (final_id == local_evidence_list.size())
|
|
{
|
|
ui_evidence_name->setText(tr("Add new evidence..."));
|
|
}
|
|
else if (final_id < local_evidence_list.size())
|
|
{
|
|
ui_evidence_name->setText(local_evidence_list.at(final_id).name);
|
|
}
|
|
}
|
|
else if (current_evidence < local_evidence_list.size())
|
|
{
|
|
ui_evidence_name->setText(local_evidence_list.at(current_evidence).name);
|
|
}
|
|
else
|
|
{
|
|
ui_evidence_name->setText("");
|
|
}
|
|
}
|
|
|
|
void Courtroom::on_evidence_left_clicked()
|
|
{
|
|
--current_evidence_page;
|
|
|
|
set_evidence_page();
|
|
}
|
|
|
|
void Courtroom::on_evidence_right_clicked()
|
|
{
|
|
++current_evidence_page;
|
|
|
|
set_evidence_page();
|
|
}
|
|
|
|
void Courtroom::on_evidence_present_clicked()
|
|
{
|
|
if (!current_evidence_global)
|
|
{
|
|
ui_evidence_present->hide();
|
|
is_presenting_evidence = false;
|
|
return; // otherwise we get force-disconnected
|
|
}
|
|
if (is_presenting_evidence)
|
|
{
|
|
ui_evidence_present->setImage("present");
|
|
}
|
|
else
|
|
{
|
|
ui_evidence_present->setImage("present_disabled");
|
|
}
|
|
|
|
is_presenting_evidence = !is_presenting_evidence;
|
|
|
|
ui_ic_chat_message->setFocus();
|
|
}
|
|
|
|
void Courtroom::on_evidence_delete_clicked()
|
|
{
|
|
evidence_close();
|
|
if (current_evidence_global)
|
|
{
|
|
ao_app->send_server_packet(AOPacket("DE", {QString::number(current_evidence)}));
|
|
}
|
|
else
|
|
{
|
|
local_evidence_list.remove(current_evidence);
|
|
private_evidence_list = local_evidence_list;
|
|
set_evidence_page();
|
|
|
|
// Autosave private evidence
|
|
evidence_save("inventories/autosave.ini");
|
|
}
|
|
|
|
current_evidence = 0;
|
|
}
|
|
|
|
bool Courtroom::on_evidence_x_clicked()
|
|
{
|
|
if (current_evidence >= local_evidence_list.size()) // Should never happen but you never know.
|
|
{
|
|
return true;
|
|
}
|
|
|
|
if (ui_evidence_ok->isHidden())
|
|
{
|
|
// Nothing was modified
|
|
evidence_close();
|
|
return true;
|
|
}
|
|
QMessageBox *msgBox = new QMessageBox;
|
|
msgBox->setAttribute(Qt::WA_DeleteOnClose);
|
|
msgBox->setText(tr("Evidence has been modified."));
|
|
msgBox->setInformativeText(tr("Do you want to save your changes?"));
|
|
msgBox->setStandardButtons(QMessageBox::Save | QMessageBox::Discard | QMessageBox::Cancel);
|
|
msgBox->setDefaultButton(QMessageBox::Save);
|
|
int ret = msgBox->exec();
|
|
switch (ret)
|
|
{
|
|
case QMessageBox::Save:
|
|
evidence_close();
|
|
on_evidence_ok_clicked();
|
|
return true;
|
|
case QMessageBox::Discard:
|
|
evidence_close();
|
|
return true;
|
|
case QMessageBox::Cancel:
|
|
default:
|
|
// Cancel was clicked, report that.
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void Courtroom::on_evidence_ok_clicked()
|
|
{
|
|
ui_evidence_ok->hide();
|
|
if (current_evidence < local_evidence_list.size())
|
|
{
|
|
EvidenceItem f_evi = local_evidence_list.at(current_evidence);
|
|
if (current_evidence_global)
|
|
{
|
|
QStringList f_contents;
|
|
f_contents.append(QString::number(current_evidence));
|
|
f_contents.append(ui_evidence_name->text());
|
|
f_contents.append(ui_evidence_description->toPlainText());
|
|
f_contents.append(ui_evidence_image_name->text());
|
|
|
|
ao_app->send_server_packet(AOPacket("EE", f_contents));
|
|
}
|
|
else
|
|
{
|
|
f_evi.name = ui_evidence_name->text();
|
|
f_evi.description = ui_evidence_description->toPlainText();
|
|
f_evi.image = ui_evidence_image_name->text();
|
|
local_evidence_list.replace(current_evidence, f_evi);
|
|
private_evidence_list = local_evidence_list;
|
|
ui_evidence_ok->hide();
|
|
set_evidence_page();
|
|
}
|
|
}
|
|
|
|
// Autosave private evidence
|
|
if (!current_evidence_global)
|
|
{
|
|
evidence_save("inventories/autosave.ini");
|
|
}
|
|
}
|
|
|
|
void Courtroom::on_evidence_switch_clicked()
|
|
{
|
|
evidence_switch(!current_evidence_global);
|
|
}
|
|
|
|
void Courtroom::on_evidence_transfer_clicked()
|
|
{
|
|
if (current_evidence >= local_evidence_list.size())
|
|
{
|
|
return;
|
|
}
|
|
|
|
QString name;
|
|
if (!current_evidence_global) // Transfer private evidence to global
|
|
{
|
|
EvidenceItem f_evi = local_evidence_list.at(current_evidence);
|
|
|
|
QStringList f_contents;
|
|
f_contents.append(f_evi.name);
|
|
f_contents.append(f_evi.description);
|
|
f_contents.append(f_evi.image);
|
|
|
|
name = f_evi.name;
|
|
ao_app->send_server_packet(AOPacket("PE", f_contents));
|
|
}
|
|
else // Transfer global evidence to private
|
|
{
|
|
EvidenceItem f_evi = local_evidence_list.at(current_evidence);
|
|
name = f_evi.name;
|
|
private_evidence_list.append(f_evi);
|
|
|
|
// Autosave private evidence
|
|
evidence_save("inventories/autosave.ini");
|
|
}
|
|
|
|
QMessageBox *msgBox = new QMessageBox;
|
|
msgBox->setAttribute(Qt::WA_DeleteOnClose);
|
|
msgBox->setText(tr("\"%1\" has been transferred.").arg(name));
|
|
msgBox->setStandardButtons(QMessageBox::Ok);
|
|
msgBox->setDefaultButton(QMessageBox::Ok);
|
|
msgBox->exec();
|
|
}
|
|
|
|
void Courtroom::on_evidence_edited()
|
|
{
|
|
if (current_evidence >= local_evidence_list.size()) // Should never happen but you never know.
|
|
{
|
|
return;
|
|
}
|
|
EvidenceItem fake_evidence;
|
|
fake_evidence.name = ui_evidence_name->text();
|
|
fake_evidence.description = ui_evidence_description->toPlainText();
|
|
fake_evidence.image = ui_evidence_image_name->text();
|
|
if (compare_evidence_changed(fake_evidence, local_evidence_list.at(current_evidence)))
|
|
{
|
|
ui_evidence_ok->show();
|
|
}
|
|
else
|
|
{
|
|
ui_evidence_ok->hide();
|
|
}
|
|
}
|
|
|
|
void Courtroom::evidence_close()
|
|
{
|
|
ui_evidence_description->setReadOnly(true);
|
|
ui_evidence_name->setReadOnly(true);
|
|
ui_evidence_image_name->setReadOnly(true);
|
|
ui_evidence_overlay->hide();
|
|
}
|
|
|
|
void Courtroom::evidence_switch(bool global)
|
|
{
|
|
evidence_close();
|
|
current_evidence_global = global;
|
|
is_presenting_evidence = false;
|
|
ui_evidence_present->setImage("present");
|
|
local_evidence_list.clear();
|
|
if (current_evidence_global)
|
|
{
|
|
local_evidence_list = global_evidence_list;
|
|
ui_evidence_present->show();
|
|
ui_evidence_save->hide();
|
|
ui_evidence_load->hide();
|
|
ui_evidence_switch->setImage("evidence_global");
|
|
ui_evidence->setImage("evidence_background");
|
|
ui_evidence_overlay->setImage("evidence_overlay");
|
|
ui_evidence_transfer->setImage("evidence_transfer");
|
|
ui_evidence_transfer->setToolTip(tr("Transfer evidence to private inventory."));
|
|
ui_evidence_switch->setToolTip(tr("Current evidence is global. Click to switch to private."));
|
|
}
|
|
else
|
|
{
|
|
local_evidence_list = private_evidence_list;
|
|
ui_evidence_present->hide();
|
|
ui_evidence_save->show();
|
|
ui_evidence_load->show();
|
|
ui_evidence_switch->setImage("evidence_private");
|
|
ui_evidence->setImage("evidence_background_private");
|
|
ui_evidence_overlay->setImage("evidence_overlay_private");
|
|
ui_evidence_transfer->setImage("evidence_transfer_private");
|
|
ui_evidence_transfer->setToolTip(tr("Transfer evidence to global inventory."));
|
|
ui_evidence_switch->setToolTip(tr("Current evidence is private. Click to switch to global."));
|
|
}
|
|
current_evidence_page = 0;
|
|
set_evidence_page();
|
|
}
|
|
|
|
void Courtroom::on_evidence_save_clicked()
|
|
{
|
|
if (current_evidence_global)
|
|
{
|
|
return; // Don't allow saving/loading operations when in global inventory
|
|
// mode for now
|
|
}
|
|
|
|
// "Inventories" dir keeps our private evidence data
|
|
if (!dir_exists("inventories"))
|
|
{
|
|
// Create one if it doesn't yet exist
|
|
QDir("inventories").mkdir("inventories");
|
|
}
|
|
|
|
QString p_path = QFileDialog::getSaveFileName(this, tr("Save Inventory"), "inventories/", tr("Ini Files (*.ini)"));
|
|
|
|
evidence_close();
|
|
ui_evidence_name->setText("");
|
|
|
|
evidence_save(p_path);
|
|
}
|
|
|
|
void Courtroom::on_evidence_load_clicked()
|
|
{
|
|
if (current_evidence_global)
|
|
{
|
|
return; // Don't allow saving/loading operations when in global inventory
|
|
// mode for now
|
|
}
|
|
|
|
QString p_path = QFileDialog::getOpenFileName(this, tr("Open Inventory"), "inventories/", tr("Ini Files (*.ini)"));
|
|
if (p_path.isEmpty())
|
|
{
|
|
return;
|
|
}
|
|
|
|
evidence_close();
|
|
ui_evidence_name->setText("");
|
|
evidence_load(p_path);
|
|
local_evidence_list = private_evidence_list;
|
|
set_evidence_page();
|
|
}
|
|
|
|
void Courtroom::evidence_load(QString filename)
|
|
{
|
|
if (!file_exists(filename))
|
|
{
|
|
qWarning() << "Trying to load a non-existant evidence save file:" << filename;
|
|
return;
|
|
}
|
|
QSettings inventory(filename, QSettings::IniFormat);
|
|
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
|
|
inventory.setIniCodec("UTF-8");
|
|
#endif
|
|
private_evidence_list.clear();
|
|
foreach (QString evi, inventory.childGroups())
|
|
{
|
|
if (evi == "General")
|
|
{
|
|
continue;
|
|
}
|
|
|
|
EvidenceItem f_evi;
|
|
f_evi.name = inventory.value(evi + "/name", "<name>").value<QString>();
|
|
f_evi.description = inventory.value(evi + "/description", "<description>").value<QString>();
|
|
f_evi.image = inventory.value(evi + "/image", "empty.png").value<QString>();
|
|
private_evidence_list.append(f_evi);
|
|
}
|
|
}
|
|
|
|
void Courtroom::evidence_save(QString filename)
|
|
{
|
|
// "Inventories" dir keeps our private evidence data
|
|
if (!dir_exists("inventories"))
|
|
{
|
|
// Create one if it doesn't yet exist
|
|
QDir("inventories").mkdir("inventories");
|
|
}
|
|
|
|
QSettings inventory(filename, QSettings::IniFormat);
|
|
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
|
|
inventory.setIniCodec("UTF-8");
|
|
#endif
|
|
inventory.clear();
|
|
for (int i = 0; i < private_evidence_list.size(); i++)
|
|
{
|
|
inventory.beginGroup(QString::number(i));
|
|
inventory.setValue("name", private_evidence_list[i].name);
|
|
inventory.setValue("description", private_evidence_list[i].description);
|
|
inventory.setValue("image", private_evidence_list[i].image);
|
|
inventory.endGroup();
|
|
}
|
|
inventory.sync();
|
|
}
|
|
|
|
bool Courtroom::compare_evidence_changed(EvidenceItem evi_a, EvidenceItem evi_b)
|
|
{
|
|
return evi_a.name != evi_b.name || evi_a.image != evi_b.image || evi_a.description != evi_b.description;
|
|
}
|