Horizon
core.hpp
1 #pragma once
2 #include "canvas/selectables.hpp"
3 #include "canvas/target.hpp"
4 #include "common/layer.hpp"
5 #include "common/object_descr.hpp"
6 #include "common/keepout.hpp"
7 #include "cores.hpp"
8 #include "tool_data.hpp"
9 #include "nlohmann/json_fwd.hpp"
10 #include "pool/pool.hpp"
11 #include "pool/symbol.hpp"
12 #include <gdk/gdkkeysyms.h>
13 #include <iostream>
14 #include <memory>
15 #include <sigc++/sigc++.h>
16 #include "tool_id.hpp"
17 
18 namespace horizon {
19 enum class ToolEventType { NONE, MOVE, CLICK, CLICK_RELEASE, KEY, LAYER_CHANGE, DATA };
20 
21 
26 class ToolArgs {
27 public:
28  ToolEventType type = ToolEventType::NONE;
29  Coordi coords;
30  std::set<SelectableRef> selection;
31  bool keep_selection = false;
32  unsigned int button = 0;
33  unsigned int key = 0;
34  enum Modifieres {
35  MOD_FINE = (1 << 0),
36  MOD_ALT = (1 << 1),
37  MOD_CTRL = (1 << 2),
38  };
39  unsigned int mod = 0;
40 
41  Target target;
42  int work_layer = 0;
43  std::unique_ptr<ToolData> data = nullptr;
44  ToolArgs()
45  {
46  }
47 };
48 
52 class ToolResponse {
53 public:
54  ToolID next_tool = ToolID::NONE;
55  std::unique_ptr<ToolData> data = nullptr;
56  bool end_tool = false;
57  int layer = 10000;
58  bool fast_draw = false;
59 
60  ToolResponse()
61  {
62  }
67  static ToolResponse end()
68  {
69  ToolResponse r;
70  r.end_tool = true;
71  return r;
72  }
73 
74  static ToolResponse fast()
75  {
76  ToolResponse r;
77  r.fast_draw = true;
78  return r;
79  }
80 
84  static ToolResponse change_layer(int l)
85  {
86  ToolResponse r;
87  r.layer = l;
88  return r;
89  }
90 
94  static ToolResponse next(ToolID t, std::unique_ptr<ToolData> data = nullptr)
95  {
96  ToolResponse r;
97  r.end_tool = true;
98  r.next_tool = t;
99  r.data = std::move(data);
100  return r;
101  };
102 };
103 
105 public:
106  virtual void load_from_json(const json &j) = 0;
107  virtual json serialize() const = 0;
108  virtual ~ToolSettings()
109  {
110  }
111 };
112 
114 public:
115  ToolSettingsProxy(class ToolBase *t, ToolSettings *s) : tool(t), settings(s)
116  {
117  }
118  ToolSettings &operator*()
119  {
120  return *settings;
121  }
122  operator ToolSettings *()
123  {
124  return settings;
125  }
126  ToolSettings *operator->()
127  {
128  return settings;
129  }
131 
132 private:
133  ToolBase *tool;
134  ToolSettings *settings;
135 };
136 
137 
141 class ToolBase {
142 public:
143  ToolBase(class Core *c, ToolID tid);
144  void set_imp_interface(class ImpInterface *i);
145  void set_transient();
146  virtual ToolID get_tool_id_for_settings() const
147  {
148  return tool_id;
149  }
150  virtual const ToolSettings *get_settings_const() const
151  {
152  return nullptr;
153  }
154  ToolSettingsProxy get_settings_proxy()
155  {
156  return ToolSettingsProxy(this, get_settings());
157  }
158  virtual void apply_settings()
159  {
160  }
161 
162 
169  virtual ToolResponse begin(const ToolArgs &args) = 0;
170 
174  virtual ToolResponse update(const ToolArgs &args) = 0;
175 
179  virtual bool can_begin()
180  {
181  return false;
182  }
183 
187  virtual bool is_specific()
188  {
189  return false;
190  }
191 
195  virtual bool handles_esc()
196  {
197  return false;
198  }
199 
200  virtual ~ToolBase()
201  {
202  }
203 
204 protected:
205  Cores core;
206  class ImpInterface *imp = nullptr;
207  ToolID tool_id = ToolID::NONE;
208  bool is_transient = false;
209  virtual ToolSettings *get_settings()
210  {
211  return nullptr;
212  }
213 };
214 
240 class Core {
241 public:
242  virtual bool has_object_type(ObjectType ty) const
243  {
244  return false;
245  }
246 
247  virtual class Junction *insert_junction(const UUID &uu, bool work = true);
248  virtual class Junction *get_junction(const UUID &uu, bool work = true);
249  virtual void delete_junction(const UUID &uu, bool work = true);
250 
251  virtual class Line *insert_line(const UUID &uu, bool work = true);
252  virtual class Line *get_line(const UUID &uu, bool work = true);
253  virtual void delete_line(const UUID &uu, bool work = true);
254 
255  virtual class Arc *insert_arc(const UUID &uu, bool work = true);
256  virtual class Arc *get_arc(const UUID &uu, bool work = true);
257  virtual void delete_arc(const UUID &uu, bool work = true);
258 
259  virtual class Text *insert_text(const UUID &uu, bool work = true);
260  virtual class Text *get_text(const UUID &uu, bool work = true);
261  virtual void delete_text(const UUID &uu, bool work = true);
262 
263  virtual class Polygon *insert_polygon(const UUID &uu, bool work = true);
264  virtual class Polygon *get_polygon(const UUID &uu, bool work = true);
265  virtual void delete_polygon(const UUID &uu, bool work = true);
266 
267  virtual class Hole *insert_hole(const UUID &uu, bool work = true);
268  virtual class Hole *get_hole(const UUID &uu, bool work = true);
269  virtual void delete_hole(const UUID &uu, bool work = true);
270 
271  virtual class Dimension *insert_dimension(const UUID &uu);
272  virtual class Dimension *get_dimension(const UUID &uu);
273  virtual void delete_dimension(const UUID &uu);
274 
275  virtual class Keepout *insert_keepout(const UUID &uu);
276  virtual class Keepout *get_keepout(const UUID &uu);
277  virtual void delete_keepout(const UUID &uu);
278 
279  virtual std::vector<Line *> get_lines(bool work = true);
280  virtual std::vector<Arc *> get_arcs(bool work = true);
281  virtual std::vector<Keepout *> get_keepouts();
282 
283  virtual class Block *get_block(bool work = true)
284  {
285  return nullptr;
286  }
287 
292  virtual void rebuild(bool from_undo = false);
293  ToolResponse tool_begin(ToolID tool_id, const ToolArgs &args, class ImpInterface *imp, bool transient = false);
294  ToolResponse tool_update(const ToolArgs &args);
295  std::pair<bool, bool> tool_can_begin(ToolID tool_id, const std::set<SelectableRef> &selection);
296  bool tool_handles_esc();
297  virtual void commit() = 0;
298  virtual void revert() = 0;
299  virtual void save() = 0;
300  void undo();
301  void redo();
302 
303  bool can_undo() const;
304  bool can_redo() const;
305 
306  inline bool tool_is_active()
307  {
308  return tool != nullptr;
309  }
310 
311  virtual bool set_property(ObjectType type, const UUID &uu, ObjectProperty::ID property,
312  const class PropertyValue &value);
313  virtual bool get_property(ObjectType type, const UUID &uu, ObjectProperty::ID property, class PropertyValue &value);
314  virtual bool get_property_meta(ObjectType type, const UUID &uu, ObjectProperty::ID property,
315  class PropertyMeta &meta);
316 
317  virtual std::string get_display_name(ObjectType type, const UUID &uu);
318  virtual std::string get_display_name(ObjectType type, const UUID &uu, const UUID &sheet);
319 
320  void set_property_begin();
321  void set_property_commit();
322  bool get_property_transaction() const;
323 
324  virtual class LayerProvider *get_layer_provider()
325  {
326  return nullptr;
327  };
328 
333  virtual json get_meta();
334 
335  virtual class Rules *get_rules()
336  {
337  return nullptr;
338  }
339  virtual void update_rules()
340  {
341  }
342 
343  virtual bool can_search_for_object_type(ObjectType type) const
344  {
345  return false;
346  };
347 
348  class SearchQuery {
349  public:
350  std::string query;
351  std::set<ObjectType> types;
352  std::pair<Coordf, Coordf> area_visible;
353  };
354 
355  class SearchResult {
356  public:
357  SearchResult(ObjectType ty, const UUID &uu) : type(ty), uuid(uu)
358  {
359  }
360  ObjectType type;
361  UUID uuid;
362  Coordi location;
363  UUID sheet;
364  bool selectable = false;
365  };
366 
367  virtual std::list<SearchResult> search(const SearchQuery &q)
368  {
369  return {};
370  };
371 
372  virtual std::pair<Coordi, Coordi> get_bbox() = 0;
373 
374  virtual ~Core()
375  {
376  }
377  std::set<SelectableRef> selection;
378  Pool *m_pool;
379 
380  bool get_needs_save() const;
381  void set_needs_save();
382 
383  virtual const std::string &get_filename() const = 0;
384 
385  typedef sigc::signal<void, ToolID> type_signal_tool_changed;
386  type_signal_tool_changed signal_tool_changed()
387  {
388  return s_signal_tool_changed;
389  }
390  typedef sigc::signal<void> type_signal_rebuilt;
391  type_signal_rebuilt signal_rebuilt()
392  {
393  return s_signal_rebuilt;
394  }
400  type_signal_rebuilt signal_save()
401  {
402  return s_signal_save;
403  }
404 
405  type_signal_rebuilt signal_can_undo_redo()
406  {
407  return s_signal_can_undo_redo;
408  }
409 
410  typedef sigc::signal<json> type_signal_request_save_meta;
415  type_signal_request_save_meta signal_request_save_meta()
416  {
417  return s_signal_request_save_meta;
418  }
419 
420  typedef sigc::signal<void, bool> type_signal_needs_save;
421  type_signal_needs_save signal_needs_save()
422  {
423  return s_signal_needs_save;
424  }
425 
426  typedef sigc::signal<json, ToolID> type_signal_load_tool_settings;
427  type_signal_load_tool_settings signal_load_tool_settings()
428  {
429  return s_signal_load_tool_settings;
430  }
431 
432  typedef sigc::signal<void, ToolID, json> type_signal_save_tool_settings;
433  type_signal_save_tool_settings signal_save_tool_settings()
434  {
435  return s_signal_save_tool_settings;
436  }
437 
438  virtual void reload_pool()
439  {
440  }
441 
442 protected:
443  virtual std::map<UUID, Junction> *get_junction_map(bool work = true)
444  {
445  return nullptr;
446  }
447  virtual std::map<UUID, Line> *get_line_map(bool work = true)
448  {
449  return nullptr;
450  }
451  virtual std::map<UUID, Arc> *get_arc_map(bool work = true)
452  {
453  return nullptr;
454  }
455  virtual std::map<UUID, Text> *get_text_map(bool work = true)
456  {
457  return nullptr;
458  }
459  virtual std::map<UUID, Polygon> *get_polygon_map(bool work = true)
460  {
461  return nullptr;
462  }
463  virtual std::map<UUID, Hole> *get_hole_map(bool work = true)
464  {
465  return nullptr;
466  }
467  virtual std::map<UUID, Dimension> *get_dimension_map()
468  {
469  return nullptr;
470  }
471  virtual std::map<UUID, Keepout> *get_keepout_map()
472  {
473  return nullptr;
474  }
475 
476  bool reverted = false;
477  std::unique_ptr<ToolBase> tool = nullptr;
478  type_signal_tool_changed s_signal_tool_changed;
479  type_signal_rebuilt s_signal_rebuilt;
480  type_signal_rebuilt s_signal_save;
481  type_signal_rebuilt s_signal_can_undo_redo;
482  type_signal_request_save_meta s_signal_request_save_meta;
483  type_signal_needs_save s_signal_needs_save;
484  type_signal_load_tool_settings s_signal_load_tool_settings;
485  type_signal_save_tool_settings s_signal_save_tool_settings;
486  bool needs_save = false;
487  void set_needs_save(bool v);
488 
489  class HistoryItem {
490  public:
491  // Symbol sym;
492  // HistoryItem(const Symbol &s): sym(s) {}
493  std::string comment;
494  virtual ~HistoryItem()
495  {
496  }
497  };
498  std::deque<std::unique_ptr<HistoryItem>> history;
499  int history_current = -1;
500  virtual void history_push() = 0;
501  virtual void history_load(unsigned int i) = 0;
502  void history_clear();
503 
504  bool property_transaction = false;
505 
506  void layers_to_meta(class PropertyMeta &meta);
507  void get_placement(const Placement &placement, class PropertyValue &value, ObjectProperty::ID property);
508  void set_placement(Placement &placement, const class PropertyValue &value, ObjectProperty::ID property);
509 
510  void sort_search_results(std::list<Core::SearchResult> &results, const SearchQuery &q);
511 
512 private:
513  std::unique_ptr<ToolBase> create_tool(ToolID tool_id);
514 };
515 } // namespace horizon
virtual bool can_begin()
Definition: core.hpp:179
Definition: target.hpp:6
Polygon used in Padstack, Package and Board for specifying filled Regions.
Definition: polygon.hpp:27
Definition: core.hpp:355
a class to store JSON values
Definition: json.hpp:161
This is what a Tool receives when the user did something.
Definition: core.hpp:26
Definition: core.hpp:104
virtual bool handles_esc()
Definition: core.hpp:195
type_signal_request_save_meta signal_request_save_meta()
connect to this signal for providing meta information when the document is saved
Definition: core.hpp:415
Graphical line.
Definition: line.hpp:19
Definition: core_properties.hpp:7
Definition: placement.hpp:8
Definition: rules.hpp:44
Definition: core.hpp:348
Definition: keepout.hpp:9
A block is one level of hierarchy in the netlist.
Definition: block.hpp:26
Tools use this class to actually access the core.
Definition: cores.hpp:13
static ToolResponse change_layer(int l)
Use this for changing the work layer from a Tool.
Definition: core.hpp:84
Used wherever a user-editable text is needed.
Definition: text.hpp:19
static ToolResponse next(ToolID t, std::unique_ptr< ToolData > data=nullptr)
If you want another Tool to be launched you&#39;ve finished, use this one.
Definition: core.hpp:94
Definition: imp_interface.hpp:7
Where Tools and and documents meet.
Definition: core.hpp:240
Definition: dimension.hpp:12
virtual bool is_specific()
Definition: core.hpp:187
Definition: core.hpp:113
Definition: layer_provider.hpp:7
Definition: core_properties.hpp:77
This class encapsulates a UUID and allows it to be uses as a value type.
Definition: uuid.hpp:16
To signal back to the core what the Tool did, a Tool returns a ToolResponse.
Definition: core.hpp:52
static ToolResponse end()
Use this if you&#39;re done.
Definition: core.hpp:67
Stores objects (Unit, Entity, Symbol, Part, etc.) from the pool.
Definition: pool.hpp:21
Definition: block.cpp:9
type_signal_rebuilt signal_save()
Gets emitted right before saving.
Definition: core.hpp:400
Definition: core.hpp:489
Common interface for all Tools.
Definition: core.hpp:141
A Junction is a point in 2D-Space.
Definition: junction.hpp:25
Graphical arc.
Definition: arc.hpp:20
A hole with diameter and position, that&#39;s it.
Definition: hole.hpp:19