ship flags stylization pass (#7437)

MjnMixael · web-flow · commit 17b08706c1b2 · 2026-05-14T07:53:23.000-04:00
diff --git a/qtfred/src/mission/dialogs/ShipEditor/ShipFlagsDialogModel.cpp b/qtfred/src/mission/dialogs/ShipEditor/ShipFlagsDialogModel.cpp
@@ -1,6 +1,3 @@
-//
-//
-
 #include "ShipFlagsDialogModel.h"
 
 #include <object/object.h>
@@ -13,81 +10,82 @@ static const Ship::Ship_Flags player_start_hidden_flags[] = {
 	Ship::Ship_Flags::Reinforcement,
 	Ship::Ship_Flags::Kill_before_mission,
 };
-int ShipFlagsDialogModel::tristate_set(int val, int cur_state)
+
+int ShipFlagsDialogModel::tristateSet(int val, int curState)
 {
-	// cur_state uses Qt::CheckState encoding (0=Unchecked, 1=PartiallyChecked, 2=Checked)
-	if (cur_state == Qt::PartiallyChecked)
+	// curState uses Qt::CheckState encoding (0=Unchecked, 1=PartiallyChecked, 2=Checked)
+	if (curState == Qt::PartiallyChecked)
 		return Qt::PartiallyChecked;
-	bool cur_bool = (cur_state == Qt::Checked);
+	bool cur_bool = (curState == Qt::Checked);
 	if (static_cast<bool>(val) != cur_bool)
 		return Qt::PartiallyChecked;
-	return cur_state;
+	return curState;
 }
-std::pair<SCP_string, int>* ShipFlagsDialogModel::getFlag(const SCP_string& flag_name)
-{
 
-	for (auto& flag : flags) {
-		if (!stricmp(flag_name.c_str(), flag.first.c_str())) {
+std::pair<SCP_string, int>* ShipFlagsDialogModel::getFlag(const SCP_string& flagName)
+{
+	for (auto& flag : _flags) {
+		if (!stricmp(flagName.c_str(), flag.first.c_str())) {
 			return &flag;
 		}
 	}
 	// Only assert if the name isn't a known flag at all; it may have been legitimately filtered out for ship starts
 	bool known = false;
 	for (size_t i = 0; i < Num_Parse_ship_flags && !known; ++i)
-		known = !stricmp(flag_name.c_str(), Parse_ship_flags[i].name);
+		known = !stricmp(flagName.c_str(), Parse_ship_flags[i].name);
 	for (size_t i = 0; i < Num_Parse_ship_ai_flags && !known; ++i)
-		known = !stricmp(flag_name.c_str(), Parse_ship_ai_flags[i].name);
+		known = !stricmp(flagName.c_str(), Parse_ship_ai_flags[i].name);
 	for (size_t i = 0; i < Num_Parse_ship_object_flags && !known; ++i)
-		known = !stricmp(flag_name.c_str(), Parse_ship_object_flags[i].name);
-	Assertion(known, "Illegal flag name \"%s\"", flag_name.c_str());
+		known = !stricmp(flagName.c_str(), Parse_ship_object_flags[i].name);
+	Assertion(known, "Illegal flag name \"%s\"", flagName.c_str());
 	return nullptr;
 }
 
-void ShipFlagsDialogModel::setFlag(const SCP_string& flag_name, int value)
+void ShipFlagsDialogModel::setFlag(const SCP_string& flagName, int state)
 {
-	for (auto& flag : flags) {
-		if (!stricmp(flag_name.c_str(), flag.first.c_str())) {
-			flag.second = value;
+	for (auto& flag : _flags) {
+		if (!stricmp(flagName.c_str(), flag.first.c_str())) {
+			flag.second = state;
 			set_modified();
 		}
 	}
 }
 
-void ShipFlagsDialogModel::setDestroyTime(int value)
+void ShipFlagsDialogModel::setDestroyTime(int destroyTime)
 {
-	modify(destroytime, value);
+	modify(_destroyTime, destroyTime);
 }
 
 int ShipFlagsDialogModel::getDestroyTime() const
 {
-	return destroytime;
+	return _destroyTime;
 }
 
-void ShipFlagsDialogModel::setEscortPriority(int value)
+void ShipFlagsDialogModel::setEscortPriority(int priority)
 {
-	modify(escortp, value);
+	modify(_escortPriority, priority);
 }
 
 int ShipFlagsDialogModel::getEscortPriority() const
 {
-	return escortp;
+	return _escortPriority;
 }
 
-void ShipFlagsDialogModel::setKamikazeDamage(int value)
+void ShipFlagsDialogModel::setKamikazeDamage(int damage)
 {
-	modify(kamikazed, value);
+	modify(_kamikazeDamage, damage);
 }
 
 int ShipFlagsDialogModel::getKamikazeDamage() const
 {
-	return kamikazed;
+	return _kamikazeDamage;
 }
 
-void ShipFlagsDialogModel::update_ship(const int shipnum)
+void ShipFlagsDialogModel::updateShip(int shipNum)
 {
-	ship* shipp = &Ships[shipnum];
+	ship* shipp = &Ships[shipNum];
 	object* objp = &Objects[shipp->objnum];
-	for (const auto& [name, checked] : flags) {
+	for (const auto& [name, checked] : _flags) {
 		// PartiallyChecked means mixed selection — leave each ship's flag as-is
 		if (checked == Qt::PartiallyChecked)
 			continue;
@@ -145,10 +143,11 @@ void ShipFlagsDialogModel::update_ship(const int shipnum)
 			}
 		}
 	}
-	Ai_info[shipp->ai_index].kamikaze_damage = kamikazed;
-	shipp->escort_priority = escortp;
-	shipp->final_death_time = destroytime;
+	Ai_info[shipp->ai_index].kamikaze_damage = _kamikazeDamage;
+	shipp->escort_priority = _escortPriority;
+	shipp->final_death_time = _destroyTime;
 }
+
 ShipFlagsDialogModel::ShipFlagsDialogModel(QObject* parent, EditorViewport* viewport)
 	: AbstractDialogModel(parent, viewport)
 {
@@ -163,7 +162,7 @@ bool ShipFlagsDialogModel::apply()
 	while (objp != END_OF_LIST(&obj_used_list)) {
 		if ((objp->type == OBJ_START) || (objp->type == OBJ_SHIP)) {
 			if (objp->flags[Object::Object_Flags::Marked]) {
-				update_ship(objp->instance);
+				updateShip(objp->instance);
 			}
 		}
 		objp = GET_NEXT(objp);
@@ -176,7 +175,7 @@ void ShipFlagsDialogModel::reject() {}
 
 const SCP_vector<std::pair<SCP_string, int>>& ShipFlagsDialogModel::getFlagsList()
 {
-	return flags;
+	return _flags;
 }
 
 SCP_vector<std::pair<SCP_string, SCP_string>> ShipFlagsDialogModel::getShipFlagDescriptions()
@@ -262,9 +261,9 @@ void ShipFlagsDialogModel::initializeData()
 			if (objp->flags[Object::Object_Flags::Marked]) {
 				shipp = &Ships[objp->instance];
 				if (first) {
-					kamikazed = Ai_info[shipp->ai_index].kamikaze_damage;
-					escortp = shipp->escort_priority;
-					destroytime = shipp->final_death_time;
+					_kamikazeDamage = Ai_info[shipp->ai_index].kamikaze_damage;
+					_escortPriority = shipp->escort_priority;
+					_destroyTime = shipp->final_death_time;
 					for (size_t i = 0; i < Num_Parse_ship_flags; i++) {
 						auto flagDef = Parse_ship_flags[i];
 
@@ -290,12 +289,12 @@ void ShipFlagsDialogModel::initializeData()
 							if (hidden) continue;
 						}
 						bool checked = shipp->flags[flagDef.def];
-						flags.emplace_back(flagDef.name, checked ? Qt::Checked : Qt::Unchecked);
+						_flags.emplace_back(flagDef.name, checked ? Qt::Checked : Qt::Unchecked);
 					}
 					for (size_t i = 0; i < Num_Parse_ship_ai_flags; i++) {
 						auto flagDef = Parse_ship_ai_flags[i];
 						bool checked = Ai_info[shipp->ai_index].ai_flags[flagDef.def];
-						flags.emplace_back(flagDef.name, checked ? Qt::Checked : Qt::Unchecked);
+						_flags.emplace_back(flagDef.name, checked ? Qt::Checked : Qt::Unchecked);
 					}
 					for (size_t i = 0; i < Num_Parse_ship_object_flags; i++) {
 						auto flagDef = Parse_ship_object_flags[i];
@@ -305,7 +304,7 @@ void ShipFlagsDialogModel::initializeData()
 						} else {
 							checked = objp->flags[flagDef.def];
 						}
-						flags.emplace_back(flagDef.name, checked ? Qt::Checked : Qt::Unchecked);
+						_flags.emplace_back(flagDef.name, checked ? Qt::Checked : Qt::Unchecked);
 					}
 					first = 0;
 				} else {
@@ -333,12 +332,12 @@ void ShipFlagsDialogModel::initializeData()
 							if (hidden) continue;
 						}
 						bool checked = shipp->flags[flagDef.def];
-						getFlag(flagDef.name)->second = tristate_set(checked, getFlag(flagDef.name)->second);
+						getFlag(flagDef.name)->second = tristateSet(checked, getFlag(flagDef.name)->second);
 					}
 					for (size_t i = 0; i < Num_Parse_ship_ai_flags; i++) {
 						auto flagDef = Parse_ship_ai_flags[i];
 						bool checked = Ai_info[shipp->ai_index].ai_flags[flagDef.def];
-						getFlag(flagDef.name)->second = tristate_set(checked, getFlag(flagDef.name)->second);
+						getFlag(flagDef.name)->second = tristateSet(checked, getFlag(flagDef.name)->second);
 					}
 					for (size_t i = 0; i < Num_Parse_ship_object_flags; i++) {
 						auto flagDef = Parse_ship_object_flags[i];
@@ -352,15 +351,17 @@ void ShipFlagsDialogModel::initializeData()
 						} else {
 							checked = objp->flags[flagDef.def];
 						}
-						getFlag(flagDef.name)->second = tristate_set(checked, getFlag(flagDef.name)->second);
+						getFlag(flagDef.name)->second = tristateSet(checked, getFlag(flagDef.name)->second);
 					}
 				}
 			}
 		}
 
 		objp = GET_NEXT(objp);
 	}
+	_modified = false;
 	modelChanged();
 	_modified = false;
 }
+
 } // namespace fso::fred::dialogs
diff --git a/qtfred/src/mission/dialogs/ShipEditor/ShipFlagsDialogModel.h b/qtfred/src/mission/dialogs/ShipEditor/ShipFlagsDialogModel.h
@@ -7,31 +7,33 @@
 namespace fso::fred::dialogs {
 
 class ShipFlagsDialogModel : public AbstractDialogModel {
-  private:
-	static int tristate_set(const int val, const int cur_state);
-	void update_ship(const int);
-	SCP_vector<std::pair<SCP_string, int>> flags;
-	int destroytime;
-	int escortp;
-	int kamikazed;
-
+	Q_OBJECT
   public:
 	ShipFlagsDialogModel(QObject* parent, EditorViewport* viewport);
-	void initializeData();
 
 	bool apply() override;
 	void reject() override;
 
 	const SCP_vector<std::pair<SCP_string, int>>& getFlagsList();
 	static SCP_vector<std::pair<SCP_string, SCP_string>> getShipFlagDescriptions();
-	std::pair<SCP_string, int>* getFlag(const SCP_string& flag_name);
-	void setFlag(const SCP_string& flag_name, int);
+	std::pair<SCP_string, int>* getFlag(const SCP_string& flagName);
+	void setFlag(const SCP_string& flagName, int state);
 
-	void setDestroyTime(int);
+	void setDestroyTime(int destroyTime);
 	int getDestroyTime() const;
-	void setEscortPriority(int);
+	void setEscortPriority(int priority);
 	int getEscortPriority() const;
-	void setKamikazeDamage(int);
+	void setKamikazeDamage(int damage);
 	int getKamikazeDamage() const;
+
+  private: // NOLINT(readability-redundant-access-specifiers)
+	void initializeData();
+	static int tristateSet(int val, int curState);
+	void updateShip(int shipNum);
+
+	SCP_vector<std::pair<SCP_string, int>> _flags;
+	int _destroyTime;
+	int _escortPriority;
+	int _kamikazeDamage;
 };
-} // namespace fso::fred::dialogs
+} // namespace fso::fred::dialogs
diff --git a/qtfred/src/ui/dialogs/ShipEditor/ShipFlagsDialog.cpp b/qtfred/src/ui/dialogs/ShipEditor/ShipFlagsDialog.cpp
@@ -21,7 +21,7 @@ ShipFlagsDialog::ShipFlagsDialog(QWidget* parent, EditorViewport* viewport)
 			for (const auto& [name, state] : snapshot) {
 				_model->setFlag(name.toUtf8().constData(), state);
 			}
-			updateUI();
+			updateUi();
 		});
 
 	const auto& flags = _model->getFlagsList();
@@ -33,16 +33,19 @@ ShipFlagsDialog::ShipFlagsDialog(QWidget* parent, EditorViewport* viewport)
 		toWidget.append({name, p.second});
 	}
 
-	ui->flagList->setFlags(toWidget);
+	{
+		QSignalBlocker blocker(ui->flagList);
+		ui->flagList->setFlags(toWidget);
 
-	const auto descs = _model->getShipFlagDescriptions();
-	QVector<std::pair<QString, QString>> qtDescs;
-	qtDescs.reserve(static_cast<int>(descs.size()));
-	for (const auto& d : descs)
-		qtDescs.append({QString::fromUtf8(d.first.c_str()), QString::fromUtf8(d.second.c_str())});
-	ui->flagList->setFlagDescriptions(qtDescs);
+		const auto descs = _model->getShipFlagDescriptions();
+		QVector<std::pair<QString, QString>> qtDescs;
+		qtDescs.reserve(static_cast<int>(descs.size()));
+		for (const auto& d : descs)
+			qtDescs.append({QString::fromUtf8(d.first.c_str()), QString::fromUtf8(d.second.c_str())});
+		ui->flagList->setFlagDescriptions(qtDescs);
+	}
 
-	updateUI();
+	updateUi();
 	// Resize the dialog to the minimum size
 	resize(QDialog::sizeHint());
 }
@@ -92,7 +95,7 @@ void ShipFlagsDialog::on_kamikazeDamageSpinBox_valueChanged(int value)
 {
 	_model->setKamikazeDamage(value);
 }
-void ShipFlagsDialog::updateUI()
+void ShipFlagsDialog::updateUi()
 {
 	util::SignalBlockers blockers(this);
 	ui->destroySecondsSpinBox->setValue(_model->getDestroyTime());
diff --git a/qtfred/src/ui/dialogs/ShipEditor/ShipFlagsDialog.h b/qtfred/src/ui/dialogs/ShipEditor/ShipFlagsDialog.h
@@ -1,5 +1,4 @@
-#ifndef SHIPFLAGDIALOG_H
-#define SHIPFLAGDIALOG_H
+#pragma once
 
 #include <mission/dialogs/ShipEditor/ShipFlagsDialogModel.h>
 #include <ui/FredView.h>
@@ -33,8 +32,6 @@ class ShipFlagsDialog : public QDialog {
 	std::unique_ptr<Ui::ShipFlagsDialog> ui;
 	std::unique_ptr<ShipFlagsDialogModel> _model;
 	EditorViewport* _viewport;
-	void updateUI();
+	void updateUi();
 };
 } // namespace fso::fred::dialogs
-
-#endif // !SHIPFLAGDIALOG_H

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,3 @@`
`1`		`-//`
`2`		`-//`
`3`		`-`
`4`	`1`	`#include "ShipFlagsDialogModel.h"`
`5`	`2`
`6`	`3`	`#include <object/object.h>`
`@@ -13,81 +10,82 @@ static const Ship::Ship_Flags player_start_hidden_flags[] = {`
`13`	`10`	`Ship::Ship_Flags::Reinforcement,`
`14`	`11`	`Ship::Ship_Flags::Kill_before_mission,`
`15`	`12`	`};`
`16`		`-int ShipFlagsDialogModel::tristate_set(int val, int cur_state)`
	`13`	`+`
	`14`	`+int ShipFlagsDialogModel::tristateSet(int val, int curState)`
`17`	`15`	`{`
`18`		`- // cur_state uses Qt::CheckState encoding (0=Unchecked, 1=PartiallyChecked, 2=Checked)`
`19`		`- if (cur_state == Qt::PartiallyChecked)`
	`16`	`+ // curState uses Qt::CheckState encoding (0=Unchecked, 1=PartiallyChecked, 2=Checked)`
	`17`	`+ if (curState == Qt::PartiallyChecked)`
`20`	`18`	`return Qt::PartiallyChecked;`
`21`		`- bool cur_bool = (cur_state == Qt::Checked);`
	`19`	`+ bool cur_bool = (curState == Qt::Checked);`
`22`	`20`	`if (static_cast<bool>(val) != cur_bool)`
`23`	`21`	`return Qt::PartiallyChecked;`
`24`		`- return cur_state;`
	`22`	`+ return curState;`
`25`	`23`	`}`
`26`		`-std::pair<SCP_string, int>* ShipFlagsDialogModel::getFlag(const SCP_string& flag_name)`
`27`		`-{`
`28`	`24`
`29`		`- for (auto& flag : flags) {`
`30`		`- if (!stricmp(flag_name.c_str(), flag.first.c_str())) {`
	`25`	`+std::pair<SCP_string, int>* ShipFlagsDialogModel::getFlag(const SCP_string& flagName)`
	`26`	`+{`
	`27`	`+ for (auto& flag : _flags) {`
	`28`	`+ if (!stricmp(flagName.c_str(), flag.first.c_str())) {`
`31`	`29`	`return &flag;`
`32`	`30`	`}`
`33`	`31`	`}`
`34`	`32`	`// Only assert if the name isn't a known flag at all; it may have been legitimately filtered out for ship starts`
`35`	`33`	`bool known = false;`
`36`	`34`	`for (size_t i = 0; i < Num_Parse_ship_flags && !known; ++i)`
`37`		`- known = !stricmp(flag_name.c_str(), Parse_ship_flags[i].name);`
	`35`	`+ known = !stricmp(flagName.c_str(), Parse_ship_flags[i].name);`
`38`	`36`	`for (size_t i = 0; i < Num_Parse_ship_ai_flags && !known; ++i)`
`39`		`- known = !stricmp(flag_name.c_str(), Parse_ship_ai_flags[i].name);`
	`37`	`+ known = !stricmp(flagName.c_str(), Parse_ship_ai_flags[i].name);`
`40`	`38`	`for (size_t i = 0; i < Num_Parse_ship_object_flags && !known; ++i)`
`41`		`- known = !stricmp(flag_name.c_str(), Parse_ship_object_flags[i].name);`
`42`		`- Assertion(known, "Illegal flag name \"%s\"", flag_name.c_str());`
	`39`	`+ known = !stricmp(flagName.c_str(), Parse_ship_object_flags[i].name);`
	`40`	`+ Assertion(known, "Illegal flag name \"%s\"", flagName.c_str());`
`43`	`41`	`return nullptr;`
`44`	`42`	`}`
`45`	`43`
`46`		`-void ShipFlagsDialogModel::setFlag(const SCP_string& flag_name, int value)`
	`44`	`+void ShipFlagsDialogModel::setFlag(const SCP_string& flagName, int state)`
`47`	`45`	`{`
`48`		`- for (auto& flag : flags) {`
`49`		`- if (!stricmp(flag_name.c_str(), flag.first.c_str())) {`
`50`		`- flag.second = value;`
	`46`	`+ for (auto& flag : _flags) {`
	`47`	`+ if (!stricmp(flagName.c_str(), flag.first.c_str())) {`
	`48`	`+ flag.second = state;`
`51`	`49`	`set_modified();`
`52`	`50`	`}`
`53`	`51`	`}`
`54`	`52`	`}`
`55`	`53`
`56`		`-void ShipFlagsDialogModel::setDestroyTime(int value)`
	`54`	`+void ShipFlagsDialogModel::setDestroyTime(int destroyTime)`
`57`	`55`	`{`
`58`		`- modify(destroytime, value);`
	`56`	`+ modify(_destroyTime, destroyTime);`
`59`	`57`	`}`
`60`	`58`
`61`	`59`	`int ShipFlagsDialogModel::getDestroyTime() const`
`62`	`60`	`{`
`63`		`- return destroytime;`
	`61`	`+ return _destroyTime;`
`64`	`62`	`}`
`65`	`63`
`66`		`-void ShipFlagsDialogModel::setEscortPriority(int value)`
	`64`	`+void ShipFlagsDialogModel::setEscortPriority(int priority)`
`67`	`65`	`{`
`68`		`- modify(escortp, value);`
	`66`	`+ modify(_escortPriority, priority);`
`69`	`67`	`}`
`70`	`68`
`71`	`69`	`int ShipFlagsDialogModel::getEscortPriority() const`
`72`	`70`	`{`
`73`		`- return escortp;`
	`71`	`+ return _escortPriority;`
`74`	`72`	`}`
`75`	`73`
`76`		`-void ShipFlagsDialogModel::setKamikazeDamage(int value)`
	`74`	`+void ShipFlagsDialogModel::setKamikazeDamage(int damage)`
`77`	`75`	`{`
`78`		`- modify(kamikazed, value);`
	`76`	`+ modify(_kamikazeDamage, damage);`
`79`	`77`	`}`
`80`	`78`
`81`	`79`	`int ShipFlagsDialogModel::getKamikazeDamage() const`
`82`	`80`	`{`
`83`		`- return kamikazed;`
	`81`	`+ return _kamikazeDamage;`
`84`	`82`	`}`
`85`	`83`
`86`		`-void ShipFlagsDialogModel::update_ship(const int shipnum)`
	`84`	`+void ShipFlagsDialogModel::updateShip(int shipNum)`
`87`	`85`	`{`
`88`		`- ship* shipp = &Ships[shipnum];`
	`86`	`+ ship* shipp = &Ships[shipNum];`
`89`	`87`	`object* objp = &Objects[shipp->objnum];`
`90`		`- for (const auto& [name, checked] : flags) {`
	`88`	`+ for (const auto& [name, checked] : _flags) {`
`91`	`89`	`// PartiallyChecked means mixed selection — leave each ship's flag as-is`
`92`	`90`	`if (checked == Qt::PartiallyChecked)`
`93`	`91`	`continue;`
`@@ -145,10 +143,11 @@ void ShipFlagsDialogModel::update_ship(const int shipnum)`
`145`	`143`	`}`
`146`	`144`	`}`
`147`	`145`	`}`
`148`		`- Ai_info[shipp->ai_index].kamikaze_damage = kamikazed;`
`149`		`- shipp->escort_priority = escortp;`
`150`		`- shipp->final_death_time = destroytime;`
	`146`	`+ Ai_info[shipp->ai_index].kamikaze_damage = _kamikazeDamage;`
	`147`	`+ shipp->escort_priority = _escortPriority;`
	`148`	`+ shipp->final_death_time = _destroyTime;`
`151`	`149`	`}`
	`150`	`+`
`152`	`151`	`ShipFlagsDialogModel::ShipFlagsDialogModel(QObject* parent, EditorViewport* viewport)`
`153`	`152`	`: AbstractDialogModel(parent, viewport)`
`154`	`153`	`{`
`@@ -163,7 +162,7 @@ bool ShipFlagsDialogModel::apply()`
`163`	`162`	`while (objp != END_OF_LIST(&obj_used_list)) {`
`164`	`163`	`if ((objp->type == OBJ_START) \|\| (objp->type == OBJ_SHIP)) {`
`165`	`164`	`if (objp->flags[Object::Object_Flags::Marked]) {`
`166`		`- update_ship(objp->instance);`
	`165`	`+ updateShip(objp->instance);`
`167`	`166`	`}`
`168`	`167`	`}`
`169`	`168`	`objp = GET_NEXT(objp);`
`@@ -176,7 +175,7 @@ void ShipFlagsDialogModel::reject() {}`
`176`	`175`
`177`	`176`	`const SCP_vector<std::pair<SCP_string, int>>& ShipFlagsDialogModel::getFlagsList()`
`178`	`177`	`{`
`179`		`- return flags;`
	`178`	`+ return _flags;`
`180`	`179`	`}`
`181`	`180`
`182`	`181`	`SCP_vector<std::pair<SCP_string, SCP_string>> ShipFlagsDialogModel::getShipFlagDescriptions()`
`@@ -262,9 +261,9 @@ void ShipFlagsDialogModel::initializeData()`
`262`	`261`	`if (objp->flags[Object::Object_Flags::Marked]) {`
`263`	`262`	`shipp = &Ships[objp->instance];`
`264`	`263`	`if (first) {`
`265`		`- kamikazed = Ai_info[shipp->ai_index].kamikaze_damage;`
`266`		`- escortp = shipp->escort_priority;`
`267`		`- destroytime = shipp->final_death_time;`
	`264`	`+ _kamikazeDamage = Ai_info[shipp->ai_index].kamikaze_damage;`
	`265`	`+ _escortPriority = shipp->escort_priority;`
	`266`	`+ _destroyTime = shipp->final_death_time;`
`268`	`267`	`for (size_t i = 0; i < Num_Parse_ship_flags; i++) {`
`269`	`268`	`auto flagDef = Parse_ship_flags[i];`
`270`	`269`
`@@ -290,12 +289,12 @@ void ShipFlagsDialogModel::initializeData()`
`290`	`289`	`if (hidden) continue;`
`291`	`290`	`}`
`292`	`291`	`bool checked = shipp->flags[flagDef.def];`
`293`		`- flags.emplace_back(flagDef.name, checked ? Qt::Checked : Qt::Unchecked);`
	`292`	`+ _flags.emplace_back(flagDef.name, checked ? Qt::Checked : Qt::Unchecked);`
`294`	`293`	`}`
`295`	`294`	`for (size_t i = 0; i < Num_Parse_ship_ai_flags; i++) {`
`296`	`295`	`auto flagDef = Parse_ship_ai_flags[i];`
`297`	`296`	`bool checked = Ai_info[shipp->ai_index].ai_flags[flagDef.def];`
`298`		`- flags.emplace_back(flagDef.name, checked ? Qt::Checked : Qt::Unchecked);`
	`297`	`+ _flags.emplace_back(flagDef.name, checked ? Qt::Checked : Qt::Unchecked);`
`299`	`298`	`}`
`300`	`299`	`for (size_t i = 0; i < Num_Parse_ship_object_flags; i++) {`
`301`	`300`	`auto flagDef = Parse_ship_object_flags[i];`
`@@ -305,7 +304,7 @@ void ShipFlagsDialogModel::initializeData()`
`305`	`304`	`} else {`
`306`	`305`	`checked = objp->flags[flagDef.def];`
`307`	`306`	`}`
`308`		`- flags.emplace_back(flagDef.name, checked ? Qt::Checked : Qt::Unchecked);`
	`307`	`+ _flags.emplace_back(flagDef.name, checked ? Qt::Checked : Qt::Unchecked);`
`309`	`308`	`}`
`310`	`309`	`first = 0;`
`311`	`310`	`} else {`
`@@ -333,12 +332,12 @@ void ShipFlagsDialogModel::initializeData()`
`333`	`332`	`if (hidden) continue;`
`334`	`333`	`}`
`335`	`334`	`bool checked = shipp->flags[flagDef.def];`
`336`		`- getFlag(flagDef.name)->second = tristate_set(checked, getFlag(flagDef.name)->second);`
	`335`	`+ getFlag(flagDef.name)->second = tristateSet(checked, getFlag(flagDef.name)->second);`
`337`	`336`	`}`
`338`	`337`	`for (size_t i = 0; i < Num_Parse_ship_ai_flags; i++) {`
`339`	`338`	`auto flagDef = Parse_ship_ai_flags[i];`
`340`	`339`	`bool checked = Ai_info[shipp->ai_index].ai_flags[flagDef.def];`
`341`		`- getFlag(flagDef.name)->second = tristate_set(checked, getFlag(flagDef.name)->second);`
	`340`	`+ getFlag(flagDef.name)->second = tristateSet(checked, getFlag(flagDef.name)->second);`
`342`	`341`	`}`
`343`	`342`	`for (size_t i = 0; i < Num_Parse_ship_object_flags; i++) {`
`344`	`343`	`auto flagDef = Parse_ship_object_flags[i];`
`@@ -352,15 +351,17 @@ void ShipFlagsDialogModel::initializeData()`
`352`	`351`	`} else {`
`353`	`352`	`checked = objp->flags[flagDef.def];`
`354`	`353`	`}`
`355`		`- getFlag(flagDef.name)->second = tristate_set(checked, getFlag(flagDef.name)->second);`
	`354`	`+ getFlag(flagDef.name)->second = tristateSet(checked, getFlag(flagDef.name)->second);`
`356`	`355`	`}`
`357`	`356`	`}`
`358`	`357`	`}`
`359`	`358`	`}`
`360`	`359`
`361`	`360`	`objp = GET_NEXT(objp);`
`362`	`361`	`}`
	`362`	`+ _modified = false;`
`363`	`363`	`modelChanged();`
`364`	`364`	`_modified = false;`
`365`	`365`	`}`
	`366`	`+`
`366`	`367`	`} // namespace fso::fred::dialogs`