Skip to content

Commit

Permalink
Event pages: Switch to LcfWidgetBinding
Browse files Browse the repository at this point in the history 
The event pages use LcfWidgetBinding now for the event conditions
and settings.
  • Loading branch information
rueter37 committed Nov 30, 2021
1 parent 9040d9b commit ef1f254
Show file tree
Hide file tree
Showing 3 changed files with 117 additions and 434 deletions.
283 changes: 111 additions & 172 deletions src/ui/event/event_page_widget.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -32,6 +32,52 @@ EventPageWidget::EventPageWidget(ProjectData& project, QWidget *parent) :
{
ui->setupUi(this);

ui->comboVarOperation->addItem("Equal to (==)", lcf::rpg::EventPageCondition::Comparison_equal);
ui->comboVarOperation->addItem("Greater or equal to (>=)", lcf::rpg::EventPageCondition::Comparison_greater_equal);
ui->comboVarOperation->addItem("Lesser or equal to (<=)", lcf::rpg::EventPageCondition::Comparison_less_equal);
ui->comboVarOperation->addItem("Greater than (>)", lcf::rpg::EventPageCondition::Comparison_greater);
ui->comboVarOperation->addItem("Lesser than (<)", lcf::rpg::EventPageCondition::Comparison_less);
ui->comboVarOperation->addItem("Not equal to (!=)", lcf::rpg::EventPageCondition::Comparison_not_equal);
ui->comboVarOperation->setCurrentIndex(1);

ui->comboMoveType->addItem("Stationary", lcf::rpg::EventPage::MoveType_stationary);
ui->comboMoveType->addItem("Random", lcf::rpg::EventPage::MoveType_random);
ui->comboMoveType->addItem("Vertical", lcf::rpg::EventPage::MoveType_vertical);
ui->comboMoveType->addItem("Horizontal", lcf::rpg::EventPage::MoveType_horizontal);
ui->comboMoveType->addItem("Toward Hero", lcf::rpg::EventPage::MoveType_toward);
ui->comboMoveType->addItem("Away from Hero", lcf::rpg::EventPage::MoveType_away);
ui->comboMoveType->addItem("Custom Pattern", lcf::rpg::EventPage::MoveType_custom);

for (int i = 1; i <= 8; i++) {
ui->comboMoveFrequency->addItem(QString("%1").arg(i), i);
}
ui->comboMoveFrequency->setCurrentIndex(2);

ui->comboCondition->addItem("Action Key", lcf::rpg::EventPage::Trigger_action);
ui->comboCondition->addItem("Touched by Hero", lcf::rpg::EventPage::Trigger_touched);
ui->comboCondition->addItem("Collision with Hero", lcf::rpg::EventPage::Trigger_collision);
ui->comboCondition->addItem("AutoStart", lcf::rpg::EventPage::Trigger_auto_start);
ui->comboCondition->addItem("Parallel Process", lcf::rpg::EventPage::Trigger_parallel);

ui->comboLayer->addItem("Below Hero", lcf::rpg::EventPage::Layers_below);
ui->comboLayer->addItem("Same as Hero", lcf::rpg::EventPage::Layers_same);
ui->comboLayer->addItem("Above Hero", lcf::rpg::EventPage::Layers_above);

ui->comboAnimationType->addItem("Non-Continuous", lcf::rpg::EventPage::AnimType_non_continuous);
ui->comboAnimationType->addItem("Continuous", lcf::rpg::EventPage::AnimType_continuous);
ui->comboAnimationType->addItem("Fixed Dir/Non-Continuous", lcf::rpg::EventPage::AnimType_fixed_non_continuous);
ui->comboAnimationType->addItem("Fixed Dir/Continuous", lcf::rpg::EventPage::AnimType_fixed_continuous);
ui->comboAnimationType->addItem("Fixed Graphic", lcf::rpg::EventPage::AnimType_fixed_graphic);
ui->comboAnimationType->addItem("Spin Around", lcf::rpg::EventPage::AnimType_spin);

ui->comboMoveSpeed->addItem("1: (1/8) Normal", lcf::rpg::EventPage::MoveSpeed_eighth);
ui->comboMoveSpeed->addItem("2: (1/4) Normal", lcf::rpg::EventPage::MoveSpeed_quarter);
ui->comboMoveSpeed->addItem("3: (1/2) Normal", lcf::rpg::EventPage::MoveSpeed_half);
ui->comboMoveSpeed->addItem("4: Normal", lcf::rpg::EventPage::MoveSpeed_normal);
ui->comboMoveSpeed->addItem("5: Normal x 2", lcf::rpg::EventPage::MoveSpeed_double);
ui->comboMoveSpeed->addItem("6: Normal x 4", lcf::rpg::EventPage::MoveSpeed_fourfold);
ui->comboMoveSpeed->setCurrentIndex(2);

m_charaItem = new CharSetGraphicsItem(project);
m_tileItem = new QGraphicsPixmapItem();
m_scene = new QGraphicsScene(this);
Expand All @@ -54,6 +100,29 @@ EventPageWidget::EventPageWidget(ProjectData& project, QWidget *parent) :
ui->comboVariable->makeModel(project);
ui->comboItem->makeModel(project);
ui->comboHero->makeModel(project);

LcfWidgetBinding::connect<bool>(this, ui->checkSwitchA);
LcfWidgetBinding::connect<int32_t>(this, ui->comboSwitchA);
LcfWidgetBinding::connect<bool>(this, ui->checkSwitchB);
LcfWidgetBinding::connect<int32_t>(this, ui->comboSwitchB);
LcfWidgetBinding::connect<bool>(this, ui->checkVar);
LcfWidgetBinding::connect<int32_t>(this, ui->comboVariable);
LcfWidgetBinding::connect<int32_t>(this, ui->comboVarOperation);
LcfWidgetBinding::connect<int32_t>(this, ui->spinVarValue);
LcfWidgetBinding::connect<bool>(this, ui->checkItem);
LcfWidgetBinding::connect<int32_t>(this, ui->comboItem);
LcfWidgetBinding::connect<bool>(this, ui->checkHero);
LcfWidgetBinding::connect<int32_t>(this, ui->comboHero);
LcfWidgetBinding::connect<bool>(this, ui->checkTimerA);
LcfWidgetBinding::connect<bool>(this, ui->checkTimerB);
LcfWidgetBinding::connect<bool>(this, ui->checkTransparent);
LcfWidgetBinding::connect<int32_t>(this, ui->comboMoveType);
LcfWidgetBinding::connect<int32_t>(this, ui->comboMoveFrequency);
LcfWidgetBinding::connect<int32_t>(this, ui->comboCondition);
LcfWidgetBinding::connect<int32_t>(this, ui->comboLayer);
LcfWidgetBinding::connect<bool>(this, ui->checkOverlapForbidden);
LcfWidgetBinding::connect<int32_t>(this, ui->comboAnimationType);
LcfWidgetBinding::connect<int32_t>(this, ui->comboMoveSpeed);
}

EventPageWidget::~EventPageWidget()
Expand All @@ -70,136 +139,63 @@ lcf::rpg::EventPage *EventPageWidget::eventPage() const
void EventPageWidget::setEventPage(lcf::rpg::EventPage *eventPage)
{
m_eventPage = eventPage;
ui->checkSwitchA->setChecked(eventPage->condition.flags.switch_a);
ui->comboSwitchA->setCurrentIndex(eventPage->condition.switch_a_id-1);
ui->checkSwitchB->setChecked(eventPage->condition.flags.switch_b);
ui->comboSwitchB->setCurrentIndex(eventPage->condition.switch_b_id-1);
ui->checkVar->setChecked(eventPage->condition.flags.variable);
ui->comboVariable->setCurrentIndex(eventPage->condition.variable_id-1);
ui->comboVarOperation->setCurrentIndex(eventPage->condition.compare_operator);
ui->spinVarValue->setValue(eventPage->condition.variable_value);
ui->checkItem->setChecked(eventPage->condition.flags.item);
ui->comboItem->setCurrentIndex(eventPage->condition.item_id-1);
ui->checkHero->setChecked(eventPage->condition.flags.actor);
ui->comboHero->setCurrentIndex(eventPage->condition.actor_id-1);
ui->checkTimerA->setChecked(eventPage->condition.flags.timer);
LcfWidgetBinding::bind(ui->checkSwitchA, eventPage->condition.flags.switch_a);
LcfWidgetBinding::bind(ui->comboSwitchA, eventPage->condition.switch_a_id);
LcfWidgetBinding::bind(ui->checkSwitchB, eventPage->condition.flags.switch_b);
LcfWidgetBinding::bind(ui->comboSwitchB, eventPage->condition.switch_b_id);
LcfWidgetBinding::bind(ui->checkVar, eventPage->condition.flags.variable);
LcfWidgetBinding::bind(ui->comboVariable, eventPage->condition.variable_id);
LcfWidgetBinding::bind(ui->comboVarOperation, eventPage->condition.compare_operator);
LcfWidgetBinding::bind(ui->spinVarValue, eventPage->condition.variable_value);
LcfWidgetBinding::bind(ui->checkItem, eventPage->condition.flags.item);
LcfWidgetBinding::bind(ui->comboItem, eventPage->condition.item_id);
LcfWidgetBinding::bind(ui->checkHero, eventPage->condition.flags.actor);
LcfWidgetBinding::bind(ui->comboHero, eventPage->condition.actor_id);
LcfWidgetBinding::bind(ui->checkTimerA, eventPage->condition.flags.timer);
LcfWidgetBinding::bind(ui->checkTimerB, eventPage->condition.flags.timer2);
LcfWidgetBinding::bind(ui->checkTransparent, eventPage->translucent);
LcfWidgetBinding::bind(ui->comboMoveType, eventPage->move_type);
LcfWidgetBinding::bind(ui->comboMoveFrequency, eventPage->move_frequency);
LcfWidgetBinding::bind(ui->comboCondition, eventPage->trigger);
LcfWidgetBinding::bind(ui->comboLayer, eventPage->layer);
LcfWidgetBinding::bind(ui->checkOverlapForbidden, eventPage->overlap_forbidden);
LcfWidgetBinding::bind(ui->comboAnimationType, eventPage->animation_type);
LcfWidgetBinding::bind(ui->comboMoveSpeed, eventPage->move_speed);

ui->spinTimerAMin->setValue(eventPage->condition.timer_sec/60);
ui->spinTimerASec->setValue(eventPage->condition.timer_sec%60);
ui->checkTimerB->setChecked(eventPage->condition.flags.timer2);
ui->spinTimerBMin->setValue(eventPage->condition.timer2_sec/60);
ui->spinTimerBSec->setValue(eventPage->condition.timer2_sec%60);
ui->checkTransparent->setChecked(eventPage->translucent);
ui->comboMoveType->setCurrentIndex(eventPage->move_type);
ui->comboMoveFrequency->setCurrentIndex(eventPage->move_frequency-1);
ui->comboCondition->setCurrentIndex(eventPage->trigger);
ui->comboLayer->setCurrentIndex(eventPage->layer);
ui->checkOverlapForbidden->setChecked(eventPage->overlap_forbidden);
ui->comboAnimationType->setCurrentIndex(eventPage->animation_type);
ui->comboMoveSpeed->setCurrentIndex(eventPage->move_speed-1);

m_effect->setEnabled(m_eventPage->translucent);
updateGraphic();

ui->commands->setData(m_project, eventPage);
}

void EventPageWidget::on_comboMoveType_currentIndexChanged(int index)
{
if (!m_eventPage)
return;
ui->label->setEnabled(index != 0);
ui->comboMoveFrequency->setEnabled(index != 0);
m_eventPage->move_type = index;
}

void EventPageWidget::on_checkSwitchA_toggled(bool checked)
{
if (!m_eventPage)
return;
m_eventPage->condition.flags.switch_a = checked;
}

void EventPageWidget::on_comboSwitchA_currentIndexChanged(int index)
{
if (!m_eventPage)
return;
m_eventPage->condition.switch_a_id = index+1;
}

void EventPageWidget::on_checkSwitchB_toggled(bool checked)
{
if (!m_eventPage)
return;
m_eventPage->condition.flags.switch_b = checked;
}

void EventPageWidget::on_comboSwitchB_currentIndexChanged(int index)
{
if (!m_eventPage)
return;
m_eventPage->condition.switch_b_id = index+1;
}

void EventPageWidget::on_checkVar_toggled(bool checked)
{
if (!m_eventPage)
return;
m_eventPage->condition.flags.variable = checked;
}

void EventPageWidget::on_comboVariable_currentIndexChanged(int index)
{
if (!m_eventPage)
return;
m_eventPage->condition.variable_id = index+1;
}

void EventPageWidget::on_checkItem_toggled(bool checked)
{
if (!m_eventPage)
return;
m_eventPage->condition.flags.item = checked;
}

void EventPageWidget::on_comboVarOperation_currentIndexChanged(int index)
{
if (!m_eventPage)
return;
m_eventPage->condition.compare_operator = index;
}

void EventPageWidget::on_spinVarValue_valueChanged(int arg1)
{
if (!m_eventPage)
return;
m_eventPage->condition.variable_value = arg1;
}

void EventPageWidget::on_comboItem_currentIndexChanged(int index)
{
if (!m_eventPage)
return;
m_eventPage->condition.item_id = index+1;
}

void EventPageWidget::on_comboHero_currentIndexChanged(int index)
{
if (!m_eventPage)
return;
m_eventPage->condition.actor_id = index+1;
ui->comboSwitchA->setEnabled(ui->checkSwitchA->isChecked());
ui->comboSwitchB->setEnabled(ui->checkSwitchB->isChecked());
ui->comboVariable->setEnabled(ui->checkVar->isChecked());
ui->comboVarOperation->setEnabled(ui->checkVar->isChecked());
ui->spinVarValue->setEnabled(ui->checkVar->isChecked());
ui->spinTimerAMin->setEnabled(ui->checkTimerA->isChecked());
ui->spinTimerASec->setEnabled(ui->checkTimerA->isChecked());
ui->spinTimerBMin->setEnabled(ui->checkTimerB->isChecked());
ui->spinTimerBSec->setEnabled(ui->checkTimerB->isChecked());
ui->comboItem->setEnabled(ui->checkItem->isChecked());
ui->comboHero->setEnabled(ui->checkHero->isChecked());
ui->label->setEnabled(ui->comboMoveType->currentIndex() != lcf::rpg::EventPage::MoveType_stationary);
ui->comboMoveFrequency->setEnabled(ui->comboMoveType->currentIndex() != lcf::rpg::EventPage::MoveType_stationary);
}

void EventPageWidget::on_checkHero_toggled(bool checked)
void EventPageWidget::on_comboMoveType_currentIndexChanged(int index)
{
if (!m_eventPage)
return;
m_eventPage->condition.flags.actor = checked;
ui->label->setEnabled(index != lcf::rpg::EventPage::MoveType_stationary);
ui->comboMoveFrequency->setEnabled(index != lcf::rpg::EventPage::MoveType_stationary);
}

void EventPageWidget::on_checkTimerA_toggled(bool checked)
void EventPageWidget::on_checkTransparent_toggled(bool checked)
{
if (!m_eventPage)
return;
m_eventPage->condition.flags.timer = checked;
m_effect->setEnabled(checked);
}

void EventPageWidget::on_spinTimerAMin_valueChanged(int arg1)
Expand All @@ -216,13 +212,6 @@ void EventPageWidget::on_spinTimerASec_valueChanged(int arg1)
m_eventPage->condition.timer_sec = ui->spinTimerAMin->value()*60 + arg1;
}

void EventPageWidget::on_checkTimerB_toggled(bool checked)
{
if (!m_eventPage)
return;
m_eventPage->condition.flags.timer2 = checked;
}

void EventPageWidget::on_spinTimerBMin_valueChanged(int arg1)
{
if (!m_eventPage)
Expand All @@ -237,56 +226,6 @@ void EventPageWidget::on_spinTimerBSec_valueChanged(int arg1)
m_eventPage->condition.timer2_sec = ui->spinTimerBMin->value()*60 + arg1;
}

void EventPageWidget::on_checkTransparent_toggled(bool checked)
{
if (!m_eventPage)
return;
m_eventPage->translucent = checked;
m_effect->setEnabled(checked);
}

void EventPageWidget::on_comboMoveFrequency_currentIndexChanged(int index)
{
if (!m_eventPage)
return;
m_eventPage->move_frequency = index+1;
}

void EventPageWidget::on_comboCondition_currentIndexChanged(int index)
{
if (!m_eventPage)
return;
m_eventPage->trigger = index;
}

void EventPageWidget::on_comboLayer_currentIndexChanged(int index)
{
if (!m_eventPage)
return;
m_eventPage->layer = index;
}

void EventPageWidget::on_checkOverlapForbidden_toggled(bool checked)
{
if (!m_eventPage)
return;
m_eventPage->overlap_forbidden = checked;
}

void EventPageWidget::on_comboAnimationType_currentIndexChanged(int index)
{
if (!m_eventPage)
return;
m_eventPage->animation_type = index;
}

void EventPageWidget::on_comboMoveSpeed_currentIndexChanged(int index)
{
if (!m_eventPage)
return;
m_eventPage->move_speed = index+1;
}

void EventPageWidget::on_pushSetSprite_clicked()
{
/* FIXME CharSetPickerDialog dlg(this, true);
Expand Down
42 changes: 1 addition & 41 deletions src/ui/event/event_page_widget.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -49,56 +49,16 @@ class EventPageWidget : public QWidget
private slots:
void on_comboMoveType_currentIndexChanged(int index);

void on_checkSwitchA_toggled(bool checked);

void on_comboSwitchA_currentIndexChanged(int index);

void on_checkSwitchB_toggled(bool checked);

void on_comboSwitchB_currentIndexChanged(int index);

void on_checkVar_toggled(bool checked);

void on_comboVariable_currentIndexChanged(int index);

void on_checkItem_toggled(bool checked);

void on_comboVarOperation_currentIndexChanged(int index);

void on_spinVarValue_valueChanged(int arg1);

void on_comboItem_currentIndexChanged(int index);

void on_comboHero_currentIndexChanged(int index);

void on_checkHero_toggled(bool checked);

void on_checkTimerA_toggled(bool checked);
void on_checkTransparent_toggled(bool checked);

void on_spinTimerAMin_valueChanged(int arg1);

void on_spinTimerASec_valueChanged(int arg1);

void on_checkTimerB_toggled(bool checked);

void on_spinTimerBMin_valueChanged(int arg1);

void on_spinTimerBSec_valueChanged(int arg1);

void on_checkTransparent_toggled(bool checked);

void on_comboMoveFrequency_currentIndexChanged(int index);

void on_comboCondition_currentIndexChanged(int index);

void on_comboLayer_currentIndexChanged(int index);

void on_checkOverlapForbidden_toggled(bool checked);

void on_comboAnimationType_currentIndexChanged(int index);

void on_comboMoveSpeed_currentIndexChanged(int index);

void on_pushSetSprite_clicked();

private:
Expand Down

0 comments on commit ef1f254

Please sign in to comment.