Freeciv-3.3
Loading...
Searching...
No Matches
cityrep.cpp
Go to the documentation of this file.
1/***********************************************************************
2 Freeciv - Copyright (C) 1996 - A Kjeldberg, L Gregersen, P Unold
3 This program is free software; you can redistribute it and/or modify
4 it under the terms of the GNU General Public License as published by
5 the Free Software Foundation; either version 2, or (at your option)
6 any later version.
7
8 This program is distributed in the hope that it will be useful,
9 but WITHOUT ANY WARRANTY; without even the implied warranty of
10 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 GNU General Public License for more details.
12***********************************************************************/
13
14#ifdef HAVE_CONFIG_H
15#include <fc_config.h>
16#endif
17
18// Qt
19#include <QApplication>
20#include <QHeaderView>
21#include <QVBoxLayout>
22
23// client
24#include "client_main.h"
25
26// gui-qt
27#include "cityrep.h"
28#include "fc_client.h"
29#include "gui_main.h"
30#include "hudwidget.h"
31
32/***********************************************************************/
36 const QModelIndex &right) const
37{
40 int i;
43
44 qleft = sourceModel()->data(left);
45 qright = sourceModel()->data(right);
46 l_bytes = qleft.toString().toUtf8();
47 r_bytes = qright.toString().toUtf8();
48 i = cityrepfield_compare(l_bytes.data(), r_bytes.data());
49
50 if (i >= 0) {
51 return true;
52 } else {
53 return false;
54 }
55}
56
57
58/***********************************************************************/
62 :QItemDelegate(parent)
63{
64 QFont f = QApplication::font();
66
67 item_height = fm.height() + 4;
68}
69
70/***********************************************************************/
75 const QModelIndex &index) const
76{
77 QStyleOptionViewItem opt = QItemDelegate::setOptions(index, option);
79 QFont font;
81 struct city_report_spec *spec;
82 spec = city_report_specs + index.column();
83 txt = spec->tagname;
84 if (txt == "cityname") {
85 font.setCapitalization(QFont::SmallCaps);
86 font.setBold(true);
87 opt.font = font;
88 }
89 if (txt == "hstate_verbose") {
90 font.setItalic(true);
91 opt.font = font;
92 }
93 if (txt == "prodplus") {
94 txt = index.data().toString();
95 if (txt.toInt() < 0) {
96 font.setBold(true);
97 palette.setColor(QPalette::Text, QColor(255, 0, 0));
98 opt.font = font;
99 opt.palette = palette;
100 }
101 }
102
103 QItemDelegate::paint(painter, opt, index);
104}
105
106/***********************************************************************/
110 const QModelIndex &index) const
111{
112 QSize s = QItemDelegate::sizeHint(option, index);
113
114 s.setHeight(item_height + 4);
115 return s;
116}
117
118/***********************************************************************/
122{
123 i_city = pcity;
124}
125
126/***********************************************************************/
130{
131 return i_city;
132}
133
134/***********************************************************************/
137bool city_item::setData(int column, const QVariant &value, int role)
138{
139 return false;
140}
141
142/***********************************************************************/
146{
147 struct city_report_spec *spec;
148 char buf[64];
149
150 if (role == Qt::UserRole && column == 0) {
151 return QVariant::fromValue((void *)i_city);
152 }
153 if (role != Qt::DisplayRole) {
154 return QVariant();
155 }
157 fc_snprintf(buf, sizeof(buf), "%*s", NEG_VAL(spec->width),
158 spec->func(i_city, spec->data));
159 return QString(buf).trimmed();
160}
161
162/***********************************************************************/
165city_model::city_model(QObject *parent): QAbstractListModel(parent)
166{
167 populate();
168}
169
170/***********************************************************************/
178
179/***********************************************************************/
183{
184 emit dataChanged(index(row, 0), index(row, columnCount() - 1));
185}
186
187/***********************************************************************/
191{
192 if (!index.isValid()) {
193 return QVariant();
194 }
195 if (index.row() >= 0 && index.row() < rowCount() && index.column() >= 0
196 && index.column() < columnCount()) {
197 return city_list[index.row()]->data(index.column(), role);
198 }
199 return QVariant();
200}
201
202/***********************************************************************/
205bool city_model::setData(const QModelIndex &index, const QVariant &value,
206 int role)
207{
208 if (!index.isValid() || role != Qt::DisplayRole) {
209 return false;
210 }
211 if (index.row() >= 0 && index.row() < rowCount() && index.column() >= 0
212 && index.column() < columnCount()) {
213 bool change = city_list[index.row()]->setData(index.column(), value, role);
214
215 if (change) {
216 notify_city_changed(index.row());
217 }
218 return change;
219 }
220 return false;
221}
222
223/***********************************************************************/
227 int role) const
228{
229 char buf[64];
230 struct city_report_spec *spec;
231
232 if (orientation == Qt::Horizontal && section < NUM_CREPORT_COLS) {
233 if (role == Qt::DisplayRole) {
234 spec = city_report_specs + section;
235 fc_snprintf(buf, sizeof(buf), "%*s\n%*s",
236 NEG_VAL(spec->width), spec->title1 ? spec->title1 : "",
237 NEG_VAL(spec->width), spec->title2 ? spec->title2 : "");
238 return QString(buf).trimmed();
239 }
240 if (role == Qt::ToolTipRole) {
241 spec = city_report_specs + section;
242 return QString(spec->explanation);
243 }
244 }
245 return QVariant();
246}
247
248/***********************************************************************/
252{
253 struct city_report_spec *spec;
254
256 spec = city_report_specs + section;
257 return QString(spec->explanation);
258 }
259 return QVariant();
260}
261
262/***********************************************************************/
266{
267 struct city_report_spec *spec;
268
270 spec = city_report_specs + section;
271 return spec->show;
272 }
273 return QVariant();
274}
275
276/***********************************************************************/
280{
281 city_item *ci;
282
283 if (client_has_player()) {
285 ci = new city_item(pcity);
286 city_list << ci;
288 } else {
290 ci = new city_item(pcity);
291 city_list << ci;
293 }
294}
295
296/***********************************************************************/
300{
302
305 for (int i = 0; i < city_list.count(); i++) {
306 item = city_list.at(i);
307 if (pcity == item->get_city()) {
309 }
310 }
311}
312
313/***********************************************************************/
317{
318 city_list.clear();
320 populate();
322}
323
324/***********************************************************************/
328{
329 QItemSelection selection;
331 struct city *pcity;
333
334 if (selected_cities.isEmpty()) {
335 return;
336 }
337 for (int j = 0; j < filter_model->rowCount(); j++) {
338 i = filter_model->index(j, 0);
339 qvar = i.data(Qt::UserRole);
340 if (qvar.isNull()) {
341 continue;
342 }
343 pcity = reinterpret_cast<city *>(qvar.value<void *>());
344 if (selected_cities.contains(pcity)) {
345 selection.append(QItemSelectionRange(i));
346 }
347 }
348 selectionModel()->select(selection, QItemSelectionModel::Rows
349 | QItemSelectionModel::SelectCurrent);
350}
351
352/***********************************************************************/
356{
357 cr = ctr;
358 c_i_d = new city_item_delegate(this);
360 list_model = new city_model(this);
362 filter_model->setDynamicSortFilter(true);
363 filter_model->setSourceModel(list_model);
364 filter_model->setFilterRole(Qt::DisplayRole);
366 setRootIsDecorated(false);
368 setSortingEnabled(true);
369 setSelectionMode(QAbstractItemView::ExtendedSelection);
370 setSelectionBehavior(QAbstractItemView::SelectRows);
371 setItemsExpandable(false);
372 setAutoScroll(true);
373 setProperty("uniformRowHeights", "true");
375 header()->setContextMenuPolicy(Qt::CustomContextMenu);
376 header()->setMinimumSectionSize(10);
377 setContextMenuPolicy(Qt::CustomContextMenu);
378 hide_columns();
379 connect(header(), &QWidget::customContextMenuRequested,
381 connect(selectionModel(),
383 const QItemSelection &)),
385 const QItemSelection &)));
386 connect(this, &QAbstractItemView::doubleClicked, this,
388 connect(this, &QWidget::customContextMenuRequested,
390}
391
392/***********************************************************************/
396{
397 city_view();
398}
399
400/***********************************************************************/
404{
405 struct city *pcity;
406
407 if (selected_cities.isEmpty()) {
408 return;
409 }
411
412 Q_ASSERT(pcity != nullptr);
415 }
417}
418
419/***********************************************************************/
423{
424 struct worklist empty;
426 struct city *pcity;
427
428 foreach(pcity, selected_cities) {
429 Q_ASSERT(pcity != nullptr);
431 }
432}
433
434/***********************************************************************/
438{
439 struct city *pcity;
440
441 foreach(pcity, selected_cities) {
442 Q_ASSERT(pcity != nullptr);
444 }
445}
446
447/***********************************************************************/
451{
452 struct city *pcity;
453
454 if (selected_cities.isEmpty()) {
455 return;
456 }
458 Q_ASSERT(pcity != nullptr);
460 gui()->game_tab_widget->setCurrentIndex(0);
461}
462
463/***********************************************************************/
467{
470 QMenu *some_menu;
471 QMenu *tmp2_menu;
472 QMenu *tmp_menu;
473 struct city *pcity_outer;
474 QMenu *list_menu;
475
476 QAction wl_clear(_("Clear"), 0);
477 QAction wl_empty(_("(no worklists defined)"), 0);
478 bool worklist_defined = true;
479
481 return;
482 }
483 list_menu = new QMenu(this);
484 if (!selected_cities.isEmpty()) {
485 some_menu = list_menu->addMenu(_("Production"));
486 tmp_menu = some_menu->addMenu(_("Change"));
488 tmp_menu);
489 tmp_menu = some_menu->addMenu(_("Add next"));
491 tmp_menu);
492 tmp_menu = some_menu->addMenu(_("Add before last"));
495 tmp_menu = some_menu->addMenu(_("Add last"));
497 tmp_menu);
498
499 tmp_menu = some_menu->addMenu(_("Worklist"));
500 tmp_menu->addAction(&wl_clear);
501 connect(&wl_clear, &QAction::triggered, this, &city_widget::clear_worlist);
502 tmp2_menu = tmp_menu->addMenu(_("Add"));
504 if (cma_labels.count() == 0) {
505 tmp2_menu->addAction(&wl_empty);
506 worklist_defined = false;
507 }
509 tmp2_menu = tmp_menu->addMenu(_("Change"));
510 if (cma_labels.count() == 0) {
511 tmp2_menu->addAction(&wl_empty);
512 worklist_defined = false;
513 }
515 some_menu = list_menu->addMenu(_("Governor"));
518 some_menu = list_menu->addMenu(_("Sell"));
522 }
523 some_menu = list_menu->addMenu(_("Select"));
525 if (!selected_cities.isEmpty()) {
526 char buy_costs_label[200];
527 int buy_costs = 0;
528
529 some_menu = list_menu->addMenu(_("City/Buy"));
530 if (selected_cities.count() == 1) {
531 connect(some_menu->addAction(_("View")), &QAction::triggered, this,
533 connect(some_menu->addAction(_("Center")), &QAction::triggered, this,
535 }
536
537 foreach(pcity_outer, selected_cities) {
538 buy_costs = buy_costs + pcity_outer->client.buy_cost;
539 }
541 _("Buy ( Cost: %d )"), buy_costs);
542 connect(some_menu->addAction(buy_costs_label), &QAction::triggered, this,
544 }
545
546 list_menu->setAttribute(Qt::WA_DeleteOnClose);
547 connect(list_menu, &QMenu::triggered, this,
550 enum menu_labels m_state;
551 cid id;
552 struct universal target;
553 char buf[200];
554 const char *imprname;
555 const struct impr_type *building_outer;
557 struct city *pcity_mid;
558 int city_id;
559 bool need_clear = true;
560 bool sell_ask = true;
561
562 if (!act) {
563 return;
564 }
565
566 qvar2 = act->property("FC");
567 m_state = static_cast<menu_labels>(qvar2.toInt());
568 qvar = act->data();
569 id = qvar.toInt();
570 target = cid_decode(id);
571
573 if (iter_city != nullptr) {
574 switch (m_state) {
575 case SELECT_IMPR:
576 if (need_clear) {
578 }
579 need_clear = false;
580 if (city_building_present(iter_city, &target)) {
582 }
583 break;
584 case SELECT_WONDERS:
585 if (need_clear) {
587 }
588 need_clear = false;
589 if (city_building_present(iter_city, &target)) {
591 }
592 break;
594 if (need_clear) {
596 }
597 need_clear = false;
598 if (city_unit_supported(iter_city, &target)) {
600 }
601 break;
603 if (need_clear) {
605 }
606 need_clear = false;
607 if (city_unit_present(iter_city, &target)) {
609 }
610 break;
612 if (need_clear) {
614 }
615 need_clear = false;
616 if (can_city_build_now(&(wld.map), iter_city, &target)) {
618 }
619 break;
621 if (need_clear) {
623 }
624 need_clear = false;
625 if (can_city_build_now(&(wld.map), iter_city, &target)) {
627 }
628 break;
630 if (need_clear) {
632 }
633 need_clear = false;
634 if (can_city_build_now(&(wld.map), iter_city, &target)) {
636 }
637 break;
638 default:
639 break;
640 }
641 }
643
644 foreach (pcity_mid, selected_cities) {
645 if (pcity_mid != nullptr) {
646 switch (m_state) {
647 case CHANGE_PROD_NOW:
649 break;
650 case CHANGE_PROD_NEXT:
651 city_queue_insert(pcity_mid, 1, &target);
652 break;
655 &target);
656 break;
657 case CHANGE_PROD_LAST:
658 city_queue_insert(pcity_mid, -1, &target);
659 break;
660 case SELL:
662 if (sell_ask) {
663 hud_message_box *ask = new hud_message_box(gui()->central_wdg);
664
666 fc_snprintf(buf, sizeof(buf),
667 _("Are you sure you want to sell those %s?"),
668 imprname);
669 sell_ask = false;
670 ask->setStandardButtons(QMessageBox::Cancel | QMessageBox::Ok);
671 ask->setDefaultButton(QMessageBox::Cancel);
672 ask->set_text_title(buf, _("Sell?"));
673 ask->setAttribute(Qt::WA_DeleteOnClose);
674 city_id = pcity_mid->id;
676 connect(ask, &hud_message_box::accepted, this, [=]() {
677 struct city *pcity = game_city_by_number(city_id);
678 struct impr_type *building = improvement_by_number(impr_id);
679
680 if (!pcity || !building) {
681 return;
682 }
683 if (!pcity->did_sell && city_has_building(pcity, building)) {
685 }
686 });
687 ask->show();
688 }
689 break;
690 case CMA:
691 if (pcity_mid != nullptr) {
692 if (CMA_NONE == id) {
694 } else {
697 }
698 }
699
700 break;
701 case WORKLIST_ADD:
702 if (worklist_defined) {
705 }
706 break;
707
708 case WORKLIST_CHANGE:
709 if (worklist_defined) {
712 }
713 break;
714 case BUY:
715 if (pcity_mid != nullptr) {
716 if (city_can_buy(pcity_mid)) {
718 }
719 }
720 break;
721 default:
722 break;
723 }
724 }
725 }
726 });
727 list_menu->popup(QCursor::pos());
728}
729
730/***********************************************************************/
735 TestCityFunc test_func, QMenu *menu)
736{
737 QMenu *m1, *m2, *m3;
738
739 m1 = menu->addMenu(_("Buildings"));
740 m2 = menu->addMenu(_("Units"));
741 m3 = menu->addMenu(_("Wonders"));
748}
749
750
751/***********************************************************************/
755 QMap<QString, cid> &custom_labels, QMenu *menu)
756{
758 QMap<QString, cid>::const_iterator map_iter;
759
760 map_iter = custom_labels.constBegin();
761 while (map_iter != custom_labels.constEnd()) {
762 action = menu->addAction(map_iter.key());
763 action->setData(map_iter.value());
764 action->setProperty("FC", which);
765 map_iter++;
766 }
767 if (custom_labels.isEmpty()) {
768 menu->setDisabled(true);
769 }
770}
771
772/***********************************************************************/
776{
777 selectAll();
778}
779
780/***********************************************************************/
787
788/***********************************************************************/
792{
793 QItemSelection selection;
795 struct city *pcity;
797
798 for (int j = 0; j < filter_model->rowCount(); j++) {
799 i = filter_model->index(j, 0);
800 qvar = i.data(Qt::UserRole);
801 if (qvar.isNull()) {
802 continue;
803 }
804 pcity = reinterpret_cast<city *>(qvar.value<void *>());
805 if (!selected_cities.contains(pcity)) {
806 selection.append(QItemSelectionRange(i));
807 }
808 }
810 selectionModel()->select(selection, QItemSelectionModel::Rows
811 | QItemSelectionModel::SelectCurrent);
812
813}
814
815/***********************************************************************/
819{
820 QItemSelection selection;
822 struct city *pcity;
824
825 for (int j = 0; j < filter_model->rowCount(); j++) {
826 i = filter_model->index(j, 0);
827 qvar = i.data(Qt::UserRole);
828 if (qvar.isNull()) {
829 continue;
830 }
831 pcity = reinterpret_cast<city *>(qvar.value<void *>());
832 if (pcity == spcity) {
833 selection.append(QItemSelectionRange(i));
834 }
835 }
836 selectionModel()->select(selection, QItemSelectionModel::Rows
837 | QItemSelectionModel::Select);
838
839}
840
841/***********************************************************************/
845{
846 QItemSelection selection;
848 struct city *pcity;
850
852 for (int j = 0; j < filter_model->rowCount(); j++) {
853 i = filter_model->index(j, 0);
854 qvar = i.data(Qt::UserRole);
855 if (qvar.isNull()) {
856 continue;
857 }
858 pcity = reinterpret_cast<city *>(qvar.value<void *>());
859 if (pcity != nullptr
861 selection.append(QItemSelectionRange(i));
862 }
863 }
864 selectionModel()->select(selection, QItemSelectionModel::Rows
865 | QItemSelectionModel::SelectCurrent);
866}
867
868/***********************************************************************/
872{
873 QItemSelection selection;
875 struct city *pcity;
876 struct city *pscity;
878
879 for (int j = 0; j < filter_model->rowCount(); j++) {
880 i = filter_model->index(j, 0);
881 qvar = i.data(Qt::UserRole);
882 if (qvar.isNull()) {
883 continue;
884 }
885 pcity = reinterpret_cast<city *>(qvar.value<void *>());
886 foreach (pscity, selected_cities) {
887 if (pcity != nullptr
889 == tile_continent(pscity->tile))) {
890 selection.append(QItemSelectionRange(i));
891 }
892 }
893 }
894 selectionModel()->select(selection, QItemSelectionModel::Rows
895 | QItemSelectionModel::SelectCurrent);
896}
897
898/***********************************************************************/
903{
904 QItemSelection selection;
906 struct city *pcity;
908 QAction *act;
909 QString str;
910
912 for (int j = 0; j < filter_model->rowCount(); j++) {
913 i = filter_model->index(j, 0);
914 qvar = i.data(Qt::UserRole);
915 if (qvar.isNull()) {
916 continue;
917 }
918 pcity = reinterpret_cast<city *>(qvar.value<void *>());
920 qvar = act->data();
921 str = qvar.toString();
922 if (pcity != nullptr) {
923 if (str == "impr" && VUT_IMPROVEMENT == pcity->production.kind
924 && !is_wonder(pcity->production.value.building)
925 && !is_convert_improvement(pcity->production.value.building)) {
926 selection.append(QItemSelectionRange(i));
927 } else if (str == "unit" && VUT_UTYPE == pcity->production.kind) {
928 selection.append(QItemSelectionRange(i));
929 } else if (str == "wonder"
930 && VUT_IMPROVEMENT == pcity->production.kind
931 && is_wonder(pcity->production.value.building)) {
932 selection.append(QItemSelectionRange(i));
933 }
934 }
935 }
936 selectionModel()->select(selection, QItemSelectionModel::Rows
937 | QItemSelectionModel::SelectCurrent);
938}
939
940/***********************************************************************/
944{
945 list.clear();
946 for (int i = 0; i < cmafec_preset_num(); i++) {
948 }
949}
950
951/***********************************************************************/
955{
956 QAction *act;
957 QMenu *tmp_menu;
959
960 act = menu->addAction(_("All Cities"));
961 connect(act, &QAction::triggered, this, &city_widget::select_all);
962 act = menu->addAction(_("No Cities"));
963 connect(act, &QAction::triggered, this, &city_widget::select_none);
964 act = menu->addAction(_("Invert Selection"));
965 connect(act, &QAction::triggered, this, &city_widget::invert_selection);
966 menu->addSeparator();
967 act = menu->addAction(_("Coastal Cities"));
968 connect(act, &QAction::triggered, this, &city_widget::select_coastal);
969 act = menu->addAction(_("Same Island"));
970 connect(act, &QAction::triggered, this, &city_widget::select_same_island);
971 if (selected_cities.isEmpty()) {
972 act->setDisabled(true);
973 }
974 menu->addSeparator();
975 act = menu->addAction(_("Building Units"));
976 act->setData("unit");
977 connect(act, &QAction::triggered, this, &city_widget::select_building_something);
978 act = menu->addAction(_("Building Improvements"));
979 act->setData("impr");
980 connect(act, &QAction::triggered, this, &city_widget::select_building_something);
981 act = menu->addAction(_("Building Wonders"));
982 act->setData("wonder");
983 connect(act, &QAction::triggered, this, &city_widget::select_building_something);
984 menu->addSeparator();
985 tmp_menu = menu->addMenu(_("Improvements in City"));
989 tmp_menu = menu->addMenu(_("Wonders in City"));
993 menu->addSeparator();
994 tmp_menu = menu->addMenu(_("Supported Units"));
996 city_unit_supported, true);
998 tmp_menu = menu->addMenu(_("Units Present"));
1000 city_unit_present, true);
1002 menu->addSeparator();
1003 tmp_menu = menu->addMenu(_("Available Units"));
1007 tmp_menu = menu->addMenu(_("Available Improvements"));
1011 tmp_menu = menu->addMenu(_("Available Wonders"));
1015}
1016
1017/***********************************************************************/
1027
1028/***********************************************************************/
1033 bool append_units,
1034 bool append_wonders,
1036 bool global)
1037{
1038 struct universal targets[MAX_NUM_PRODUCTION_TARGETS];
1039 struct item items[MAX_NUM_PRODUCTION_TARGETS];
1040 int i, item, targets_used;
1041 QString str;
1042 char *row[4];
1043 char buf[4][64];
1044 struct city **city_data;
1045 int num_sel = 0;
1046
1047 if (global) {
1049 } else {
1050 num_sel = selected_cities.count();
1051 }
1052 city_data = (struct city **)fc_malloc(sizeof(struct city *) * num_sel);
1053
1054 if (global) {
1055 i = 0;
1057 city_data[i] = pcity;
1058 i++;
1060 } else {
1061 for (i = 0; i < num_sel; i++) {
1063 }
1064 }
1067 append_wonders, true, test_func);
1068 free(city_data);
1069 name_and_sort_items(targets, targets_used, items, true, nullptr);
1070 for (i = 0; i < 4; i++) {
1071 row[i] = buf[i];
1072 }
1073 list.clear();
1074 for (item = 0; item < targets_used; item++) {
1075 struct universal target = items[item].item;
1076 char txt[256];
1077
1078 str.clear();
1079 get_city_dialog_production_row(row, sizeof(buf[0]), &target, nullptr);
1080 fc_snprintf(txt, ARRAY_SIZE(txt), "%s ", row[0]);
1081 str = str + QString(txt);
1082 list.insert(str, cid_encode(target));
1083 }
1084}
1085
1086/***********************************************************************/
1094
1095/***********************************************************************/
1099{
1100 QFont f = QApplication::font();
1101 QFontMetrics fm(f);
1103 QString s, str;
1104 int width;
1105
1106 setUpdatesEnabled(false);
1109 header()->resizeSections(QHeaderView::ResizeToContents);
1110 for (int j = 0; j < filter_model->columnCount(); j++) {
1111 str = list_model->headerData(j, Qt::Horizontal, Qt::DisplayRole).toString();
1112 if (str.contains('\n')) {
1113 sl = str.split('\n');
1114 width = 0;
1115 foreach (s, sl) {
1116 width = qMax(width, fm.horizontalAdvance(s));
1117 }
1118 header()->resizeSection(j, width + 10);
1119 }
1120 }
1121 setUpdatesEnabled(true);
1122}
1123
1124/***********************************************************************/
1128{
1129 QMenu *hideshow_column = new QMenu(this);
1131
1132 hideshow_column->setTitle(_("Column visibility"));
1133 for (int i = 0; i < list_model->columnCount(); i++) {
1134 QAction *myAct = hideshow_column->addAction(
1135 list_model->menu_data(i).toString());
1136 myAct->setCheckable(true);
1137 myAct->setChecked(!isColumnHidden(i));
1138 actions.append(myAct);
1139 }
1140 hideshow_column->setAttribute(Qt::WA_DeleteOnClose);
1141 connect(hideshow_column, &QMenu::triggered, this,
1143 int col;
1144 struct city_report_spec *spec;
1145 if (!act) {
1146 return;
1147 }
1148
1149 col = actions.indexOf(act);
1150 fc_assert_ret(col >= 0);
1152 spec = city_report_specs + col;
1153 spec->show = !spec->show;
1154 if (!isColumnHidden(col) && columnWidth(col) <= 5)
1155 setColumnWidth(col, 100);
1156 });
1157 hideshow_column->popup(QCursor::pos());
1158}
1159
1160/***********************************************************************/
1164{
1165 int col;
1166
1167 for (col = 0; col < list_model->columnCount(); col++) {
1168 if (!list_model->hide_data(col).toBool()) {
1170 }
1171 }
1172}
1173
1174/***********************************************************************/
1179 const QItemSelection &ds)
1180{
1181 QModelIndexList indexes = selectionModel()->selectedIndexes();
1182 QModelIndex i;
1183 QVariant qvar;
1184 struct city *pcity;
1185
1186 selected_cities.clear();
1187
1188 if (indexes.isEmpty()) {
1189 return;
1190 }
1191 foreach(i,indexes) {
1192 qvar = i.data(Qt::UserRole);
1193 if (qvar.isNull()) {
1194 continue;
1195 }
1196 pcity = reinterpret_cast<city *>(qvar.value<void *>());
1198 }
1199}
1200
1201/***********************************************************************/
1205{
1206 return list_model;
1207}
1208
1209/***********************************************************************/
1213{
1214 delete c_i_d;
1215 delete list_model;
1216 delete filter_model;
1217 gui()->qt_settings.city_repo_sort_col = header()->sortIndicatorSection();
1218 gui()->qt_settings.city_report_sort = header()->sortIndicatorOrder();
1219}
1220
1221/***********************************************************************/
1225{
1226 layout = new QVBoxLayout;
1227 city_wdg = new city_widget(this);
1228 if (gui()->qt_settings.city_repo_sort_col != -1) {
1229 city_wdg->sortByColumn(gui()->qt_settings.city_repo_sort_col,
1230 gui()->qt_settings.city_report_sort);
1231 }
1232 layout->addWidget(city_wdg);
1234}
1235
1236/***********************************************************************/
1240{
1241 gui()->remove_repo_dlg("CTS");
1242}
1243
1244/***********************************************************************/
1248{
1249 gui()->gimme_place(this, "CTS");
1250 index = gui()->add_game_tab(this);
1251 gui()->game_tab_widget->setCurrentIndex(index);
1252}
1253
1254/***********************************************************************/
1261
1262/***********************************************************************/
1269
1270/***********************************************************************/
1274{
1275 int i;
1276 city_report *cr;
1277 QWidget *w;
1278
1279 if (!gui()->is_repo_dlg_open("CTS")) {
1280 cr = new city_report;
1281 cr->init();
1282 cr->update_report();
1283 } else {
1284 i = gui()->gimme_index_of("CTS");
1285 fc_assert(i != -1);
1286 w = gui()->game_tab_widget->widget(i);
1287 if (w->isVisible()) {
1288 gui()->game_tab_widget->setCurrentIndex(0);
1289 return;
1290 }
1291 cr = reinterpret_cast<city_report*>(w);
1292 gui()->game_tab_widget->setCurrentWidget(cr);
1293 cr->update_report();
1294 }
1295}
1296
1297/***********************************************************************/
1301{
1302 int i;
1303 city_report *cr;
1304 QWidget *w;
1305
1306 if (gui()->is_repo_dlg_open("CTS")) {
1307 i = gui()->gimme_index_of("CTS");
1308 if (gui()->game_tab_widget->currentIndex() == i) {
1309 w = gui()->game_tab_widget->widget(i);
1310 cr = reinterpret_cast<city_report *>(w);
1311 cr->update_report();
1312 }
1313 }
1314}
1315
1316/***********************************************************************/
1320{
1321 int i;
1322 city_report *cr;
1323 QWidget *w;
1324
1325 if (gui()->is_repo_dlg_open("CTS")) {
1326 i = gui()->gimme_index_of("CTS");
1327 if (gui()->game_tab_widget->currentIndex() == i) {
1328 w = gui()->game_tab_widget->widget(i);
1329 cr = reinterpret_cast<city_report *>(w);
1330 cr->update_city(pcity);
1331 }
1332 }
1333}
1334
1335/***********************************************************************/
1339{
1340 int i;
1341 city_report *cr;
1342 QWidget *w;
1343
1344 if (gui()->is_repo_dlg_open("CTS")) {
1345 i = gui()->gimme_index_of("CTS");
1346 fc_assert(i != -1);
1347 w = gui()->game_tab_widget->widget(i);
1348 cr = reinterpret_cast<city_report *>(w);
1349 cr->deleteLater();
1350 }
1351}
1352
1353/***********************************************************************/
1359{
1360 // PORTME
1361}
1362
1363/***********************************************************************/
1367{
1368 // PORTME
1369}
static struct action * actions[MAX_NUM_ACTIONS]
Definition actions.c:57
#define str
Definition astring.c:76
struct canvas int int struct sprite int int int width
Definition canvas_g.h:44
bool city_has_building(const struct city *pcity, const struct impr_type *pimprove)
Definition city.c:1240
bool can_city_build_now(const struct civ_map *nmap, const struct city *pcity, const struct universal *target)
Definition city.c:1013
#define cities_iterate_end
Definition city.h:514
#define city_list_iterate(citylist, pcity)
Definition city.h:505
#define cities_iterate(pcity)
Definition city.h:509
#define city_list_iterate_end
Definition city.h:507
void qtg_real_city_dialog_popup(struct city *pcity)
Definition citydlg.cpp:3824
void get_city_dialog_production_row(char *buf[], size_t column_size, struct universal *target, struct city *pcity)
int city_set_worklist(struct city *pcity, const struct worklist *pworklist)
int city_buy_production(struct city *pcity)
bool city_queue_insert(struct city *pcity, int position, struct universal *item)
bool city_queue_insert_worklist(struct city *pcity, int position, const struct worklist *worklist)
bool city_set_queue(struct city *pcity, const struct worklist *pqueue)
int city_change_production(struct city *pcity, struct universal *target)
int city_sell_improvement(struct city *pcity, Impr_type_id sell_id)
bool city_can_buy(const struct city *pcity)
void real_city_report_dialog_update(void *unused)
Definition cityrep.cpp:1300
void real_city_report_update_city(struct city *pcity)
Definition cityrep.cpp:1319
void toggle_city_hilite(struct city *pcity, bool on_off)
Definition cityrep.cpp:1366
void hilite_cities_from_canvas(void)
Definition cityrep.cpp:1358
void city_report_dialog_popup(bool raise)
Definition cityrep.cpp:1273
void popdown_city_report()
Definition cityrep.cpp:1338
bool can_city_sell_universal(const struct city *pcity, const struct universal *target)
struct city_report_spec * city_report_specs
int cityrepfield_compare(const char *str1, const char *str2)
#define NUM_CREPORT_COLS
Definition cityrepdata.h:25
QSize sizeHint(const QStyleOptionViewItem &option, const QModelIndex &index) const
Definition cityrep.cpp:109
void paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const
Definition cityrep.cpp:73
city_item_delegate(QObject *parent)
Definition cityrep.cpp:61
struct city * get_city()
Definition cityrep.cpp:129
QVariant data(int column, int role=Qt::DisplayRole) const
Definition cityrep.cpp:145
struct city * i_city
Definition cityrep.h:96
city_item(struct city *pcity)
Definition cityrep.cpp:121
bool setData(int column, const QVariant &value, int role=Qt::DisplayRole)
Definition cityrep.cpp:137
void city_changed(struct city *pcity)
Definition cityrep.cpp:299
QVariant headerData(int section, Qt::Orientation orientation, int role) const
Definition cityrep.cpp:226
QVariant hide_data(int section) const
Definition cityrep.cpp:265
void populate()
Definition cityrep.cpp:279
int columnCount(const QModelIndex &parent=QModelIndex()) const
Definition cityrep.h:112
QVariant menu_data(int section) const
Definition cityrep.cpp:251
QVariant data(const QModelIndex &index, int role=Qt::DisplayRole) const
Definition cityrep.cpp:190
void all_changed()
Definition cityrep.cpp:316
QList< city_item * > city_list
Definition cityrep.h:129
bool setData(const QModelIndex &index, const QVariant &value, int role=Qt::DisplayRole)
Definition cityrep.cpp:205
city_model(QObject *parent=0)
Definition cityrep.cpp:165
int rowCount(const QModelIndex &index=QModelIndex()) const
Definition cityrep.h:108
void notify_city_changed(int row)
Definition cityrep.cpp:182
void init()
Definition cityrep.cpp:1247
QVBoxLayout * layout
Definition cityrep.h:206
void update_report()
Definition cityrep.cpp:1257
city_widget * city_wdg
Definition cityrep.h:205
void update_city(struct city *pcity)
Definition cityrep.cpp:1265
bool lessThan(const QModelIndex &left, const QModelIndex &right) const
Definition cityrep.cpp:35
void city_view()
Definition cityrep.cpp:403
void buy()
Definition cityrep.cpp:437
void select_city(struct city *pcity)
Definition cityrep.cpp:818
city_widget(city_report *ctr)
Definition cityrep.cpp:355
void fill_data(menu_labels which, QMap< QString, cid > &custom_labels, QMenu *menu)
Definition cityrep.cpp:754
void city_doubleclick(const QModelIndex &index)
Definition cityrep.cpp:395
void center()
Definition cityrep.cpp:450
void update_model()
Definition cityrep.cpp:1098
city_item_delegate * c_i_d
Definition cityrep.h:140
QSortFilterProxyModel * filter_model
Definition cityrep.h:139
void fill_production_menus(city_widget::menu_labels what, QMap< QString, cid > &custom_labels, TestCityFunc test_func, QMenu *menu)
Definition cityrep.cpp:733
city_report * cr
Definition cityrep.h:141
void select_coastal()
Definition cityrep.cpp:844
void gen_production_labels(menu_labels which, QMap< QString, cid > &list, bool append_units, bool append_wonders, TestCityFunc test_func, bool global=false)
Definition cityrep.cpp:1031
void select_building_something()
Definition cityrep.cpp:902
void display_header_menu(const QPoint &)
Definition cityrep.cpp:1127
void hide_columns()
Definition cityrep.cpp:1163
void clear_worlist()
Definition cityrep.cpp:422
void update_city(struct city *pcity)
Definition cityrep.cpp:1089
city_model * list_model
Definition cityrep.h:138
void select_all()
Definition cityrep.cpp:775
void select_none()
Definition cityrep.cpp:783
void display_list_menu(const QPoint &)
Definition cityrep.cpp:466
void gen_worklist_labels(QMap< QString, int > &list)
Definition cityrep.cpp:1020
void cities_selected(const QItemSelection &sl, const QItemSelection &ds)
Definition cityrep.cpp:1178
void gen_cma_labels(QMap< QString, int > &list)
Definition cityrep.cpp:943
city_model * get_model() const
Definition cityrep.cpp:1204
QList< city * > selected_cities
Definition cityrep.h:164
void restore_selection()
Definition cityrep.cpp:327
void invert_selection()
Definition cityrep.cpp:791
void gen_select_labels(QMenu *menu)
Definition cityrep.cpp:954
void select_same_island()
Definition cityrep.cpp:871
@ CHANGE_PROD_BEF_LAST
Definition cityrep.h:146
@ SELECT_AVAIL_UNITS
Definition cityrep.h:155
@ SELECT_AVAIL_WONDERS
Definition cityrep.h:157
@ SELECT_SUPP_UNITS
Definition cityrep.h:153
@ CHANGE_PROD_NOW
Definition cityrep.h:143
@ CHANGE_PROD_LAST
Definition cityrep.h:145
@ SELECT_AVAIL_IMPR
Definition cityrep.h:156
@ WORKLIST_CHANGE
Definition cityrep.h:150
@ SELECT_WONDERS
Definition cityrep.h:152
@ CHANGE_PROD_NEXT
Definition cityrep.h:144
@ SELECT_PRES_UNITS
Definition cityrep.h:154
struct civclient client
bool can_client_issue_orders(void)
bool client_has_player(void)
#define client_player()
bool city_unit_supported(const struct city *pcity, const struct universal *target)
Definition climisc.c:545
void cityrep_buy(struct city *pcity)
Definition climisc.c:1155
void name_and_sort_items(struct universal *targets, int num_targets, struct item *items, bool show_cost, struct city *pcity)
Definition climisc.c:650
cid cid_encode(struct universal target)
Definition climisc.c:483
bool city_building_present(const struct city *pcity, const struct universal *target)
Definition climisc.c:583
struct universal cid_decode(cid id)
Definition climisc.c:526
bool can_city_build_now_client(const struct city *pcity, const struct universal *target)
Definition climisc.c:593
bool city_unit_present(const struct city *pcity, const struct universal *target)
Definition climisc.c:564
int collect_production_targets(struct universal *targets, struct city **selected_cities, int num_selected_cities, bool append_units, bool append_wonders, bool change_prod, TestCityFunc test_func)
Definition climisc.c:700
#define MAX_NUM_PRODUCTION_TARGETS
Definition climisc.h:89
int cid
Definition climisc.h:31
bool(* TestCityFunc)(const struct city *, const struct universal *)
Definition climisc.h:87
static struct fc_sockaddr_list * list
Definition clinet.c:102
void cma_put_city_under_agent(struct city *pcity, const struct cm_parameter *const parameter)
Definition cma_core.c:524
void cma_release_city(struct city *pcity)
Definition cma_core.c:542
char * cmafec_preset_get_descr(int idx)
Definition cma_fec.c:169
const struct cm_parameter * cmafec_preset_get_parameter(int idx)
Definition cma_fec.c:182
int cmafec_preset_num(void)
Definition cma_fec.c:213
char * incite_cost
Definition comments.c:76
struct unit struct city struct unit struct tile struct extra_type const struct act_prob *act_probs int actor_unit_id struct unit struct unit int const struct action *paction struct unit struct city * pcity
Definition dialogs_g.h:78
int int id
Definition editgui_g.h:28
int Impr_type_id
Definition fc_types.h:235
#define _(String)
Definition fcintl.h:67
struct world wld
Definition game.c:62
struct city * game_city_by_number(int id)
Definition game.c:106
struct global_worklist * global_worklist_by_id(int id)
const char * global_worklist_name(const struct global_worklist *pgwl)
int global_worklist_id(const struct global_worklist *pgwl)
const struct worklist * global_worklist_get(const struct global_worklist *pgwl)
#define global_worklists_iterate(pgwl)
#define global_worklists_iterate_end
#define CMA_NONE
Definition cityrep.h:49
#define NEG_VAL(x)
Definition cityrep.h:48
#define CAPTURE_DEFAULT_THIS
Definition gui_main.h:31
struct impr_type * improvement_by_number(const Impr_type_id id)
Impr_type_id improvement_number(const struct impr_type *pimprove)
bool is_wonder(const struct impr_type *pimprove)
bool is_convert_improvement(const struct impr_type *pimprove)
const char * improvement_name_translation(const struct impr_type *pimprove)
#define fc_assert_ret(condition)
Definition log.h:192
#define fc_assert(condition)
Definition log.h:177
void center_tile_mapcanvas(const struct tile *ptile)
#define fc_malloc(sz)
Definition mem.h:34
static mpgui * gui
Definition mpgui_qt.cpp:52
struct client_options gui_options
Definition options.c:71
struct city_list * cities
Definition packhand.c:119
#define ARRAY_SIZE(x)
Definition shared.h:85
const char * tagname
Definition cityrepdata.h:35
const char *(* func)(const struct city *pcity, const void *data)
Definition cityrepdata.h:34
const char * title2
Definition cityrepdata.h:31
const char * explanation
Definition cityrepdata.h:32
const char * title1
Definition cityrepdata.h:30
Definition city.h:317
struct connection conn
Definition client_main.h:96
bool center_when_popup_city
Definition options.h:162
struct player * playing
Definition connection.h:151
Definition climisc.h:82
struct universal item
Definition climisc.h:83
struct city_list * cities
Definition player.h:281
int index
Definition unit.h:198
struct tile * tile
Definition unit.h:142
universals_u value
Definition fc_types.h:607
struct civ_map map
int fc_snprintf(char *str, size_t n, const char *format,...)
Definition support.c:960
bool is_terrain_class_near_tile(const struct civ_map *nmap, const struct tile *ptile, enum terrain_class tclass)
Definition terrain.c:612
#define tile_continent(_tile)
Definition tile.h:93
const struct impr_type * building
Definition fc_types.h:546
void worklist_init(struct worklist *pwl)
Definition worklist.c:38
int worklist_length(const struct worklist *pwl)
Definition worklist.c:57