]> Shamusworld >> Repos - architektonas/blob - src/base/rs_graphicview.cpp
Final round of dialogs/forms needing to be converted from Qt3 to 4
[architektonas] / src / base / rs_graphicview.cpp
1 // rs_graphicview.cpp
2 //
3 // Part of the Architektonas Project
4 // Originally part of QCad Community Edition by Andrew Mustun
5 // Extensively rewritten and refactored by James L. Hammons
6 // (C) 2010 Underground Software
7 //
8 // JLH = James L. Hammons <jlhamm@acm.org>
9 //
10 // Who  When        What
11 // ---  ----------  -----------------------------------------------------------
12 // JLH  05/21/2010  Added this text. :-)
13 //
14
15 #include "rs_graphicview.h"
16
17 #include <stdio.h>
18 #include "rs_actioninterface.h"
19 #include "rs_block.h"
20 #include "rs_dialogfactory.h"
21 #include "drawing.h"
22 #include "rs_eventhandler.h"
23 #include "rs_grid.h"
24 #include "rs_insert.h"
25 #include "rs_layer.h"
26 #include "rs_line.h"
27 #include "rs_solid.h"
28 #include "rs_text.h"
29 #include "rs_units.h"
30 #include "paintintf.h"
31 #include "settings.h"
32
33 /**
34  * Constructor.
35  */
36 RS_GraphicView::RS_GraphicView(): background(), foreground(), previewMode(false),
37         previewOffset(Vector(0, 0)), snapperDraw(false)
38 {
39         drawingMode = RS2::ModeFull;
40         printing = false;
41         deleteMode = false;
42         factor = Vector(1.0, 1.0);
43         offsetX = 0;
44         offsetY = 0;
45         previousFactor = Vector(1.0, 1.0);
46         previousOffsetX = 0;
47         previousOffsetY = 0;
48         container = NULL;
49         eventHandler = new RS_EventHandler(this);
50         gridColor = Qt::gray;
51         metaGridColor = RS_Color(64, 64, 64);
52         grid = new RS_Grid(this);
53         updateEnabled = 0;
54         zoomFrozen = false;
55         //gridVisible = true;
56         draftMode = false;
57         painter = NULL;
58         //drawRecursion = 0;
59
60         borderLeft = 0;
61         borderTop = 0;
62         borderRight = 0;
63         borderBottom = 0;
64
65         relativeZero = Vector(false);
66         relativeZeroLocked = false;
67
68         mx = my = 0;
69
70         defaultSnapMode = RS2::SnapFree;
71         defaultSnapRes = RS2::RestrictNothing;
72
73         /*
74                 background = RS_Color(0,0,0);
75                 foreground = RS_Color(255,255,255);
76                 gridColor = RS_Color("gray");
77         metaGridColor = RS_Color("#404040");
78                 selectedColor = RS_Color("#a54747");
79                 highlightedColor = RS_Color("#739373");
80         */
81
82         settings.beginGroup("Appearance");
83         setBackground(QColor(settings.value("BackgroundColor", "#000000").toString()));
84         setGridColor(QColor(settings.value("GridColor", "#7F7F7F").toString()));
85         setMetaGridColor(QColor(settings.value("MetaGridColor", "#3F3F3F").toString()));
86         setSelectedColor(QColor(settings.value("SelectedColor", "#A54747").toString()));
87         setHighlightedColor(QColor(settings.value("HighlightedColor", "#739373").toString()));
88         settings.endGroup();
89
90         printPreview = false;
91
92         simulationSpeed = 100;
93         simulationSmooth = false;
94         simulationRapid = false;
95         simulationRunning = false;
96
97         //currentInsert = NULL;
98 }
99
100 /**
101  * Destructor.
102  */
103 RS_GraphicView::~RS_GraphicView()
104 {
105         //delete eventHandler;
106         if (painter != NULL)
107                 delete painter;
108
109         delete grid;
110 }
111
112 /**
113  * Must be called by any derrived class in the destructor.
114  */
115 void RS_GraphicView::cleanUp()
116 {
117         delete eventHandler;
118 }
119
120 /**
121  * @return Pointer to the graphic entity if the entity container
122  * connected to this view is a graphic and valid.
123  * NULL otherwise.
124  */
125 Drawing * RS_GraphicView::getGraphic()
126 {
127         if (container != NULL && container->rtti() == RS2::EntityGraphic)
128                 return (Drawing*)container;
129         else
130                 return NULL;
131 }
132
133 /**
134  * Sets the drawing mode.
135  */
136 void RS_GraphicView::setDrawingMode(RS2::DrawingMode m)
137 {
138         drawingMode = m;
139 }
140
141 /**
142  * @return Current drawing mode.
143  */
144 RS2::DrawingMode RS_GraphicView::getDrawingMode()
145 {
146         return drawingMode;
147 }
148
149 /**
150  * Activates or deactivates the delete mode.
151  */
152 void RS_GraphicView::setDeleteMode(bool m)
153 {
154         deleteMode = m;
155 }
156
157 /**
158  * @reval true Deleting instead of drawing.
159  *        false Normal drawing mode.
160  */
161 bool RS_GraphicView::getDeleteMode()
162 {
163         return deleteMode;
164 }
165
166 /** This virtual method must be overwritten and is then
167         called whenever the view changed */
168 void RS_GraphicView::adjustOffsetControls()
169 {
170 }
171
172 /** This virtual method must be overwritten and is then
173         called whenever the view changed */
174 void RS_GraphicView::adjustZoomControls()
175 {
176 }
177
178 /**
179  * Sets an external painter device.
180  */
181 //void RS_GraphicView::setPainter(RS_Painter * p)
182 void RS_GraphicView::setPainter(PaintInterface * p)
183 {
184         painter = p;
185 }
186
187 /**
188  * Sets the background color. Note that applying the background
189  * color for the widget is up to the implementing class.
190  */
191 void RS_GraphicView::setBackground(const RS_Color & bg)
192 {
193         background = bg;
194
195         // bright background:
196         if (bg.red() + bg.green() + bg.blue() > 380)
197 //              foreground = Qt::black;
198                 foreground = RS_Color(0, 0, 0);
199         else
200 //              foreground = Qt::white;
201                 foreground = RS_Color(255, 255, 255);
202 }
203
204 /**
205  * @return Current background color.
206  */
207 RS_Color RS_GraphicView::getBackground()
208 {
209         return background;
210 }
211
212 /**
213  * @return Current foreground color.
214  */
215 RS_Color RS_GraphicView::getForeground()
216 {
217         return foreground;
218 }
219
220 /**
221  * Sets the grid color.
222  */
223 void RS_GraphicView::setGridColor(const RS_Color & c)
224 {
225         gridColor = c;
226 }
227
228 /**
229  * Sets the meta grid color.
230  */
231 void RS_GraphicView::setMetaGridColor(const RS_Color & c)
232 {
233         metaGridColor = c;
234 }
235
236 /**
237  * Sets the selection color.
238  */
239 void RS_GraphicView::setSelectedColor(const RS_Color & c)
240 {
241         selectedColor = c;
242 }
243
244 /**
245  * Sets the highlight color.
246  */
247 void RS_GraphicView::setHighlightedColor(const RS_Color & c)
248 {
249         highlightedColor = c;
250 }
251
252 /**
253  * This virtual method can be overwritten to set the mouse
254  * cursor to the given type.
255  */
256 void RS_GraphicView::setMouseCursor(RS2::CursorType /*c*/)
257 {
258 }
259
260 RS_EntityContainer * RS_GraphicView::getContainer()
261 {
262         return container;
263 }
264
265 void RS_GraphicView::setFactor(double f)
266 {
267         setFactorX(f);
268         setFactorY(f);
269 }
270
271 Vector RS_GraphicView::getFactor()
272 {
273         return factor;
274 }
275
276 /**
277  * Sets the offset of the graphic.
278  */
279 void RS_GraphicView::setOffset(int ox, int oy)
280 {
281         setOffsetX(ox);
282         setOffsetY(oy);
283 }
284
285 void RS_GraphicView::setOffsetX(int ox)
286 {
287         offsetX = ox;
288 }
289
290 void RS_GraphicView::setOffsetY(int oy)
291 {
292         offsetY = oy;
293 }
294
295 int RS_GraphicView::getOffsetX()
296 {
297         return offsetX;
298 }
299
300 int RS_GraphicView::getOffsetY()
301 {
302         return offsetY;
303 }
304
305 /**
306  * Sets a fixed border in pixel around the graphic. This border
307  * specifies how far the user can scroll outside the graphic
308  * area.
309  */
310 void RS_GraphicView::setBorders(int left, int top, int right, int bottom)
311 {
312         borderLeft = left;
313         borderTop = top;
314         borderRight = right;
315         borderBottom = bottom;
316 }
317
318 int RS_GraphicView::getBorderLeft()
319 {
320         return borderLeft;
321 }
322
323 int RS_GraphicView::getBorderTop()
324 {
325         return borderTop;
326 }
327
328 int RS_GraphicView::getBorderRight()
329 {
330         return borderRight;
331 }
332
333 int RS_GraphicView::getBorderBottom()
334 {
335         return borderBottom;
336 }
337
338 void RS_GraphicView::disableUpdate()
339 {
340         updateEnabled--;
341 }
342
343 void RS_GraphicView::enableUpdate()
344 {
345         updateEnabled++;
346 }
347
348 bool RS_GraphicView::isUpdateEnabled()
349 {
350         return (updateEnabled == 0);
351 }
352
353 void RS_GraphicView::freezeZoom(bool freeze)
354 {
355         zoomFrozen = freeze;
356 }
357
358 bool RS_GraphicView::isZoomFrozen()
359 {
360         return zoomFrozen;
361 }
362
363 /**
364  * Sets the pointer to the graphic which contains the entities
365  * which are visualized by this widget.
366  */
367 void RS_GraphicView::setContainer(RS_EntityContainer * container)
368 {
369         this->container = container;
370         //adjustOffsetControls();
371 }
372
373 /**
374  * Sets the zoom factor in X for this visualization of the graphic.
375  */
376 void RS_GraphicView::setFactorX(double f)
377 {
378         if (!zoomFrozen)
379                 factor.x = fabs(f);
380 }
381
382 /**
383  * Sets the zoom factor in Y for this visualization of the graphic.
384  */
385 void RS_GraphicView::setFactorY(double f)
386 {
387         if (!zoomFrozen)
388                 factor.y = fabs(f);
389 }
390
391 /**
392  * @return true if the grid is switched on.
393  */
394 bool RS_GraphicView::isGridOn()
395 {
396         if (container != NULL)
397         {
398                 Drawing * g = container->getGraphic();
399
400                 if (g != NULL)
401                         return g->isGridOn();
402         }
403
404         return true;
405 }
406
407 /**
408  * Centers the drawing in x-direction.
409  */
410 void RS_GraphicView::centerOffsetX()
411 {
412         if (container != NULL && !zoomFrozen)
413                 offsetX = (int)(((getWidth() - borderLeft - borderRight)
414                         - (container->getSize().x * factor.x)) / 2.0
415                         - (container->getMin().x * factor.x)) + borderLeft;
416 }
417
418 /**
419  * Centers the drawing in y-direction.
420  */
421 void RS_GraphicView::centerOffsetY()
422 {
423         if (container != NULL && !zoomFrozen)
424                 offsetY = (int)((getHeight() - borderTop - borderBottom
425                         - (container->getSize().y * factor.y)) / 2.0
426                         - (container->getMin().y * factor.y)) + borderBottom;
427 }
428
429 /**
430  * Centers the given coordinate in the view in x-direction.
431  */
432 void RS_GraphicView::centerX(double v)
433 {
434         if (!zoomFrozen)
435                 offsetX = (int)((v * factor.x) - (double)(getWidth() - borderLeft - borderRight) / 2.0);
436 }
437
438 /**
439  * Centers the given coordinate in the view in y-direction.
440  */
441 void RS_GraphicView::centerY(double v)
442 {
443     if (!zoomFrozen)
444         offsetY = (int)((v * factor.y) - (double)(getHeight() - borderTop - borderBottom) / 2.0);
445 }
446
447 void RS_GraphicView::updateView()
448 {
449         static int running = 0;
450         running++;
451
452         if (running < 100)
453         {
454                 adjustZoomControls();
455                 adjustOffsetControls();
456         }
457
458         running--;
459
460         if (running == 0)
461                 redraw();
462 }
463
464 /**
465  * @return Current action or NULL.
466  */
467 RS_ActionInterface * RS_GraphicView::getDefaultAction()
468 {
469         if (eventHandler != NULL)
470                 return eventHandler->getDefaultAction();
471         else
472                 return NULL;
473 }
474
475 /**
476  * Sets the default action of the event handler.
477  */
478 void RS_GraphicView::setDefaultAction(RS_ActionInterface * action)
479 {
480     if (eventHandler != NULL)
481         eventHandler->setDefaultAction(action);
482 }
483
484 /**
485  * @return Current action or NULL.
486  */
487 RS_ActionInterface * RS_GraphicView::getCurrentAction()
488 {
489         if (eventHandler != NULL)
490                 return eventHandler->getCurrentAction();
491         else
492                 return NULL;
493 }
494
495 /**
496  * Sets the current action of the event handler.
497  */
498 void RS_GraphicView::setCurrentAction(RS_ActionInterface * action)
499 {
500         RS_DEBUG->print("RS_GraphicView::setCurrentAction");
501
502         if (eventHandler != NULL)
503                 eventHandler->setCurrentAction(action);
504
505         RS_DEBUG->print("RS_GraphicView::setCurrentAction: OK");
506 }
507
508 /**
509  * Kills all running selection actions. Called when a selection action
510  * is launched to reduce confusion.
511  */
512 void RS_GraphicView::killSelectActions()
513 {
514         if (eventHandler != NULL)
515                 eventHandler->killSelectActions();
516 }
517
518 /**
519  * Kills all running actions.
520  */
521 void RS_GraphicView::killAllActions()
522 {
523         if (eventHandler != NULL)
524                 eventHandler->killAllActions();
525 }
526
527 /**
528  * Go back in menu or current action.
529  */
530 void RS_GraphicView::back()
531 {
532         if (eventHandler != NULL && eventHandler->hasAction())
533                 eventHandler->back();
534         else
535                 if (RS_DIALOGFACTORY != NULL)
536                         RS_DIALOGFACTORY->requestPreviousMenu();
537 }
538
539 /**
540  * Go forward with the current action.
541  */
542 void RS_GraphicView::enter()
543 {
544         if (eventHandler != NULL && eventHandler->hasAction())
545                 eventHandler->enter();
546 }
547
548 /**
549  * Called by the actual GUI class which implements the RS_GraphicView
550  * interface to notify qcadlib about mouse events.
551  */
552 void RS_GraphicView::mousePressEvent(QMouseEvent * e)
553 {
554         if (eventHandler != NULL)
555                 eventHandler->mousePressEvent(e);
556 }
557
558 /**
559  * Called by the actual GUI class which implements the RS_GraphicView
560  * interface to notify qcadlib about mouse events.
561  */
562 void RS_GraphicView::mouseReleaseEvent(QMouseEvent * e)
563 {
564         RS_DEBUG->print("RS_GraphicView::mouseReleaseEvent");
565
566         if (eventHandler != NULL)
567         {
568                 if (e->button() != Qt::RightButton || eventHandler->hasAction())
569                 {
570                         eventHandler->mouseReleaseEvent(e);
571                         //e->accept();
572                 }
573                 else
574                 {
575                         back();
576                         e->accept();
577                 }
578         }
579
580         RS_DEBUG->print("RS_GraphicView::mouseReleaseEvent: OK");
581 }
582
583 /**
584  * Called by the actual GUI class which implements the RS_GraphicView
585  * interface to notify qcadlib about mouse events.
586  */
587 void RS_GraphicView::mouseMoveEvent(QMouseEvent * e)
588 {
589         RS_DEBUG->print("RS_GraphicView::mouseMoveEvent begin");
590
591         Drawing * graphic = NULL;
592
593         if (container->rtti() == RS2::EntityGraphic)
594                 graphic = (Drawing *)container;
595
596         RS_DEBUG->print("RS_GraphicView::mouseMoveEvent 001");
597
598         if (e != NULL)
599         {
600                 mx = e->x();
601                 my = e->y();
602         }
603
604         RS_DEBUG->print("RS_GraphicView::mouseMoveEvent 002");
605
606         if (eventHandler != NULL)
607                 eventHandler->mouseMoveEvent(e);
608
609         RS_DEBUG->print("RS_GraphicView::mouseMoveEvent 003");
610
611         if (eventHandler == NULL || !eventHandler->hasAction() && graphic != NULL)
612         {
613                 Vector mouse = toGraph(Vector(mx, my));
614                 Vector relMouse = mouse - getRelativeZero();
615
616                 if (RS_DIALOGFACTORY != NULL)
617                         RS_DIALOGFACTORY->updateCoordinateWidget(mouse, relMouse);
618         }
619
620         RS_DEBUG->print("RS_GraphicView::mouseMoveEvent end");
621 }
622
623 /**
624  * Called by the actual GUI class which implements the RS_GraphicView
625  * interface to notify qcadlib about mouse events.
626  */
627 void RS_GraphicView::mouseLeaveEvent()
628 {
629         if (eventHandler != NULL)
630                 eventHandler->mouseLeaveEvent();
631 }
632
633 /**
634  * Called by the actual GUI class which implements the RS_GraphicView
635  * interface to notify qcadlib about mouse events.
636  */
637 void RS_GraphicView::mouseEnterEvent()
638 {
639         if (eventHandler != NULL)
640                 eventHandler->mouseEnterEvent();
641 }
642
643 /**
644  * Called by the actual GUI class which implements the RS_GraphicView
645  * interface to notify qcadlib about key events.
646  */
647 void RS_GraphicView::keyPressEvent(QKeyEvent * e)
648 {
649         if (eventHandler != NULL)
650                 eventHandler->keyPressEvent(e);
651 }
652
653 /**
654  * Called by the actual GUI class which implements the RS_GraphicView
655  * interface to notify qcadlib about key events.
656  */
657 void RS_GraphicView::keyReleaseEvent(QKeyEvent * e)
658 {
659         if (eventHandler != NULL)
660                 eventHandler->keyReleaseEvent(e);
661 }
662
663 /**
664  * Called by the actual GUI class which implements a command line.
665  */
666 void RS_GraphicView::commandEvent(RS_CommandEvent * e)
667 {
668         if (eventHandler != NULL)
669                 eventHandler->commandEvent(e);
670 }
671
672 /**
673  * Enables coordinate input in the command line.
674  */
675 void RS_GraphicView::enableCoordinateInput()
676 {
677         if (eventHandler != NULL)
678                 eventHandler->enableCoordinateInput();
679 }
680
681 /**
682  * Disables coordinate input in the command line.
683  */
684 void RS_GraphicView::disableCoordinateInput()
685 {
686         if (eventHandler != NULL)
687                 eventHandler->disableCoordinateInput();
688 }
689
690 /**
691  * zooms in by factor f
692  */
693 void RS_GraphicView::zoomIn(double f, const Vector & center)
694 {
695         if (f < 1.0e-6)
696         {
697                 RS_DEBUG->print(RS_Debug::D_WARNING, "RS_GraphicView::zoomIn: invalid factor");
698                 return;
699         }
700
701         if (simulationRunning)
702                 return;
703
704         Vector c = center;
705         if (c.valid == false)
706                 c = toGraph(Vector(getWidth() / 2, getHeight() / 2));
707
708         zoomWindow(
709                 toGraph(Vector(0, 0)).scale(c, Vector(1.0 / f, 1.0 / f)),
710                 toGraph(Vector(getWidth(), getHeight())).scale(c, Vector(1.0 / f, 1.0 / f)));
711
712         //adjustOffsetControls();
713         //adjustZoomControls();
714         //updateGrid();
715         //redraw();
716 }
717
718 /**
719  * zooms in by factor f in x
720  */
721 void RS_GraphicView::zoomInX(double f)
722 {
723         if (simulationRunning)
724                 return;
725
726         factor.x *= f;
727         offsetX = (int)((offsetX - getWidth() / 2) * f) + getWidth() / 2;
728         adjustOffsetControls();
729         adjustZoomControls();
730         updateGrid();
731         redraw();
732 }
733
734 /**
735  * zooms in by factor f in y
736  */
737 void RS_GraphicView::zoomInY(double f)
738 {
739         if (simulationRunning)
740                 return;
741
742         factor.y *= f;
743         offsetY = (int)((offsetY - getHeight() / 2) * f)+getHeight() / 2;
744         adjustOffsetControls();
745         adjustZoomControls();
746         updateGrid();
747         redraw();
748 }
749
750 /**
751  * zooms out by factor f
752  */
753 void RS_GraphicView::zoomOut(double f, const Vector & center)
754 {
755         if (f < 1.0e-6)
756         {
757                 RS_DEBUG->print(RS_Debug::D_WARNING,
758                         "RS_GraphicView::zoomOut: invalid factor");
759                 return;
760         }
761
762         if (simulationRunning)
763                 return;
764
765         zoomIn(1/f, center);
766 }
767
768 /**
769  * zooms out by factor f in x
770  */
771 void RS_GraphicView::zoomOutX(double f)
772 {
773         if (f < 1.0e-6)
774         {
775                 RS_DEBUG->print(RS_Debug::D_WARNING,
776                         "RS_GraphicView::zoomOutX: invalid factor");
777                 return;
778         }
779
780         if (simulationRunning)
781                 return;
782
783         factor.x /= f;
784         offsetX = (int)(offsetX / f);
785         adjustOffsetControls();
786         adjustZoomControls();
787         updateGrid();
788         redraw();
789 }
790
791 /**
792  * zooms out by factor f y
793  */
794 void RS_GraphicView::zoomOutY(double f)
795 {
796         if (f < 1.0e-6)
797         {
798                 RS_DEBUG->print(RS_Debug::D_WARNING,
799                         "RS_GraphicView::zoomOutY: invalid factor");
800                 return;
801         }
802
803         if (simulationRunning)
804                 return;
805
806         factor.y /= f;
807         offsetY = (int)(offsetY / f);
808         adjustOffsetControls();
809         adjustZoomControls();
810         updateGrid();
811         redraw();
812 }
813
814 /**
815  * performs autozoom
816  *
817  * @param axis include axis in zoom
818  * @param keepAspectRatio true: keep aspect ratio 1:1
819  *                        false: factors in x and y are stretched to the max
820  */
821 void RS_GraphicView::zoomAuto(bool axis, bool keepAspectRatio)
822 {
823         RS_DEBUG->print("RS_GraphicView::zoomAuto");
824
825         if (simulationRunning)
826                 return;
827
828         saveView();
829
830         if (container != NULL)
831         {
832                 container->calculateBorders();
833
834                 double sx, sy;
835                 if (axis)
836                 {
837                         sx = std::max(container->getMax().x, 0.0) - std::min(container->getMin().x, 0.0);
838                         sy = std::max(container->getMax().y, 0.0) - std::min(container->getMin().y, 0.0);
839                 }
840                 else
841                 {
842                         sx = container->getSize().x;
843                         sy = container->getSize().y;
844                 }
845
846                 double fx, fy;
847
848                 if (sx > RS_TOLERANCE)
849                         fx = (getWidth() - borderLeft - borderRight) / sx;
850                 else
851                         fx = 1.0;
852
853                 if (sy > RS_TOLERANCE)
854                         fy = (getHeight() - borderTop - borderBottom) / sy;
855                 else
856                         fy = 1.0;
857
858                 RS_DEBUG->print("f: %f/%f", fx, fy);
859
860                 if (keepAspectRatio)
861                         fx = fy = std::min(fx, fy);
862
863                 RS_DEBUG->print("f: %f/%f", fx, fy);
864
865                 if (fx < RS_TOLERANCE)
866                         fx = fy = 1.0;
867
868                 setFactorX(fx);
869                 setFactorY(fy);
870
871                 RS_DEBUG->print("f: %f/%f", fx, fy);
872
873                 RS_DEBUG->print("adjustOffsetControls");
874                 adjustOffsetControls();
875                 RS_DEBUG->print("adjustZoomControls");
876                 adjustZoomControls();
877                 RS_DEBUG->print("centerOffsetX");
878                 centerOffsetX();
879                 RS_DEBUG->print("centerOffsetY");
880                 centerOffsetY();
881                 RS_DEBUG->print("updateGrid");
882                 updateGrid();
883                 redraw();
884         }
885
886         RS_DEBUG->print("RS_GraphicView::zoomAuto OK");
887 }
888
889 /**
890  * Shows previous view.
891  */
892 void RS_GraphicView::zoomPrevious()
893 {
894         RS_DEBUG->print("RS_GraphicView::zoomPrevious");
895
896         if (simulationRunning)
897                 return;
898
899         if (container != NULL)
900                 restoreView();
901 }
902
903 /**
904  * Saves the current view as previous view to which we can
905  * switch back later with @see restoreView().
906  */
907 void RS_GraphicView::saveView()
908 {
909         previousOffsetX = offsetX;
910         previousOffsetY = offsetY;
911         previousFactor = factor;
912 }
913
914 /**
915  * Restores the view previously saved with
916  * @see saveView().
917  */
918 void RS_GraphicView::restoreView()
919 {
920         int pox = previousOffsetX;
921         int poy = previousOffsetY;
922         Vector pf = previousFactor;
923
924         saveView();
925
926         offsetX = pox;
927         offsetY = poy;
928         factor = pf;
929
930         adjustOffsetControls();
931         adjustZoomControls();
932         updateGrid();
933         redraw();
934 }
935
936 /**
937  * performs autozoom in y only
938  *
939  * @param axis include axis in zoom
940  */
941 void RS_GraphicView::zoomAutoY(bool axis)
942 {
943         if (simulationRunning)
944                 return;
945
946         if (container != NULL)
947         {
948                 double visibleHeight = 0.0;
949                 double minY = RS_MAXDOUBLE;
950                 double maxY = RS_MINDOUBLE;
951                 bool noChange = false;
952
953                 for(RS_Entity * e=container->firstEntity(RS2::ResolveNone);
954                         e!=NULL; e = container->nextEntity(RS2::ResolveNone))
955                 {
956                         if (e->rtti() == RS2::EntityLine)
957                         {
958                                 RS_Line * l = (RS_Line *)e;
959                                 double x1, x2;
960                                 x1 = toGuiX(l->getStartpoint().x);
961                                 x2 = toGuiX(l->getEndpoint().x);
962
963                                 if (x1 > 0.0 && x1 < (double)getWidth() || x2 > 0.0 && x2 < (double)getWidth())
964                                 {
965                                         minY = std::min(minY, l->getStartpoint().y);
966                                         minY = std::min(minY, l->getEndpoint().y);
967                                         maxY = std::max(maxY, l->getStartpoint().y);
968                                         maxY = std::max(maxY, l->getEndpoint().y);
969                                 }
970                         }
971                 }
972
973                 if (axis)
974                         visibleHeight = std::max(maxY, 0.0) - std::min(minY, 0.0);
975                 else
976                         visibleHeight = maxY - minY;
977
978                 if (visibleHeight < 1.0)
979                         noChange = true;
980
981                 double fy = 1.0;
982
983                 if (visibleHeight > 1.0e-6)
984                 {
985                         fy = (getHeight() - borderTop - borderBottom) / visibleHeight;
986
987                         if (factor.y < 0.000001)
988                                 noChange = true;
989                 }
990
991                 if (noChange == false)
992                 {
993                         setFactorY(fy);
994                         //centerOffsetY();
995                         offsetY = (int)((getHeight() - borderTop - borderBottom - (visibleHeight * factor.y)) / 2.0
996                                 - (minY * factor.y)) + borderBottom;
997                         adjustOffsetControls();
998                         adjustZoomControls();
999                         updateGrid();
1000                 }
1001
1002                 RS_DEBUG->print("Auto zoom y ok");
1003         }
1004 }
1005
1006 /**
1007  * Zooms the area given by v1 and v2.
1008  *
1009  * @param keepAspectRatio true: keeps the aspect ratio 1:1
1010  *                        false: zooms exactly the selected range to the
1011  *                               current graphic view
1012  */
1013 void RS_GraphicView::zoomWindow(Vector v1, Vector v2, bool keepAspectRatio)
1014 {
1015         if (simulationRunning)
1016                 return;
1017
1018         saveView();
1019
1020         double zoomX = 480.0;    // Zoom for X-Axis
1021         double zoomY = 640.0;    // Zoom for Y-Axis   (Set smaller one)
1022         double dum;            // Dummy for switching values
1023         int zoomBorder = 0;
1024
1025         // Switch left/right and top/bottom is necessary:
1026         if (v1.x > v2.x)
1027         {
1028                 dum = v1.x;
1029                 v1.x = v2.x;
1030                 v2.x = dum;
1031         }
1032
1033         if (v1.y > v2.y)
1034         {
1035                 dum = v1.y;
1036                 v1.y = v2.y;
1037                 v2.y = dum;
1038         }
1039
1040         // Get zoom in X and zoom in Y:
1041         if (v2.x - v1.x > 1.0e-6)
1042                 zoomX = getWidth() / (v2.x - v1.x);
1043
1044         if (v2.y - v1.y > 1.0e-6)
1045                 zoomY = getHeight() / (v2.y - v1.y);
1046
1047         // Take smaller zoom:
1048         if (keepAspectRatio)
1049         {
1050                 if (zoomX < zoomY)
1051                 {
1052                         if (getWidth() != 0)
1053                         {
1054                                 zoomX = zoomY = ((double)(getWidth() - 2 * zoomBorder)) /
1055                                                                 (double)getWidth() * zoomX;
1056                         }
1057                 }
1058                 else
1059                 {
1060                         if (getHeight() != 0)
1061                         {
1062                                 zoomX = zoomY = ((double)(getHeight() - 2 * zoomBorder)) /
1063                                                                 (double)getHeight() * zoomY;
1064                         }
1065                 }
1066         }
1067
1068         if (zoomX < 0.0)
1069                 zoomX *= -1;
1070
1071         if (zoomY < 0.0)
1072                 zoomY *= -1;
1073
1074         // Borders in pixel after zoom
1075         int pixLeft   = (int)(v1.x * zoomX);
1076         int pixTop    = (int)(v2.y * zoomY);
1077         int pixRight  = (int)(v2.x * zoomX);
1078         int pixBottom = (int)(v1.y * zoomY);
1079
1080         // Set new offset for zero point:
1081         offsetX = - pixLeft + (getWidth() - pixRight + pixLeft) / 2;
1082         offsetY = - pixTop + (getHeight() - pixBottom + pixTop) / 2;
1083         factor.x = zoomX;
1084         factor.y = zoomY;
1085
1086         adjustOffsetControls();
1087         adjustZoomControls();
1088         updateGrid();
1089         redraw();
1090 }
1091
1092 /**
1093  * Centers the point v1.
1094  */
1095 void RS_GraphicView::zoomPan(int dx, int dy)
1096 {
1097         //offsetX+=(int)toGuiDX(v1.x);
1098         //offsetY+=(int)toGuiDY(v1.y);
1099         if (simulationRunning)
1100                 return;
1101
1102         offsetX += dx;
1103         offsetY -= dy;
1104
1105         disableUpdate();
1106         adjustOffsetControls();
1107         //adjustZoomControls();
1108         updateGrid();
1109         enableUpdate();
1110         redraw();
1111 }
1112
1113 /**
1114  * Scrolls in the given direction.
1115  */
1116 void RS_GraphicView::zoomScroll(RS2::Direction direction)
1117 {
1118         if (simulationRunning)
1119                 return;
1120
1121         switch (direction)
1122         {
1123         case RS2::Up:
1124                 offsetY -= 50;
1125                 break;
1126         case RS2::Down:
1127                 offsetY += 50;
1128                 break;
1129         case RS2::Right:
1130                 offsetX += 50;
1131                 break;
1132         case RS2::Left:
1133                 offsetX -= 50;
1134                 break;
1135         }
1136
1137         adjustOffsetControls();
1138         adjustZoomControls();
1139         updateGrid();
1140         redraw();
1141 }
1142
1143 /**
1144  * Zooms to page extends.
1145  */
1146 void RS_GraphicView::zoomPage()
1147 {
1148         RS_DEBUG->print("RS_GraphicView::zoomPage");
1149
1150         if (container == NULL)
1151                 return;
1152
1153         if (simulationRunning)
1154                 return;
1155
1156         Drawing * graphic = container->getGraphic();
1157
1158         if (graphic == NULL)
1159                 return;
1160
1161         Vector s = graphic->getPaperSize();
1162         Vector pinsbase = graphic->getPaperInsertionBase();
1163
1164         double fx, fy;
1165
1166         if (s.x > RS_TOLERANCE)
1167                 fx = (getWidth() - borderLeft - borderRight) / s.x;
1168         else
1169                 fx = 1.0;
1170
1171         if (s.y > RS_TOLERANCE)
1172                 fy = (getHeight() - borderTop - borderBottom) / s.y;
1173         else
1174                 fy = 1.0;
1175
1176         RS_DEBUG->print("f: %f/%f", fx, fy);
1177
1178         fx = fy = std::min(fx, fy);
1179
1180         RS_DEBUG->print("f: %f/%f", fx, fy);
1181
1182         if (fx < RS_TOLERANCE)
1183                 fx = fy = 1.0;
1184
1185         setFactorX(fx);
1186         setFactorY(fy);
1187
1188         RS_DEBUG->print("f: %f/%f", fx, fy);
1189
1190         centerOffsetX();
1191         centerOffsetY();
1192         adjustOffsetControls();
1193         adjustZoomControls();
1194         updateGrid();
1195         redraw();
1196 }
1197
1198 /**
1199  * Draws the entities within the given range.
1200  */
1201 void RS_GraphicView::drawWindow(Vector v1, Vector v2)
1202 {
1203         RS_DEBUG->print("RS_GraphicView::drawWindow() begin");
1204
1205         if (simulationRunning)
1206                 return;
1207
1208         if (container != NULL)
1209         {
1210                 for (RS_Entity * se=container->firstEntity(RS2::ResolveNone);
1211                         se!=NULL; se = container->nextEntity(RS2::ResolveNone))
1212                 {
1213                         if (se->isInWindow(v1, v2))
1214                                 drawEntity(se);
1215                 }
1216         }
1217
1218         RS_DEBUG->print("RS_GraphicView::drawWindow() end");
1219 }
1220
1221 /**
1222  * Draws the entities. If painter is NULL a new painter will
1223  * be created and destroyed.
1224  */
1225 void RS_GraphicView::drawIt()
1226 {
1227         if (!isUpdateEnabled())
1228 //{
1229 //printf("RS_GraphicView::drawIt(): isUpdateEnabled() == false!\n");
1230                 return;
1231 //}
1232
1233         if (simulationRunning)
1234 //{
1235 //printf("RS_GraphicView::drawIt(): simulationRunning == true!\n");
1236                 return;
1237 //}
1238
1239 //      bool painterCreated = false;
1240
1241         settings.beginGroup("Appearance");
1242         draftMode = settings.value("DraftMode", false).toBool();
1243         settings.endGroup();
1244
1245         //RS_DEBUG->print("RS_GraphicView::drawIt() begin");
1246         //RS_DEBUG->print("  factors: %f/%f", factor.x, factor.y);
1247         //RS_DEBUG->timestamp();
1248
1249         if (painter == NULL)
1250         {
1251 printf("RS_GraphicView::drawIt(): painter == NULL!\n");
1252                 return;
1253 //              createPainter();
1254 //              painterCreated = true;
1255         }
1256         else
1257                 painter->erase();
1258
1259         // drawing paper border:
1260         if (isPrintPreview())
1261                 drawPaper();
1262         // drawing meta grid:
1263         else
1264                 drawMetaGrid();
1265
1266         //if (draftMode) {
1267         //    painter->setPen(RS_Pen(foreground, RS2::Width00, RS2::SolidLine));
1268         //}
1269
1270         // drawing entities:
1271 //#warning "!!! This looks like a bug, no match for 'drawEntity(RS_Entity *, bool) !!!"
1272 // and indeed it *is* a bug... true is converted to 1.0 here. Dumb, dumb, dumb.
1273         drawEntity(container, true);
1274
1275         //RS_DEBUG->timestamp();
1276         //RS_DEBUG->print(" draw zero..");
1277
1278         // drawing zero points:
1279         if (!isPrintPreview())
1280         {
1281                 drawAbsoluteZero();
1282                 drawRelativeZero();
1283         }
1284
1285         //RS_DEBUG->timestamp();
1286         //RS_DEBUG->print(" draw grid..");
1287
1288         // drawing grid:
1289         if (!isPrintPreview())
1290                 drawGrid();
1291
1292         //RS_DEBUG->timestamp();
1293         //RS_DEBUG->print("RS_GraphicView::drawIt() end");
1294 //      if (painterCreated == true)
1295 //              destroyPainter();
1296 }
1297
1298 /**
1299  * Sets the pen of the painter object to the suitable pen for the given
1300  * entity.
1301  */
1302 void RS_GraphicView::setPenForEntity(RS_Entity * e)
1303 {
1304         if (drawingMode == RS2::ModePreview /*|| draftMode==true*/)
1305                 return;
1306
1307         // set color of entity
1308         if (painter != NULL && !painter->isPreviewMode())
1309         {
1310                 // Getting pen from entity (or layer)
1311                 RS_Pen pen = e->getPen(true);
1312
1313                 int w = pen.getWidth();
1314
1315                 if (w < 0)
1316                         w = 0;
1317
1318                 // scale pen width:
1319                 if (!draftMode)
1320                 {
1321                         double uf = 1.0;  // unit factor
1322                         double wf = 1.0;  // width factor
1323                         Drawing * graphic = container->getGraphic();
1324
1325                         if (graphic != NULL)
1326                         {
1327                                 uf = RS_Units::convert(1.0, RS2::Millimeter, graphic->getUnit());
1328
1329                                 if ((isPrinting() || isPrintPreview()) && graphic->getPaperScale() > 1.0e-6)
1330                                         wf = 1.0 / graphic->getPaperScale();
1331                         }
1332
1333                         pen.setScreenWidth(toGuiDX(w / 100.0 * uf * wf));
1334                 }
1335                 else
1336                 {
1337                         //pen.setWidth(RS2::Width00);
1338                         pen.setScreenWidth(0);
1339                 }
1340
1341                 // prevent drawing with 1-width which is slow:
1342                 if (RS_Math::round(pen.getScreenWidth()) == 1)
1343                         pen.setScreenWidth(0.0);
1344
1345                 // prevent background color on background drawing:
1346                 if (pen.getColor().stripFlags() == background.stripFlags())
1347                         pen.setColor(foreground);
1348
1349                 // this entity is selected:
1350                 if (e->isSelected())
1351                 {
1352                         pen.setLineType(RS2::DotLine);
1353                         //pen.setColor(RS_Color(0xa5,0x47,0x47));
1354                         pen.setColor(selectedColor);
1355                 }
1356
1357                 // this entity is highlighted:
1358                 if (e->isHighlighted())
1359                 {
1360                         //pen.setColor(RS_Color(0x73, 0x93, 0x73));
1361                         pen.setColor(highlightedColor);
1362                 }
1363
1364                 // deleting not drawing:
1365                 if (getDeleteMode())
1366                         pen.setColor(background);
1367
1368                 painter->setPen(pen);
1369         }
1370 }
1371
1372 /**
1373  * Draws an entity. Might be recusively called e.g. for polylines.
1374  * If the class wide painter is NULL a new painter will be created
1375  * and destroyed afterwards.
1376  *
1377  * @param patternOffset Offset of line pattern (used for connected
1378  *        lines e.g. in splines).
1379  * @param db Double buffering on (recommended) / off
1380  */
1381 void RS_GraphicView::drawEntity(RS_Entity * e, double patternOffset, bool db)
1382 {
1383         //RS_DEBUG->print("RS_GraphicView::drawEntity() begin");
1384
1385         // update is diabled:
1386         if (!isUpdateEnabled())
1387                 return;
1388
1389         // given entity is NULL:
1390         if (e == NULL)
1391                 return;
1392
1393         // entity is not visible:
1394         if (!e->isVisible())
1395                 return;
1396
1397         // test if the entity is in the viewport
1398         if (!e->isContainer() && !isPrinting()
1399                 && (painter == NULL || !painter->isPreviewMode())
1400                 && (toGuiX(e->getMax().x) < 0 || toGuiX(e->getMin().x) > getWidth()
1401                 || toGuiY(e->getMin().y) < 0 || toGuiY(e->getMax().y) > getHeight()))
1402 //{
1403 //printf("RS_GraphicView::drawEntity(): Bailing out of big test!!!\n");
1404                 return;
1405 //}
1406
1407         //drawRecursion++;
1408         //RS_DEBUG->print("recursion 1: %d", drawRecursion);
1409
1410         // set pen (color):
1411         setPenForEntity(e);
1412
1413         //RS_DEBUG->print("draw plain");
1414         if (draftMode)
1415         {
1416                 // large texts as rectangles:
1417                 if (e->rtti() == RS2::EntityText)
1418                 {
1419                         if (toGuiDX(((RS_Text *)e)->getHeight()) < 4 || e->countDeep() > 100)
1420                                 painter->drawRect(toGui(e->getMin()), toGui(e->getMax()));
1421                         else
1422                                 drawEntityPlain(e, patternOffset);
1423                 }
1424                 // all images as rectangles:
1425                 else if (e->rtti() == RS2::EntityImage)
1426                         painter->drawRect(toGui(e->getMin()), toGui(e->getMax()));
1427                 // hide hatches:
1428                 else if (e->rtti() == RS2::EntityHatch)
1429                 {
1430                         // nothing
1431                 }
1432                 else
1433                         drawEntityPlain(e, patternOffset);
1434         }
1435         else
1436                 drawEntityPlain(e, patternOffset);
1437
1438         // draw reference points:
1439         if (e->isSelected())
1440         {
1441                 if (!e->isParentSelected())
1442                 {
1443                         VectorSolutions s = e->getRefPoints();
1444
1445                         for(int i=0; i<s.getNumber(); ++i)
1446                         {
1447                                 int sz = -1;
1448                                 RS_Color col = RS_Color(0, 0, 255);
1449
1450                                 if (e->rtti() == RS2::EntityPolyline)
1451                                 {
1452                                         if (i == 0 || i == s.getNumber() - 1)
1453                                         {
1454                                                 if (i == 0)
1455                                                 {
1456                                                         sz = 4;
1457 //                                                      col = QColor(0, 64, 255);
1458                                                         col = RS_Color(0, 64, 255);
1459                                                 }
1460                                                 else
1461                                                 {
1462                                                         sz = 3;
1463 //                                                      col = QColor(0, 0, 128);
1464                                                         col = RS_Color(0, 0, 128);
1465                                                 }
1466                                         }
1467                                 }
1468
1469                                 if (getDeleteMode())
1470                                         painter->drawHandle(toGui(s.get(i)), background, sz);
1471                                 else
1472                                         painter->drawHandle(toGui(s.get(i)), col, sz);
1473                         }
1474                 }
1475         }
1476
1477         //RS_DEBUG->print("draw plain OK");
1478         //RS_DEBUG->print("RS_GraphicView::drawEntity() end");
1479 }
1480
1481 /**
1482  * Deletes an entity with the background color.
1483  * Might be recusively called e.g. for polylines.
1484  */
1485 void RS_GraphicView::deleteEntity(RS_Entity * e)
1486 {
1487         setDeleteMode(true);
1488         drawEntity(e);
1489         setDeleteMode(false);
1490 }
1491
1492 /**
1493  * Draws an entity.
1494  * The painter must be initialized and all the attributes (pen) must be set.
1495  */
1496 void RS_GraphicView::drawEntityPlain(RS_Entity * e, double patternOffset)
1497 {
1498         if (e == NULL)
1499 //{
1500 //printf("RS_GraphicView::drawEntityPlain(): Entity passed in is NULL!\n");
1501                 return;
1502 //}
1503
1504 //printf("RS_GraphicView::drawEntityPlain(): Passing in painter=%08X, view=%08X\n", painter, this);
1505         e->draw(painter, this, patternOffset);
1506 }
1507
1508 /**
1509  * Simulates this drawing in slow motion.
1510  */
1511 void RS_GraphicView::simulateIt()
1512 {
1513         if (simulationRunning)
1514                 return;
1515
1516         simulationRunning = true;
1517         simulationLast = Vector(0.0, 0.0);
1518
1519         destroyPainter();
1520
1521         createDirectPainter();
1522         painter->erase();
1523
1524         // drawing paper border:
1525         if (isPrintPreview())
1526                 drawPaper();
1527
1528         // drawing meta grid:
1529         if (!isPrintPreview())
1530                 drawMetaGrid();
1531
1532         // drawing grid:
1533         if (!isPrintPreview())
1534                 drawGrid();
1535
1536         //if (draftMode) {
1537         //painter->setPen(RS_Pen(foreground,
1538         //      RS2::Width00, RS2::SolidLine));
1539         //}
1540
1541         // drawing entities:
1542         RS_Pen pen(foreground, RS2::Width00, RS2::SolidLine);
1543         simulateEntity(container, pen);
1544
1545         //RS_DEBUG->timestamp();
1546         //RS_DEBUG->print(" draw zero..");
1547
1548         // drawing zero points:
1549         if (!isPrintPreview())
1550         {
1551                 drawAbsoluteZero();
1552                 drawRelativeZero();
1553         }
1554
1555         //RS_DEBUG->timestamp();
1556         //RS_DEBUG->print(" draw grid..");
1557
1558         //RS_DEBUG->timestamp();
1559         //RS_DEBUG->print("RS_GraphicView::drawIt() end");
1560         //if (painterCreated==true) {
1561         destroyPainter();
1562         //}
1563         simulationRunning = false;
1564 }
1565
1566 /**
1567  * Simulates the given entity.
1568  *
1569  * @param smooth If true, the entity will be drawn slowly (pixel by pixel).
1570  */
1571 void RS_GraphicView::simulateEntity(RS_Entity * e, const RS_Pen & pen)
1572 {
1573         if (painter == NULL || e == NULL)
1574                 return;
1575
1576         if (e->isContainer())
1577         {
1578                 RS_EntityContainer * ec = (RS_EntityContainer *)e;
1579
1580                 for(RS_Entity* en=ec->firstEntity(RS2::ResolveNone);
1581                                 en!=NULL; en = ec->nextEntity(RS2::ResolveNone))
1582                 {
1583                         if (en->isVisible() && en->isUndone() == false)
1584                         {
1585                                 // draw rapid move:
1586                                 if (en->isAtomic() && simulationRapid)
1587                                 {
1588                                         Vector sp = ((RS_AtomicEntity *)en)->getStartpoint();
1589
1590                                         if (sp.distanceTo(simulationLast) > 1.0e-4)
1591                                         {
1592                                                 createDirectPainter();
1593                                                 RS_Pen rpen(RS_Color(0, 0, 255), RS2::Width00, RS2::SolidLine);
1594                                                 //painter->setPen(pen);
1595                                                 RS_Line rapidLine(NULL, RS_LineData(simulationLast, sp));
1596                                                 simulateEntity(&rapidLine, rpen);
1597                                         }
1598                                 }
1599
1600                                 if (en->isHighlighted())
1601                                 {
1602                                         RS_Pen hpen(highlightedColor, RS2::Width00, RS2::SolidLine);
1603                                         simulateEntity(en, hpen);
1604                                 }
1605                                 else
1606                                         simulateEntity(en, pen);
1607
1608                                 if (en->isAtomic())
1609                                         simulationLast = ((RS_AtomicEntity *)en)->getEndpoint();
1610
1611                                 if (!simulationSmooth)
1612                                         simulationDelay(true);
1613                         }
1614                 }
1615         }
1616         else
1617         {
1618                 if (simulationSmooth)
1619                 {
1620                         switch (e->rtti())
1621                         {
1622                         case RS2::EntityLine:
1623                         {
1624                                 RS_Line * line = (RS_Line *)e;
1625                                 drawLineSmooth(toGui(line->getStartpoint()), toGui(line->getEndpoint()), pen);
1626                                         //simulationSpeed);
1627                         }
1628                                 break;
1629
1630                         case RS2::EntityArc:
1631                         {
1632                                 RS_Arc * arc = (RS_Arc *)e;
1633                                 drawArcSmooth(toGui(arc->getCenter()), toGuiDX(arc->getRadius()),
1634                                         arc->getAngle1(), arc->getAngle2(), arc->isReversed(), pen);
1635                         }
1636                                 break;
1637
1638                         case RS2::EntityCircle:
1639                         {
1640                                 RS_Circle * circle = (RS_Circle *)e;
1641                                 drawArcSmooth(toGui(circle->getCenter()), toGuiDX(circle->getRadius()),
1642                                         0.0, 2.0 * M_PI, false, pen);
1643                         }
1644                                 break;
1645
1646                         default:
1647                                 break;
1648                         }
1649                 }
1650                 else
1651                 {
1652                         createDirectPainter();
1653                         //RS_Pen pen(foreground, RS2::Width00, RS2::SolidLine);
1654                         painter->setPen(pen);
1655                         drawEntityPlain(e);
1656                 }
1657         }
1658 }
1659
1660 /**
1661  * Delay for slow motion simulation.
1662  *
1663  * @param step true: stepping mode (entity by entity simulation). adds a delay.
1664  */
1665 void RS_GraphicView::simulationDelay(bool step)
1666 {
1667         int delay;
1668         settings.beginGroup("CAM");
1669         double fact = settings.value("SimulationFactor", 12000.0).toDouble();
1670         settings.endGroup();
1671
1672         // simulationSpeed: 0..100
1673
1674 #ifdef __APPLE__
1675         delay = (int)(((1.0 / (simulationSpeed + 1.0)) * fact) - (fact / 100.0));
1676         if (step)
1677                 delay *= 16;
1678
1679         //usleep(delay);
1680         static int call = 0;
1681
1682         if (call >= (fact - delay) / 1000)
1683         {
1684                 call = 0;
1685                 for(int i=0; i<delay; ++i)
1686                         RS_APP->processEvents(10);
1687         }
1688         else
1689                 call++;
1690 #else
1691         delay = (int)(((1.0 / (simulationSpeed + 1.0)) * fact) - (fact / 100.0));
1692
1693         if (step)
1694         {
1695                 delay *= 16;
1696         }
1697
1698         for(int i=0; i<delay; ++i)
1699         {
1700 #warning "Qt3->4 conversion: commented out problem line... !!! FIX !!!"
1701 //        RS_APP->processEvents(10);
1702         }
1703 #endif
1704 }
1705
1706 /**
1707  * Draws a line slowly from (x1, y1) to (x2, y2). This is used for simulation only.
1708  */
1709 void RS_GraphicView::drawLineSmooth(const Vector & p1, const Vector & p2, const RS_Pen & pen)
1710 {
1711         double alpha = p1.angleTo(p2);
1712         double xStep, yStep;
1713         bool  xIsOne;
1714
1715         if (RS_Math::cmpDouble(alpha, 0.0) || RS_Math::cmpDouble(alpha, 2 * M_PI))
1716         {
1717                 xStep = 1.0;
1718                 yStep = 0.0;
1719                 xIsOne = true;
1720         }
1721         else if (RS_Math::cmpDouble(alpha, M_PI / 2.0))
1722         {
1723                 xStep = 0.0;
1724                 yStep = 1.0;
1725                 xIsOne = false;
1726         }
1727         else if (RS_Math::cmpDouble(alpha, M_PI))
1728         {
1729                 xStep = -1.0;
1730                 yStep = 0.0;
1731                 xIsOne = true;
1732         }
1733         else if (RS_Math::cmpDouble(alpha, M_PI / 2.0 * 3.0))
1734         {
1735                 xStep = 0.0;
1736                 yStep = -1.0;
1737                 xIsOne = false;
1738         }
1739         else if (fabs(p2.x - p1.x) > fabs(p2.y - p1.y))
1740         {
1741                 if (p2.x > p1.x)
1742                         xStep = 1.0;
1743                 else
1744                         xStep = -1.0;
1745
1746                 yStep = tan(alpha) * xStep;
1747                 xIsOne = true;
1748         }
1749         else
1750         {
1751                 if (p2.y > p1.y)
1752                         yStep = 1.0;
1753                 else
1754                         yStep = -1.0;
1755
1756                 xStep = yStep / tan(alpha);
1757                 xIsOne = false;
1758         }
1759
1760         double lx = p1.x;
1761         double ly = p1.y;
1762         //RS_Pen pen(foreground, RS2::Width00, RS2::SolidLine);
1763
1764         do
1765         {
1766                 if (lx >= 0.0 && lx <= (double)getWidth() && ly >= 0.0 && ly <= (double)getHeight())
1767                 {
1768                         //if (painter==NULL) {
1769                         createDirectPainter();
1770                         //}
1771                         painter->setPen(pen);
1772                         painter->drawGridPoint(Vector(lx, ly));
1773
1774                         simulationDelay();
1775                 }
1776
1777                 lx += xStep;
1778                 ly += yStep;
1779
1780         }
1781         while ((xIsOne && ((lx >= p1.x && lx <= p2.x) || (lx >= p2.x && lx <= p1.x)))
1782                 || (!xIsOne && ((ly >= p1.y && ly <= p2.y) || (ly >= p2.y && ly <= p1.y))));
1783 }
1784
1785 void RS_GraphicView::drawArcSmooth(const Vector & center, double radius, double a1, double a2, bool rev,
1786         const RS_Pen & pen)
1787 {
1788         //int icx = graphic->realToScreenX(cx);
1789         //int icy = graphic->realToScreenY(cy);
1790         //RS_Pen pen(foreground, RS2::Width00, RS2::SolidLine);
1791
1792         if (radius <= 1.4)
1793         {
1794                 createDirectPainter();
1795                 painter->setPen(pen);
1796                 painter->drawGridPoint(center);
1797         }
1798         else
1799         {
1800                 int ix1 = RS_Math::round(center.x + cos(a1) * radius);
1801                 int iy1 = RS_Math::round(center.y - sin(a1) * radius);
1802                 int ix2 = RS_Math::round(center.x + cos(a2) * radius);
1803                 int iy2 = RS_Math::round(center.y - sin(a2) * radius);
1804                 int k2x = 0;            // Next point on circle
1805                 int k2y = 0;            //
1806                 int k1x = ix1;          // Prev point on circle
1807                 int k1y = iy1;          //
1808                 double aStep;          // Angle Step (rad)
1809                 double a;              // Actual Angle (rad)
1810                 double a2cp = a2;      // Copy of a2
1811
1812                 if (1.0 / (radius * factor.x) <= 1.0)
1813                         aStep = asin(1.0 / (radius * factor.x));
1814                 else
1815                         aStep = 0.01;
1816
1817                 if (aStep < 0.01)
1818                         aStep = 0.01;
1819
1820                 if (!rev)
1821                 {
1822                         // Arc Counterclockwise:
1823                         //
1824                         if (a1 > a2cp - 0.01)
1825                                 a2cp += 2 * M_PI;
1826
1827                         //if (painter==NULL) {
1828                         //painter->setPen(pen);
1829                         //createDirectPainter();
1830                         //}
1831                         //painter->moveTo(ix1, iy1);
1832
1833                         for(a=a1+aStep; a<=a2cp; a+=aStep)
1834                         {
1835                                 k2x = RS_Math::round(center.x+cos(a)*radius);
1836                                 k2y = RS_Math::round(center.y-sin(a)*radius);
1837                                 //if(graphic->isPointOnScreen(k2x, k2y) ||
1838                                 //   graphic->isPointOnScreen(k1x, k1y)    ) {
1839                                 createDirectPainter();
1840                                 painter->setPen(pen);
1841                                 if ((k2x >= 0 && k2x <= painter->getWidth()
1842                                         && k2y >= 0 && k2y <= painter->getHeight())
1843                                         || (k1x >= 0 && k1x <= painter->getWidth()
1844                                         && k1y >= 0 && k1y <= painter->getHeight()))
1845                                 {
1846                                         //painter->lineTo(k2x, k2y);
1847                                         painter->drawLine(Vector(k1x, k1y), Vector(k2x, k2y));
1848                                         simulationDelay();
1849                                         //graphic->simulationDelay();
1850                                 }
1851                                 //createDirectPainter();
1852                                 //painter->setPen(pen);
1853                                 //painter->moveTo(k2x, k2y);
1854
1855                                 k1x = k2x;
1856                                 k1y = k2y;
1857                         }
1858
1859                         createDirectPainter();
1860                         painter->setPen(pen);
1861                         painter->drawLine(Vector(k2x, k2y), Vector(ix2, iy2));
1862                         //painter->lineTo(ix2, iy2);
1863                 }
1864                 else
1865                 {
1866                         // Arc Clockwise:
1867                         //
1868                         if (a1 < a2cp + 0.01)
1869                                 a2cp -= 2 * M_PI;
1870
1871                         //createDirectPainter();
1872                         //painter->setPen(pen);
1873                         //painter->moveTo(ix1, iy1);
1874                         for(a=a1-aStep; a>=a2cp; a-=aStep)
1875                         {
1876                                 k2x = RS_Math::round(center.x + cos(a) * radius);
1877                                 k2y = RS_Math::round(center.y - sin(a) * radius);
1878                                 //if(graphic->isPointOnScreen(k2x, k2y) ||
1879                                 //        graphic->isPointOnScreen(k1x, k1y)    ) {
1880                                 createDirectPainter();
1881                                 painter->setPen(pen);
1882                                 if ((k2x >=0 && k2x <= painter->getWidth()
1883                                         && k2y >= 0 && k2y <= painter->getHeight())
1884                                         || (k1x >= 0 && k1x <= painter->getWidth()
1885                                         && k1y >= 0 && k1y <= painter->getHeight()))
1886                                 {
1887                                         //painter->lineTo(k2x, k2y);
1888                                         painter->drawLine(Vector(k1x, k1y), Vector(k2x, k2y));
1889                                         simulationDelay();
1890                                 }
1891                                 //createDirectPainter();
1892                                 //painter->setPen(pen);
1893                                 //painter->moveTo(k2x, k2y);
1894                                 k1x = k2x;
1895                                 k1y = k2y;
1896                         }
1897
1898                         createDirectPainter();
1899                         painter->setPen(pen);
1900                         //painter->lineTo(ix2, iy2);
1901                         painter->drawLine(Vector(k2x, k2y), Vector(ix2, iy2));
1902                 }
1903         }
1904 }
1905
1906 /**
1907  * @return Pointer to the static pattern struct that belongs to the
1908  * given pattern type or NULL.
1909  */
1910 RS_LineTypePattern * RS_GraphicView::getPattern(RS2::LineType t)
1911 {
1912         switch (t)
1913         {
1914         case RS2::SolidLine:
1915                 return &patternSolidLine;
1916                 break;
1917
1918         case RS2::DotLine:
1919                 return &patternDotLine;
1920                 break;
1921         case RS2::DotLine2:
1922                 return &patternDotLine2;
1923                 break;
1924         case RS2::DotLineX2:
1925                 return &patternDotLineX2;
1926                 break;
1927
1928         case RS2::DashLine:
1929                 return &patternDashLine;
1930                 break;
1931         case RS2::DashLine2:
1932                 return &patternDashLine2;
1933                 break;
1934         case RS2::DashLineX2:
1935                 return &patternDashLineX2;
1936                 break;
1937
1938         case RS2::DashDotLine:
1939                 return &patternDashDotLine;
1940                 break;
1941         case RS2::DashDotLine2:
1942                 return &patternDashDotLine2;
1943                 break;
1944         case RS2::DashDotLineX2:
1945                 return &patternDashDotLineX2;
1946                 break;
1947
1948         case RS2::DivideLine:
1949                 return &patternDivideLine;
1950                 break;
1951         case RS2::DivideLine2:
1952                 return &patternDivideLine2;
1953                 break;
1954         case RS2::DivideLineX2:
1955                 return &patternDivideLineX2;
1956                 break;
1957
1958         case RS2::CenterLine:
1959                 return &patternCenterLine;
1960                 break;
1961         case RS2::CenterLine2:
1962                 return &patternCenterLine2;
1963                 break;
1964         case RS2::CenterLineX2:
1965                 return &patternCenterLineX2;
1966                 break;
1967
1968         case RS2::BorderLine:
1969                 return &patternBorderLine;
1970                 break;
1971         case RS2::BorderLine2:
1972                 return &patternBorderLine2;
1973                 break;
1974         case RS2::BorderLineX2:
1975                 return &patternBorderLineX2;
1976                 break;
1977
1978         case RS2::LineByLayer:
1979                 return &patternBlockLine;
1980                 break;
1981         case RS2::LineByBlock:
1982                 return &patternBlockLine;
1983                 break;
1984         default:
1985                 break;
1986         }
1987
1988         return NULL;
1989 }
1990
1991 /**
1992  * This virtual method can be overwritten to draw the absolute
1993  * zero. It's called from within drawIt(). The default implemetation
1994  * draws a simple red round zero point.
1995  *
1996  * @see drawIt()
1997  */
1998 void RS_GraphicView::drawAbsoluteZero()
1999 {
2000 //RS_DEBUG->print(RS_Debug::D_CRITICAL, "RS_GraphicView::drawAbsoluteZero (painter=%08X)", painter);
2001 //      bool painterCreated = false;
2002
2003         // create a temporary painter device
2004         if (painter == NULL)
2005         {
2006                 return;
2007 //Hrm.          createDirectPainter();
2008 //              createPainter();
2009 //              painterCreated = true;
2010         }
2011
2012         int zr = 20;
2013
2014 //      RS_Pen pen(metaGridColor, RS2::Width00, RS2::SolidLine);
2015 //      painter->setPen(pen);
2016 //      RS_Pen p(Qt::red, RS2::Width00, RS2::SolidLine);
2017 //Using Qt::red doesn't seem to work here...
2018 //It's because Qt colors and RS_Color are not 100% compatible...
2019         RS_Pen p(RS_Color(255, 0, 0), RS2::Width00, RS2::SolidLine);
2020 //      p.setScreenWidth(0);
2021         painter->setPen(p);
2022         //painter->setBrush(Qt::NoBrush);
2023
2024         painter->drawLine(Vector(toGuiX(0.0) - zr, toGuiY(0.0)),
2025                 Vector(toGuiX(0.0) + zr, toGuiY(0.0)));
2026
2027         painter->drawLine(Vector(toGuiX(0.0), toGuiY(0.0) - zr),
2028                 Vector(toGuiX(0.0), toGuiY(0.0) + zr));
2029
2030 //      if (painterCreated)
2031 //              destroyPainter();
2032 }
2033
2034 /**
2035  * This virtual method can be overwritten to draw the relative
2036  * zero point. It's called from within drawIt(). The default implemetation
2037  * draws a simple red round zero point.
2038  *
2039  * @see drawIt()
2040  */
2041 void RS_GraphicView::drawRelativeZero()
2042 {
2043 //#warning "!!! drawRelativeZero() not working AT ALL !!!"
2044 #if 1
2045 //      bool painterCreated = false;
2046
2047         if (relativeZero.valid == false)
2048                 return;
2049
2050         // create a temporary painter device
2051         if (painter == NULL)
2052         {
2053                 return;
2054 //hrm.          createDirectPainter();
2055 //              createPainter();
2056 //              painterCreated = true;
2057         }
2058
2059 //      RS_Pen p(Qt::red, RS2::Width00, RS2::SolidLine);
2060 //      p.setScreenWidth(0);
2061 //Using Qt::red doesn't seem to work here...
2062         RS_Pen p(RS_Color(255, 0, 0), RS2::Width00, RS2::SolidLine);
2063         painter->setPen(p);
2064         painter->setXORMode();
2065
2066         int zr = 5;
2067
2068         painter->drawLine(Vector(toGuiX(relativeZero.x) - zr, toGuiY(relativeZero.y)),
2069                 Vector(toGuiX(relativeZero.x) + zr, toGuiY(relativeZero.y)));
2070
2071         painter->drawLine(Vector(toGuiX(relativeZero.x), toGuiY(relativeZero.y) - zr),
2072                 Vector(toGuiX(relativeZero.x), toGuiY(relativeZero.y) + zr));
2073
2074         painter->drawCircle(toGui(relativeZero), zr);
2075
2076         painter->setNormalMode();
2077
2078 //      if (painterCreated)
2079 //              destroyPainter();
2080 #endif
2081 }
2082
2083 /**
2084  * Draws the paper border (for print previews).
2085  *
2086  * @see drawIt()
2087  */
2088 void RS_GraphicView::drawPaper()
2089 {
2090         bool painterCreated = false;
2091
2092         if (container == NULL)
2093                 return;
2094
2095         Drawing * graphic = container->getGraphic();
2096
2097         if (graphic == NULL)
2098                 return;
2099
2100         if (graphic->getPaperScale() < 1.0e-6)
2101                 return;
2102
2103         // create a temporary painter device
2104         if (painter == NULL)
2105         {
2106                 createDirectPainter();
2107                 painterCreated = true;
2108         }
2109
2110         // draw paper:
2111         painter->setPen(RS_Pen(Qt::gray));
2112
2113         Vector pinsbase = graphic->getPaperInsertionBase();
2114         Vector size = graphic->getPaperSize();
2115         double scale = graphic->getPaperScale();
2116
2117         Vector v1 = toGui((Vector(0, 0) - pinsbase) / scale);
2118         Vector v2 = toGui((size - pinsbase) / scale);
2119
2120         // gray background:
2121         painter->fillRect(0,0, getWidth(), getHeight(), RS_Color(200, 200, 200));
2122
2123         // shadow
2124         painter->fillRect((int)(v1.x) + 6, (int)(v1.y) + 6,
2125                 (int)((v2.x - v1.x)), (int)((v2.y - v1.y)),
2126                 RS_Color(64, 64, 64));
2127
2128         // border:
2129         painter->fillRect((int)(v1.x), (int)(v1.y),
2130                 (int)((v2.x - v1.x)), (int)((v2.y - v1.y)),
2131                 RS_Color(64, 64, 64));
2132
2133         // paper
2134         painter->fillRect((int)(v1.x) + 1, (int)(v1.y) - 1,
2135                 (int)((v2.x - v1.x)) - 2, (int)((v2.y - v1.y)) + 2,
2136                 RS_Color(255, 255, 255));
2137
2138         if (painterCreated)
2139                 destroyPainter();
2140 }
2141
2142 /**
2143  * Draws the grid.
2144  *
2145  * @see drawIt()
2146  */
2147 void RS_GraphicView::drawGrid()
2148 {
2149         if (grid == NULL || isGridOn() == false)
2150 //      {
2151 //              printf("RS_GraphicView::drawGrid(): Aborting: grid=%08X, isGridOn=%s\n", grid, (isGridOn() ? "true" : "false"));
2152                 return;
2153 //      }
2154
2155         // draw grid:
2156         //painter->setPen(Qt::gray);
2157         painter->setPen(gridColor);
2158 //      painter->setPen(RS_Pen(RS_Color(128, 128, 128), RS2::Width00, RS2::SolidLine));
2159
2160 //Problem here: pts is NULL!
2161         Vector * pts = grid->getPoints();
2162
2163         if (pts != NULL)
2164         {
2165                 for(int i=0; i<grid->count(); ++i)
2166                         painter->drawGridPoint(toGui(pts[i]));
2167         }
2168 //      else
2169 //              printf("RS_GraphicView::drawGrid(): pts == NULL!\n");
2170
2171         // draw grid info:
2172         //painter->setPen(Qt::white);
2173         QString info = grid->getInfo();
2174         //info = QString("%1 / %2")
2175         //       .arg(grid->getSpacing())
2176         //       .arg(grid->getMetaSpacing());
2177
2178         updateGridStatusWidget(info);
2179 }
2180
2181 /**
2182  * Draws the meta grid.
2183  *
2184  * @see drawIt()
2185  */
2186 void RS_GraphicView::drawMetaGrid()
2187 {
2188         if (grid == NULL || isGridOn() == false /*|| grid->getMetaSpacing()<0.0*/)
2189                 return;
2190
2191         bool painterCreated = false;
2192
2193         // create a temporary painter device
2194         if (painter == NULL)
2195         {
2196 //hrm           createDirectPainter();
2197                 createPainter();
2198                 painterCreated = true;
2199         }
2200
2201         RS_Pen pen(metaGridColor, RS2::Width00, RS2::DotLine);
2202         painter->setPen(pen);
2203
2204         // draw meta grid:
2205         double * mx = grid->getMetaX();
2206
2207         if (mx != NULL)
2208         {
2209                 for(int i=0; i<grid->countMetaX(); ++i)
2210                         painter->drawLine(Vector(toGuiX(mx[i]), 0), Vector(toGuiX(mx[i]), getHeight()));
2211         }
2212
2213         double * my = grid->getMetaY();
2214
2215         if (my != NULL)
2216         {
2217                 for(int i=0; i<grid->countMetaY(); ++i)
2218                         painter->drawLine(Vector(0, toGuiY(my[i])), Vector(getWidth(), toGuiY(my[i])));
2219         }
2220
2221         if (painterCreated)
2222                 destroyPainter();
2223 }
2224
2225 /**
2226  * Updates the grid if there is one.
2227  */
2228 void RS_GraphicView::updateGrid()
2229 {
2230         if (grid != NULL)
2231                 grid->update();
2232 }
2233
2234 RS_Grid * RS_GraphicView::getGrid()
2235 {
2236         return grid;
2237 }
2238
2239 void RS_GraphicView::updateGridStatusWidget(const QString & /*text*/)
2240 {
2241 }
2242
2243 RS2::SnapMode RS_GraphicView::getDefaultSnapMode()
2244 {
2245         return defaultSnapMode;
2246 }
2247
2248 RS2::SnapRestriction RS_GraphicView::getSnapRestriction()
2249 {
2250         return defaultSnapRes;
2251 }
2252
2253 /**
2254  * Sets the default snap mode used by newly created actions.
2255  */
2256 void RS_GraphicView::setDefaultSnapMode(RS2::SnapMode sm)
2257 {
2258         defaultSnapMode = sm;
2259
2260         if (eventHandler != NULL)
2261                 eventHandler->setSnapMode(sm);
2262 }
2263
2264 /**
2265  * Sets a snap restriction (e.g. orthogonal).
2266  */
2267 void RS_GraphicView::setSnapRestriction(RS2::SnapRestriction sr)
2268 {
2269         defaultSnapRes = sr;
2270
2271         if (eventHandler != NULL)
2272                 eventHandler->setSnapRestriction(sr);
2273 }
2274
2275 /**
2276  * Translates a vector in real coordinates to a vector in screen coordinates.
2277  */
2278 Vector RS_GraphicView::toGui(Vector v)
2279 {
2280         return Vector(toGuiX(v.x), toGuiY(v.y), 0.0);
2281 }
2282
2283 /**
2284  * Translates a real coordinate in X to a screen coordinate X.
2285  * @param visible Pointer to a boolean which will contain true
2286  * after the call if the coordinate is within the visible range.
2287  */
2288 double RS_GraphicView::toGuiX(double x, bool * visible)
2289 {
2290         if (visible != NULL)
2291         {
2292                 double res = x * factor.x + offsetX;
2293
2294                 if (res > 0.0 && res < getWidth())
2295                         *visible = true;
2296                 else
2297                         *visible = false;
2298         }
2299
2300         return x * factor.x + offsetX;
2301 }
2302
2303 /**
2304  * Translates a real coordinate in Y to a screen coordinate Y.
2305  */
2306 double RS_GraphicView::toGuiY(double y)
2307 {
2308         return -y * factor.y + getHeight() - offsetY;
2309 }
2310
2311 /**
2312  * Translates a real coordinate distance to a screen coordinate distance.
2313  */
2314 double RS_GraphicView::toGuiDX(double d)
2315 {
2316         return d * factor.x;
2317 }
2318
2319 /**
2320  * Translates a real coordinate distance to a screen coordinate distance.
2321  */
2322 double RS_GraphicView::toGuiDY(double d)
2323 {
2324         return d * factor.y;
2325 }
2326
2327 /**
2328  * Translates a vector in screen coordinates to a vector in real coordinates.
2329  */
2330 Vector RS_GraphicView::toGraph(Vector v)
2331 {
2332         return Vector(toGraphX(RS_Math::round(v.x)), toGraphY(RS_Math::round(v.y)), 0.0);
2333 }
2334
2335 /**
2336  * Translates two screen coordinates to a vector in real coordinates.
2337  */
2338 Vector RS_GraphicView::toGraph(int x, int y)
2339 {
2340         return Vector(toGraphX(x), toGraphY(y), 0.0);
2341 }
2342
2343 /**
2344  * Translates a screen coordinate in X to a real coordinate X.
2345  */
2346 double RS_GraphicView::toGraphX(int x)
2347 {
2348         return (x - offsetX) / factor.x;
2349 }
2350
2351 /**
2352  * Translates a screen coordinate in Y to a real coordinate Y.
2353  */
2354 double RS_GraphicView::toGraphY(int y)
2355 {
2356         return -(y - getHeight() + offsetY) / factor.y;
2357 }
2358
2359 /**
2360  * Translates a screen coordinate distance to a real coordinate distance.
2361  */
2362 double RS_GraphicView::toGraphDX(int d)
2363 {
2364         return d / factor.x;
2365 }
2366
2367 /**
2368  * Translates a screen coordinate distance to a real coordinate distance.
2369  */
2370 double RS_GraphicView::toGraphDY(int d)
2371 {
2372         return d / factor.y;
2373 }
2374
2375 /**
2376  * (Un-)Locks the position of the relative zero.
2377  *
2378  * @param lock true: lock, false: unlock
2379  */
2380 void RS_GraphicView::lockRelativeZero(bool lock)
2381 {
2382         relativeZeroLocked=lock;
2383 }
2384
2385 /**
2386  * @return true if the position of the realtive zero point is
2387  * locked.
2388  */
2389 bool RS_GraphicView::isRelativeZeroLocked()
2390 {
2391         return relativeZeroLocked;
2392 }
2393
2394 /**
2395  * @return Relative zero coordinate.
2396  */
2397 Vector RS_GraphicView::getRelativeZero()
2398 {
2399         return relativeZero;
2400 }
2401
2402 /**
2403  * Sets the relative zero coordinate (if not locked)
2404  * without deleting / drawing the point.
2405  */
2406 void RS_GraphicView::setRelativeZero(const Vector & pos)
2407 {
2408         if (!relativeZeroLocked)
2409                 relativeZero = pos;
2410 }
2411
2412 /**
2413  * Sets the relative zero coordinate, deletes the old position
2414  * on the screen and draws the new one.
2415  */
2416 void RS_GraphicView::moveRelativeZero(const Vector & pos)
2417 {
2418 //      bool painterCreated = false;
2419
2420         if (painter == NULL)
2421         {
2422                 return;
2423 //hrm           painter = createDirectPainter();
2424 //              painter = createPainter();
2425 //              painterCreated = true;
2426         }
2427
2428         //painter->setXORMode();
2429         drawRelativeZero();
2430
2431         setRelativeZero(pos);
2432
2433         drawRelativeZero();
2434
2435 //      if (painterCreated)
2436 //              destroyPainter();
2437 }
2438
2439 RS_EventHandler * RS_GraphicView::getEventHandler()
2440 {
2441         return eventHandler;
2442 }
2443
2444 /**
2445  * Enables or disables print preview.
2446  */
2447 void RS_GraphicView::setPrintPreview(bool pv)
2448 {
2449         printPreview = pv;
2450 }
2451
2452 /**
2453  * @retval true This is a print preview graphic view.
2454  * @retval false Otherwise.
2455  */
2456 bool RS_GraphicView::isPrintPreview()
2457 {
2458         return printPreview;
2459 }
2460
2461 /**
2462  * Enables or disables printing.
2463  */
2464 void RS_GraphicView::setPrinting(bool p)
2465 {
2466         printing = p;
2467 }
2468
2469 /**
2470  * @retval true This is a a graphic view for printing.
2471  * @retval false Otherwise.
2472  */
2473 bool RS_GraphicView::isPrinting()
2474 {
2475         return printing;
2476 }
2477
2478 /**
2479  * @retval true Draft mode is on for this view (all lines with 1 pixel / no style scaling).
2480  * @retval false Otherwise.
2481  */
2482 bool RS_GraphicView::isDraftMode()
2483 {
2484         return draftMode;
2485 }
2486
2487 /**
2488  * Sets the simulation speed in percentage.
2489  */
2490 void RS_GraphicView::setSimulationSpeed(int s)
2491 {
2492         simulationSpeed = s;
2493 }
2494
2495 /**
2496  * @return the simulation speed in percentage.
2497  */
2498 int RS_GraphicView::getSimulationSpeed()
2499 {
2500         return simulationSpeed;
2501 }
2502
2503 /**
2504  * Sets the simulation smooth mode.
2505  */
2506 void RS_GraphicView::setSimulationSmooth(bool s)
2507 {
2508         simulationSmooth = s;
2509 }
2510 /**
2511  * Sets the simulation rapid mode.
2512  */
2513 void RS_GraphicView::setSimulationRapid(bool r)
2514 {
2515         simulationRapid = r;
2516 }
2517
2518 /**
2519  * @return the simulation rapid mode.
2520  */
2521 bool RS_GraphicView::getSimulationRapid()
2522 {
2523         return simulationRapid;
2524 }
2525
2526 // These functions are here because of the focacta way that this
2527 // program set up its rendering...
2528 void RS_GraphicView::SetPreviewMode(bool mode/*= true*/)
2529 {
2530         previewMode = mode;
2531 }
2532
2533 void RS_GraphicView::SetPreviewEntity(RS_Preview * p)
2534 {
2535         previewEntity = p;
2536 }
2537
2538 void RS_GraphicView::SetPreviewOffset(Vector o)
2539 {
2540         previewOffset = o;
2541 }
2542
2543 void RS_GraphicView::SetSnapperDraw(bool mode)
2544 {
2545         snapperDraw = mode;
2546 }
2547
2548 void RS_GraphicView::SetSnapperVars(Vector snapSpot, Vector snapCoord, bool showCrosshairs)
2549 {
2550         snapSpot1 = snapSpot;
2551         snapCoord1 = snapCoord;
2552         showCrosshairs1 = showCrosshairs;
2553 }