]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: view.cpp | |
3 | // Purpose: Implements view functionality | |
4 | // Author: Julian Smart | |
5 | // Modified by: | |
6 | // Created: 12/07/98 | |
7 | // RCS-ID: $Id$ | |
8 | // Copyright: (c) Julian Smart | |
9 | // Licence: | |
10 | ///////////////////////////////////////////////////////////////////////////// | |
11 | ||
12 | #ifdef __GNUG__ | |
13 | // #pragma implementation | |
14 | #endif | |
15 | ||
16 | // For compilers that support precompilation, includes "wx.h". | |
17 | #include "wx/wxprec.h" | |
18 | ||
19 | #ifdef __BORLANDC__ | |
20 | #pragma hdrstop | |
21 | #endif | |
22 | ||
23 | #ifndef WX_PRECOMP | |
24 | #include <wx/wx.h> | |
25 | #endif | |
26 | ||
27 | #include <wx/colordlg.h> | |
28 | ||
29 | #if !wxUSE_DOC_VIEW_ARCHITECTURE | |
30 | #error You must set wxUSE_DOC_VIEW_ARCHITECTURE to 1 in wx_setup.h! | |
31 | #endif | |
32 | ||
33 | #include "studio.h" | |
34 | #include "doc.h" | |
35 | #include "view.h" | |
36 | #include "cspalette.h" | |
37 | #include "symbols.h" | |
38 | #include "dialogs.h" | |
39 | #include <wx/ogl/basicp.h> | |
40 | #include <wx/ogl/linesp.h> | |
41 | ||
42 | IMPLEMENT_DYNAMIC_CLASS(csDiagramView, wxView) | |
43 | ||
44 | BEGIN_EVENT_TABLE(csDiagramView, wxView) | |
45 | EVT_MENU(wxID_CUT, csDiagramView::OnCut) | |
46 | EVT_MENU(wxID_COPY, csDiagramView::OnCopy) | |
47 | EVT_MENU(wxID_CLEAR, csDiagramView::OnClear) | |
48 | EVT_MENU(wxID_PASTE, csDiagramView::OnPaste) | |
49 | EVT_MENU(wxID_DUPLICATE, csDiagramView::OnDuplicate) | |
50 | EVT_MENU(ID_CS_CHANGE_BACKGROUND_COLOUR, csDiagramView::OnChangeBackgroundColour) | |
51 | EVT_MENU(ID_CS_EDIT_PROPERTIES, csDiagramView::OnEditProperties) | |
52 | EVT_MENU(ID_CS_SELECT_ALL, csDiagramView::OnSelectAll) | |
53 | EVT_TOOL(DIAGRAM_TOOLBAR_LINE_ARROW, csDiagramView::OnToggleArrowTool) | |
54 | EVT_COMBOBOX(ID_WINDOW_POINT_SIZE_COMBOBOX, csDiagramView::OnPointSizeComboSel) | |
55 | EVT_COMBOBOX(ID_WINDOW_ZOOM_COMBOBOX, csDiagramView::OnZoomSel) | |
56 | EVT_TEXT(ID_WINDOW_POINT_SIZE_COMBOBOX, csDiagramView::OnPointSizeComboText) | |
57 | EVT_TOOL(DIAGRAM_TOOLBAR_ALIGNL, csDiagramView::OnAlign) | |
58 | EVT_TOOL(DIAGRAM_TOOLBAR_ALIGNR, csDiagramView::OnAlign) | |
59 | EVT_TOOL(DIAGRAM_TOOLBAR_ALIGNB, csDiagramView::OnAlign) | |
60 | EVT_TOOL(DIAGRAM_TOOLBAR_ALIGNT, csDiagramView::OnAlign) | |
61 | EVT_TOOL(DIAGRAM_TOOLBAR_ALIGN_HORIZ, csDiagramView::OnAlign) | |
62 | EVT_TOOL(DIAGRAM_TOOLBAR_ALIGN_VERT, csDiagramView::OnAlign) | |
63 | EVT_TOOL(DIAGRAM_TOOLBAR_COPY_SIZE, csDiagramView::OnAlign) | |
64 | EVT_TOOL(DIAGRAM_TOOLBAR_NEW_POINT, csDiagramView::OnNewLinePoint) | |
65 | EVT_TOOL(DIAGRAM_TOOLBAR_CUT_POINT, csDiagramView::OnCutLinePoint) | |
66 | EVT_TOOL(DIAGRAM_TOOLBAR_STRAIGHTEN, csDiagramView::OnStraightenLines) | |
67 | EVT_UPDATE_UI(DIAGRAM_TOOLBAR_ALIGNL, csDiagramView::OnAlignUpdate) | |
68 | EVT_UPDATE_UI(DIAGRAM_TOOLBAR_ALIGNR, csDiagramView::OnAlignUpdate) | |
69 | EVT_UPDATE_UI(DIAGRAM_TOOLBAR_ALIGNB, csDiagramView::OnAlignUpdate) | |
70 | EVT_UPDATE_UI(DIAGRAM_TOOLBAR_ALIGNT, csDiagramView::OnAlignUpdate) | |
71 | EVT_UPDATE_UI(DIAGRAM_TOOLBAR_ALIGN_HORIZ, csDiagramView::OnAlignUpdate) | |
72 | EVT_UPDATE_UI(DIAGRAM_TOOLBAR_ALIGN_VERT, csDiagramView::OnAlignUpdate) | |
73 | EVT_UPDATE_UI(DIAGRAM_TOOLBAR_COPY_SIZE, csDiagramView::OnAlignUpdate) | |
74 | EVT_UPDATE_UI(DIAGRAM_TOOLBAR_NEW_POINT, csDiagramView::OnNewLinePointUpdate) | |
75 | EVT_UPDATE_UI(DIAGRAM_TOOLBAR_CUT_POINT, csDiagramView::OnCutLinePointUpdate) | |
76 | EVT_UPDATE_UI(DIAGRAM_TOOLBAR_STRAIGHTEN, csDiagramView::OnStraightenLinesUpdate) | |
77 | EVT_UPDATE_UI(DIAGRAM_TOOLBAR_LINE_ARROW, csDiagramView::OnToggleArrowToolUpdate) | |
78 | EVT_UPDATE_UI(wxID_CUT, csDiagramView::OnCutUpdate) | |
79 | EVT_UPDATE_UI(wxID_COPY, csDiagramView::OnCopyUpdate) | |
80 | EVT_UPDATE_UI(wxID_CLEAR, csDiagramView::OnClearUpdate) | |
81 | EVT_UPDATE_UI(wxID_PASTE, csDiagramView::OnPasteUpdate) | |
82 | EVT_UPDATE_UI(wxID_DUPLICATE, csDiagramView::OnDuplicateUpdate) | |
83 | EVT_UPDATE_UI(ID_CS_EDIT_PROPERTIES, csDiagramView::OnEditPropertiesUpdate) | |
84 | EVT_UPDATE_UI(wxID_UNDO, csDiagramView::OnUndoUpdate) | |
85 | EVT_UPDATE_UI(wxID_REDO, csDiagramView::OnRedoUpdate) | |
86 | END_EVENT_TABLE() | |
87 | ||
88 | // What to do when a view is created. Creates actual | |
89 | // windows for displaying the view. | |
90 | bool csDiagramView::OnCreate(wxDocument *doc, long WXUNUSED(flags)) | |
91 | { | |
92 | wxMenu* editMenu; | |
93 | frame = wxGetApp().CreateChildFrame(doc, this, &editMenu); | |
94 | canvas = wxGetApp().CreateCanvas(this, frame); | |
95 | canvas->SetView(this); | |
96 | ||
97 | SetFrame(frame); | |
98 | Activate(true); | |
99 | ||
100 | // Initialize the edit menu Undo and Redo items | |
101 | doc->GetCommandProcessor()->SetEditMenu(editMenu); | |
102 | doc->GetCommandProcessor()->Initialize(); | |
103 | ||
104 | wxShapeCanvas *shapeCanvas = (wxShapeCanvas *)canvas; | |
105 | csDiagramDocument *diagramDoc = (csDiagramDocument *)doc; | |
106 | shapeCanvas->SetDiagram(diagramDoc->GetDiagram()); | |
107 | diagramDoc->GetDiagram()->SetCanvas(shapeCanvas); | |
108 | ||
109 | diagramDoc->GetDiagram()->SetGridSpacing((double) wxGetApp().GetGridSpacing()); | |
110 | ||
111 | switch (wxGetApp().GetGridStyle()) | |
112 | { | |
113 | case csGRID_STYLE_NONE: | |
114 | { | |
115 | diagramDoc->GetDiagram()->SetSnapToGrid(false); | |
116 | break; | |
117 | } | |
118 | case csGRID_STYLE_INVISIBLE: | |
119 | { | |
120 | diagramDoc->GetDiagram()->SetSnapToGrid(true); | |
121 | break; | |
122 | } | |
123 | case csGRID_STYLE_DOTTED: | |
124 | { | |
125 | // TODO (not implemented in OGL) | |
126 | break; | |
127 | } | |
128 | } | |
129 | ||
130 | ||
131 | return true; | |
132 | } | |
133 | ||
134 | csDiagramView::~csDiagramView(void) | |
135 | { | |
136 | if (frame) | |
137 | { | |
138 | ((wxDocMDIChildFrame*)frame)->SetView(NULL); | |
139 | } | |
140 | } | |
141 | ||
142 | // Sneakily gets used for default print/preview | |
143 | // as well as drawing on the screen. | |
144 | void csDiagramView::OnDraw(wxDC *WXUNUSED(dc)) | |
145 | { | |
146 | } | |
147 | ||
148 | void csDiagramView::OnUpdate(wxView *WXUNUSED(sender), wxObject *WXUNUSED(hint)) | |
149 | { | |
150 | if (canvas) | |
151 | canvas->Refresh(); | |
152 | } | |
153 | ||
154 | // Clean up windows used for displaying the view. | |
155 | bool csDiagramView::OnClose(bool deleteWindow) | |
156 | { | |
157 | if (!GetDocument()->Close()) | |
158 | return false; | |
159 | ||
160 | csDiagramDocument *diagramDoc = (csDiagramDocument *)GetDocument(); | |
161 | diagramDoc->GetDiagram()->SetCanvas(NULL); | |
162 | ||
163 | canvas->ClearBackground(); | |
164 | canvas->SetDiagram(NULL); | |
165 | canvas->SetView(NULL); | |
166 | canvas = NULL; | |
167 | ||
168 | wxMenu* fileMenu = frame->GetMenuBar()->GetMenu(0); | |
169 | ||
170 | // Remove file menu from those managed by the command history | |
171 | wxGetApp().GetDocManager()->FileHistoryRemoveMenu(fileMenu); | |
172 | ||
173 | Activate(false); | |
174 | frame->Show(false); | |
175 | ||
176 | if (deleteWindow) | |
177 | { | |
178 | frame->Destroy(); | |
179 | } | |
180 | ||
181 | return true; | |
182 | } | |
183 | ||
184 | // Adds or removes shape from m_selections | |
185 | void csDiagramView::SelectShape(wxShape* shape, bool select) | |
186 | { | |
187 | if (select && !m_selections.Member(shape)) | |
188 | m_selections.Append(shape); | |
189 | else if (!select) | |
190 | m_selections.DeleteObject(shape); | |
191 | } | |
192 | ||
193 | void csDiagramView::OnSelectAll(wxCommandEvent& WXUNUSED(event)) | |
194 | { | |
195 | SelectAll(true); | |
196 | } | |
197 | ||
198 | wxShape *csDiagramView::FindFirstSelectedShape(void) | |
199 | { | |
200 | csDiagramDocument *doc = (csDiagramDocument *)GetDocument(); | |
201 | wxObjectList::compatibility_iterator node = doc->GetDiagram()->GetShapeList()->GetFirst(); | |
202 | while (node) | |
203 | { | |
204 | wxShape *eachShape = (wxShape *)node->GetData(); | |
205 | if ((eachShape->GetParent() == NULL) && !eachShape->IsKindOf(CLASSINFO(wxLabelShape)) && eachShape->Selected()) | |
206 | { | |
207 | return eachShape; | |
208 | } | |
209 | else node = node->GetNext(); | |
210 | } | |
211 | return NULL; | |
212 | } | |
213 | ||
214 | void csDiagramView::FindSelectedShapes(wxList& selections, wxClassInfo* toFind) | |
215 | { | |
216 | csDiagramDocument *doc = (csDiagramDocument *)GetDocument(); | |
217 | wxObjectList::compatibility_iterator node = doc->GetDiagram()->GetShapeList()->GetFirst(); | |
218 | while (node) | |
219 | { | |
220 | wxShape *eachShape = (wxShape *)node->GetData(); | |
221 | if ((eachShape->GetParent() == NULL) && !eachShape->IsKindOf(CLASSINFO(wxLabelShape)) && eachShape->Selected() && ((toFind == NULL) || (eachShape->IsKindOf(toFind)))) | |
222 | { | |
223 | selections.Append(eachShape); | |
224 | } | |
225 | node = node->GetNext(); | |
226 | } | |
227 | } | |
228 | ||
229 | void csDiagramView::OnUndoUpdate(wxUpdateUIEvent& event) | |
230 | { | |
231 | csDiagramDocument *doc = (csDiagramDocument *)GetDocument(); | |
232 | event.Enable(doc->GetCommandProcessor()->CanUndo()); | |
233 | } | |
234 | ||
235 | void csDiagramView::OnRedoUpdate(wxUpdateUIEvent& event) | |
236 | { | |
237 | csDiagramDocument *doc = (csDiagramDocument *)GetDocument(); | |
238 | event.Enable(doc->GetCommandProcessor()->CanRedo()); | |
239 | } | |
240 | ||
241 | void csDiagramView::OnCut(wxCommandEvent& WXUNUSED(event)) | |
242 | { | |
243 | csDiagramDocument *doc = (csDiagramDocument *)GetDocument(); | |
244 | ||
245 | // Copy the shapes to the clipboard | |
246 | wxGetApp().GetDiagramClipboard().Copy(doc->GetDiagram()); | |
247 | ||
248 | wxList selections; | |
249 | FindSelectedShapes(selections); | |
250 | ||
251 | DoCut(selections); | |
252 | } | |
253 | ||
254 | void csDiagramView::OnClear(wxCommandEvent& WXUNUSED(event)) | |
255 | { | |
256 | wxList selections; | |
257 | FindSelectedShapes(selections); | |
258 | ||
259 | DoCut(selections); | |
260 | } | |
261 | ||
262 | void csDiagramView::OnCopy(wxCommandEvent& WXUNUSED(event)) | |
263 | { | |
264 | csDiagramDocument *doc = (csDiagramDocument *)GetDocument(); | |
265 | ||
266 | // Copy the shapes to the clipboard | |
267 | if (wxGetApp().GetDiagramClipboard().Copy(doc->GetDiagram())) | |
268 | { | |
269 | #ifdef __WXMSW__ | |
270 | // Copy to the Windows clipboard | |
271 | wxGetApp().GetDiagramClipboard().CopyToClipboard(1.0); | |
272 | #endif | |
273 | } | |
274 | } | |
275 | ||
276 | void csDiagramView::OnPaste(wxCommandEvent& WXUNUSED(event)) | |
277 | { | |
278 | csDiagramDocument *doc = (csDiagramDocument *)GetDocument(); | |
279 | ||
280 | wxGetApp().GetDiagramClipboard().Paste(doc->GetDiagram()); | |
281 | } | |
282 | ||
283 | void csDiagramView::OnDuplicate(wxCommandEvent& WXUNUSED(event)) | |
284 | { | |
285 | csDiagramDocument *doc = (csDiagramDocument *)GetDocument(); | |
286 | ||
287 | // Do a copy, then a paste | |
288 | wxGetApp().GetDiagramClipboard().Copy(doc->GetDiagram()); | |
289 | ||
290 | // Apply an offset. Really, this offset should keep being incremented, | |
291 | // but where do we reset it again? | |
292 | wxGetApp().GetDiagramClipboard().Paste(doc->GetDiagram(), NULL, 20, 20); | |
293 | } | |
294 | ||
295 | void csDiagramView::OnCutUpdate(wxUpdateUIEvent& event) | |
296 | { | |
297 | event.Enable( (m_selections.GetCount() > 0) ); | |
298 | } | |
299 | ||
300 | void csDiagramView::OnClearUpdate(wxUpdateUIEvent& event) | |
301 | { | |
302 | event.Enable( (m_selections.GetCount() > 0) ); | |
303 | } | |
304 | ||
305 | void csDiagramView::OnCopyUpdate(wxUpdateUIEvent& event) | |
306 | { | |
307 | event.Enable( (m_selections.GetCount() > 0) ); | |
308 | } | |
309 | ||
310 | void csDiagramView::OnPasteUpdate(wxUpdateUIEvent& event) | |
311 | { | |
312 | /* csDiagramDocument *doc = */ (csDiagramDocument *)GetDocument(); | |
313 | ||
314 | int n = wxGetApp().GetDiagramClipboard().GetCount(); | |
315 | ||
316 | event.Enable( (n > 0) ); | |
317 | } | |
318 | ||
319 | void csDiagramView::OnDuplicateUpdate(wxUpdateUIEvent& event) | |
320 | { | |
321 | event.Enable( (m_selections.GetCount() > 0) ); | |
322 | } | |
323 | ||
324 | void csDiagramView::DoCut(wxList& shapes) | |
325 | { | |
326 | csDiagramDocument *doc = (csDiagramDocument *)GetDocument(); | |
327 | ||
328 | if (shapes.GetCount() > 0) | |
329 | { | |
330 | csDiagramCommand* cmd = new csDiagramCommand(_T("Cut"), doc); | |
331 | ||
332 | wxObjectList::compatibility_iterator node = shapes.GetFirst(); | |
333 | while (node) | |
334 | { | |
335 | wxShape *theShape = (wxShape*) node->GetData(); | |
336 | csCommandState* state = new csCommandState(ID_CS_CUT, NULL, theShape); | |
337 | ||
338 | // Insert lines at the front, so they are cut first. | |
339 | // Otherwise we may try to remove a shape with a line still | |
340 | // attached. | |
341 | if (theShape->IsKindOf(CLASSINFO(wxLineShape))) | |
342 | cmd->InsertState(state); | |
343 | else | |
344 | cmd->AddState(state); | |
345 | ||
346 | node = node->GetNext(); | |
347 | } | |
348 | cmd->RemoveLines(); // Schedule any connected lines, not already mentioned, | |
349 | // to be removed first | |
350 | ||
351 | doc->GetCommandProcessor()->Submit(cmd); | |
352 | } | |
353 | } | |
354 | ||
355 | // Generalised command | |
356 | void csDiagramView::DoCmd(wxList& shapes, wxList& oldShapes, int cmd, const wxString& op) | |
357 | { | |
358 | csDiagramDocument *doc = (csDiagramDocument *)GetDocument(); | |
359 | ||
360 | if (shapes.GetCount() > 0) | |
361 | { | |
362 | csDiagramCommand* command = new csDiagramCommand(op, doc); | |
363 | ||
364 | wxObjectList::compatibility_iterator node = shapes.GetFirst(); | |
365 | wxObjectList::compatibility_iterator node1 = oldShapes.GetFirst(); | |
366 | while (node && node1) | |
367 | { | |
368 | wxShape *theShape = (wxShape*) node->GetData(); | |
369 | wxShape *oldShape = (wxShape*) node1->GetData(); | |
370 | csCommandState* state = new csCommandState(cmd, theShape, oldShape); | |
371 | command->AddState(state); | |
372 | ||
373 | node = node->GetNext(); | |
374 | node1 = node1->GetNext(); | |
375 | } | |
376 | doc->GetCommandProcessor()->Submit(command); | |
377 | } | |
378 | } | |
379 | ||
380 | void csDiagramView::OnChangeBackgroundColour(wxCommandEvent& WXUNUSED(event)) | |
381 | { | |
382 | csDiagramDocument *doc = (csDiagramDocument *)GetDocument(); | |
383 | ||
384 | wxList selections; | |
385 | FindSelectedShapes(selections); | |
386 | ||
387 | if (selections.GetCount() > 0) | |
388 | { | |
389 | wxColourData data; | |
390 | data.SetChooseFull(true); | |
391 | if (selections.GetCount() == 1) | |
392 | { | |
393 | wxShape* firstShape = (wxShape*) selections.GetFirst()->GetData(); | |
394 | data.SetColour(firstShape->GetBrush()->GetColour()); | |
395 | } | |
396 | ||
397 | wxColourDialog *dialog = new wxColourDialog(frame, &data); | |
398 | wxBrush *theBrush = NULL; | |
399 | if (dialog->ShowModal() == wxID_OK) | |
400 | { | |
401 | wxColourData retData = dialog->GetColourData(); | |
402 | wxColour col = retData.GetColour(); | |
403 | theBrush = wxTheBrushList->FindOrCreateBrush(col, wxSOLID); | |
404 | } | |
405 | dialog->Close(true); | |
406 | if (!theBrush) | |
407 | return; | |
408 | ||
409 | csDiagramCommand* cmd = new csDiagramCommand(_T("Change colour"), doc); | |
410 | ||
411 | wxObjectList::compatibility_iterator node = selections.GetFirst(); | |
412 | while (node) | |
413 | { | |
414 | wxShape *theShape = (wxShape*) node->GetData(); | |
415 | wxShape* newShape = theShape->CreateNewCopy(); | |
416 | newShape->SetBrush(theBrush); | |
417 | ||
418 | csCommandState* state = new csCommandState(ID_CS_CHANGE_BACKGROUND_COLOUR, newShape, theShape); | |
419 | cmd->AddState(state); | |
420 | ||
421 | node = node->GetNext(); | |
422 | } | |
423 | doc->GetCommandProcessor()->Submit(cmd); | |
424 | } | |
425 | } | |
426 | ||
427 | void csDiagramView::OnEditProperties(wxCommandEvent& WXUNUSED(event)) | |
428 | { | |
429 | wxShape *theShape = FindFirstSelectedShape(); | |
430 | if (theShape) | |
431 | ((csEvtHandler *)theShape->GetEventHandler())->EditProperties(); | |
432 | } | |
433 | ||
434 | void csDiagramView::OnEditPropertiesUpdate(wxUpdateUIEvent& event) | |
435 | { | |
436 | wxList selections; | |
437 | FindSelectedShapes(selections); | |
438 | event.Enable( (selections.GetCount() > 0) ); | |
439 | } | |
440 | ||
441 | void csDiagramView::OnPointSizeComboSel(wxCommandEvent& event) | |
442 | { | |
443 | wxComboBox* combo = (wxComboBox*) event.GetEventObject(); | |
444 | wxASSERT( combo != NULL ); | |
445 | ||
446 | int newPointSize = (combo->GetSelection() + 1); | |
447 | ||
448 | ApplyPointSize(newPointSize); | |
449 | ||
450 | } | |
451 | ||
452 | // TODO: must find out how to intercept the Return key, rather than | |
453 | // every key stroke. But for now, do every key stroke. | |
454 | void csDiagramView::OnPointSizeComboText(wxCommandEvent& event) | |
455 | { | |
456 | wxComboBox* combo = (wxComboBox*) event.GetEventObject(); | |
457 | wxASSERT( combo != NULL ); | |
458 | ||
459 | wxString str(combo->GetValue()); | |
460 | long newPointSize; | |
461 | str.ToLong( &newPointSize ); | |
462 | ||
463 | if (newPointSize < 2) | |
464 | return; | |
465 | ||
466 | ApplyPointSize(newPointSize); | |
467 | } | |
468 | ||
469 | void csDiagramView::ApplyPointSize(int pointSize) | |
470 | { | |
471 | csDiagramDocument *doc = (csDiagramDocument *)GetDocument(); | |
472 | ||
473 | wxList selections; | |
474 | FindSelectedShapes(selections); | |
475 | ||
476 | if (selections.GetCount() > 0) | |
477 | { | |
478 | csDiagramCommand* cmd = new csDiagramCommand(_T("Point size"), doc); | |
479 | ||
480 | wxObjectList::compatibility_iterator node = selections.GetFirst(); | |
481 | while (node) | |
482 | { | |
483 | wxShape *theShape = (wxShape*) node->GetData(); | |
484 | wxShape *newShape = theShape->CreateNewCopy(); | |
485 | ||
486 | wxFont* newFont = wxTheFontList->FindOrCreateFont(pointSize, | |
487 | theShape->GetFont()->GetFamily(), | |
488 | theShape->GetFont()->GetStyle(), | |
489 | theShape->GetFont()->GetWeight(), | |
490 | theShape->GetFont()->GetUnderlined(), | |
491 | theShape->GetFont()->GetFaceName()); | |
492 | ||
493 | newShape->SetFont(newFont); | |
494 | ||
495 | csCommandState* state = new csCommandState(ID_CS_FONT_CHANGE, newShape, theShape); | |
496 | ||
497 | cmd->AddState(state); | |
498 | ||
499 | node = node->GetNext(); | |
500 | } | |
501 | doc->GetCommandProcessor()->Submit(cmd); | |
502 | } | |
503 | } | |
504 | ||
505 | void csDiagramView::OnZoomSel(wxCommandEvent& event) | |
506 | { | |
507 | int maxZoom = 200; | |
508 | int minZoom = 5; | |
509 | int inc = 5; | |
510 | int noStrings = (maxZoom - minZoom)/inc ; | |
511 | ||
512 | wxComboBox* combo = (wxComboBox*) event.GetEventObject(); | |
513 | wxASSERT( combo != NULL ); | |
514 | ||
515 | int scale = (int) ((noStrings - combo->GetSelection() - 1)*inc + minZoom); | |
516 | ||
517 | canvas->SetScale((double) (scale/100.0), (double) (scale/100.0)); | |
518 | canvas->Refresh(); | |
519 | } | |
520 | ||
521 | // Select or deselect all | |
522 | void csDiagramView::SelectAll(bool select) | |
523 | { | |
524 | wxClientDC dc(canvas); | |
525 | canvas->PrepareDC(dc); | |
526 | ||
527 | if (!select) | |
528 | { | |
529 | wxList selections; | |
530 | FindSelectedShapes(selections); | |
531 | ||
532 | wxObjectList::compatibility_iterator node = selections.GetFirst(); | |
533 | while (node) | |
534 | { | |
535 | wxShape *theShape = (wxShape*) node->GetData(); | |
536 | theShape->Select(false, &dc); | |
537 | SelectShape(theShape, false); | |
538 | ||
539 | node = node->GetNext(); | |
540 | } | |
541 | } | |
542 | else | |
543 | { | |
544 | csDiagramDocument *doc = (csDiagramDocument *)GetDocument(); | |
545 | wxObjectList::compatibility_iterator node = doc->GetDiagram()->GetShapeList()->GetFirst(); | |
546 | while (node) | |
547 | { | |
548 | wxShape *eachShape = (wxShape *)node->GetData(); | |
549 | if (eachShape->GetParent() == NULL && | |
550 | !eachShape->IsKindOf(CLASSINFO(wxControlPoint)) && | |
551 | !eachShape->IsKindOf(CLASSINFO(wxLabelShape))) | |
552 | { | |
553 | eachShape->Select(true, &dc); | |
554 | SelectShape(eachShape, true); | |
555 | } | |
556 | node = node->GetNext(); | |
557 | } | |
558 | } | |
559 | } | |
560 | ||
561 | ||
562 | void csDiagramView::OnToggleArrowTool(wxCommandEvent& WXUNUSED(event)) | |
563 | { | |
564 | csDiagramDocument *doc = (csDiagramDocument *)GetDocument(); | |
565 | ||
566 | bool state = wxGetApp().GetDiagramToolBar()->GetToolState(DIAGRAM_TOOLBAR_LINE_ARROW); | |
567 | wxString stateName; | |
568 | if (state) | |
569 | stateName = _T("Arrow on"); | |
570 | else | |
571 | stateName = _T("Arrow off"); | |
572 | ||
573 | wxList selections; | |
574 | FindSelectedShapes(selections, CLASSINFO(wxLineShape)); | |
575 | ||
576 | if (selections.GetCount() > 0) | |
577 | { | |
578 | csDiagramCommand* cmd = new csDiagramCommand(stateName, doc); | |
579 | ||
580 | wxObjectList::compatibility_iterator node = selections.GetFirst(); | |
581 | while (node) | |
582 | { | |
583 | wxLineShape *theShape = (wxLineShape*) node->GetData(); | |
584 | wxLineShape *newShape = NULL; | |
585 | ||
586 | if (state) | |
587 | { | |
588 | // Add arrow | |
589 | if (theShape->GetArrows().GetCount() == 0) | |
590 | { | |
591 | newShape = (wxLineShape*) theShape->CreateNewCopy(); | |
592 | newShape->AddArrow(ARROW_ARROW, ARROW_POSITION_MIDDLE, 10.0, 0.0, _T("Normal arrowhead")); | |
593 | } | |
594 | } | |
595 | else | |
596 | { | |
597 | if (theShape->GetArrows().GetCount() > 0) | |
598 | { | |
599 | newShape = (wxLineShape*) theShape->CreateNewCopy(); | |
600 | newShape->ClearArrowsAtPosition(); | |
601 | } | |
602 | } | |
603 | ||
604 | // If the new state is the same as the old, don't bother adding it to the command state. | |
605 | if (newShape) | |
606 | { | |
607 | csCommandState* state = new csCommandState(ID_CS_ARROW_CHANGE, newShape, theShape); | |
608 | cmd->AddState(state); | |
609 | } | |
610 | ||
611 | node = node->GetNext(); | |
612 | } | |
613 | doc->GetCommandProcessor()->Submit(cmd); | |
614 | } | |
615 | } | |
616 | ||
617 | void csDiagramView::OnToggleArrowToolUpdate(wxUpdateUIEvent& event) | |
618 | { | |
619 | wxList selections; | |
620 | FindSelectedShapes(selections, CLASSINFO(wxLineShape)); | |
621 | event.Enable( (selections.GetCount() > 0) ); | |
622 | } | |
623 | ||
624 | // Make the point size combobox reflect this | |
625 | void csDiagramView::ReflectPointSize(int pointSize) | |
626 | { | |
627 | wxComboBox* comboBox = wxGetApp().GetPointSizeComboBox(); | |
628 | comboBox->SetSelection(pointSize -1); | |
629 | } | |
630 | ||
631 | // Make the arrow toggle button reflect the state of the line | |
632 | void csDiagramView::ReflectArrowState(wxLineShape* lineShape) | |
633 | { | |
634 | bool haveArrow = false; | |
635 | wxObjectList::compatibility_iterator node = lineShape->GetArrows().GetFirst(); | |
636 | while (node) | |
637 | { | |
638 | wxArrowHead *arrow = (wxArrowHead *)node->GetData(); | |
639 | if (ARROW_POSITION_MIDDLE == arrow->GetArrowEnd()) | |
640 | haveArrow = true; | |
641 | node = node->GetNext(); | |
642 | } | |
643 | ||
644 | wxGetApp().GetDiagramToolBar()->ToggleTool(DIAGRAM_TOOLBAR_LINE_ARROW, haveArrow); | |
645 | } | |
646 | ||
647 | void csDiagramView::OnAlign(wxCommandEvent& event) | |
648 | { | |
649 | // Make a copy of the selections, keeping only those shapes | |
650 | // that are top-level non-line shapes. | |
651 | wxList selections; | |
652 | wxObjectList::compatibility_iterator node = GetSelectionList().GetFirst(); | |
653 | while (node) | |
654 | { | |
655 | wxShape* shape = (wxShape*) node->GetData(); | |
656 | if ((shape->GetParent() == NULL) && (!shape->IsKindOf(CLASSINFO(wxLineShape)))) | |
657 | { | |
658 | selections.Append(shape); | |
659 | } | |
660 | node = node->GetNext(); | |
661 | } | |
662 | ||
663 | if (selections.GetCount() == 0) | |
664 | return; | |
665 | ||
666 | csDiagramDocument *doc = (csDiagramDocument *)GetDocument(); | |
667 | csDiagramCommand* cmd = new csDiagramCommand(_T("Align"), doc); | |
668 | ||
669 | node = selections.GetFirst(); | |
670 | wxShape* firstShape = (wxShape*) node->GetData(); | |
671 | ||
672 | double x = firstShape->GetX(); | |
673 | double y = firstShape->GetY(); | |
674 | double width, height; | |
675 | firstShape->GetBoundingBoxMax(&width, &height); | |
676 | ||
677 | node = selections.GetFirst(); | |
678 | while (node) | |
679 | { | |
680 | wxShape* shape = (wxShape*) node->GetData(); | |
681 | if (shape != firstShape) | |
682 | { | |
683 | /* double x1 = */ shape->GetX(); | |
684 | /* double y1 = */ shape->GetY(); | |
685 | double width1, height1; | |
686 | shape->GetBoundingBoxMax(& width1, & height1); | |
687 | ||
688 | wxShape* newShape = shape->CreateNewCopy(); | |
689 | ||
690 | switch (event.GetId()) | |
691 | { | |
692 | case DIAGRAM_TOOLBAR_ALIGNL: | |
693 | { | |
694 | double x2 = (double)(x - (width/2.0) + (width1/2.0)); | |
695 | newShape->SetX(x2); | |
696 | break; | |
697 | } | |
698 | case DIAGRAM_TOOLBAR_ALIGNR: | |
699 | { | |
700 | double x2 = (double)(x + (width/2.0) - (width1/2.0)); | |
701 | newShape->SetX(x2); | |
702 | break; | |
703 | } | |
704 | case DIAGRAM_TOOLBAR_ALIGNB: | |
705 | { | |
706 | double y2 = (double)(y + (height/2.0) - (height1/2.0)); | |
707 | newShape->SetY(y2); | |
708 | break; | |
709 | } | |
710 | case DIAGRAM_TOOLBAR_ALIGNT: | |
711 | { | |
712 | double y2 = (double)(y - (height/2.0) + (height1/2.0)); | |
713 | newShape->SetY(y2); | |
714 | break; | |
715 | } | |
716 | case DIAGRAM_TOOLBAR_ALIGN_HORIZ: | |
717 | { | |
718 | newShape->SetX(x); | |
719 | break; | |
720 | } | |
721 | case DIAGRAM_TOOLBAR_ALIGN_VERT: | |
722 | { | |
723 | newShape->SetY(y); | |
724 | break; | |
725 | } | |
726 | case DIAGRAM_TOOLBAR_COPY_SIZE: | |
727 | { | |
728 | newShape->SetSize(width, height); | |
729 | break; | |
730 | } | |
731 | } | |
732 | csCommandState* state = new csCommandState(ID_CS_ALIGN, newShape, shape); | |
733 | cmd->AddState(state); | |
734 | } | |
735 | node = node->GetNext(); | |
736 | } | |
737 | doc->GetCommandProcessor()->Submit(cmd); | |
738 | } | |
739 | ||
740 | void csDiagramView::OnAlignUpdate(wxUpdateUIEvent& event) | |
741 | { | |
742 | // This is an approximation, since there may be lines | |
743 | // amongst the selections. | |
744 | event.Enable( (m_selections.GetCount() > 1) ) ; | |
745 | } | |
746 | ||
747 | void csDiagramView::OnNewLinePoint(wxCommandEvent& WXUNUSED(event)) | |
748 | { | |
749 | csDiagramDocument *doc = (csDiagramDocument *)GetDocument(); | |
750 | csDiagramCommand* cmd = new csDiagramCommand(_T("New line point"), doc); | |
751 | ||
752 | wxObjectList::compatibility_iterator node = m_selections.GetFirst(); | |
753 | while (node) | |
754 | { | |
755 | wxShape* shape = (wxShape*) node->GetData(); | |
756 | if (shape->IsKindOf(CLASSINFO(wxLineShape))) | |
757 | { | |
758 | wxShape* newShape = shape->CreateNewCopy(); | |
759 | ((wxLineShape*)newShape)->InsertLineControlPoint(NULL); | |
760 | csCommandState* state = new csCommandState(ID_CS_NEW_POINT, newShape, shape); | |
761 | cmd->AddState(state); | |
762 | } | |
763 | node = node->GetNext(); | |
764 | } | |
765 | doc->GetCommandProcessor()->Submit(cmd); | |
766 | } | |
767 | ||
768 | void csDiagramView::OnCutLinePoint(wxCommandEvent& WXUNUSED(event)) | |
769 | { | |
770 | csDiagramDocument *doc = (csDiagramDocument *)GetDocument(); | |
771 | csDiagramCommand* cmd = new csDiagramCommand(_T("Cut line point"), doc); | |
772 | ||
773 | wxObjectList::compatibility_iterator node = m_selections.GetFirst(); | |
774 | while (node) | |
775 | { | |
776 | wxShape* shape = (wxShape*) node->GetData(); | |
777 | if (shape->IsKindOf(CLASSINFO(wxLineShape))) | |
778 | { | |
779 | wxShape* newShape = shape->CreateNewCopy(); | |
780 | ((wxLineShape*)newShape)->DeleteLineControlPoint(); | |
781 | csCommandState* state = new csCommandState(ID_CS_CUT_POINT, newShape, shape); | |
782 | cmd->AddState(state); | |
783 | } | |
784 | node = node->GetNext(); | |
785 | } | |
786 | doc->GetCommandProcessor()->Submit(cmd); | |
787 | } | |
788 | ||
789 | void csDiagramView::OnStraightenLines(wxCommandEvent& WXUNUSED(event)) | |
790 | { | |
791 | csDiagramDocument *doc = (csDiagramDocument *)GetDocument(); | |
792 | csDiagramCommand* cmd = new csDiagramCommand(_T("Straighten lines"), doc); | |
793 | ||
794 | wxObjectList::compatibility_iterator node = m_selections.GetFirst(); | |
795 | while (node) | |
796 | { | |
797 | wxShape* shape = (wxShape*) node->GetData(); | |
798 | if (shape->IsKindOf(CLASSINFO(wxLineShape))) | |
799 | { | |
800 | wxShape* newShape = shape->CreateNewCopy(); | |
801 | ((wxLineShape*)newShape)->Straighten(); | |
802 | csCommandState* state = new csCommandState(ID_CS_STRAIGHTEN, newShape, shape); | |
803 | cmd->AddState(state); | |
804 | } | |
805 | node = node->GetNext(); | |
806 | } | |
807 | doc->GetCommandProcessor()->Submit(cmd); | |
808 | } | |
809 | ||
810 | void csDiagramView::OnNewLinePointUpdate(wxUpdateUIEvent& event) | |
811 | { | |
812 | wxList selections; | |
813 | FindSelectedShapes(selections, CLASSINFO(wxLineShape)); | |
814 | event.Enable( (selections.GetCount() > 0) ); | |
815 | } | |
816 | ||
817 | void csDiagramView::OnCutLinePointUpdate(wxUpdateUIEvent& event) | |
818 | { | |
819 | wxList selections; | |
820 | FindSelectedShapes(selections, CLASSINFO(wxLineShape)); | |
821 | event.Enable( (selections.GetCount() > 0) ); | |
822 | } | |
823 | ||
824 | void csDiagramView::OnStraightenLinesUpdate(wxUpdateUIEvent& event) | |
825 | { | |
826 | wxList selections; | |
827 | FindSelectedShapes(selections, CLASSINFO(wxLineShape)); | |
828 | event.Enable( (selections.GetCount() > 0) ); | |
829 | } | |
830 | ||
831 | /* | |
832 | * Window implementations | |
833 | */ | |
834 | ||
835 | IMPLEMENT_CLASS(csCanvas, wxShapeCanvas) | |
836 | ||
837 | BEGIN_EVENT_TABLE(csCanvas, wxShapeCanvas) | |
838 | EVT_MOUSE_EVENTS(csCanvas::OnMouseEvent) | |
839 | EVT_PAINT(csCanvas::OnPaint) | |
840 | END_EVENT_TABLE() | |
841 | ||
842 | // Define a constructor for my canvas | |
843 | csCanvas::csCanvas(csDiagramView *v, wxWindow *parent, wxWindowID id, const wxPoint& pos, | |
844 | const wxSize& size, long style): | |
845 | wxShapeCanvas(parent, id, pos, size, style) | |
846 | { | |
847 | m_view = v; | |
848 | } | |
849 | ||
850 | csCanvas::~csCanvas(void) | |
851 | { | |
852 | } | |
853 | ||
854 | void csCanvas::DrawOutline(wxDC& dc, double x1, double y1, double x2, double y2) | |
855 | { | |
856 | wxPen dottedPen(wxColour(0, 0, 0), 1, wxDOT); | |
857 | dc.SetPen(dottedPen); | |
858 | dc.SetBrush(* wxTRANSPARENT_BRUSH); | |
859 | ||
860 | dc.DrawRectangle((long) x1, (long) y1, (long) (x2 - x1), (long) (y2 - y1)); | |
861 | } | |
862 | ||
863 | void csCanvas::OnLeftClick(double x, double y, int WXUNUSED(keys)) | |
864 | { | |
865 | csEditorToolPalette *palette = wxGetApp().GetDiagramPalette(); | |
866 | ||
867 | if (palette->GetSelection() == PALETTE_ARROW) | |
868 | { | |
869 | GetView()->SelectAll(false); | |
870 | ||
871 | wxClientDC dc(this); | |
872 | PrepareDC(dc); | |
873 | ||
874 | Redraw(dc); | |
875 | return; | |
876 | } | |
877 | ||
878 | if (palette->GetSelection() == PALETTE_TEXT_TOOL) | |
879 | { | |
880 | // Ask for a label and create a new free-floating text region | |
881 | csLabelEditingDialog* dialog = new csLabelEditingDialog(GetParent()); | |
882 | ||
883 | dialog->SetShapeLabel( wxEmptyString ); | |
884 | dialog->SetTitle(_T("New text box")); | |
885 | if (dialog->ShowModal() == wxID_CANCEL) | |
886 | { | |
887 | dialog->Destroy(); | |
888 | return; | |
889 | } | |
890 | ||
891 | wxString newLabel = dialog->GetShapeLabel(); | |
892 | dialog->Destroy(); | |
893 | ||
894 | wxShape* shape = new csTextBoxShape; | |
895 | shape->AssignNewIds(); | |
896 | shape->SetEventHandler(new csEvtHandler(shape, shape, newLabel)); | |
897 | ||
898 | wxComboBox* comboBox = wxGetApp().GetPointSizeComboBox(); | |
899 | wxString str(comboBox->GetValue()); | |
900 | long pointSize; | |
901 | str.ToLong( &pointSize ); | |
902 | ||
903 | wxFont* newFont = wxTheFontList->FindOrCreateFont(pointSize, | |
904 | shape->GetFont()->GetFamily(), | |
905 | shape->GetFont()->GetStyle(), | |
906 | shape->GetFont()->GetWeight(), | |
907 | shape->GetFont()->GetUnderlined(), | |
908 | shape->GetFont()->GetFaceName()); | |
909 | ||
910 | shape->SetFont(newFont); | |
911 | ||
912 | shape->SetX(x); | |
913 | shape->SetY(y); | |
914 | ||
915 | csDiagramCommand* cmd = new csDiagramCommand(_T("Text box"), | |
916 | (csDiagramDocument *)GetView()->GetDocument(), | |
917 | new csCommandState(ID_CS_ADD_SHAPE, shape, NULL)); | |
918 | GetView()->GetDocument()->GetCommandProcessor()->Submit(cmd); | |
919 | ||
920 | palette->SetSelection(PALETTE_ARROW); | |
921 | ||
922 | return; | |
923 | } | |
924 | ||
925 | csSymbol* symbol = wxGetApp().GetSymbolDatabase()->FindSymbol(palette->GetSelection()); | |
926 | if (symbol) | |
927 | { | |
928 | wxShape* theShape = symbol->GetShape()->CreateNewCopy(); | |
929 | ||
930 | wxComboBox* comboBox = wxGetApp().GetPointSizeComboBox(); | |
931 | wxString str(comboBox->GetValue()); | |
932 | long pointSize; | |
933 | str.ToLong( &pointSize ); | |
934 | ||
935 | wxFont* newFont = wxTheFontList->FindOrCreateFont(pointSize, | |
936 | symbol->GetShape()->GetFont()->GetFamily(), | |
937 | symbol->GetShape()->GetFont()->GetStyle(), | |
938 | symbol->GetShape()->GetFont()->GetWeight(), | |
939 | symbol->GetShape()->GetFont()->GetUnderlined(), | |
940 | symbol->GetShape()->GetFont()->GetFaceName()); | |
941 | ||
942 | theShape->SetFont(newFont); | |
943 | ||
944 | theShape->AssignNewIds(); | |
945 | theShape->SetX(x); | |
946 | theShape->SetY(y); | |
947 | ||
948 | csDiagramCommand* cmd = new csDiagramCommand(symbol->GetName(), | |
949 | (csDiagramDocument *)GetView()->GetDocument(), | |
950 | new csCommandState(ID_CS_ADD_SHAPE, theShape, NULL)); | |
951 | GetView()->GetDocument()->GetCommandProcessor()->Submit(cmd); | |
952 | ||
953 | palette->SetSelection(PALETTE_ARROW); | |
954 | } | |
955 | } | |
956 | ||
957 | void csCanvas::OnRightClick(double WXUNUSED(x), double WXUNUSED(y), int WXUNUSED(keys)) | |
958 | { | |
959 | } | |
960 | ||
961 | // Initial point | |
962 | static double sg_initialX, sg_initialY; | |
963 | ||
964 | void csCanvas::OnDragLeft(bool WXUNUSED(draw), double x, double y, int WXUNUSED(keys)) | |
965 | { | |
966 | wxClientDC dc(this); | |
967 | PrepareDC(dc); | |
968 | ||
969 | dc.SetLogicalFunction(OGLRBLF); | |
970 | DrawOutline(dc, sg_initialX, sg_initialY, x, y); | |
971 | } | |
972 | ||
973 | void csCanvas::OnBeginDragLeft(double x, double y, int WXUNUSED(keys)) | |
974 | { | |
975 | sg_initialX = x; | |
976 | sg_initialY = y; | |
977 | ||
978 | wxClientDC dc(this); | |
979 | PrepareDC(dc); | |
980 | ||
981 | dc.SetLogicalFunction(OGLRBLF); | |
982 | DrawOutline(dc, sg_initialX, sg_initialY, x, y); | |
983 | CaptureMouse(); | |
984 | } | |
985 | ||
986 | void csCanvas::OnEndDragLeft(double x, double y, int WXUNUSED(keys)) | |
987 | { | |
988 | ReleaseMouse(); | |
989 | ||
990 | wxClientDC dc(this); | |
991 | PrepareDC(dc); | |
992 | ||
993 | // Select all images within the rectangle | |
994 | float min_x, max_x, min_y, max_y; | |
995 | min_x = wxMin(x, sg_initialX); | |
996 | max_x = wxMax(x, sg_initialX); | |
997 | min_y = wxMin(y, sg_initialY); | |
998 | max_y = wxMax(y, sg_initialY); | |
999 | ||
1000 | wxObjectList::compatibility_iterator node = GetDiagram()->GetShapeList()->GetFirst(); | |
1001 | while (node) | |
1002 | { | |
1003 | wxShape *shape = (wxShape *)node->GetData(); | |
1004 | if (shape->GetParent() == NULL && !shape->IsKindOf(CLASSINFO(wxControlPoint))) | |
1005 | { | |
1006 | float image_x = shape->GetX(); | |
1007 | float image_y = shape->GetY(); | |
1008 | if (image_x >= min_x && image_x <= max_x && | |
1009 | image_y >= min_y && image_y <= max_y) | |
1010 | { | |
1011 | shape->Select(true, &dc); | |
1012 | GetView()->SelectShape(shape, true); | |
1013 | } | |
1014 | } | |
1015 | node = node->GetNext(); | |
1016 | } | |
1017 | } | |
1018 | ||
1019 | void csCanvas::OnDragRight(bool WXUNUSED(draw), double WXUNUSED(x), double WXUNUSED(y), int WXUNUSED(keys)) | |
1020 | { | |
1021 | } | |
1022 | ||
1023 | void csCanvas::OnBeginDragRight(double WXUNUSED(x), double WXUNUSED(y), int WXUNUSED(keys)) | |
1024 | { | |
1025 | } | |
1026 | ||
1027 | void csCanvas::OnEndDragRight(double WXUNUSED(x), double WXUNUSED(y), int WXUNUSED(keys)) | |
1028 | { | |
1029 | } | |
1030 | ||
1031 | void csCanvas::OnMouseEvent(wxMouseEvent& event) | |
1032 | { | |
1033 | wxShapeCanvas::OnMouseEvent(event); | |
1034 | } | |
1035 | ||
1036 | void csCanvas::OnPaint(wxPaintEvent& event) | |
1037 | { | |
1038 | // if (GetDiagram()) | |
1039 | wxShapeCanvas::OnPaint(event); | |
1040 | } |