├── CMakeLists.txt
├── Colormap.cpp
├── GUI.cpp
├── Graph.cpp
├── PPP
    ├── GUI.h
    ├── GUI_private.h
    ├── Graph.h
    ├── Image_private.h
    ├── Point.h
    ├── Simple_window.h
    ├── Window.h
    └── std_lib_facilities.h
├── Programming_Qt.sln
├── Programming_Qt.vcxproj
├── README.md
├── Simple_window.cpp
├── UserGuide.odt
├── UserGuide.pdf
├── Window.cpp
└── main.cpp


/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 3.5)
 2 | 
 3 | project(Programming_Qt VERSION 0.1 LANGUAGES CXX)
 4 | 
 5 | set(CMAKE_AUTOUIC ON)
 6 | set(CMAKE_AUTOMOC ON)
 7 | set(CMAKE_AUTORCC ON)
 8 | 
 9 | set(CMAKE_CXX_STANDARD 20)
10 | set(CMAKE_CXX_STANDARD_REQUIRED ON)
11 | 
12 | find_package(QT NAMES Qt6 Qt5 REQUIRED COMPONENTS Widgets)
13 | find_package(Qt${QT_VERSION_MAJOR} REQUIRED COMPONENTS Widgets)
14 | 
15 | set(PROJECT_SOURCES
16 |     main.cpp
17 |     PPP/Window.h
18 |     PPP/Graph.h
19 |     PPP/GUI.h
20 |     PPP/Simple_window.h
21 |     PPP/Point.h
22 |     PPP/std_lib_facilities.h
23 |     Window.cpp
24 |     Graph.cpp
25 |     PPP/Image_private.h
26 |     GUI.cpp
27 |     PPP/GUI_private.h
28 |     Simple_window.cpp
29 |     Colormap.cpp
30 | )
31 | 
32 | if(${QT_VERSION_MAJOR} GREATER_EQUAL 6)
33 |     qt_add_executable(Programming_Qt
34 |         MANUAL_FINALIZATION
35 |         ${PROJECT_SOURCES}
36 |     )
37 | 
38 | # Define target properties for Android with Qt 6 as:
39 | #    set_property(TARGET Programming_Qt APPEND PROPERTY QT_ANDROID_PACKAGE_SOURCE_DIR
40 | #                 ${CMAKE_CURRENT_SOURCE_DIR}/android)
41 | # For more information, see https://doc.qt.io/qt-6/qt-add-executable.html#target-creation
42 | else()
43 |     if(ANDROID)
44 |         add_library(Programming_Qt SHARED
45 |             ${PROJECT_SOURCES}
46 |         )
47 | # Define properties for Android with Qt 5 after find_package() calls as:
48 | #    set(ANDROID_PACKAGE_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/android")
49 |     else()
50 |         add_executable(Programming_Qt
51 |             ${PROJECT_SOURCES}
52 |         )
53 |     endif()
54 | endif()
55 | 
56 | target_link_libraries(Programming_Qt PRIVATE Qt${QT_VERSION_MAJOR}::Widgets)
57 | target_include_directories(Programming_Qt PRIVATE .)
58 | 
59 | set_target_properties(Programming_Qt PROPERTIES
60 |     MACOSX_BUNDLE_GUI_IDENTIFIER my.example.com
61 |     MACOSX_BUNDLE_BUNDLE_VERSION ${PROJECT_VERSION}
62 |     MACOSX_BUNDLE_SHORT_VERSION_STRING ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}
63 |     MACOSX_BUNDLE TRUE
64 |     WIN32_EXECUTABLE TRUE
65 | )
66 | 
67 | if(MSVC)
68 |   target_compile_options(Programming_Qt PRIVATE /EHsc /W4 /WX)
69 | else()
70 |   target_compile_options(Programming_Qt PRIVATE -Wall -Wextra -Wpedantic -Werror)
71 | endif()
72 | 
73 | if (EMSCRIPTEN)
74 |     target_link_options(Programming_Qt PUBLIC -sASYNCIFY -Os)
75 | endif()
76 | 
77 | install(TARGETS Programming_Qt
78 |     BUNDLE DESTINATION .
79 |     LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
80 | 
81 | if(QT_VERSION_MAJOR EQUAL 6)
82 |     qt_finalize_executable(Programming_Qt)
83 | endif()
84 | 


--------------------------------------------------------------------------------
/Colormap.cpp:
--------------------------------------------------------------------------------
  1 | #include <QColor>
  2 | #include <PPP/Image_private.h>
  3 | 
  4 | static QColor paletteColorMap[] = {
  5 |     {0, 0, 0},
  6 |     {255, 0, 0},
  7 |     {0, 255, 0},
  8 |     {255, 255, 0},
  9 |     {0, 0, 255},
 10 |     {255, 0, 255},
 11 |     {0, 255, 255},
 12 |     {255, 255, 255},
 13 |     {85, 85, 85},
 14 |     {198, 113, 113},
 15 |     {113, 198, 113},
 16 |     {142, 142, 56},
 17 |     {113, 113, 198},
 18 |     {142, 56, 142},
 19 |     {56, 142, 142},
 20 |     {0, 0, 128},
 21 |     {168, 168, 152},
 22 |     {232, 232, 216},
 23 |     {104, 104, 88},
 24 |     {152, 168, 168},
 25 |     {216, 232, 232},
 26 |     {88, 104, 104},
 27 |     {156, 156, 168},
 28 |     {220, 220, 232},
 29 |     {92, 92, 104},
 30 |     {156, 168, 156},
 31 |     {220, 232, 220},
 32 |     {92, 104, 92},
 33 |     {144, 144, 144},
 34 |     {192, 192, 192},
 35 |     {80, 80, 80},
 36 |     {160, 160, 160},
 37 |     {0, 0, 0},
 38 |     {13, 13, 13},
 39 |     {26, 26, 26},
 40 |     {38, 38, 38},
 41 |     {49, 49, 49},
 42 |     {61, 61, 61},
 43 |     {72, 72, 72},
 44 |     {85, 85, 85},
 45 |     {95, 95, 95},
 46 |     {106, 106, 106},
 47 |     {117, 117, 117},
 48 |     {128, 128, 128},
 49 |     {138, 138, 138},
 50 |     {149, 149, 149},
 51 |     {160, 160, 160},
 52 |     {170, 170, 170},
 53 |     {181, 181, 181},
 54 |     {192, 192, 192},
 55 |     {203, 203, 203},
 56 |     {213, 213, 213},
 57 |     {224, 224, 224},
 58 |     {234, 234, 234},
 59 |     {245, 245, 245},
 60 |     {255, 255, 255},
 61 |     {0, 0, 0},
 62 |     {0, 36, 0},
 63 |     {0, 72, 0},
 64 |     {0, 109, 0},
 65 |     {0, 145, 0},
 66 |     {0, 182, 0},
 67 |     {0, 218, 0},
 68 |     {0, 255, 0},
 69 |     {63, 0, 0},
 70 |     {63, 36, 0},
 71 |     {63, 72, 0},
 72 |     {63, 109, 0},
 73 |     {63, 145, 0},
 74 |     {63, 182, 0},
 75 |     {63, 218, 0},
 76 |     {63, 255, 0},
 77 |     {127, 0, 0},
 78 |     {127, 36, 0},
 79 |     {127, 72, 0},
 80 |     {127, 109, 0},
 81 |     {127, 145, 0},
 82 |     {127, 182, 0},
 83 |     {127, 218, 0},
 84 |     {127, 255, 0},
 85 |     {191, 0, 0},
 86 |     {191, 36, 0},
 87 |     {191, 72, 0},
 88 |     {191, 109, 0},
 89 |     {191, 145, 0},
 90 |     {191, 182, 0},
 91 |     {191, 218, 0},
 92 |     {191, 255, 0},
 93 |     {255, 0, 0},
 94 |     {255, 36, 0},
 95 |     {255, 72, 0},
 96 |     {255, 109, 0},
 97 |     {255, 145, 0},
 98 |     {255, 182, 0},
 99 |     {255, 218, 0},
100 |     {255, 255, 0},
101 |     {0, 0, 63},
102 |     {0, 36, 63},
103 |     {0, 72, 63},
104 |     {0, 109, 63},
105 |     {0, 145, 63},
106 |     {0, 182, 63},
107 |     {0, 218, 63},
108 |     {0, 255, 63},
109 |     {63, 0, 63},
110 |     {63, 36, 63},
111 |     {63, 72, 63},
112 |     {63, 109, 63},
113 |     {63, 145, 63},
114 |     {63, 182, 63},
115 |     {63, 218, 63},
116 |     {63, 255, 63},
117 |     {127, 0, 63},
118 |     {127, 36, 63},
119 |     {127, 72, 63},
120 |     {127, 109, 63},
121 |     {127, 145, 63},
122 |     {127, 182, 63},
123 |     {127, 218, 63},
124 |     {127, 255, 63},
125 |     {191, 0, 63},
126 |     {191, 36, 63},
127 |     {191, 72, 63},
128 |     {191, 109, 63},
129 |     {191, 145, 63},
130 |     {191, 182, 63},
131 |     {191, 218, 63},
132 |     {191, 255, 63},
133 |     {255, 0, 63},
134 |     {255, 36, 63},
135 |     {255, 72, 63},
136 |     {255, 109, 63},
137 |     {255, 145, 63},
138 |     {255, 182, 63},
139 |     {255, 218, 63},
140 |     {255, 255, 63},
141 |     {0, 0, 127},
142 |     {0, 36, 127},
143 |     {0, 72, 127},
144 |     {0, 109, 127},
145 |     {0, 145, 127},
146 |     {0, 182, 127},
147 |     {0, 218, 127},
148 |     {0, 255, 127},
149 |     {63, 0, 127},
150 |     {63, 36, 127},
151 |     {63, 72, 127},
152 |     {63, 109, 127},
153 |     {63, 145, 127},
154 |     {63, 182, 127},
155 |     {63, 218, 127},
156 |     {63, 255, 127},
157 |     {127, 0, 127},
158 |     {127, 36, 127},
159 |     {127, 72, 127},
160 |     {127, 109, 127},
161 |     {127, 145, 127},
162 |     {127, 182, 127},
163 |     {127, 218, 127},
164 |     {127, 255, 127},
165 |     {191, 0, 127},
166 |     {191, 36, 127},
167 |     {191, 72, 127},
168 |     {191, 109, 127},
169 |     {191, 145, 127},
170 |     {191, 182, 127},
171 |     {191, 218, 127},
172 |     {191, 255, 127},
173 |     {255, 0, 127},
174 |     {255, 36, 127},
175 |     {255, 72, 127},
176 |     {255, 109, 127},
177 |     {255, 145, 127},
178 |     {255, 182, 127},
179 |     {255, 218, 127},
180 |     {255, 255, 127},
181 |     {0, 0, 191},
182 |     {0, 36, 191},
183 |     {0, 72, 191},
184 |     {0, 109, 191},
185 |     {0, 145, 191},
186 |     {0, 182, 191},
187 |     {0, 218, 191},
188 |     {0, 255, 191},
189 |     {63, 0, 191},
190 |     {63, 36, 191},
191 |     {63, 72, 191},
192 |     {63, 109, 191},
193 |     {63, 145, 191},
194 |     {63, 182, 191},
195 |     {63, 218, 191},
196 |     {63, 255, 191},
197 |     {127, 0, 191},
198 |     {127, 36, 191},
199 |     {127, 72, 191},
200 |     {127, 109, 191},
201 |     {127, 145, 191},
202 |     {127, 182, 191},
203 |     {127, 218, 191},
204 |     {127, 255, 191},
205 |     {191, 0, 191},
206 |     {191, 36, 191},
207 |     {191, 72, 191},
208 |     {191, 109, 191},
209 |     {191, 145, 191},
210 |     {191, 182, 191},
211 |     {191, 218, 191},
212 |     {191, 255, 191},
213 |     {255, 0, 191},
214 |     {255, 36, 191},
215 |     {255, 72, 191},
216 |     {255, 109, 191},
217 |     {255, 145, 191},
218 |     {255, 182, 191},
219 |     {255, 218, 191},
220 |     {255, 255, 191},
221 |     {0, 0, 255},
222 |     {0, 36, 255},
223 |     {0, 72, 255},
224 |     {0, 109, 255},
225 |     {0, 145, 255},
226 |     {0, 182, 255},
227 |     {0, 218, 255},
228 |     {0, 255, 255},
229 |     {63, 0, 255},
230 |     {63, 36, 255},
231 |     {63, 72, 255},
232 |     {63, 109, 255},
233 |     {63, 145, 255},
234 |     {63, 182, 255},
235 |     {63, 218, 255},
236 |     {63, 255, 255},
237 |     {127, 0, 255},
238 |     {127, 36, 255},
239 |     {127, 72, 255},
240 |     {127, 109, 255},
241 |     {127, 145, 255},
242 |     {127, 182, 255},
243 |     {127, 218, 255},
244 |     {127, 255, 255},
245 |     {191, 0, 255},
246 |     {191, 36, 255},
247 |     {191, 72, 255},
248 |     {191, 109, 255},
249 |     {191, 145, 255},
250 |     {191, 182, 255},
251 |     {191, 218, 255},
252 |     {191, 255, 255},
253 |     {255, 0, 255},
254 |     {255, 36, 255},
255 |     {255, 72, 255},
256 |     {255, 109, 255},
257 |     {255, 145, 255},
258 |     {255, 182, 255},
259 |     {255, 218, 255},
260 |     {255, 255, 255}
261 | };
262 | 
263 | namespace Graph_lib {
264 | QColor mapPaletteColor(int rawColor)
265 | {
266 |     return paletteColorMap[rawColor % 256];
267 | }
268 | 
269 | }
270 | 


--------------------------------------------------------------------------------
/GUI.cpp:
--------------------------------------------------------------------------------
  1 | #include "PPP/GUI.h"
  2 | #include "PPP/GUI_private.h"
  3 | #include "PPP/Window.h"
  4 | #include "PPP/std_lib_facilities.h"
  5 | #include <sstream>
  6 | 
  7 | #include <QHBoxLayout>
  8 | #include <QVBoxLayout>
  9 | #include <QPushButton>
 10 | 
 11 | #include <QInputDialog>
 12 | #include <QKeyEvent>
 13 | #include <QMessageBox>
 14 | 
 15 | using namespace Graph_lib;
 16 | 
 17 | 
 18 | Widget::Widget(Point xy, int w, int h, const string& s, Callback cb)
 19 |     : loc(xy), width(w), height(h), label(s), do_it(cb), impl(std::make_unique<WidgetPrivate>())
 20 | {}
 21 | 
 22 | Widget::~Widget()
 23 | {
 24 | 
 25 | }
 26 | 
 27 | void Widget::move(int dx,int dy)
 28 | {
 29 |     QRect geom = impl->widget->geometry();
 30 |     geom.moveLeft(geom.left() + dx);
 31 |     geom.moveTop(geom.top() + dy);
 32 |     impl->widget->setGeometry(geom);
 33 |     loc.x += dx;
 34 |     loc.y += dy;
 35 | }
 36 | 
 37 | void Widget::hide() {impl->widget->setVisible(false);}
 38 | void Widget::show() {impl->widget->setVisible(true);}
 39 | 
 40 | Button::Button(Point xy, int w, int h, const string& label, Callback cb)
 41 |     : Widget(xy,w,h,label,cb)
 42 | {
 43 |     WidgetPrivate& w_impl = get_impl();
 44 |     QPushButton* button = new QPushButton();
 45 |     w_impl.widget.reset(button);
 46 |     button->setText(QString::fromStdString(label));
 47 |     QObject::connect(button, &QPushButton::clicked, [this]{ do_it(); });
 48 | }
 49 | 
 50 | class InputDialog : public QInputDialog
 51 | {
 52 | public:
 53 |     InputDialog(QWidget* parent = nullptr) : QInputDialog(parent) {}
 54 |     void done(int result) override
 55 |     {
 56 |         if (result == QDialog::Rejected) {
 57 |             if (close_on_accept) {
 58 |                 QInputDialog::done(result);
 59 |             } else {
 60 |                 QInputDialog::rejected();
 61 |             }
 62 |         } else if (result == QDialog::Accepted) {
 63 |             if (close_on_accept) {
 64 |                 QInputDialog::done(result);
 65 |             } else {
 66 |                 QInputDialog::accepted();
 67 |             }
 68 |         }
 69 |     }
 70 |     void keyPressEvent(QKeyEvent *e) override {
 71 |         if ((options() | QInputDialog::NoButtons)) {
 72 |             if (e->key() == Qt::Key_Return) {
 73 |                 done(QDialog::Accepted);
 74 |             } else if (e->key() == Qt::Key_Escape) {
 75 |                 done(QDialog::Rejected);
 76 |             }
 77 |         } else {
 78 |             QInputDialog::keyPressEvent(e);
 79 |         }
 80 |     }
 81 |     void set_close_on_accept(bool val) {close_on_accept = val;}
 82 | private:
 83 |     bool close_on_accept = false;
 84 | };
 85 | 
 86 | In_box::In_box(Point xy, int w, int h, const string& s, Callback cb)
 87 |     :Widget(xy,w,h,s,0)
 88 | {
 89 |     WidgetPrivate& w_impl = get_impl();
 90 |     InputDialog* dialog = new InputDialog();
 91 |     dialog->setVisible(false);
 92 |     w_impl.widget.reset(dialog);
 93 |     do_it = cb;
 94 | }
 95 | 
 96 | void setup_input(InputDialog* dialog, const std::string& label,
 97 |                  bool close_on_accept,
 98 |                  QInputDialog::InputMode inputMode,
 99 |                  Callback& do_it,
100 |                  In_box::ResultData& result)
101 | {
102 |     dialog->setWindowTitle(QString::fromStdString(label));
103 |     dialog->setLabelText(QString::fromStdString(label));
104 |     dialog->set_close_on_accept(close_on_accept);
105 |     dialog->setInputMode(inputMode);
106 |     dialog->setModal(false);
107 |     QObject::connect(dialog, &QInputDialog::accepted,
108 |         [dialog, &do_it, &result] {
109 |             result.state = Graph_lib::In_box::accepted;
110 |             if (dialog->inputMode() == QInputDialog::IntInput) {
111 |                 result.last_int = dialog->intValue();
112 |                 dialog->setIntValue(0);
113 |             } else if ((dialog->inputMode() == QInputDialog::TextInput)) {
114 |                 result.last_string = dialog->textValue().toStdString();
115 |                 dialog->setTextValue("");
116 |             }
117 |             if (do_it) {
118 |                 do_it();
119 |             }
120 |     });
121 |     QObject::connect(dialog, &QInputDialog::rejected,
122 |         [dialog, &do_it, &result] {
123 |             result.state = Graph_lib::In_box::rejected;
124 |             if (dialog->inputMode() == QInputDialog::TextInput) {
125 |                 dialog->setTextValue("");
126 |             } else if (dialog->inputMode() == QInputDialog::IntInput) {
127 |                 dialog->setIntValue(0);
128 |             }
129 |             if (do_it) {
130 |                 do_it();
131 |             }
132 |     });
133 | 
134 | }
135 | 
136 | void wait_for_input(InputDialog* dialog, In_box::State& state)
137 | {
138 |     QEventLoop nested_loop;
139 |     QTimer timer(&nested_loop);
140 |     timer.setSingleShot(true);
141 |     QObject::connect(&timer, &QTimer::timeout,
142 |                      [&] {nested_loop.quit();});
143 |     auto conn1 = QObject::connect(dialog, &QInputDialog::accepted,
144 |         [&] {
145 |                 state = In_box::accepted;
146 |                 timer.start(0);
147 |     });
148 |     auto conn2 = QObject::connect(dialog, &QInputDialog::rejected,
149 |         [&] {
150 |                 state = In_box::rejected;
151 |                 timer.start(0);
152 |     });
153 |     nested_loop.exec();
154 |     QObject::disconnect(conn1);
155 |     QObject::disconnect(conn2);
156 | }
157 | 
158 | void exec_input(InputDialog* dialog, In_box::State& state)
159 | {
160 |     auto conn1 = QObject::connect(dialog, &QInputDialog::accepted,
161 |         [&] {
162 |                 state = In_box::accepted;
163 |     });
164 |     auto conn2 = QObject::connect(dialog, &QInputDialog::rejected,
165 |         [&] {
166 |                 state = In_box::rejected;
167 |     });
168 |     dialog->exec();
169 |     QObject::disconnect(conn1);
170 |     QObject::disconnect(conn2);
171 | }
172 | 
173 | int In_box::get_int()
174 | {
175 |     InputDialog* dialog = static_cast<InputDialog*>(get_impl().widget.get());
176 |     if (waiting) {
177 |         dialog->reject();
178 |         result.state = rejected;
179 |         return 0;
180 |     }
181 |     result.state = idle;
182 |     setup_input(dialog, label, true, QInputDialog::IntInput,
183 |                 do_it, result);
184 |     waiting = true;
185 |     exec_input(dialog, result.state);
186 |     waiting = false;
187 |     return dialog->intValue();
188 | }
189 | 
190 | int In_box::get_int_keep_open()
191 | {
192 |     InputDialog* dialog = static_cast<InputDialog*>(get_impl().widget.get());
193 |     if (waiting) {
194 |         dialog->reject();
195 |         result.state = rejected;
196 |         return 0;
197 |     }
198 |     result.state = idle;
199 |     setup_input(dialog, label, false, QInputDialog::IntInput,
200 |                 do_it, result);
201 |     dialog->show();
202 |     waiting = true;
203 |     wait_for_input(dialog, result.state);
204 |     waiting = false;
205 |     return dialog->intValue();
206 | }
207 | 
208 | string In_box::get_string()
209 | {
210 |     InputDialog* dialog = static_cast<InputDialog*>(get_impl().widget.get());
211 |     if (waiting) {
212 |         dialog->reject();
213 |         result.state = rejected;
214 |         return "";
215 |     }
216 |     result.state = idle;
217 |     setup_input(dialog, label, true, QInputDialog::TextInput,
218 |                 do_it, result);
219 |     waiting = true;
220 |     exec_input(dialog, result.state);
221 |     waiting = false;
222 |     return dialog->textValue().toStdString();
223 | }
224 | 
225 | string In_box::get_string_keep_open()
226 | {
227 |     InputDialog* dialog = static_cast<InputDialog*>(get_impl().widget.get());
228 |     if (waiting) {
229 |         dialog->reject();
230 |         result.state = rejected;
231 |         return "";
232 |     }
233 |     result.state = idle;
234 |     setup_input(dialog, label, false, QInputDialog::TextInput,
235 |                 do_it, result);
236 |     dialog->show();
237 |     waiting = true;
238 |     wait_for_input(dialog, result.state);
239 |     waiting = false;
240 |     return dialog->textValue().toStdString();
241 | }
242 | 
243 | void In_box::attach(Window& win)
244 | {
245 |     InputDialog* dialog = static_cast<InputDialog*>(get_impl().widget.get());
246 |     dialog->hide();
247 |     QObject::connect(&win.get_impl(), &WindowPrivate::windowClosed,
248 |                      [=] {dialog->reject();});
249 | }
250 | 
251 | void In_box::dismiss()
252 | {
253 |     InputDialog* dialog = static_cast<InputDialog*>(get_impl().widget.get());
254 |     dialog->reject();
255 |     result.state = rejected;
256 | }
257 | 
258 | void In_box::hide()
259 | {
260 |     InputDialog* dialog = static_cast<InputDialog*>(get_impl().widget.get());
261 |     dialog->hide();
262 | }
263 | 
264 | void In_box::show()
265 | {
266 |     InputDialog* dialog = static_cast<InputDialog*>(get_impl().widget.get());
267 |     setup_input(dialog, label, false, QInputDialog::TextInput,
268 |                 do_it, result);
269 |     dialog->show();
270 | }
271 | 
272 | void In_box::hide_buttons()
273 | {
274 |     InputDialog* dialog = static_cast<InputDialog*>(get_impl().widget.get());
275 |     dialog->setOption(QInputDialog::NoButtons, true);
276 | }
277 | 
278 | void In_box::show_buttons()
279 | {
280 |     InputDialog* dialog = static_cast<InputDialog*>(get_impl().widget.get());
281 |     dialog->setOption(QInputDialog::NoButtons, false);
282 | }
283 | 
284 | In_box::State In_box::last_result()
285 | {
286 |      return result.state;
287 | }
288 | 
289 | void In_box::clear_last_result()
290 | {
291 |      result.state = idle;
292 |      result.last_string = "";
293 |      result.last_int = 0;
294 | }
295 | 
296 | std::string In_box::last_string_value()
297 | {
298 |      return result.last_string;
299 | }
300 | 
301 | int In_box::last_int_value()
302 | {
303 |      return result.last_int;
304 | }
305 | 
306 | Menu::Menu(Point xy, int w, int h, Kind kk, const string& label)
307 |     : Widget(xy,w,h,label,0), k(kk), offset(0)
308 | {
309 |     WidgetPrivate& w_impl = get_impl();
310 |     QWidget* widget = new QWidget();
311 |     w_impl.widget.reset(widget);
312 |     if (k == Menu::horizontal) {
313 |         QHBoxLayout* layout = new QHBoxLayout();
314 |         layout->setContentsMargins(0,0,0,0);
315 |         layout->setSpacing(0);
316 |         widget->setLayout(layout);
317 |     } else {
318 |         QVBoxLayout* layout = new QVBoxLayout();
319 |         layout->setContentsMargins(0,0,0,0);
320 |         layout->setSpacing(0);
321 |         widget->setLayout(layout);
322 |     }
323 | 
324 | }
325 | 
326 | void Menu::layoutButtons(Button& b)
327 | {
328 |     b.width = width;
329 |     b.height = height;
330 | 
331 |     switch(k) {
332 |     case horizontal:
333 |         b.loc = Point{loc.x+offset,loc.y};
334 |         offset+= b.width;
335 |         break;
336 |     case vertical:
337 |         b.loc = Point{loc.x,loc.y+offset};
338 |         offset+= b.height;
339 |         break;
340 |     }
341 |     b.get_impl().widget->setMaximumHeight(height);
342 |     b.get_impl().widget->setMaximumWidth(width);
343 |     get_impl().widget->layout()->addWidget(b.get_impl().widget.get());
344 | }
345 | 
346 | void Menu::layoutMenu()
347 | {
348 |     if (k == vertical) {
349 |         get_impl().widget->setMinimumHeight(height * selection.size());
350 |     } else {
351 |         get_impl().widget->setMinimumWidth(width * selection.size());
352 |     }
353 | }
354 | 
355 | int Menu::attach(Button& b)
356 | {
357 |     layoutButtons(b);
358 |     selection.push_back(b);
359 |     layoutMenu();
360 |     return int(selection.size()-1);
361 | }
362 | 
363 | int Menu::attach(unique_ptr<Button> p)
364 | {
365 |     layoutButtons(*p);
366 |     selection.push_back(std::move(p));
367 |     layoutMenu();
368 |     return int(selection.size()-1);
369 | }
370 | 


--------------------------------------------------------------------------------
/Graph.cpp:
--------------------------------------------------------------------------------
  1 | #include "PPP/Graph.h"
  2 | #include "PPP/Window.h"
  3 | #include "PPP/Image_private.h"
  4 | 
  5 | 
  6 | namespace Graph_lib {
  7 | 
  8 | Shape::~Shape()
  9 | {
 10 |     if (parent_window) {
 11 |         parent_window->detach(*this);
 12 |     }
 13 | }
 14 | 
 15 | void Shape::draw(Painter& painter) const
 16 | {
 17 |     painter.save();
 18 |     painter.set_line_style(style());
 19 |     // Color must be set after line style so that
 20 |     // setting an invisible color can set the line style to "no pen".
 21 |     painter.set_color(color());
 22 |     painter.set_fill_color(fill_color());
 23 |     draw_specifics(painter);
 24 |     painter.restore();
 25 | }
 26 | 
 27 | void Shape::redraw()
 28 | {
 29 |     if (parent_window)
 30 |         parent_window->draw();
 31 | }
 32 | // does two lines (p1,p2) and (p3,p4) intersect?
 33 | // if se return the distance of the intersect point as distances from p1
 34 | inline pair<double,double> line_intersect(Point p1, Point p2, Point p3, Point p4, bool& parallel) 
 35 | {
 36 |     double x1 = p1.x;
 37 |     double x2 = p2.x;
 38 | 	double x3 = p3.x;
 39 | 	double x4 = p4.x;
 40 | 	double y1 = p1.y;
 41 | 	double y2 = p2.y;
 42 | 	double y3 = p3.y;
 43 | 	double y4 = p4.y;
 44 | 
 45 | 	double denom = ((y4 - y3)*(x2-x1) - (x4-x3)*(y2-y1));
 46 | 	if (denom == 0){
 47 | 		parallel= true;
 48 | 		return pair<double,double>(0,0);
 49 | 	}
 50 | 	parallel = false;
 51 | 	return pair<double,double>( ((x4-x3)*(y1-y3) - (y4-y3)*(x1-x3))/denom,
 52 | 								((x2-x1)*(y1-y3) - (y2-y1)*(x1-x3))/denom);
 53 | }
 54 | 
 55 | 
 56 | //intersection between two line segments
 57 | //Returns true if the two segments intersect,
 58 | //in which case intersection is set to the point of intersection
 59 | bool line_segment_intersect(Point p1, Point p2, Point p3, Point p4, Point& intersection){
 60 |    bool parallel;
 61 |    pair<double,double> u = line_intersect(p1,p2,p3,p4,parallel);
 62 |    if (parallel || u.first < 0 || u.first > 1 || u.second < 0 || u.second > 1) return false;
 63 |    intersection.x = p1.x + u.first*(p2.x - p1.x);
 64 |    intersection.y = p1.y + u.first*(p2.y - p1.y);
 65 |    return true;
 66 | } 
 67 | 
 68 | void Polygon::add(Point p)
 69 | {
 70 | 	int np = number_of_points();
 71 | 
 72 | 	if (1<np) {	// check that thenew line isn't parallel to the previous one
 73 | 		if (p==point(np-1)) error("polygon point equal to previous point");
 74 | 		bool parallel;
 75 | 		line_intersect(point(np-1),p,point(np-2),point(np-1),parallel);
 76 | 		if (parallel)
 77 | 			error("two polygon points lie in a straight line");
 78 | 	}
 79 | 
 80 | 	for (int i = 1; i<np-1; ++i) {	// check that new segment doesn't interset and old point
 81 |         Point ignored_point{0,0};
 82 |         if (line_segment_intersect(point(np-1),p,point(i-1),point(i),ignored_point))
 83 | 			error("intersect in polygon");
 84 | 	}
 85 | 	
 86 | 
 87 | 	Closed_polyline::add(p);
 88 | }
 89 | 
 90 | 
 91 | void Polygon::draw_specifics(Painter& painter) const
 92 | {
 93 |     if (number_of_points() < 3) error("less than 3 points in a Polygon");
 94 |     Closed_polyline::draw_specifics(painter);
 95 | }
 96 | 
 97 | void Open_polyline::draw_specifics(Painter& painter) const
 98 | {
 99 |     if (color().visibility() && 1<number_of_points())	// draw sole pixel?
100 |         for (int i=1; i<number_of_points(); ++i)
101 |             painter.draw_line(point(i-1), point(i));
102 | }
103 | 
104 | void Closed_polyline::draw_specifics(Painter& painter) const
105 | {
106 |     painter.draw_polygon(*this);
107 | }
108 | void Shape::move(int dx, int dy)
109 | {
110 | 	for (unsigned int i = 0; i<points.size(); ++i) {
111 | 		points[i].x+=dx;
112 | 		points[i].y+=dy;
113 | 	}
114 |     redraw();
115 | }
116 | 
117 | void Lines::draw_specifics(Painter& painter) const
118 | {
119 |     if (number_of_points()%2==1) error("odd number of points in set of lines");
120 | 	if (color().visibility())
121 | 		for (int i=1; i<number_of_points(); i+=2)
122 |             painter.draw_line(point(i-1) ,point(i));
123 | }
124 | 
125 | void Text::draw_specifics(Painter& painter) const
126 | {
127 |     painter.set_font(font());
128 |     painter.set_font_size(font_size());
129 |     painter.draw_text(point(0), lab);
130 | }
131 | 
132 | Function::Function(std::function<double(double)> f, double r1, double r2, Point xy, int count, double xscale, double yscale)
133 | // graph f(x) for x in [r1:r2) using count line segments with (0,0) displayed at xy
134 | // x coordinates are scaled by xscale and y coordinates scaled by yscale
135 | {
136 | 	if (r2-r1<=0) error("bad graphing range");
137 | 	if (count<=0) error("non-positive graphing count");
138 | 	double dist = (r2-r1)/count;
139 | 	double r = r1;
140 |     for (int i = 0; i<count; ++i) {
141 |         add(Point{xy.x+int(r*xscale),xy.y-int(f(r)*yscale)});
142 | 		r += dist;
143 | 	}
144 | }
145 | void Line::draw_specifics(Painter& painter) const
146 | {
147 |     painter.draw_line(point(0), point(1));
148 | }
149 | 
150 | void Rectangle::draw_specifics(Painter& painter) const
151 | {
152 |     painter.draw_rectangle(point(0), w, h);
153 | }
154 | 
155 | 
156 | Axis::Axis(Orientation d, Point xy, int length, int n, string lab)
157 |     :label(Point{0,0},lab),
158 |     line(xy, d==x ?
159 |                    Point{xy.x+length, xy.y} :
160 |                    Point{xy.x, xy.y-length})
161 | {
162 | 	if (length<0) error("bad axis length");
163 | 	switch (d){
164 | 	case Axis::x:
165 |         {
166 | 			if (1<n) {
167 | 				int dist = length/n;
168 | 				int x = xy.x+dist;
169 |                 for (int i = 0; i<n; ++i) {
170 |                     notches.add(Point{x,xy.y},Point{x,xy.y-5});
171 | 				x += dist;
172 | 			}
173 | 		}
174 | 		// label under the line
175 | 		label.move(length/3,xy.y+20);
176 | 		break;
177 | 	}
178 | 	case Axis::y:
179 |         {
180 | 			if (1<n) {
181 | 			int dist = length/n;
182 | 			int y = xy.y-dist;
183 |             for (int i = 0; i<n; ++i) {
184 |                 notches.add(Point{xy.x,y},Point{xy.x+5,y});
185 | 				y -= dist;
186 | 			}
187 | 		}
188 | 		// label at top
189 | 		label.move(xy.x-10,xy.y-length-10);
190 | 		break;
191 | 	}
192 | 	case Axis::z:
193 | 		error("z axis not implemented");
194 | 	}
195 | }
196 | 
197 | void Axis::draw_specifics(Painter& painter) const
198 | {
199 |     line.draw(painter);	// the line
200 |     notches.draw(painter);	// the notches may have a different color from the line
201 |     label.draw(painter);	// the label may have a different color from the line
202 | }
203 | 
204 | 
205 | void Axis::set_color(Color c)
206 | {
207 | 	Shape::set_color(c);
208 | 	notches.set_color(c);
209 | 	label.set_color(c);
210 |     line.set_color(c);
211 |     redraw();
212 | }
213 | 
214 | void Axis::move(int dx, int dy)
215 | {
216 | 	Shape::move(dx,dy);
217 | 	notches.move(dx,dy);
218 | 	label.move(dx,dy);
219 |     redraw();
220 | }
221 | 
222 | void Circle::draw_specifics(Painter& painter) const
223 | {
224 |     painter.draw_ellipse(center(), r, r);
225 | }
226 | 
227 | 
228 | void Ellipse::draw_specifics(Painter& painter) const
229 | {
230 |     painter.draw_ellipse(center(), w, h);
231 | }
232 | 
233 | void Arc::draw_specifics(Painter& painter) const
234 | {
235 |     painter.draw_arc(point(0), w*2, h*2, start_angle*16, degrees*16);
236 | }
237 | 
238 | void Pie::draw_specifics(Painter& painter) const
239 | {
240 |     painter.draw_pie(point(0), w*2, h*2, start_angle*16, degrees*16);
241 | }
242 | 
243 | void draw_mark(Painter& painter, Point xy, char c)
244 | {
245 |     string m(1,c);
246 |     painter.draw_centered_text(xy, m);
247 | }
248 | 
249 | void Marked_polyline::draw_specifics(Painter& painter) const
250 | {
251 |     Open_polyline::draw_specifics(painter);
252 | 
253 |     painter.set_line_style(style());
254 |     painter.set_color(m_color);
255 |     painter.set_font(font());
256 |     painter.set_font_size(font_size());
257 |     for (int i=0; i<number_of_points(); ++i)
258 |         draw_mark(painter, point(i),mark[i%mark.size()]);
259 | }
260 | 
261 | bool can_open(const string& s)
262 |             // check if a file named s exists and can be opened for reading
263 | {
264 | 	ifstream ff(s.c_str());
265 |     return static_cast<bool>(ff);
266 | }
267 | 
268 | 
269 | 
270 | // somewhat overelaborate constructor
271 | // because errors related to image files can be such a pain to debug
272 | Image::Image(Point xy, string s)
273 |     :w(0), h(0), fn(xy,""), impl(std::make_unique<ImagePrivate>())
274 | {
275 | 	add(xy);
276 | 
277 | 	if (!can_open(s)) {
278 | 		fn.set_label("cannot open \""+s+'\"');
279 | 		return;
280 | 	}
281 |     impl->load(s);
282 | }
283 | 
284 | Image::~Image() {}
285 | 
286 | void Image::draw_specifics(Painter& painter) const
287 | {
288 |     if (fn.label()!="") fn.draw_specifics(painter);
289 | 
290 |     if (w&&h) {
291 |         Point p = point(0);
292 |         p.x += cx;
293 |         p.y += cy;
294 |         painter.draw_image(point(0), p, w, h, *this);
295 |     }
296 | 	else
297 |         painter.draw_image(point(0), *this);
298 | }
299 | 
300 | void Image::scale(int ww, int hh, bool keep_aspect_ratio)
301 | {
302 |     impl->scale(ww, hh, keep_aspect_ratio);
303 |     redraw();
304 | }
305 | 
306 | void Out_box::put(int i)
307 | {
308 |     std::ostringstream os;
309 |     os << i;
310 |     data.set_label(os.str());
311 |     redraw();
312 | }
313 | 
314 | void Out_box::put(const std::string& s)
315 | {
316 |     data.set_label(s);
317 |     redraw();
318 | }
319 | 
320 | void Out_box::draw_specifics(Painter& painter) const
321 | {
322 |     Vector_ref<const Text> texts;
323 |     texts.push_back(label);
324 |     texts.push_back(data);
325 |     if (orientation == horizontal) {
326 |         painter.draw_text_line(point(0), texts);
327 |     } else {
328 |         painter.draw_text_column(point(0), texts);
329 |     }
330 | }
331 | 
332 | } // Graph
333 | 


--------------------------------------------------------------------------------
/PPP/GUI.h:
--------------------------------------------------------------------------------
  1 | 
  2 | //
  3 | // This is a GUI support code to the chapters 12-16 of the book
  4 | // "Programming -- Principles and Practice Using C++" by Bjarne Stroustrup
  5 | //
  6 | 
  7 | #ifndef GUI_GUARD
  8 | #define GUI_GUARD
  9 | 
 10 | #include <PPP/Window.h>
 11 | #include <PPP/Graph.h>
 12 | 
 13 | namespace Graph_lib {
 14 | 
 15 | //------------------------------------------------------------------------------
 16 | 
 17 |     using Callback = std::function<void()>;
 18 | 
 19 | //------------------------------------------------------------------------------
 20 | 
 21 |     struct WidgetPrivate;
 22 |     class Widget {
 23 |     // Widget is a handle to a QWidget - it is *not* a QWidget
 24 |     // We keep our interface classes at arm's length from Qt
 25 |     public:
 26 |         Widget(Point xy, int w, int h, const string& s, Callback cb);
 27 | 
 28 |         virtual void move(int dx,int dy);
 29 |         virtual void hide();
 30 |         virtual void show();
 31 |         virtual void attach(Window&) {}
 32 | 
 33 |         Point loc;
 34 |         int width;
 35 |         int height;
 36 |         string label;
 37 |         Callback do_it;
 38 | 
 39 |         virtual ~Widget();
 40 | 
 41 |         WidgetPrivate& get_impl() const { return *impl; }
 42 |     private:
 43 |         Widget& operator=(const Widget&); // don't copy Widgets
 44 |         Widget(const Widget&);
 45 |         std::unique_ptr<WidgetPrivate> impl;
 46 |     };
 47 | 
 48 | //------------------------------------------------------------------------------
 49 | 
 50 |     struct Button : Widget {
 51 |         Button(Point xy, int w, int h, const string& label, Callback cb);
 52 | 
 53 |     };
 54 | 
 55 | //------------------------------------------------------------------------------
 56 | 
 57 |     struct In_box : Widget {
 58 |         In_box(Point xy, int w, int h, const string& s, Callback cb = {});
 59 |         int get_int();
 60 |         string get_string();
 61 |         int get_int_keep_open();
 62 |         string get_string_keep_open();
 63 |         void attach(Window& win) override;
 64 |         void dismiss();
 65 |         void hide() override;
 66 |         void show() override;
 67 |         void hide_buttons();
 68 |         void show_buttons();
 69 |         enum State {idle, accepted, rejected};
 70 |         State last_result();
 71 |         void clear_last_result();
 72 |         string last_string_value();
 73 |         int last_int_value();
 74 |         struct ResultData {
 75 |             State state = idle;
 76 |             string last_string;
 77 |             int last_int = 0;
 78 |         };
 79 | 
 80 |     private:
 81 |         ResultData result;
 82 |         bool waiting = false;
 83 |     };
 84 | 
 85 | 
 86 | //------------------------------------------------------------------------------
 87 | 
 88 |     struct Menu : Widget {
 89 |         enum Kind { horizontal, vertical };
 90 |         Menu(Point xy, int w, int h, Kind kk, const string& label);
 91 | 
 92 |         using Widget::attach;
 93 |         int attach(Button& b);      // Menu does not delete &b
 94 |         int attach(unique_ptr<Button> p);      // Menu destroys p
 95 | 
 96 |         void show()                 // show all buttons
 97 |         {
 98 |             for (auto&& x : selection)
 99 |                 x->show();
100 |         }
101 |         void hide()                 // hide all buttons
102 |         {
103 |             for (auto&& x : selection)
104 |                 x->hide();
105 |         }
106 |         void move(int dx, int dy)   // move all buttons
107 |         {
108 |             for (auto&& x : selection)
109 |                 x->move(dx,dy);
110 |         }
111 | 
112 |     private:
113 |         Vector_ref<Button> selection;
114 |         Kind k;
115 |         int offset;
116 |         void layoutButtons(Button& b);
117 |         void layoutMenu();
118 |     };
119 | 
120 | //------------------------------------------------------------------------------
121 | 
122 | } // of namespace Graph_lib
123 | 
124 | #endif // GUI_GUARD
125 | 


--------------------------------------------------------------------------------
/PPP/GUI_private.h:
--------------------------------------------------------------------------------
 1 | 
 2 | //
 3 | // This is a GUI support code to the chapters 12-16 of the book
 4 | // "Programming -- Principles and Practice Using C++" by Bjarne Stroustrup
 5 | //
 6 | 
 7 | #ifndef GUI_PRIVATE_GUARD
 8 | #define GUI_PRIVATE_GUARD
 9 | 
10 | #include <PPP/Graph.h>
11 | 
12 | #include <QEventLoop>
13 | #include <QTimer>
14 | #include <QWidget>
15 | 
16 | namespace Graph_lib {
17 | 
18 |     struct WidgetPrivate
19 |     {
20 |         std::unique_ptr<QWidget> widget;
21 |     };
22 | 
23 |     struct Button;
24 |     class Window;
25 |     class WindowPrivate : public QWidget
26 |     {
27 |         Q_OBJECT
28 |     public:
29 |         explicit WindowPrivate(Window* window) : wnd(window)
30 |         {
31 |             loop_stopping_timer.setSingleShot(true);
32 |             user_timer.setSingleShot(true);
33 |         }
34 |         ~WindowPrivate()
35 |         {
36 |             user_timer.stop();
37 |         }
38 |         void attach(Shape& s)
39 |         {
40 |             shapes.push_back(&s);
41 |             repaint();
42 |         }
43 |         void detach(Shape& s)
44 |         {
45 |             for (size_t i = shapes.size(); 0<i; --i)	// guess last attached will be first released
46 |                 if (shapes[i-1]==&s)
47 |                     shapes.erase(shapes.begin()+(i-1));//&shapes[i-1]);
48 |             repaint();
49 |         }
50 |         void put_on_top(Shape& s)
51 |         {
52 |             for (unsigned int i=0; i<shapes.size(); ++i) {
53 |                 if (&s==shapes[i]) {
54 |                     for (++i; i<shapes.size(); ++i)
55 |                         shapes[i-1] = shapes[i];
56 |                     shapes[shapes.size()-1] = &s;
57 |                     return;
58 |                 }
59 |             }
60 | 
61 |         }
62 |         void timer_wait(int milliseconds);
63 |         void timer_wait(int milliseconds, std::function<void()> cb);
64 |         void wait_for_button(Button* button);
65 |         void end_button_wait();
66 |         QEventLoop nested_loop;
67 |         QTimer user_timer{&nested_loop};
68 |         bool accept_waits = true;
69 |         QTimer loop_stopping_timer{&nested_loop};
70 |         bool invoke_stored_callback = false;
71 |     signals:
72 |         void windowClosed();
73 |     private:
74 |         void paintEvent(QPaintEvent *event) override;
75 |         void closeEvent(QCloseEvent *event) override;
76 |         vector<Shape*> shapes;	// shapes attached to window
77 |         Window* wnd{};
78 |     };
79 | 
80 | } // of namespace Graph_lib
81 | 
82 | #endif // GUI_PRIVATE_GUARD
83 | 


--------------------------------------------------------------------------------
/PPP/Graph.h:
--------------------------------------------------------------------------------
  1 | 
  2 | #ifndef GRAPH_GUARD
  3 | #define GRAPH_GUARD 1
  4 | 
  5 | #include <PPP/Point.h>
  6 | #include <PPP/std_lib_facilities.h>
  7 | 
  8 | 
  9 | namespace Graph_lib {
 10 | // defense against ill-behaved Linux macros:
 11 | #undef major
 12 | #undef minor
 13 | 
 14 | struct Color {
 15 | 	enum Color_type {
 16 |         red, blue, green,
 17 |         yellow, white, black,
 18 |         magenta, cyan, dark_red,
 19 |         dark_green, dark_yellow, dark_blue,
 20 |         dark_magenta, dark_cyan,
 21 |         palette_index,
 22 |         rgb
 23 | 	};
 24 | 	enum Transparency { invisible = 0, visible=255 };
 25 | 
 26 |     Color(Color_type cc) :c(cc), ct(cc), v(visible) { }
 27 |     Color(Color_type cc, Transparency vv) :c(cc), ct(cc), v(vv) { }
 28 |     Color(int cc) :c(cc), ct(Color_type::palette_index), v(visible) { }
 29 |     Color(Transparency vv) :c(), ct(Color_type::black), v(vv) { }
 30 |     Color(int redc, int greenc, int bluec) : c(), ct(Color_type::rgb),
 31 |         rgb_color{redc, greenc, bluec}, v(visible) {}
 32 | 
 33 |     int as_int() const { return c; }
 34 |     int red_component() {return rgb_color.r;}
 35 |     int green_component() {return rgb_color.g;}
 36 |     int blue_component() {return rgb_color.b;}
 37 |     Color_type type() {return ct;}
 38 |     Transparency visibility() const { return v; }
 39 |     void set_visibility(Transparency vv) { v= vv; }
 40 | private:
 41 |     int c = 0;
 42 |     Color_type ct = black;
 43 |     struct Rgb {int r; int g; int b;};
 44 |     Rgb rgb_color = {0, 0, 0};
 45 |     Transparency v;	// 0 or 1 for now
 46 | };
 47 | 
 48 | inline bool operator<(Color a, Color b)
 49 | {
 50 |     if (a.type() != Color::palette_index || b.type() != Color::palette_index)
 51 |         return a.type() < b.type();
 52 |     return a.as_int() < b.as_int();
 53 | }
 54 | 
 55 | struct Line_style {
 56 | 	enum Line_style_type {
 57 |         solid,				// -------
 58 |         dash,				// - - - -
 59 |         dot,					// .......
 60 |         dashdot,			// - . - .
 61 |         dashdotdot,	// -..-..
 62 |         none
 63 |     };
 64 |     Line_style() {}
 65 |     Line_style(Line_style_type ss) :s(ss) { }
 66 | 	Line_style(Line_style_type lst, int ww) :s(lst), w(ww) { }
 67 | 
 68 | 	int width() const { return w; }
 69 | 	int style() const { return s; }
 70 | private:
 71 |     int s = Line_style::solid;
 72 |     int w = 1;
 73 | };
 74 | 
 75 | inline bool operator<(Line_style a, Line_style b)
 76 | {
 77 |     return a.style() < b.style();
 78 | }
 79 | 
 80 | class Font {
 81 | public:
 82 | 	enum Font_type {
 83 |         helvetica,
 84 |         helvetica_bold,
 85 |         helvetica_italic,
 86 |         helvetica_bold_italic,
 87 |         courier,
 88 |         courier_bold,
 89 |         courier_italic,
 90 |         courier_bold_italic,
 91 |         times,
 92 |         times_bold,
 93 |         times_italic,
 94 |         times_bold_italic,
 95 |         symbol,
 96 |         screen,
 97 |         screen_bold,
 98 |         zapf_dingbats
 99 | 	};
100 | 
101 | 	Font(Font_type ff) :f(ff) { }
102 | 
103 | 	int as_int() const { return f; }
104 | private:
105 |     int f;
106 | };
107 | 
108 | inline bool operator<(Font a, Font b)
109 | {
110 |     return a.as_int() < b.as_int();
111 | }
112 | 
113 | template<class T> class Vector_ref {
114 |     vector<T*> v;
115 |     vector<unique_ptr<T>> owned;
116 | public:
117 | 	Vector_ref() {}
118 | 
119 |     Vector_ref(unique_ptr<T> a, unique_ptr<T> b={}, unique_ptr<T> c={}, unique_ptr<T> d={})
120 |     {
121 |             if (a) push_back(std::move(a));
122 |             if (b) push_back(std::move(b));
123 |             if (c) push_back(std::move(c));
124 |             if (d) push_back(std::move(d));
125 | 	}
126 | 
127 |     ~Vector_ref() = default;
128 | 
129 |     void push_back(T& s) { v.push_back(&s); }
130 |     void push_back(unique_ptr<T> p) { v.push_back(p.get()); owned.push_back(std::move(p)); }
131 | 
132 | 	// ???void erase(???)
133 | 
134 | 	T& operator[](int i) { return *v[i]; }
135 | 	const T& operator[](int i) const { return *v[i]; }
136 |     int size() const { return (int)v.size(); }
137 |     auto begin() { return v.begin(); }
138 |     auto end() { return v.end(); }
139 |     auto begin() const { return v.begin(); }
140 |     auto end() const { return v.end(); }
141 | };
142 | 
143 | typedef double Fct(double);
144 | 
145 | 
146 | class Painter;
147 | class Window;
148 | class Shape  {	// deals with color and style, and holds sequence of lines
149 | protected:
150 |     Shape(std::initializer_list<Point> points = {}) { for (auto&& x : points) add(x);}
151 | 
152 |     void add(Point p){ points.push_back(p); redraw();}
153 |     void set_point(int i, Point p) { points[i] = p; redraw();}
154 | public:
155 |     void draw(Painter& painter) const;					// deal with color and draw_lines
156 | private:
157 |     virtual void draw_specifics(Painter& painter) const = 0;	// no default implementation that can be called
158 | public:
159 | 	virtual void move(int dx, int dy);	// move the shape +=dx and +=dy
160 | 
161 |     void set_color(Color col) { lcolor = col; redraw();}
162 | 	Color color() const { return lcolor; }
163 | 
164 |     void set_style(Line_style sty) { ls = sty; redraw();}
165 | 	Line_style style() const { return ls; }
166 | 
167 |     void set_fill_color(Color col) { fcolor = col; redraw();}
168 | 	Color fill_color() const { return fcolor; }
169 | 
170 | 	Point point(int i) const { return points[i]; }
171 | 	int number_of_points() const { return int(points.size()); }
172 |     void set_window(Window* win) {
173 |         parent_window = win;
174 |         set_parent_window(win);
175 |     }
176 |     virtual ~Shape();
177 | 	Shape(const Shape&) = delete;
178 | 	Shape& operator=(const Shape&) = delete;
179 | protected:
180 |     void redraw();
181 | private:
182 |     virtual void set_parent_window(Window* /*win*/) {}
183 |     Window* parent_window = nullptr;
184 |     vector<Point> points;	// not used by all shapes
185 |     Color lcolor {Color::black};
186 |     Line_style ls;
187 | 	Color fcolor {Color::invisible};
188 | 
189 | //	Shape(const Shape&);
190 | //	Shape& operator=(const Shape&);
191 | };
192 | 
193 | 
194 | struct Fill {
195 | 	Fill() :no_fill(true), fcolor(0) { }
196 | 	Fill(Color c) :no_fill(false), fcolor(c) { }
197 | 
198 |     void set_fill_color(Color col) { fcolor = col; }
199 | 	Color fill_color() { return fcolor; }
200 | protected:
201 | 	bool no_fill;
202 | 	Color fcolor;
203 | };
204 | 
205 | struct Line : Shape {
206 | 	Line(Point p1, Point p2) { add(p1); add(p2); }
207 |     void draw_specifics(Painter& painter) const override;
208 | };
209 | 
210 | struct Rectangle : Shape {
211 | 
212 | 	Rectangle(Point xy, int ww, int hh) :w{ ww }, h{ hh }
213 | 	{
214 | 		if (h<=0 || w<=0) error("Bad rectangle: non-positive side");
215 | 		add(xy);
216 | 	}
217 | 	Rectangle(Point x, Point y) :w{ y.x - x.x }, h{ y.y - x.y }
218 | 	{
219 | 		if (h<=0 || w<=0) error("Bad rectangle: first point is not top left");
220 | 		add(x);
221 | 	}
222 |     void draw_specifics(Painter& painter) const override;
223 | 
224 | //	void set_fill_color(Color col) { fcolor = col; }
225 | //	Color fill_color() { return fcolor; }
226 | 
227 | 	int height() const { return h; }
228 | 	int width() const { return w; }
229 | private:
230 |     int w;			// width
231 |     int h;			// height
232 | //	Color fcolor;	// fill color; 0 means "no fill"
233 | };
234 | 
235 | bool intersect(Point p1, Point p2, Point p3, Point p4);
236 | 
237 | 
238 | struct Open_polyline : Shape {	// open sequence of lines
239 |     using Shape::Shape;
240 |     Open_polyline(std::initializer_list<Point> p = {}) : Shape(p) {}
241 |     void add(Point p) { Shape::add(p); redraw();}
242 |     void draw_specifics(Painter& painter) const override;
243 | };
244 | 
245 | struct Closed_polyline : Open_polyline {	// closed sequence of lines
246 | 	using Open_polyline::Open_polyline;
247 |     void draw_specifics(Painter& painter) const override;
248 | };
249 | 
250 | struct Function : Open_polyline {
251 |     // the function parameters are not stored
252 |     Function(std::function<double(double)> f, double r1, double r2, Point orig, int count = 100, double xscale = 25, double yscale = 25);
253 |     //Function(Point orig, Fct f, double r1, double r2, int count, double xscale = 1, double yscale = 1);
254 | };
255 | 
256 | struct Polygon : Closed_polyline {	// closed sequence of non-intersecting lines
257 | 	using Closed_polyline::Closed_polyline;
258 | 	void add(Point p);
259 |     void draw_specifics(Painter& painter) const override;
260 | };
261 | 
262 | struct Lines : Shape {	// independent lines
263 |     Lines(initializer_list<Point> lst = {}) : Shape{lst} { if (lst.size() % 2) error("odd number of points for Lines"); }
264 |     void draw_specifics(Painter& painter) const override;
265 |     void add(Point p1, Point p2) { Shape::add(p1); Shape::add(p2); redraw();}
266 | };
267 | 
268 | struct Text : Shape {
269 |     // the point is the top left of the first letter
270 | 	Text(Point x, const string& s) : lab{ s } { add(x); }
271 | 
272 |     void draw_specifics(Painter& painter) const override;
273 | 
274 |     void set_label(const string& s) { lab = s; redraw();}
275 | 	string label() const { return lab; }
276 | 
277 |     void set_font(Font f) { fnt = f; redraw();}
278 | 	Font font() const { return Font(fnt); }
279 | 
280 |     void set_font_size(int s) { fnt_sz = s; redraw();}
281 | 	int font_size() const { return fnt_sz; }
282 | private:
283 | 	string lab;	// label
284 |     Font fnt{ Font::courier };
285 |     int fnt_sz{ 14 };	// at least 14 point
286 | };
287 | 
288 | 
289 | struct Axis : Shape {
290 | 	// representation left public
291 | 	enum Orientation { x, y, z };
292 |     Axis(Orientation d, Point xy, int length, int number_of_notches=0, string label = "");
293 | 
294 |     void draw_specifics(Painter& painter) const override;
295 |     void move(int dx, int dy) override;
296 | 
297 | 	void set_color(Color c);
298 | 
299 | 	Text label;
300 | 	Lines notches;
301 |     Line line;
302 | //	Orientation orin;
303 | //	int notches;
304 | };
305 | 
306 | struct Circle : Shape {
307 | 	Circle(Point p, int rr)	// center and radius
308 | 	:r{ rr } {
309 | 		add(Point{ p.x - r, p.y - r });
310 | 	}
311 | 
312 |     void draw_specifics(Painter& painter) const override;
313 | 
314 | 	Point center() const { return { point(0).x + r, point(0).y + r }; }
315 | 
316 |     void set_radius(int rr) { r=rr; redraw();}
317 | 	int radius() const { return r; }
318 | private:
319 | 	int r;
320 | };
321 | 
322 | 
323 | struct Ellipse : Shape {
324 | 	Ellipse(Point p, int ww, int hh)	// center, min, and max distance from center
325 | 	:w{ ww }, h{ hh } {
326 | 		add(Point{ p.x - ww, p.y - hh });
327 | 	}
328 | 
329 |     void draw_specifics(Painter& painter) const override;
330 | 
331 | 	Point center() const { return{ point(0).x + w, point(0).y + h }; }
332 | 	Point focus1() const { return{ center().x + int(sqrt(double(w*w - h*h))), center().y }; }
333 |     Point focus2() const { return{ center().x - int(sqrt(double(w*w - h*h))), center().y }; }
334 | 
335 |     void set_major(int ww) { w=ww; redraw();}
336 |     int major() const { return w; }
337 |     void set_minor(int hh) { h=hh; redraw();}
338 | 	int minor() const { return h; }
339 | protected:
340 | 	int w;
341 | 	int h;
342 | };
343 | 
344 | struct Arc : Ellipse {
345 |     Arc(Point p, int ww, int hh, int s_angle, int dgr)	// center, min, and max distance from center
346 |         : Ellipse(p, ww, hh), start_angle(s_angle), degrees(dgr)
347 |     {
348 |     }
349 | 
350 |     void draw_specifics(Painter& painter) const override;
351 | protected:
352 |     int start_angle;
353 |     int degrees;
354 | };
355 | 
356 | struct Pie : Arc {
357 |     using Arc::Arc;
358 |     void draw_specifics(Painter& painter) const override;
359 | };
360 | 
361 | /*
362 | struct Mark : Text {
363 | 	static const int dw = 4;
364 | 	static const int dh = 4;
365 | 	Mark(Point xy, char c) : Text(Point(xy.x-dw, xy.y+dh),string(1,c)) {}
366 | };
367 | */
368 | 
369 | struct Marked_polyline : Open_polyline {
370 |     Marked_polyline(const string& m, initializer_list<Point> lst = {})
371 |         : Open_polyline{ lst }, mark{ m }, m_color(color())
372 |     {
373 |         if (m == "")
374 |             mark = "*";
375 |     }
376 |     void set_font(Font f) { fnt = f; redraw();}
377 |     Font font() const { return Font(fnt); }
378 | 
379 |     void set_font_size(int s) { fnt_sz = s; redraw();}
380 |     int font_size() const { return fnt_sz; }
381 | 
382 |     void set_color(Color col) { Shape::set_color(col); set_mark_color(col); redraw();}
383 |     void set_mark_color(Color c) { m_color = c; redraw();}
384 |     Color mark_color() const { return m_color;}
385 | 
386 |     void draw_specifics(Painter& painter) const override;
387 | private:
388 |     string mark;
389 |     Font fnt{ Font::courier };
390 |     int fnt_sz{ 14 };	// at least 14 point
391 |     Color m_color;
392 | };
393 | 
394 | struct Marks : Marked_polyline {
395 | public:
396 |     Marks(const string& m, initializer_list<Point> lst = {})
397 |         : Marked_polyline{ m,lst }   {
398 |         Color orig = color();
399 |         Marked_polyline::set_color(Color::invisible);
400 |         set_mark_color(orig);
401 |     }
402 |     void set_color(Color col) {
403 |         set_mark_color(col);
404 |     }
405 | };
406 | 
407 | struct Mark : Marks {
408 | 	Mark(Point xy, char c) : Marks(string(1,c)) {add(xy); }
409 | };
410 | 
411 | struct Out_box : Shape {
412 |     enum Kind { horizontal, vertical };
413 |     Out_box(Point p, const string& s, Kind k = horizontal)
414 |         : label(p, s),
415 |           data(p, ""),
416 |           orientation(k)
417 |     {
418 |         Shape::add(p);
419 |     }
420 |     void set_parent_window(Window* win) override {
421 |         label.set_window(win);
422 |         data.set_window(win);
423 |     }
424 | 
425 |     void put(int);
426 |     void put(const string&);
427 |     void draw_specifics(Painter& painter) const override;	// simply draw the appropriate lines
428 |     Text label;
429 |     Text data;
430 |     Kind orientation;
431 | };
432 | 
433 | /*
434 | 
435 | struct Marks : Shape {
436 | 	Marks(char m) : mark(string(1,m)) { }
437 | 	void add(Point p) { Shape::add(p); }
438 | 	void draw_lines() const;
439 | private:
440 | 	string mark;
441 | };
442 | */
443 | 
444 | class ImagePrivate;
445 | struct Image : Shape {
446 |     Image(Point xy, string s);
447 |     ~Image();
448 |     void draw_specifics(Painter& painter) const override;
449 |     void set_mask(Point xy, int ww, int hh) { w=ww; h=hh; cx=xy.x; cy=xy.y; redraw();}
450 |     void move(int dx,int dy) override { Shape::move(dx,dy); redraw(); /*p->draw(point(0).x,point(0).y);*/ }
451 |     ImagePrivate& get_impl() const {return *impl;}
452 |     void scale(int ww, int hh, bool keep_aspect_ratio = true);
453 | private:
454 | 	int w,h,cx,cy; // define "masking box" within image relative to position (cx,cy)
455 | 	Text fn;
456 |     std::unique_ptr<ImagePrivate> impl;
457 | };
458 | 
459 | }
460 | #endif
461 | 
462 | 


--------------------------------------------------------------------------------
/PPP/Image_private.h:
--------------------------------------------------------------------------------
 1 | 
 2 | #ifndef IMAGE_PRIVATE_GUARD
 3 | #define IMAGE_PRIVATE_GUARD 1
 4 | 
 5 | #include <QImage>
 6 | #include <QColor>
 7 | 
 8 | namespace Graph_lib {
 9 | 
10 | class ImagePrivate
11 | {
12 | public:
13 |     QImage image;
14 |     void load(const std::string& s);
15 |     void scale(int w, int h, bool keep_aspect_ratio = true);
16 | };
17 | 
18 | QColor mapPaletteColor(int rawColor);
19 | 
20 | }
21 | #endif
22 | 
23 | 


--------------------------------------------------------------------------------
/PPP/Point.h:
--------------------------------------------------------------------------------
 1 | 
 2 | #ifndef POINT_GUARD
 3 | #define POINT_GUARD
 4 | 
 5 | //typedef void (*Callback)(void*,void*);
 6 | 
 7 | namespace Graph_lib {
 8 | 
 9 | struct Point {
10 | 	int x,y;
11 | };
12 | 
13 | inline bool operator==(Point a, Point b) { return a.x==b.x && a.y==b.y; }
14 | 
15 | inline bool operator!=(Point a, Point b) { return !(a==b); }
16 | 
17 | 
18 | }
19 | #endif
20 | 


--------------------------------------------------------------------------------
/PPP/Simple_window.h:
--------------------------------------------------------------------------------
 1 | 
 2 | #include <PPP/GUI.h>	// for Simple_window only (doesn't really belong in Window.h)
 3 | 
 4 | using namespace Graph_lib;
 5 | 
 6 | // Simple_window is basic scaffolding for ultra-simple interaction with graphics
 7 | // it provides one window with one "next" button for ultra-simple animation
 8 | 
 9 | struct Simple_windowPrivate;
10 | 
11 | struct Simple_window : Window {
12 |     Simple_window(Point xy, int w, int h, const string& title );
13 |     ~Simple_window();
14 |     void wait_for_button();
15 | 
16 | private:
17 |     Button next_button;
18 | };
19 | 


--------------------------------------------------------------------------------
/PPP/Window.h:
--------------------------------------------------------------------------------
  1 | #ifndef WINDOW_GUARD
  2 | #define WINDOW_GUARD 1
  3 | 
  4 | #include <PPP/std_lib_facilities.h>
  5 | 
  6 | #include <PPP/Point.h>
  7 | #include "Graph.h"
  8 | 
  9 | namespace Graph_lib {
 10 | 
 11 | class Shape;	// "forward declare" Shape
 12 | struct Color;
 13 | struct Line_style;
 14 | class Font;
 15 | struct Image;
 16 | 
 17 | class Widget;
 18 | 
 19 | class PainterPrivate;
 20 | class Painter
 21 | {
 22 | public:
 23 |     Painter(std::unique_ptr<PainterPrivate>&& pp);
 24 |     ~Painter();
 25 |     Painter(const Painter&) = delete;
 26 |     Painter& operator=(const Painter&) = delete;
 27 | 
 28 |     void draw_rectangle(const Point& p1, int w, int h);
 29 |     void draw_line(const Point& p1, const Point& p2);
 30 |     void draw_polygon(const Shape& s);
 31 |     Point draw_text(const Point& p1, const std::string& text);
 32 |     Point draw_centered_text(const Point& p1, const std::string& text);
 33 |     void draw_text_line(const Point& p1, const Vector_ref<const Text>& texts);
 34 |     void draw_text_column(const Point& p1, const Vector_ref<const Text>& texts);
 35 |     void draw_ellipse(const Point& p1, int r, int r2);
 36 |     void draw_arc(const Point& p1, int r, int r2, int start_angle, int end_angle);
 37 |     void draw_pie(const Point& p1, int r, int r2, int start_angle, int end_angle);
 38 |     void draw_image(const Point& p1, const Image& img);
 39 |     void draw_image(const Point& p1, const Point& p2, int w, int h, const Image& img);
 40 |     void set_line_style(Line_style style); // set_color must be called after set_line_style
 41 |     void set_font_size(int s);
 42 |     void set_font(Font f);
 43 |     void set_color(Color color); // set_color must be called after set_line_style
 44 |     void set_fill_color(Color color);
 45 | private:
 46 |     void save();
 47 |     void restore();
 48 |     void setup_from_text(const Text& text);
 49 |     friend class Shape;
 50 | private:
 51 |     std::unique_ptr<PainterPrivate> impl;
 52 | };
 53 | 
 54 | class ApplicationPrivate;
 55 | class Application
 56 | {
 57 | public:
 58 |     Application();
 59 |     ~Application();
 60 |     void gui_main();
 61 |     void quit();
 62 | private:
 63 |     std::unique_ptr<ApplicationPrivate> impl;
 64 | };
 65 | 
 66 | struct Button;
 67 | class WindowPrivate;
 68 | class Window {
 69 | public: 
 70 | 	Window(int w, int h, const string& title );			// let the system pick the location
 71 | 	Window(Point xy, int w, int h, const string& title );	// top left corner in xy
 72 |     virtual ~Window();
 73 | 
 74 | 	int x_max() const { return w; }
 75 | 	int y_max() const { return h; }
 76 | 
 77 |     void resize(int ww, int hh);
 78 | 
 79 |     void set_label(const string& s);
 80 | 
 81 | 	void attach(Shape& s);
 82 | 	void attach(Widget& w);
 83 | 
 84 | 	void detach(Shape& s);	// remove s from shapes 
 85 | 	void detach(Widget& w);	// remove w from window (deactivate callbacks)
 86 | 
 87 | 	void put_on_top(Shape& s);	// put p on top of other shapes
 88 | 
 89 |     WindowPrivate& get_impl() const;
 90 | 	void draw();
 91 |     void close();
 92 |     void wait_for_button(Button* button);
 93 |     void end_button_wait();
 94 |     void timer_wait(int milliseconds);
 95 |     void timer_wait(int milliseconds, std::function<void()> cb);
 96 | private:
 97 |       Point p;
 98 |       int w,h;					// window size
 99 |       unique_ptr<WindowPrivate> impl;
100 |       void init();
101 | };
102 | 
103 | int gui_main();	// invoke GUI library's main event loop
104 | 
105 | inline int x_max() { return 1024; }	// width of screen in pixels
106 | inline int y_max() { return 768; }	// height of screen in pixels
107 | 
108 | }
109 | #endif
110 | 


--------------------------------------------------------------------------------
/PPP/std_lib_facilities.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |    std_lib_facilities.h
  3 | */
  4 | 
  5 | /*
  6 | 	simple "Programming: Principles and Practice using C++ (second edition)" course header to
  7 | 	be used for the first few weeks.
  8 | 	It provides the most common standard headers (in the global namespace)
  9 | 	and minimal exception/error support.
 10 | 
 11 | 	Students: please don't try to understand the details of headers just yet.
 12 | 	All will be explained. This header is primarily used so that you don't have
 13 | 	to understand every concept all at once.
 14 | 
 15 | 	By Chapter 10, you don't need this file and after Chapter 21, you'll understand it
 16 | 
 17 | 	Revised April 25, 2010: simple_error() added
 18 | 	
 19 | 	Revised November 25 2013: remove support for pre-C++11 compilers, use C++11: <chrono>
 20 | 	Revised November 28 2013: add a few container algorithms
 21 | 	Revised June 8 2014: added #ifndef to workaround Microsoft C++11 weakness
 22 | */
 23 | 
 24 | #ifndef H112
 25 | #define H112 251113L
 26 | 
 27 | 
 28 | #include<iostream>
 29 | #include<iomanip>
 30 | #include<fstream>
 31 | #include<sstream>
 32 | #include<cmath>
 33 | #include<cstdlib>
 34 | #include<string>
 35 | #include<list>
 36 | #include <forward_list>
 37 | #include<vector>
 38 | #include<unordered_map>
 39 | #include<algorithm>
 40 | #include<functional>
 41 | #include <array>
 42 | #include <regex>
 43 | #include <optional>
 44 | #include<random>
 45 | #include<stdexcept>
 46 | 
 47 | //------------------------------------------------------------------------------
 48 | 
 49 | 
 50 | //------------------------------------------------------------------------------
 51 | 
 52 | typedef long Unicode;
 53 | 
 54 | //------------------------------------------------------------------------------
 55 | 
 56 | using namespace std;
 57 | 
 58 | template<class T> string to_string(const T& t)
 59 | {
 60 | 	ostringstream os;
 61 | 	os << t;
 62 | 	return os.str();
 63 | }
 64 | 
 65 | struct Range_error : out_of_range {	// enhanced vector range error reporting
 66 | 	int index;
 67 | 	Range_error(int i) :out_of_range("Range error: "+to_string(i)), index(i) { }
 68 | };
 69 | 
 70 | 
 71 | // trivially range-checked vector (no iterator checking):
 72 | template< class T> struct Vector : public std::vector<T> {
 73 | 	using size_type = typename std::vector<T>::size_type;
 74 | 
 75 | #ifdef _MSC_VER
 76 | 	// microsoft doesn't yet support C++11 inheriting constructors
 77 | 	Vector() { }
 78 | 	explicit Vector(size_type n) :std::vector<T>(n) {}
 79 | 	Vector(size_type n, const T& v) :std::vector<T>(n,v) {}
 80 | 	template <class I>
 81 | 	Vector(I first, I last) : std::vector<T>(first, last) {}
 82 | 	Vector(initializer_list<T> list) : std::vector<T>(list) {}
 83 | #else
 84 | 	using std::vector<T>::vector;	// inheriting constructor
 85 | #endif
 86 | 
 87 | 	T& operator[](unsigned int i) // rather than return at(i);
 88 | 	{
 89 | 		if (i<0||this->size()<=i) throw Range_error(i);
 90 | 		return std::vector<T>::operator[](i);
 91 | 	}
 92 | 	const T& operator[](unsigned int i) const
 93 | 	{
 94 | 		if (i<0||this->size()<=i) throw Range_error(i);
 95 | 		return std::vector<T>::operator[](i);
 96 | 	}
 97 | };
 98 | 
 99 | // disgusting macro hack to get a range checked vector:
100 | //#define vector Vector
101 | 
102 | // trivially range-checked string (no iterator checking):
103 | struct String : std::string {
104 | 	using size_type = std::string::size_type;
105 | //	using string::string;
106 | 
107 | 	char& operator[](unsigned int i) // rather than return at(i);
108 | 	{
109 |         if (size()<=i) throw Range_error(i);
110 | 		return std::string::operator[](i);
111 | 	}
112 | 
113 | 	const char& operator[](unsigned int i) const
114 | 	{
115 |         if (size()<=i) throw Range_error(i);
116 | 		return std::string::operator[](i);
117 | 	}
118 | };
119 | 
120 | 
121 | namespace std {
122 | 
123 |     template<> struct hash<String>
124 |     {
125 |         size_t operator()(const String& s) const
126 |         {
127 |             return hash<std::string>()(s);
128 |         }
129 |     };
130 | 
131 | } // of namespace std
132 | 
133 | 
134 | struct Exit : runtime_error {
135 | 	Exit(): runtime_error("Exit") {}
136 | };
137 | 
138 | // error() simply disguises throws:
139 | inline void error(const string& s)
140 | {
141 | 	throw runtime_error(s);
142 | }
143 | 
144 | inline void error(const string& s, const string& s2)
145 | {
146 | 	error(s+s2);
147 | }
148 | 
149 | inline void error(const string& s, int i)
150 | {
151 | 	ostringstream os;
152 | 	os << s <<": " << i;
153 | 	error(os.str());
154 | }
155 | 
156 | 
157 | template<class T> char* as_bytes(T& i)	// needed for binary I/O
158 | {
159 | 	void* addr = &i;	// get the address of the first byte
160 | 						// of memory used to store the object
161 | 	return static_cast<char*>(addr); // treat that memory as bytes
162 | }
163 | 
164 | 
165 | inline void keep_window_open()
166 | {
167 | 	cin.clear();
168 | 	cout << "Please enter a character to exit\n";
169 | 	char ch;
170 | 	cin >> ch;
171 | 	return;
172 | }
173 | 
174 | inline void keep_window_open(string s)
175 | {
176 | 	if (s=="") return;
177 | 	cin.clear();
178 | 	cin.ignore(120,'\n');
179 | 	for (;;) {
180 | 		cout << "Please enter " << s << " to exit\n";
181 | 		string ss;
182 | 		while (cin >> ss && ss!=s)
183 | 			cout << "Please enter " << s << " to exit\n";
184 | 		return;
185 | 	}
186 | }
187 | 
188 | 
189 | 
190 | // error function to be used (only) until error() is introduced in Chapter 5:
191 | inline void simple_error(string s)	// write ``error: s and exit program
192 | {
193 | 	cerr << "error: " << s << '\n';
194 | 	keep_window_open();		// for some Windows environments
195 | 	exit(1);
196 | }
197 | 
198 | // make std::min() and std::max() accessible on systems with antisocial macros:
199 | #undef min
200 | #undef max
201 | 
202 | 
203 | // run-time checked narrowing cast (type conversion). See ???.
204 | template<class R, class A> R narrow_cast(const A& a)
205 | {
206 | 	R r = R(a);
207 | 	if (A(r)!=a) error(string("info loss"));
208 | 	return r;
209 | }
210 | 
211 | // random number generators. See 24.7.
212 | 
213 | 
214 | 
215 | inline int randint(int min, int max) { static default_random_engine ran; return uniform_int_distribution<>{min, max}(ran); }
216 | 
217 | inline int randint(int max) { return randint(0, max); }
218 | 
219 | //inline double sqrt(int x) { return sqrt(double(x)); }	// to match C++0x
220 | 
221 | // container algorithms. See 21.9.
222 | 
223 | template<typename C>
224 | using Value_type = typename C::value_type;
225 | 
226 | template<typename C>
227 | using Iterator = typename C::iterator;
228 | 
229 | template<typename C>
230 | 	// requires Container<C>()
231 | void sort(C& c)
232 | {
233 | 	std::sort(c.begin(), c.end());
234 | }
235 | 
236 | template<typename C, typename Pred>
237 | // requires Container<C>() && Binary_Predicate<Value_type<C>>()
238 | void sort(C& c, Pred p)
239 | {
240 | 	std::sort(c.begin(), c.end(), p);
241 | }
242 | 
243 | template<typename C, typename Val>
244 | 	// requires Container<C>() && Equality_comparable<C,Val>()
245 | Iterator<C> find(C& c, Val v)
246 | {
247 | 	return std::find(c.begin(), c.end(), v);
248 | }
249 | 
250 | template<typename C, typename Pred>
251 | // requires Container<C>() && Predicate<Pred,Value_type<C>>()
252 | Iterator<C> find_if(C& c, Pred p)
253 | {
254 | 	return std::find_if(c.begin(), c.end(), p);
255 | }
256 | 
257 | #endif //H112
258 | 


--------------------------------------------------------------------------------
/Programming_Qt.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio Version 17
 4 | VisualStudioVersion = 17.5.33424.131
 5 | MinimumVisualStudioVersion = 10.0.40219.1
 6 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Programming_Qt", "Programming_Qt.vcxproj", "{773840E4-9882-4A92-91AB-E3708EF977CA}"
 7 | EndProject
 8 | Global
 9 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
10 | 		Debug|x64 = Debug|x64
11 | 		Release|x64 = Release|x64
12 | 	EndGlobalSection
13 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
14 | 		{773840E4-9882-4A92-91AB-E3708EF977CA}.Debug|x64.ActiveCfg = Debug|x64
15 | 		{773840E4-9882-4A92-91AB-E3708EF977CA}.Debug|x64.Build.0 = Debug|x64
16 | 		{773840E4-9882-4A92-91AB-E3708EF977CA}.Release|x64.ActiveCfg = Release|x64
17 | 		{773840E4-9882-4A92-91AB-E3708EF977CA}.Release|x64.Build.0 = Release|x64
18 | 	EndGlobalSection
19 | 	GlobalSection(SolutionProperties) = preSolution
20 | 		HideSolutionNode = FALSE
21 | 	EndGlobalSection
22 | 	GlobalSection(ExtensibilityGlobals) = postSolution
23 | 		SolutionGuid = {10BFD644-DB99-46E1-AE83-D23ADAE4B905}
24 | 	EndGlobalSection
25 | EndGlobal
26 | 


--------------------------------------------------------------------------------
/Programming_Qt.vcxproj:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <Project DefaultTargets="Build" ToolsVersion="17.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  3 |   <ItemGroup Label="ProjectConfigurations">
  4 |     <ProjectConfiguration Include="Debug|x64">
  5 |       <Configuration>Debug</Configuration>
  6 |       <Platform>x64</Platform>
  7 |     </ProjectConfiguration>
  8 |     <ProjectConfiguration Include="Release|x64">
  9 |       <Configuration>Release</Configuration>
 10 |       <Platform>x64</Platform>
 11 |     </ProjectConfiguration>
 12 |   </ItemGroup>
 13 |   <PropertyGroup Label="Globals">
 14 |     <ProjectGuid>{773840E4-9882-4A92-91AB-E3708EF977CA}</ProjectGuid>
 15 |     <Keyword>QtVS_v304</Keyword>
 16 |     <WindowsTargetPlatformVersion Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">10.0.22000.0</WindowsTargetPlatformVersion>
 17 |     <WindowsTargetPlatformVersion Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">10.0.22000.0</WindowsTargetPlatformVersion>
 18 |     <QtMsBuild Condition="'$(QtMsBuild)'=='' OR !Exists('$(QtMsBuild)\qt.targets')">$(MSBuildProjectDirectory)\QtMsBuild</QtMsBuild>
 19 |   </PropertyGroup>
 20 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
 21 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'" Label="Configuration">
 22 |     <ConfigurationType>Application</ConfigurationType>
 23 |     <PlatformToolset>v143</PlatformToolset>
 24 |   </PropertyGroup>
 25 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'" Label="Configuration">
 26 |     <ConfigurationType>Application</ConfigurationType>
 27 |     <PlatformToolset>v143</PlatformToolset>
 28 |   </PropertyGroup>
 29 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
 30 |   <ImportGroup Condition="Exists('$(QtMsBuild)\qt_defaults.props')">
 31 |     <Import Project="$(QtMsBuild)\qt_defaults.props" />
 32 |   </ImportGroup>
 33 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'" Label="QtSettings">
 34 |     <QtInstall>$(DefaultQtVersion)</QtInstall>
 35 |     <QtModules>core;gui;widgets</QtModules>
 36 |     <QtBuildConfig>debug</QtBuildConfig>
 37 |   </PropertyGroup>
 38 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'" Label="QtSettings">
 39 |     <QtInstall>$(DefaultQtVersion)</QtInstall>
 40 |     <QtModules>core;gui;widgets</QtModules>
 41 |     <QtBuildConfig>release</QtBuildConfig>
 42 |   </PropertyGroup>
 43 |   <Target Name="QtMsBuildNotFound" BeforeTargets="CustomBuild;ClCompile" Condition="!Exists('$(QtMsBuild)\qt.targets') or !Exists('$(QtMsBuild)\qt.props')">
 44 |     <Message Importance="High" Text="QtMsBuild: could not locate qt.targets, qt.props; project may not build correctly." />
 45 |   </Target>
 46 |   <ImportGroup Label="ExtensionSettings" />
 47 |   <ImportGroup Label="Shared" />
 48 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
 49 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 50 |     <Import Project="$(QtMsBuild)\Qt.props" />
 51 |   </ImportGroup>
 52 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
 53 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 54 |     <Import Project="$(QtMsBuild)\Qt.props" />
 55 |   </ImportGroup>
 56 |   <PropertyGroup Label="UserMacros" />
 57 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
 58 |     <IncludePath>.;$(IncludePath)</IncludePath>
 59 |   </PropertyGroup>
 60 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
 61 |     <IncludePath>.;$(IncludePath)</IncludePath>
 62 |   </PropertyGroup>
 63 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
 64 |     <ClCompile>
 65 |       <LanguageStandard>stdcpp20</LanguageStandard>
 66 |       <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
 67 |     </ClCompile>
 68 |   </ItemDefinitionGroup>
 69 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
 70 |     <ClCompile>
 71 |       <LanguageStandard>stdcpp20</LanguageStandard>
 72 |     </ClCompile>
 73 |   </ItemDefinitionGroup>
 74 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'" Label="Configuration">
 75 |     <ClCompile>
 76 |       <TreatWChar_tAsBuiltInType>true</TreatWChar_tAsBuiltInType>
 77 |       <MultiProcessorCompilation>true</MultiProcessorCompilation>
 78 |       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
 79 |       <Optimization>Disabled</Optimization>
 80 |     </ClCompile>
 81 |     <Link>
 82 |       <SubSystem>Windows</SubSystem>
 83 |       <GenerateDebugInformation>true</GenerateDebugInformation>
 84 |     </Link>
 85 |   </ItemDefinitionGroup>
 86 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'" Label="Configuration">
 87 |     <ClCompile>
 88 |       <TreatWChar_tAsBuiltInType>true</TreatWChar_tAsBuiltInType>
 89 |       <MultiProcessorCompilation>true</MultiProcessorCompilation>
 90 |       <DebugInformationFormat>None</DebugInformationFormat>
 91 |       <Optimization>MaxSpeed</Optimization>
 92 |     </ClCompile>
 93 |     <Link>
 94 |       <SubSystem>Windows</SubSystem>
 95 |       <GenerateDebugInformation>false</GenerateDebugInformation>
 96 |     </Link>
 97 |   </ItemDefinitionGroup>
 98 |   <ItemGroup>
 99 |     <ClCompile Include="Colormap.cpp" />
100 |     <ClCompile Include="Simple_window.cpp" />
101 |     <ClCompile Include="Window.cpp" />
102 |     <ClCompile Include="Graph.cpp" />
103 |     <ClCompile Include="GUI.cpp" />
104 |     <ClCompile Include="main.cpp" />
105 |   </ItemGroup>
106 |   <ItemGroup>
107 |     <ClInclude Include="PPP\Graph.h" />
108 |     <ClInclude Include="PPP\GUI.h" />
109 |     <QtMoc Include="PPP\GUI_private.h" />
110 |     <ClInclude Include="PPP\Image_private.h" />
111 |     <ClInclude Include="PPP\Point.h" />
112 |     <ClInclude Include="PPP\Simple_window.h" />
113 |     <ClInclude Include="PPP\std_lib_facilities.h" />
114 |     <ClInclude Include="PPP\Window.h" />
115 |   </ItemGroup>
116 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
117 |   <ImportGroup Condition="Exists('$(QtMsBuild)\qt.targets')">
118 |     <Import Project="$(QtMsBuild)\qt.targets" />
119 |   </ImportGroup>
120 |   <ImportGroup Label="ExtensionTargets">
121 |   </ImportGroup>
122 | </Project>
123 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | This is a Qt version of https://github.com/BjarneStroustrup/Programming-_Principles_and_Practice_Using_Cpp
2 | 


--------------------------------------------------------------------------------
/Simple_window.cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | //
 3 | // This is a GUI support code to the chapters 12-16 of the book
 4 | // "Programming -- Principles and Practice Using C++" by Bjarne Stroustrup
 5 | //
 6 | 
 7 | #include "PPP/Simple_window.h"
 8 | #include <QEventLoop>
 9 | #include <QTimer>
10 | #include <PPP/GUI_private.h>
11 | //------------------------------------------------------------------------------
12 | 
13 | Simple_window::Simple_window(Point xy, int w, int h, const string& title) :
14 |     Window(xy,w,h,title),
15 |     next_button(Point{w-70,0}, 70, 20, "Next", []{})
16 | {
17 |     attach(next_button);
18 | }
19 | 
20 | Simple_window::~Simple_window() {}
21 | 
22 | //------------------------------------------------------------------------------
23 | 
24 | void Simple_window::wait_for_button()
25 | // modified event loop:
26 | // handle all events (as per default), quit when button_pushed becomes true
27 | // this allows graphics without control inversion
28 | {
29 |     get_impl().wait_for_button(&next_button);
30 | }
31 | 
32 | 
33 | //------------------------------------------------------------------------------
34 | 


--------------------------------------------------------------------------------
/UserGuide.odt:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/villevoutilainen/ProgrammingPrinciplesAndPracticeUsingQt/58c9d17cb7183829e7124ec7d04a2ee8f384debf/UserGuide.odt


--------------------------------------------------------------------------------
/UserGuide.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/villevoutilainen/ProgrammingPrinciplesAndPracticeUsingQt/58c9d17cb7183829e7124ec7d04a2ee8f384debf/UserGuide.pdf


--------------------------------------------------------------------------------
/Window.cpp:
--------------------------------------------------------------------------------
  1 | #include "PPP/Window.h"
  2 | #include "PPP/Graph.h"
  3 | #include "PPP/Image_private.h"
  4 | #include <QApplication>
  5 | #include <QFontMetrics>
  6 | #include <QPainter>
  7 | #include <QVector>
  8 | #include <QWidget>
  9 | #include "PPP/GUI.h"
 10 | #include "PPP/GUI_private.h"
 11 | 
 12 | namespace Graph_lib {
 13 | 
 14 | class PainterPrivate
 15 | {
 16 | public:
 17 |     QPainter* painter;
 18 |     QPen pen;
 19 |     QBrush brush;
 20 |     QFont font;
 21 | };
 22 | 
 23 | void Painter::draw_rectangle(const Point& p1, int w, int h)
 24 | {
 25 |     impl->painter->setPen(impl->pen);
 26 |     impl->painter->setBrush(impl->brush);
 27 |     impl->painter->drawRect(p1.x, p1.y, w, h);
 28 | }
 29 | 
 30 | void Painter::draw_line(const Point& p1, const Point& p2)
 31 | {
 32 |     impl->painter->setPen(impl->pen);
 33 |     impl->painter->drawLine(p1.x, p1.y, p2.x, p2.y);
 34 | }
 35 | 
 36 | void Painter::draw_polygon(const Shape& s)
 37 | {
 38 |     impl->painter->setPen(impl->pen);
 39 |     impl->painter->setBrush(impl->brush);
 40 |     QVector<QPoint> points;
 41 |     for (int i = 0; i < s.number_of_points(); ++i) {
 42 |         Point p = s.point(i);
 43 |         points.push_back(QPoint(p.x, p.y));
 44 |     }
 45 |     impl->painter->drawPolygon(points.data(), static_cast<int>(points.size()));
 46 | }
 47 | 
 48 | Point Painter::draw_text(const Point& p1, const std::string& text)
 49 | {
 50 |     impl->painter->setPen(impl->pen);
 51 |     impl->painter->setFont(impl->font);
 52 |     QFontMetrics font_metrics(impl->font);
 53 |     QRect bounding_rect =
 54 |         font_metrics.tightBoundingRect(
 55 |             QString::fromStdString(text + " "));
 56 |     impl->painter->drawText(QPoint(p1.x, p1.y + bounding_rect.height()),
 57 |                             QString::fromStdString(text));
 58 |     return {p1.x + bounding_rect.width(), p1.y + bounding_rect.height()};
 59 | }
 60 | 
 61 | Point Painter::draw_centered_text(const Point& p1, const std::string& text)
 62 | {
 63 |     impl->painter->setPen(impl->pen);
 64 |     impl->painter->setFont(impl->font);
 65 |     QFontMetrics font_metrics(impl->font);
 66 |     QRect bounding_rect =
 67 |         font_metrics.tightBoundingRect(
 68 |         QString::fromStdString(text));
 69 |     impl->painter->drawText(QPoint(p1.x - bounding_rect.width()/2,
 70 |                                    p1.y + bounding_rect.height()/2),
 71 |                             QString::fromStdString(text));
 72 |     return {p1.x + bounding_rect.width()/2, p1.y + bounding_rect.height()/2};
 73 | }
 74 | 
 75 | void Painter::setup_from_text(const Text& text)
 76 | {
 77 |     set_color(text.color());
 78 |     set_font(text.font());
 79 |     set_font_size(text.font_size());
 80 | }
 81 | 
 82 | void Painter::draw_text_line(const Point& p1, const Vector_ref<const Text>& texts)
 83 | {
 84 |     Point current_pos = p1;
 85 |     for (auto&& text : texts) {
 86 |         setup_from_text(*text);
 87 |         Point next_pos = draw_text(current_pos, text->label());
 88 |         current_pos.x = next_pos.x;
 89 |         current_pos.y = p1.y;
 90 |     }
 91 | }
 92 | 
 93 | void Painter::draw_text_column(const Point& p1, const Vector_ref<const Text>& texts)
 94 | {
 95 |     Point current_pos = p1;
 96 |     for (auto&& text : texts) {
 97 |         setup_from_text(*text);
 98 |         Point next_pos = draw_text(current_pos, text->label());
 99 |         current_pos.y = next_pos.y;
100 |         current_pos.x = p1.x;
101 |     }
102 | }
103 | 
104 | void Painter::draw_ellipse(const Point& p1, int r, int r2)
105 | {
106 |     impl->painter->setPen(impl->pen);
107 |     impl->painter->setBrush(impl->brush);
108 |     impl->painter->drawEllipse(QPoint(p1.x, p1.y), r, r2);
109 | }
110 | 
111 | void Painter::draw_arc(const Point& p1, int r, int r2, int start_angle, int end_angle)
112 | {
113 |     impl->painter->setPen(impl->pen);
114 |     impl->painter->setBrush(impl->brush);
115 |     impl->painter->drawArc(p1.x, p1.y, r, r2, start_angle, end_angle);
116 | }
117 | 
118 | void Painter::draw_pie(const Point& p1, int r, int r2, int start_angle, int end_angle)
119 | {
120 |     impl->painter->setPen(impl->pen);
121 |     impl->painter->setBrush(impl->brush);
122 |     impl->painter->drawPie(p1.x, p1.y, r, r2, start_angle, end_angle);
123 | }
124 | 
125 | void Painter::draw_image(const Point& p1, const Image& img)
126 | {
127 |     impl->painter->drawImage(QPoint(p1.x, p1.y), img.get_impl().image);
128 | }
129 | 
130 | void Painter::draw_image(const Point& p1, const Point& p2, int w, int h, const Image& img)
131 | {
132 |     impl->painter->drawImage(QPoint(p1.x, p1.y), img.get_impl().image, QRect(p2.x, p2.y, w, h));
133 | }
134 | 
135 | void Painter::save()
136 | {
137 |     impl->painter->save();
138 | }
139 | 
140 | void Painter::restore()
141 | {
142 |     impl->painter->restore();
143 | }
144 | 
145 | static QColor map_color(Color color)
146 | {
147 |     static const QMap<Color, QColor> color_map = {
148 |         {Color::red, QColorConstants::Red},
149 |         {Color::blue, QColorConstants::Blue},
150 |         {Color::green, QColorConstants::Green},
151 |         {Color::yellow, QColorConstants::Yellow},
152 |         {Color::white, QColorConstants::White},
153 |         {Color::black, QColorConstants::Black},
154 |         {Color::magenta, QColorConstants::Magenta},
155 |         {Color::cyan, QColorConstants::Cyan},
156 |         {Color::dark_red, QColorConstants::DarkRed},
157 |         {Color::dark_green, QColorConstants::DarkGreen},
158 |         {Color::dark_yellow, QColorConstants::DarkYellow},
159 |         {Color::dark_blue, QColorConstants::DarkBlue},
160 |         {Color::dark_magenta, QColorConstants::DarkMagenta},
161 |         {Color::dark_cyan, QColorConstants::DarkCyan},
162 |     };
163 |     if (color.type() == Color::palette_index)
164 |         return mapPaletteColor(color.as_int());
165 |     if (color.type() == Color::rgb)
166 |         return QColor(color.red_component(), color.green_component(), color.blue_component());
167 |     return color_map[color];
168 | }
169 | 
170 | void Painter::set_color(Color color)
171 | {
172 |     if (color.visibility() != Color::invisible) {
173 |         impl->pen.setColor(map_color(color));
174 |     } else {
175 |         impl->pen.setStyle(Qt::NoPen);
176 |     }
177 | 
178 | }
179 | 
180 | void Painter::set_fill_color(Color color)
181 | {
182 |     if (color.visibility() != Color::invisible) {
183 |         impl->brush.setColor(map_color(color));
184 |         impl->brush.setStyle(Qt::SolidPattern);
185 |     } else {
186 |         impl->brush.setStyle(Qt::NoBrush);
187 |     }
188 | }
189 | 
190 | void Painter::set_line_style(Line_style style)
191 | {
192 |     static const QMap<Line_style, Qt::PenStyle> line_style_map = {
193 |         {Line_style::none, Qt::NoPen},
194 |         {Line_style::solid, Qt::SolidLine},
195 |         {Line_style::dash, Qt::DashLine},
196 |         {Line_style::dot, Qt::DotLine},
197 |         {Line_style::dashdot, Qt::DashDotLine},
198 |         {Line_style::dashdotdot, Qt::DashDotDotLine}
199 |     };
200 |     impl->pen.setStyle(line_style_map[style]);
201 |     impl->pen.setWidth(style.width());
202 | }
203 | 
204 | void Painter::set_font_size(int s)
205 | {
206 |     impl->font.setPointSize(s);
207 | }
208 | 
209 | void Painter::set_font(Font f)
210 | {
211 |     static QMap<Font, QFont> fontMap = {
212 |         {Font::helvetica, QFont("Helvetica", 14) },
213 |         {Font::helvetica_bold, QFont("Helvetica", 14, QFont::Bold)},
214 |         {Font::helvetica_italic, QFont("Helvetica", 14, QFont::Normal, true)},
215 |         {Font::helvetica_bold_italic, QFont("Helvetica", 14, QFont::Bold, true)},
216 |         {Font::courier, QFont("Courier", 14) },
217 |         {Font::courier_bold, QFont("Courier", 14, QFont::Bold)},
218 |         {Font::courier_italic, QFont("Courier", 14, QFont::Normal, true)},
219 |         {Font::courier_bold_italic, QFont("Courier", 14, QFont::Bold, true)},
220 |         {Font::times, QFont("Times", 14) },
221 |         {Font::times_bold, QFont("Times", 14, QFont::Bold)},
222 |         {Font::times_italic, QFont("Times", 14, QFont::Normal, true)},
223 |         {Font::times_bold_italic, QFont("Times", 14, QFont::Bold, true)},
224 |         {Font::symbol, QFont("Symbol", 14)},
225 |         {Font::screen, QFont("Screen", 14)},
226 |         {Font::screen_bold, QFont("Screen", 14, QFont::Bold)},
227 |         {Font::zapf_dingbats, QFont("Zapf Dingbats", 14)}
228 |     };
229 |     QFont painter_font = fontMap[f];
230 |     impl->font = painter_font;
231 | }
232 | 
233 | void ImagePrivate::load(const std::string& s)
234 | {
235 |     image.load(QString::fromStdString(s));
236 | }
237 | 
238 | void ImagePrivate::scale(int ww, int hh, bool keep_aspect_ratio)
239 | {
240 |     image = image.scaled(QSize(ww, hh), keep_aspect_ratio ? Qt::KeepAspectRatio : Qt::IgnoreAspectRatio);
241 | }
242 | 
243 | class ApplicationPrivate
244 | {
245 | public:
246 |     ApplicationPrivate() : app(argc, nullptr) {}
247 |     void gui_main() { app.exec(); }
248 |     void quit() { app.quit(); }
249 | private:
250 |     int argc = 0;
251 |     QApplication app;
252 | };
253 | 
254 | Application::Application() : impl(std::make_unique<ApplicationPrivate>())
255 | {
256 | 
257 | }
258 | 
259 | Application::~Application()
260 | {
261 | 
262 | }
263 | 
264 | void Application::gui_main()
265 | {
266 |     impl->gui_main();
267 | }
268 | 
269 | void Application::quit()
270 | {
271 |     QTimer::singleShot(0, [&] { impl->quit(); });
272 | }
273 | 
274 | Painter::Painter(std::unique_ptr<PainterPrivate>&& pp)
275 |     : impl(std::move(pp))
276 | {
277 | }
278 | 
279 | Painter::~Painter() {}
280 | 
281 | void WindowPrivate::paintEvent(QPaintEvent*/*event*/)
282 | {
283 |     std::unique_ptr<PainterPrivate> priv =
284 |             std::make_unique<PainterPrivate>();
285 |     QPainter painter(this);
286 |     priv->painter = &painter;
287 |     Painter shape_painter(std::move(priv));
288 |     for (auto&& shape : shapes) {
289 |         shape->draw(shape_painter);
290 |     }
291 | }
292 | 
293 | void WindowPrivate::end_button_wait()
294 | {
295 |     invoke_stored_callback = false;
296 |     QObject::connect(&loop_stopping_timer, &QTimer::timeout,
297 |                      [this] {nested_loop.quit();});
298 |     loop_stopping_timer.start(0);
299 | }
300 | 
301 | void WindowPrivate::closeEvent(QCloseEvent*/*event*/)
302 | {
303 |     accept_waits = false;
304 |     user_timer.stop();
305 |     end_button_wait();
306 |     windowClosed();
307 | }
308 | 
309 | void WindowPrivate::timer_wait(int milliseconds)
310 | {
311 |     if (!accept_waits)
312 |         return;
313 |     auto conn = QObject::connect(&user_timer, &QTimer::timeout,
314 |                      [this] {nested_loop.quit();});
315 |     user_timer.start(milliseconds);
316 |     nested_loop.exec();
317 |     QObject::disconnect(conn);
318 | }
319 | 
320 | void WindowPrivate::timer_wait(int milliseconds, std::function<void()> cb)
321 | {
322 |     if (!accept_waits)
323 |         return;
324 |     auto conn = std::make_shared<QMetaObject::Connection>();
325 |     *conn = QObject::connect(&user_timer, &QTimer::timeout,
326 |                      [conn, func = std::move(cb)] {
327 |         QObject::disconnect(*conn);
328 |         func();
329 |     });
330 |     user_timer.start(milliseconds);
331 | }
332 | 
333 | void WindowPrivate::wait_for_button(Button* button)
334 | {
335 |     std::function<void()> stored_callback = button->do_it;
336 |     button->do_it = [&] {nested_loop.exit();};
337 |     invoke_stored_callback = true;
338 |     nested_loop.exec();
339 |     button->do_it = stored_callback;
340 |     if (invoke_stored_callback)
341 |         button->do_it();
342 | }
343 | 
344 | 
345 | Window::Window(int ww, int hh, const string& title)
346 |     : p{0, 0}, w(ww), h(hh), impl(std::make_unique<WindowPrivate>(this))
347 | {
348 |     impl->setGeometry(0, 0, ww, hh);
349 |     impl->setWindowTitle(QString::fromStdString(title));
350 |     impl->show();
351 | 	init();
352 | }
353 | 
354 | Window::Window(Point xy, int ww, int hh, const string& title)
355 |     : p{xy}, w(ww), h(hh), impl(std::make_unique<WindowPrivate>(this))
356 | {
357 |     impl->setGeometry(xy.x, xy.y, ww, hh);
358 |     impl->setWindowTitle(QString::fromStdString(title));
359 |     impl->show();
360 |     init();
361 | }
362 | 
363 | Window::~Window()
364 | {
365 | 
366 | }
367 | 
368 | void Window::set_label(const string &s)
369 | {
370 |     impl->setWindowTitle(QString::fromStdString(s));
371 | }
372 | 
373 | void Window::init()
374 | {
375 |    //resizable(this);
376 |    //show();
377 | } 
378 | 
379 | //---------------------------------------------------- 
380 | 
381 | void Window::draw()
382 | {
383 |     impl->repaint();
384 | }
385 | 
386 | void Window::attach(Widget& ww)
387 | {
388 |     auto& widget = ww.get_impl().widget;
389 |     if (widget) {
390 |         widget->setParent(impl.get());
391 |         widget->move(ww.loc.x, ww.loc.y);
392 |         widget->setMinimumWidth(ww.width);
393 |         widget->setMinimumHeight(ww.height);
394 |         widget->show();
395 |     }
396 |     ww.attach(*this);
397 | }
398 | 
399 | void Window::detach(Widget& ww)
400 | {
401 |     auto& widget = ww.get_impl().widget;
402 |     widget->setParent(nullptr);
403 |     widget->hide();
404 | }
405 | 
406 | void Window::attach(Shape& s)
407 | {
408 |     impl->attach(s);
409 |     s.set_window(this);
410 | }
411 | void Window::detach(Shape& s)
412 | {
413 |     impl->detach(s);
414 |     s.set_window(nullptr);
415 | }
416 | 
417 | 
418 | void Window::put_on_top(Shape& s) {
419 |     impl->put_on_top(s);
420 |     draw();
421 | }
422 | 
423 | void Window::close()
424 | {
425 |     impl->close();
426 | }
427 | 
428 | void Window::wait_for_button(Button *button)
429 | {
430 |     impl->wait_for_button(button);
431 | }
432 | 
433 | void Window::end_button_wait()
434 | {
435 |     impl->end_button_wait();
436 | }
437 | 
438 | WindowPrivate& Window::get_impl() const
439 | {
440 |     return *impl;
441 | }
442 | 
443 | void Window::resize(int ww, int hh)
444 | {
445 |     w = ww;
446 |     h = hh;
447 |     impl->setGeometry(p.x, p.y, ww, hh);
448 | }
449 | 
450 | void Window::timer_wait(int milliseconds)
451 | {
452 |     impl->timer_wait(milliseconds);
453 | }
454 | 
455 | void Window::timer_wait(int milliseconds, std::function<void()> cb)
456 | {
457 |     impl->timer_wait(milliseconds, cb);
458 | }
459 | 
460 | int gui_main()
461 | {
462 |     int argc=0;
463 |     QApplication a(argc, nullptr);
464 |     return a.exec();
465 | }
466 | 
467 | } // Graph
468 | 
469 | 


--------------------------------------------------------------------------------
/main.cpp:
--------------------------------------------------------------------------------
 1 | #include "PPP/Window.h"
 2 | #include "PPP/Graph.h"
 3 | 
 4 | using namespace Graph_lib;
 5 | int main(int /*argc*/, char* /*argv*/[])
 6 | {
 7 |     Application app;
 8 |     Window window({20, 20}, 600, 400, "Main window");
 9 |     Text text({150, 20}, "Well hello there!");
10 |     window.attach(text);
11 |     app.gui_main();
12 | }
13 | 


--------------------------------------------------------------------------------