Debian Codegraph @

src/pool-prj-mgr/pool-mgr/editors/editor_window.cpp

raw
1 #include "editor_window.hpp"
2 #include "unit_editor.hpp"
3 #include "entity_editor.hpp"
4 #include "part_editor.hpp"
5 #include "pool/unit.hpp"
6 #include "pool/entity.hpp"
7 #include "pool/part.hpp"
8 #include "util/util.hpp"
9 #include "util/str_util.hpp"
10 #include "util/gtk_util.hpp"
11 #include "pool/ipool.hpp"
12 #include "nlohmann/json.hpp"
13 #include "widgets/color_box.hpp"
14 #include "checks/check_entity.hpp"
15 #include "checks/check_unit.hpp"
16 #include "checks/check_part.hpp"
17 #include "common/object_descr.hpp"
18
19 namespace horizon {
20
21 EditorWindow::EditorWindow(ObjectType ty, const std::string &filename, IPool *p, class PoolParametric *pp,
22 bool a_read_only, bool is_temp)
23 : Gtk::Window(), type(ty), pool(*p), pool_parametric(pp),
24 state_store(this, "pool-editor-win-" + std::to_string(static_cast<int>(type))), read_only(a_read_only)
25 {
26 set_type_hint(Gdk::WINDOW_TYPE_HINT_DIALOG);
27 auto hb = Gtk::manage(new Gtk::HeaderBar());
28 set_titlebar(*hb);
29
30 save_button = Gtk::manage(new Gtk::Button());
31 save_button->add_accelerator("clicked", get_accel_group(), GDK_KEY_s, Gdk::CONTROL_MASK, Gtk::ACCEL_VISIBLE);
32 hb->pack_start(*save_button);
33
34 {
35 auto box = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_HORIZONTAL));
36 box->get_style_context()->add_class("linked");
37
38 undo_button = Gtk::manage(new Gtk::Button);
39 undo_button->set_tooltip_text("Undo (Ctrl+z)");
40 undo_button->set_image_from_icon_name("edit-undo-symbolic", Gtk::ICON_SIZE_BUTTON);
41 undo_button->add_accelerator("clicked", get_accel_group(), GDK_KEY_z, Gdk::CONTROL_MASK, Gtk::ACCEL_VISIBLE);
42 box->pack_start(*undo_button, false, false, 0);
43
44 redo_button = Gtk::manage(new Gtk::Button);
45 redo_button->set_tooltip_text("Redo (Ctrl+y, Ctrl+Z)");
46 redo_button->add_accelerator("clicked", get_accel_group(), GDK_KEY_z, Gdk::CONTROL_MASK | Gdk::SHIFT_MASK,
47 Gtk::ACCEL_VISIBLE);
48 redo_button->add_accelerator("clicked", get_accel_group(), GDK_KEY_y, Gdk::CONTROL_MASK, Gtk::ACCEL_VISIBLE);
49 redo_button->set_image_from_icon_name("edit-redo-symbolic", Gtk::ICON_SIZE_BUTTON);
50 box->pack_start(*redo_button, false, false, 0);
51
52 hb->pack_start(*box);
53 box->show_all();
54 }
55
56 check_button = Gtk::manage(new Gtk::MenuButton());
57 {
58 auto box = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_HORIZONTAL, 5));
59 check_color_box = Gtk::manage(new ColorBox);
60 check_color_box->set_valign(Gtk::ALIGN_CENTER);
61 check_color_box->set_size_request(16, 16);
62 box->pack_start(*check_color_box, false, false, 0);
63 check_button_stack = Gtk::manage(new Gtk::Stack);
64 check_button_stack->set_transition_duration(150);
65 check_button_stack->set_transition_type(Gtk::STACK_TRANSITION_TYPE_SLIDE_UP_DOWN);
66 box->pack_start(*check_button_stack, false, false, 0);
67 check_button->add(*box);
68 {
69 auto la = Gtk::manage(new Gtk::Label("Checks passed"));
70 la->show();
71 la->set_xalign(0);
72 check_button_stack->add(*la, "pass");
73 }
74 {
75 auto la = Gtk::manage(new Gtk::Label("Checks didn't pass"));
76 la->show();
77 la->set_xalign(0);
78 check_button_stack->add(*la, "fail");
79 }
80 }
81 check_popover = Gtk::manage(new Gtk::Popover);
82 check_button->set_popover(*check_popover);
83 check_label = Gtk::manage(new Gtk::Label("foo"));
84 check_label->property_margin() = 10;
85 check_popover->add(*check_label);
86 check_label->show();
87 hb->pack_end(*check_button);
88
89
90 hb->show_all();
91 hb->set_show_close_button(true);
92
93
94 Gtk::Widget *editor = nullptr;
95 switch (type) {
96 case ObjectType::UNIT: {
97 auto ed = UnitEditor::create(filename, pool);
98 editor = ed;
99 iface = ed;
100 hb->set_title("Unit Editor");
101 } break;
102 case ObjectType::ENTITY: {
103 auto ed = EntityEditor::create(filename, pool);
104 editor = ed;
105 iface = ed;
106 hb->set_title("Entity Editor");
107 } break;
108 case ObjectType::PART: {
109 auto ed = PartEditor::create(filename, pool, *pool_parametric);
110 editor = ed;
111 iface = ed;
112 hb->set_title("Part Editor");
113 } break;
114 default:;
115 }
116
117 update_undo_redo();
118 undo_button->signal_clicked().connect([this] {
119 iface->undo();
120 update_undo_redo();
121 });
122 redo_button->signal_clicked().connect([this] {
123 iface->redo();
124 update_undo_redo();
125 });
126
127
128 auto box = Gtk::manage(new Gtk::Box(Gtk::Orientation::ORIENTATION_VERTICAL, 0));
129 add(*box);
130 box->show();
131
132 {
133 info_bar = Gtk::manage(new Gtk::InfoBar());
134 info_bar_label = Gtk::manage(new Gtk::Label);
135 info_bar_label->set_line_wrap(true);
136 dynamic_cast<Gtk::Container &>(*info_bar->get_content_area()).add(*info_bar_label);
137 info_bar_label->show();
138 info_bar->show();
139 box->pack_start(*info_bar, false, false, 0);
140 info_bar_hide(info_bar);
141 }
142
143 {
144 const auto &version = iface->get_version();
145 if (version.get_app() < version.get_file()) {
146 info_bar_label->set_markup(version.get_message(iface->get_type()));
147 read_only = true;
148 info_bar_show(info_bar);
149 }
150 }
151 saved_version = iface->get_version().get_file();
152
153 editor->show();
154 box->pack_start(*editor, true, true, 0);
155 editor->unreference();
156
157 if (read_only)
158 save_button->set_sensitive(false);
159
160 if (is_temp) {
161 Gio::File::create_for_path(filename)->remove();
162 iface->filename.clear();
163 }
164
165 if (iface->filename.size()) {
166 save_button->set_label("Save");
167 }
168 else {
169 save_button->set_label("Save as..");
170 }
171
172 assert(iface);
173 iface->signal_goto().connect([this](ObjectType t, UUID uu) { s_signal_goto.emit(t, uu); });
174 iface->signal_open_item().connect([this](ObjectType t, UUID uu) { s_signal_open_item.emit(t, uu); });
175 if (!read_only) {
176 save_button->set_sensitive(iface->get_needs_save());
177 iface->signal_needs_save().connect([this] {
178 save_button->set_sensitive(iface->get_needs_save());
179 update_undo_redo();
180 });
181 }
182 iface->signal_needs_save().connect([this] {
183 if (iface->get_needs_save()) {
184 run_checks();
185 }
186 update_version_warning();
187 });
188 iface->signal_extra_file_saved().connect([this](const auto &fn) { s_signal_saved.emit(fn); });
189 run_checks();
190
191 if (!state_store.get_default_set())
192 set_default_size(-1, 600);
193
194 signal_delete_event().connect([this](GdkEventAny *ev) {
195 if (iface && iface->get_needs_save()) {
196 if (!read_only) { // not read only
197 Gtk::MessageDialog md(*this, "Save changes before closing?", false /* use_markup */,
198 Gtk::MESSAGE_QUESTION, Gtk::BUTTONS_NONE);
199 md.set_secondary_text(
200 "If you don't save, all your changes will be permanently "
201 "lost.");
202 md.add_button("Close without Saving", 1);
203 md.add_button("Cancel", Gtk::RESPONSE_CANCEL);
204 md.add_button("Save", 2);
205 switch (md.run()) {
206 case 1:
207 return false; // close
208
209 case 2:
210 save();
211 return false; // close
212
213 default:
214 return true; // keep window open
215 }
216 return false;
217 }
218 else {
219 Gtk::MessageDialog md(*this, "Document is read only", false /* use_markup */, Gtk::MESSAGE_QUESTION,
220 Gtk::BUTTONS_NONE);
221 md.set_secondary_text("You won't be able to save your changes");
222 md.add_button("Close without Saving", 1);
223 md.add_button("Cancel", Gtk::RESPONSE_CANCEL);
224 switch (md.run()) {
225 case 1:
226 return false; // close
227
228 default:
229 return true; // keep window open
230 }
231 return false;
232 }
233 }
234 return false;
235 });
236
237 save_button->signal_clicked().connect(sigc::mem_fun(*this, &EditorWindow::save));
238 }
239
240 void EditorWindow::update_version_warning()
241 {
242 if (read_only)
243 return;
244 if (iface->get_required_version() > saved_version) {
245 const auto &t = object_descriptions.at(iface->get_type()).name;
246 info_bar_label->set_markup("Saving this " + t + " will update it from version " + std::to_string(saved_version)
247 + " to " + std::to_string(iface->get_required_version()) + " . "
248 + FileVersion::learn_more_markup);
249 info_bar_show(info_bar);
250 }
251 else {
252 info_bar_hide(info_bar);
253 }
254 }
255
256 void EditorWindow::force_close()
257 {
258 hide();
259 }
260
261 bool EditorWindow::get_needs_save() const
262 {
263 return iface->get_needs_save();
264 }
265
266 void EditorWindow::set_original_filename(const std::string &s)
267 {
268 original_filename = s;
269 }
270
271 void EditorWindow::save()
272 {
273 if (read_only)
274 return;
275 if (iface->filename.size()) {
276 iface->save_as(iface->filename);
277 saved_version = iface->get_required_version();
278 need_update = true;
279 s_signal_saved.emit(iface->filename);
280 }
281 else {
282 GtkFileChooserNative *native = gtk_file_chooser_native_new("Save", GTK_WINDOW(gobj()),
283 GTK_FILE_CHOOSER_ACTION_SAVE, "_Save", "_Cancel");
284 auto chooser = Glib::wrap(GTK_FILE_CHOOSER(native));
285 chooser->set_do_overwrite_confirmation(true);
286 chooser->set_current_name(iface->get_name() + ".json");
287 switch (type) {
288 case ObjectType::UNIT:
289 chooser->set_current_folder(Glib::build_filename(pool.get_base_path(), "units"));
290 break;
291 case ObjectType::ENTITY:
292 chooser->set_current_folder(Glib::build_filename(pool.get_base_path(), "entities"));
293 break;
294 case ObjectType::PART:
295 chooser->set_current_folder(Glib::build_filename(pool.get_base_path(), "parts"));
296 break;
297 default:;
298 }
299 if (original_filename.size())
300 chooser->set_current_folder(Glib::path_get_dirname(original_filename));
301
302 auto success = run_native_filechooser_with_retry(chooser, "Error saving " + object_descriptions.at(type).name,
303 [this, chooser] {
304 std::string fn = append_dot_json(chooser->get_filename());
305 pool.check_filename_throw(type, fn);
306 iface->save_as(fn);
307 s_signal_filename_changed.emit(fn);
308 });
309 if (success) {
310 saved_version = iface->get_required_version();
311 s_signal_saved.emit(iface->filename);
312 save_button->set_label("Save");
313 need_update = true;
314 }
315 }
316 if (info_bar)
317 info_bar_hide(info_bar);
318 }
319
320 std::string EditorWindow::get_filename() const
321 {
322 return iface->filename;
323 }
324
325 void EditorWindow::reload()
326 {
327 iface->reload();
328 }
329
330 bool EditorWindow::get_need_update() const
331 {
332 return need_update;
333 }
334
335 ObjectType EditorWindow::get_object_type() const
336 {
337 return type;
338 }
339
340 void EditorWindow::select(const ItemSet &items)
341 {
342 if (iface)
343 iface->select(items);
344 }
345
346 const UUID &EditorWindow::get_uuid() const
347 {
348 return iface->get_uuid();
349 }
350
351 void EditorWindow::run_checks()
352 {
353 auto r = iface->run_checks();
354 check_color_box->set_color(rules_check_error_level_to_color(r.level));
355 std::string s;
356 if (r.level == RulesCheckErrorLevel::PASS) {
357 s = "Checks passed";
358 check_button_stack->set_visible_child("pass");
359 }
360 else {
361 s = "Checks didn't pass";
362 check_button_stack->set_visible_child("fail");
363 }
364 s += "\n";
365 for (const auto &it : r.errors) {
366 s += " • " + it.comment + "\n";
367 }
368 trim(s);
369 check_label->set_text(s);
370 }
371
372 void EditorWindow::update_undo_redo()
373 {
374 undo_button->set_sensitive(iface->can_undo());
375 redo_button->set_sensitive(iface->can_redo());
376 }
377
378 } // namespace horizon