• Skip to content
  • Skip to link menu
KDE API Reference
  • KDE API Reference
  • kdeedu API Reference
  • KDE Home
  • Contact Us
 

kig

  • sources
  • kde-4.14
  • kdeedu
  • kig
  • kig
kig_part.cpp
Go to the documentation of this file.
1 
21 #include "kig_part.h"
22 #include "kig_part.moc"
23 
24 #include "aboutdata.h"
25 #include "kig_commands.h"
26 #include "kig_document.h"
27 #include "kig_view.h"
28 
29 #include "../filters/exporter.h"
30 #include "../filters/filter.h"
31 #include "../misc/builtin_stuff.h"
32 #include "../misc/calcpaths.h"
33 #include "../misc/coordinate_system.h"
34 #include "../misc/guiaction.h"
35 #include "../misc/kigcoordinateprecisiondialog.h"
36 #include "../misc/kigpainter.h"
37 #include "../misc/lists.h"
38 #include "../misc/object_constructor.h"
39 #include "../misc/screeninfo.h"
40 #include "../modes/normal.h"
41 #include "../objects/object_drawer.h"
42 #include "../objects/point_imp.h"
43 
44 #include <algorithm>
45 #include <functional>
46 #include <iterator>
47 
48 #include <kaction.h>
49 #include <kdebug.h>
50 #include <kdemacros.h>
51 #include <kfiledialog.h>
52 #include <kglobal.h>
53 #include <kiconloader.h>
54 #include <kcomponentdata.h>
55 #include <klocale.h>
56 #include <kxmlguiwindow.h>
57 #include <kactioncollection.h>
58 #include <kmessagebox.h>
59 #include <kmimetype.h>
60 #include <kstandarddirs.h>
61 #include <kstandardaction.h>
62 #include <ktoggleaction.h>
63 #include <ktogglefullscreenaction.h>
64 #include <kundostack.h>
65 #include <kparts/genericfactory.h>
66 #include <kicon.h>
67 #include <kdeprintdialog.h>
68 #include <kprintpreview.h>
69 
70 #include <qbytearray.h>
71 #include <qcheckbox.h>
72 #include <qeventloop.h>
73 #include <qfile.h>
74 #include <qlayout.h>
75 #include <qsizepolicy.h>
76 #include <qtimer.h>
77 #include <QtGui/QPrinter>
78 #include <QtGui/QPrintDialog>
79 
80 using namespace std;
81 
82 static const QString typesFile = "macros.kigt";
83 
84 // export this library...
85 K_PLUGIN_FACTORY( KigPartFactory, registerPlugin< KigPart >(); )
86 K_EXPORT_PLUGIN( KigPartFactory( kigAboutData( "kig", I18N_NOOP( "KigPart" ) ) ) )
87 
88 SetCoordinateSystemAction::SetCoordinateSystemAction(
89  KigPart& d, KActionCollection* parent )
90  : KSelectAction( i18n( "&Set Coordinate System" ), &d),
91  md( d )
92 {
93  setItems( CoordinateSystemFactory::names() );
94  setCurrentItem( md.document().coordinateSystem().id() );
95  connect( this, SIGNAL( triggered( int ) ), this, SLOT( slotActivated( int ) ) );
96  if(parent)
97  parent->addAction("settings_set_coordinate_system", this);
98 }
99 
100 void SetCoordinateSystemAction::slotActivated( int index )
101 {
102  CoordinateSystem* sys = CoordinateSystemFactory::build( index );
103  assert( sys );
104  md.history()->push( KigCommand::changeCoordSystemCommand( md, sys ) );
105  setCurrentItem( index );
106 }
107 
108 class KigPrintDialogPage
109  : public QWidget
110 {
111 public:
112  KigPrintDialogPage( QWidget* parent = 0 );
113  ~KigPrintDialogPage();
114 
115  bool printShowGrid();
116  void setPrintShowGrid( bool status );
117 
118  bool printShowAxes();
119  void setPrintShowAxes( bool status );
120 
121  bool isValid( QString& );
122 
123 private:
124  QCheckBox *showgrid;
125  QCheckBox *showaxes;
126 };
127 
128 KigPrintDialogPage::KigPrintDialogPage( QWidget* parent )
129  : QWidget( parent )
130 {
131  setWindowTitle( i18n( "Kig Options" ) );
132 
133  QVBoxLayout* vl = new QVBoxLayout( this );
134 
135  showgrid = new QCheckBox( i18n( "Show grid" ), this );
136  vl->addWidget( showgrid );
137 
138  showaxes = new QCheckBox( i18n( "Show axes" ), this );
139  vl->addWidget( showaxes );
140 
141  vl->addItem( new QSpacerItem( 10, 10, QSizePolicy::Fixed, QSizePolicy::Expanding ) );
142 }
143 
144 KigPrintDialogPage::~KigPrintDialogPage()
145 {
146 }
147 
148 bool KigPrintDialogPage::printShowGrid()
149 {
150  return showgrid->isChecked();
151 }
152 
153 void KigPrintDialogPage::setPrintShowGrid( bool status )
154 {
155  showgrid->setChecked( status );
156 }
157 
158 bool KigPrintDialogPage::printShowAxes()
159 {
160  return showaxes->isChecked();
161 }
162 
163 void KigPrintDialogPage::setPrintShowAxes( bool status )
164 {
165  showaxes->setChecked( status );
166 }
167 
168 bool KigPrintDialogPage::isValid( QString& )
169 {
170  return true;
171 }
172 
173 KigPart::KigPart( QWidget *parentWidget, QObject *parent,
174  const QVariantList& )
175  : KParts::ReadWritePart( parent ),
176  mMode( 0 ), mRememberConstruction( 0 ), mdocument( new KigDocument() )
177 {
178  // we need an instance
179  setComponentData( KigPartFactory::componentData() );
180 
181  mMode = new NormalMode( *this );
182 
183  // we need a widget, to actually show the document
184  m_widget = new KigView( this, false, parentWidget );
185  m_widget->setObjectName( "kig_view" );
186  // notify the part that this is our internal widget
187  setWidget( m_widget );
188 
189  // create our actions...
190  setupActions();
191 
192  // set our XML-UI resource file
193  setXMLFile("kigpartui.rc");
194 
195  // our types...
196  setupTypes();
197 
198  // construct our command history
199  mhistory = new KUndoStack();
200  mhistory->createUndoAction( actionCollection() );
201  mhistory->createRedoAction( actionCollection() );
202  connect( mhistory, SIGNAL( cleanChanged( bool ) ), this, SLOT( setHistoryClean( bool ) ) );
203 
204  // we are read-write by default
205  setReadWrite(true);
206 
207  setModified (false);
208 
209  GUIActionList::instance()->regDoc( this );
210 }
211 
212 void KigPart::setupActions()
213 {
214  // save actions..
215  (void) KStandardAction::saveAs(this, SLOT(fileSaveAs()), actionCollection());
216  (void) KStandardAction::save(this, SLOT(fileSave()), actionCollection());
217 
218  // print actions
219  (void) KStandardAction::print( this, SLOT( filePrint() ), actionCollection() );
220  (void) KStandardAction::printPreview( this, SLOT( filePrintPreview() ), actionCollection() );
221 
222  // selection actions
223  aSelectAll = KStandardAction::selectAll(
224  this, SLOT( slotSelectAll() ), actionCollection() );
225  aDeselectAll = KStandardAction::deselect(
226  this, SLOT( slotDeselectAll() ), actionCollection() );
227  aInvertSelection = new KAction(i18n("Invert Selection"), this);
228  actionCollection()->addAction("edit_invert_selection", aInvertSelection );
229  connect(aInvertSelection, SIGNAL(triggered(bool) ), SLOT( slotInvertSelection() ));
230 
231  // we need icons...
232  KIconLoader* l = iconLoader();
233 
234  aDeleteObjects = new KAction(KIcon("edit-delete"), i18n("&Delete Objects"), this);
235  actionCollection()->addAction("delete_objects", aDeleteObjects );
236  connect(aDeleteObjects, SIGNAL(triggered(bool) ), SLOT(deleteObjects()));
237  aDeleteObjects->setShortcut(QKeySequence(Qt::Key_Delete));
238  aDeleteObjects->setToolTip(i18n("Delete the selected objects"));
239 
240  aCancelConstruction = new KAction(KIcon("process-stop"), i18n("Cancel Construction"), this);
241  actionCollection()->addAction("cancel_construction", aCancelConstruction );
242  connect(aCancelConstruction, SIGNAL(triggered(bool) ), SLOT(cancelConstruction()));
243  aCancelConstruction->setShortcut(QKeySequence(Qt::Key_Escape));
244  aCancelConstruction->setToolTip(
245  i18n("Cancel the construction of the object being constructed"));
246  aCancelConstruction->setEnabled(false);
247 
248  aRepeatLastConstruction = new KAction(KIcon("system-run"), i18n("Repeat Construction"), this);
249  actionCollection()->addAction("repeat_last_construction", aRepeatLastConstruction );
250  connect(aRepeatLastConstruction, SIGNAL(triggered(bool) ), SLOT(repeatLastConstruction()));
251  aRepeatLastConstruction->setShortcut(QKeySequence(Qt::Key_Z));
252  aRepeatLastConstruction->setToolTip(
253  i18n("Repeat the last construction (with new data)"));
254  aRepeatLastConstruction->setEnabled(false);
255 
256  aShowHidden = new KAction(i18n("U&nhide All"), this);
257  actionCollection()->addAction("edit_unhide_all", aShowHidden );
258  connect(aShowHidden, SIGNAL(triggered(bool) ), SLOT( showHidden() ));
259  aShowHidden->setToolTip(i18n("Show all hidden objects"));
260  aShowHidden->setEnabled( true );
261 
262  aNewMacro = new KAction(KIcon("system-run"), i18n("&New Macro..."), this);
263  actionCollection()->addAction("macro_action", aNewMacro );
264  connect(aNewMacro, SIGNAL(triggered(bool) ), SLOT(newMacro()));
265  aNewMacro->setToolTip(i18n("Define a new macro"));
266 
267  aConfigureTypes = new KAction(i18n("Manage &Types..."), this);
268  actionCollection()->addAction("types_edit", aConfigureTypes );
269  connect(aConfigureTypes, SIGNAL(triggered(bool) ), SLOT(editTypes()));
270  aConfigureTypes->setToolTip(i18n("Manage macro types."));
271 
272  aBrowseHistory = new KAction(KIcon("view-history"), i18n("&Browse History..."), this);
273  actionCollection()->addAction("browse_history", aBrowseHistory );
274  connect( aBrowseHistory, SIGNAL( triggered( bool ) ), SLOT( browseHistory() ) );
275  aBrowseHistory->setToolTip( i18n( "Browse the history of the current construction." ) );
276 
277  KigExportManager::instance()->addMenuAction( this, m_widget->realWidget(),
278  actionCollection() );
279 
280  QAction * a = KStandardAction::zoomIn( m_widget, SLOT( slotZoomIn() ),
281  actionCollection() );
282  a->setToolTip( i18n( "Zoom in on the document" ) );
283  a->setWhatsThis( i18n( "Zoom in on the document" ) );
284 
285  a = KStandardAction::zoomOut( m_widget, SLOT( slotZoomOut() ),
286  actionCollection() );
287  a->setToolTip( i18n( "Zoom out of the document" ) );
288  a->setWhatsThis( i18n( "Zoom out of the document" ) );
289 
290  a = KStandardAction::fitToPage( m_widget, SLOT( slotRecenterScreen() ),
291  actionCollection() );
292  // grr.. why isn't there an icon for this..
293  a->setIcon( KIcon( "view_fit_to_page", l ) );
294  a->setToolTip( i18n( "Recenter the screen on the document" ) );
295  a->setWhatsThis( i18n( "Recenter the screen on the document" ) );
296 
297  a = actionCollection()->addAction(KStandardAction::FullScreen, "fullscreen", m_widget, SLOT( toggleFullScreen() ));
298  a->setToolTip( i18n( "View this document full-screen." ) );
299  a->setWhatsThis( i18n( "View this document full-screen." ) );
300 
301  // TODO: an icon for this..
302  a = new KAction(KIcon("zoom-fit-best"), i18n("&Select Shown Area"), this);
303  actionCollection()->addAction("view_select_shown_rect", a );
304  connect(a, SIGNAL(triggered(bool) ), m_widget, SLOT( zoomRect() ));
305  a->setToolTip( i18n( "Select the area that you want to be shown in the window." ) );
306  a->setWhatsThis( i18n( "Select the area that you want to be shown in the window." ) );
307 
308  a = new KAction(KIcon("zoom-original"), i18n("S&elect Zoom Area"), this);
309  actionCollection()->addAction("view_zoom_area", a );
310  connect(a, SIGNAL(triggered(bool) ), m_widget, SLOT( zoomArea() ));
311 // a->setToolTip( i18n( "Select the area that you want to be shown in the window." ) );
312 // a->setWhatsThis( i18n( "Select the area that you want to be shown in the window." ) );
313 
314  aSetCoordinatePrecision = new KAction(i18n("Set Coordinate &Precision..."), this);
315  actionCollection()->addAction("settings_set_coordinate_precision", aSetCoordinatePrecision);
316  aSetCoordinatePrecision->setToolTip( i18n("Set the floating point precision of coordinates in the document. " ));
317  connect(aSetCoordinatePrecision, SIGNAL( triggered() ), this, SLOT( setCoordinatePrecision() ));
318 
319  aToggleGrid = new KToggleAction(i18n("Show &Grid"), this);
320  actionCollection()->addAction("settings_show_grid", aToggleGrid );
321  aToggleGrid->setToolTip( i18n( "Show or hide the grid." ) );
322  aToggleGrid->setChecked( true );
323  connect( aToggleGrid, SIGNAL( triggered() ), this, SLOT( toggleGrid() ) );
324 
325  aToggleAxes = new KToggleAction(i18n("Show &Axes"), this);
326  actionCollection()->addAction("settings_show_axes", aToggleAxes );
327  aToggleAxes->setToolTip( i18n( "Show or hide the axes." ) );
328  aToggleAxes->setChecked( true );
329  connect( aToggleAxes, SIGNAL( triggered() ), this, SLOT( toggleAxes() ) );
330 
331  aToggleNightVision = new KToggleAction(i18n("Wear Infrared Glasses"), this);
332  actionCollection()->addAction("settings_toggle_nightvision", aToggleNightVision );
333  aToggleNightVision->setToolTip( i18n( "Enable/disable hidden objects' visibility." ) );
334  aToggleNightVision->setChecked( false );
335  connect( aToggleNightVision, SIGNAL( triggered() ), this, SLOT( toggleNightVision() ) );
336 
337  // select coordinate system KActionMenu..
338  aCoordSystem = new SetCoordinateSystemAction( *this, actionCollection() );
339 }
340 
341 void KigPart::setupTypes()
342 {
343  setupBuiltinStuff();
344  setupBuiltinMacros();
345  setupMacroTypes();
346  GUIActionList& l = *GUIActionList::instance();
347  typedef GUIActionList::avectype::const_iterator iter;
348  for ( iter i = l.actions().begin(); i != l.actions().end(); ++i )
349  {
350  KigGUIAction* ret = new KigGUIAction( *i, *this );
351  aActions.push_back( ret );
352  ret->plug( this );
353  };
354 }
355 
356 void KigPart::rememberConstruction( ConstructibleAction* ca )
357 {
358  // mp:
359  // mRememberConstruction holds a pointer to the last construction
360  // done by the user, so that it can be quickly repeated
361 
362  mRememberConstruction = ca;
363  aRepeatLastConstruction->setEnabled(true);
364  aRepeatLastConstruction->setText(
365  i18n( "Repeat Construction (%1)", ca->descriptiveName() ) );
366  aRepeatLastConstruction->setToolTip(
367  i18n( "Repeat %1 (with new data)", ca->descriptiveName() ) );
368 }
369 
370 KigPart::~KigPart()
371 {
372  GUIActionList::instance()->unregDoc( this );
373 
374  // save our types...
375  saveTypes();
376 
377  // objects get deleted automatically, when mobjsref gets
378  // destructed..
379 
380  delete_all( aActions.begin(), aActions.end() );
381  aActions.clear();
382 
383  // cleanup
384  delete mMode;
385  delete mhistory;
386 
387  delete mdocument;
388 }
389 
390 bool KigPart::openFile()
391 {
392  QFileInfo fileinfo( localFilePath() );
393  if ( ! fileinfo.exists() )
394  {
395  KMessageBox::sorry( widget(),
396  i18n( "The file \"%1\" you tried to open does not exist. "
397  "Please verify that you entered the correct path.", localFilePath() ),
398  i18n( "File Not Found" ) );
399  return false;
400  };
401 
402  KMimeType::Ptr mimeType = KMimeType::mimeType( arguments().mimeType() );
403  if ( !mimeType )
404  {
405  // we can always use findByPath instead of findByURL with localFilePath()
406  mimeType = KMimeType::findByPath( localFilePath() );
407  }
408  kDebug() << "mimetype: " << mimeType->name();
409  KigFilter* filter = KigFilters::instance()->find( mimeType->name() );
410  if ( !filter )
411  {
412  // we don't support this mime type...
413  KMessageBox::sorry
414  (
415  widget(),
416  i18n( "You tried to open a document of type \"%1\"; unfortunately, Kig does not support this format. If you think the format in question would be worth implementing support for, you can open a feature request in <a href=\"https://bugs.kde.org/enter_bug.cgi?product=kig&bug_severity=wishlist\">KDE's bug tracking system</a>"
417  , mimeType->name()),
418  i18n( "Format Not Supported" ),
419  KMessageBox::Notify | KMessageBox::AllowLink
420  );
421  return false;
422  };
423 
424  KigDocument* newdoc = filter->load (localFilePath());
425  if ( !newdoc )
426  {
427  closeUrl();
428  setUrl( KUrl() );
429  return false;
430  }
431  delete mdocument;
432  mdocument = newdoc;
433  coordSystemChanged( mdocument->coordinateSystem().id() );
434  aToggleGrid->setChecked( mdocument->grid() );
435  aToggleAxes->setChecked( mdocument->axes() );
436  aToggleNightVision->setChecked( mdocument->getNightVision() );
437 
438  setModified(false);
439  mhistory->clear();
440 
441  std::vector<ObjectCalcer*> tmp = calcPath( getAllParents( getAllCalcers( document().objects() ) ) );
442  for ( std::vector<ObjectCalcer*>::iterator i = tmp.begin(); i != tmp.end(); ++i )
443  ( *i )->calc( document() );
444  emit recenterScreen();
445 
446  redrawScreen();
447 
448  return true;
449 }
450 
451 bool KigPart::saveFile()
452 {
453  if ( url().isEmpty() ) return internalSaveAs();
454  // mimetype:
455  KMimeType::Ptr mimeType = KMimeType::findByPath ( localFilePath() );
456  if ( mimeType->name() != "application/x-kig" )
457  {
458  // we don't support this mime type...
459  if( KMessageBox::warningYesNo( widget(),
460  i18n( "Kig does not support saving to any other file format than "
461  "its own. Save to Kig's format instead?" ),
462  i18n( "Format Not Supported" ), KGuiItem( i18n( "Save Kig Format" ) ), KStandardGuiItem::cancel() ) == KMessageBox::No )
463  return false;
464  internalSaveAs();
465  };
466 
467  if ( KigFilters::instance()->save( document(), localFilePath() ) )
468  {
469  setModified ( false );
470  mhistory->setClean();
471  return true;
472  }
473  return false;
474 }
475 
476 bool KigPart::queryClose()
477 {
478  if ( KParts::ReadWritePart::queryClose() )
479  {
480  if ( mode()->eventLoop() != 0 )
481  {
482  cancelConstruction();
483  }
484  return true;
485  }
486  return false;
487 }
488 
489 void KigPart::addObject(ObjectHolder* o)
490 {
491  if ( !misGroupingObjects )
492  mhistory->push( KigCommand::addCommand( *this, o ) );
493  else
494  {
495  _addObject( o );
496  mcurrentObjectGroup.push_back( o );
497  }
498 }
499 
500 void KigPart::addObjects( const std::vector<ObjectHolder*>& os )
501 {
502  if ( !misGroupingObjects )
503  mhistory->push( KigCommand::addCommand( *this, os ) );
504  else
505  {
506  _addObjects( os );
507  mcurrentObjectGroup.insert( mcurrentObjectGroup.end(), os.begin(), os.end() );
508  }
509 }
510 
511 void KigPart::_addObject( ObjectHolder* o )
512 {
513  document().addObject( o );
514  setModified(true);
515 }
516 
517 void KigPart::delObject( ObjectHolder* o )
518 {
519  // we delete all children and their children etc. too...
520  std::vector<ObjectHolder*> os;
521  os.push_back( o );
522  delObjects( os );
523 }
524 
525 void KigPart::_delObjects( const std::vector<ObjectHolder*>& o )
526 {
527  document().delObjects( o );
528  setModified( true );
529 }
530 
531 void KigPart::_delObject(ObjectHolder* o)
532 {
533  document().delObject( o );
534  setModified(true);
535 }
536 
537 void KigPart::setMode( KigMode* m )
538 {
539  mMode = m;
540  m->enableActions();
541  redrawScreen();
542 }
543 
544 void KigPart::_addObjects( const std::vector<ObjectHolder*>& os )
545 {
546  document().addObjects( os );
547  setModified( true );
548 }
549 
550 void KigPart::deleteObjects()
551 {
552  mode()->deleteObjects();
553 }
554 
555 void KigPart::startObjectGroup()
556 {
557  if ( mcurrentObjectGroup.size() > 0 )
558  kWarning() << "New object group started while already having objects in object group. Current group will be lost";
559 
560  mcurrentObjectGroup.clear();
561  misGroupingObjects = true;
562 }
563 
564 void KigPart::cancelObjectGroup()
565 {
566  misGroupingObjects = false;
567  _delObjects( mcurrentObjectGroup );
568  mcurrentObjectGroup.clear();
569 }
570 
571 void KigPart::finishObjectGroup()
572 {
573  misGroupingObjects = false;
574  _delObjects( mcurrentObjectGroup );
575  addObjects( mcurrentObjectGroup );
576  mcurrentObjectGroup.clear();
577 }
578 
579 void KigPart::cancelConstruction()
580 {
581  mode()->cancelConstruction();
582 }
583 
584 void KigPart::repeatLastConstruction()
585 {
586  if ( mRememberConstruction )
587  {
588  ConstructibleAction* ca = mRememberConstruction;
589  ca->act( *this );
590  }
591 }
592 
593 void KigPart::showHidden()
594 {
595  mode()->showHidden();
596 }
597 
598 void KigPart::newMacro()
599 {
600  mode()->newMacro();
601 }
602 
603 void KigPart::editTypes()
604 {
605  mode()->editTypes();
606 }
607 
608 void KigPart::browseHistory()
609 {
610  mode()->browseHistory();
611 }
612 
613 void KigPart::setHistoryClean( bool clean )
614 {
615  setModified( !clean );
616 }
617 
618 void KigPart::setCoordinatePrecision()
619 {
620  KigCoordinatePrecisionDialog dlg(document().isUserSpecifiedCoordinatePrecision(), document().getCoordinatePrecision() );
621 
622  if( dlg.exec() == QDialog::Accepted )
623  {
624  int coordinatePrecision = dlg.getUserSpecifiedCoordinatePrecision();
625 
626  document().setCoordinatePrecision( coordinatePrecision );
627  }
628 }
629 
630 QUndoStack* KigPart::history()
631 {
632  return mhistory;
633 }
634 
635 void KigPart::delObjects( const std::vector<ObjectHolder*>& os )
636 {
637  if ( os.size() < 1 ) return;
638  std::set<ObjectHolder*> delobjs;
639 
640  std::set<ObjectCalcer*> delcalcers = getAllChildren( getAllCalcers( os ) );
641  std::map<ObjectCalcer*, ObjectHolder*> holdermap;
642 
643  std::set<ObjectHolder*> curobjs = document().objectsSet();
644 
645  for ( std::set<ObjectHolder*>::iterator i = curobjs.begin();
646  i != curobjs.end(); ++i )
647  holdermap[( *i )->calcer()] = *i;
648 
649  for ( std::set<ObjectCalcer*>::iterator i = delcalcers.begin();
650  i != delcalcers.end(); ++i )
651  {
652  std::map<ObjectCalcer*, ObjectHolder*>::iterator j = holdermap.find( *i );
653  if ( j != holdermap.end() )
654  delobjs.insert( j->second );
655  }
656 
657  assert( delobjs.size() >= os.size() );
658 
659  std::vector<ObjectHolder*> delobjsvect( delobjs.begin(), delobjs.end() );
660  mhistory->push( KigCommand::removeCommand( *this, delobjsvect ) );
661 }
662 
663 void KigPart::enableConstructActions( bool enabled )
664 {
665  for_each( aActions.begin(), aActions.end(),
666  bind2nd( mem_fun( &KAction::setEnabled ),
667  enabled ) );
668 }
669 
670 void KigPart::unplugActionLists()
671 {
672  unplugActionList( "user_conic_types" );
673  unplugActionList( "user_segment_types" );
674  unplugActionList( "user_point_types" );
675  unplugActionList( "user_circle_types" );
676  unplugActionList( "user_line_types" );
677  unplugActionList( "user_other_types" );
678  unplugActionList( "user_types" );
679 }
680 
681 void KigPart::plugActionLists()
682 {
683  plugActionList( "user_conic_types", aMNewConic );
684  plugActionList( "user_segment_types", aMNewSegment );
685  plugActionList( "user_point_types", aMNewPoint );
686  plugActionList( "user_circle_types", aMNewCircle );
687  plugActionList( "user_line_types", aMNewLine );
688  plugActionList( "user_other_types", aMNewOther );
689  plugActionList( "user_types", aMNewAll );
690 }
691 
692 void KigPart::emitStatusBarText( const QString& text )
693 {
694  emit setStatusBarText( text );
695 }
696 
697 void KigPart::fileSaveAs()
698 {
699  internalSaveAs();
700 }
701 
702 void KigPart::fileSave()
703 {
704  save();
705 }
706 
707 bool KigPart::internalSaveAs()
708 {
709  // this slot is connected to the KStandardAction::saveAs action...
710  QString formats = i18n( "*.kig|Kig Documents (*.kig)\n"
711  "*.kigz|Compressed Kig Documents (*.kigz)" );
712 
713  // formats += "\n";
714  // formats += KImageIO::pattern( KImageIO::Writing );
715 
716  QString file_name = KFileDialog::getSaveFileName( KUrl( "kfiledialog:///document" ), formats );
717  if (file_name.isEmpty()) return false;
718  else if ( QFileInfo( file_name ).exists() )
719  {
720  int ret = KMessageBox::warningContinueCancel( m_widget,
721  i18n( "The file \"%1\" already exists. Do you wish to overwrite it?" ,
722  file_name ), i18n( "Overwrite File?" ), KStandardGuiItem::overwrite() );
723  if ( ret != KMessageBox::Continue )
724  {
725  return false;
726  }
727  }
728  saveAs( KUrl( file_name ) );
729  return true;
730 }
731 
732 void KigPart::runMode( KigMode* m )
733 {
734  KigMode* prev = mMode;
735 
736  setMode( m );
737 
738  QEventLoop e;
739  m->setEventLoop( &e );
740  e.exec( QEventLoop::AllEvents | QEventLoop::WaitForMoreEvents );
741 
742  setMode( prev );
743  redrawScreen();
744 }
745 
746 void KigPart::doneMode( KigMode* d )
747 {
748  assert( d == mMode );
749 
750  if ( d->eventLoop() )
751  d->eventLoop()->exit();
752 }
753 
754 void KigPart::actionRemoved( GUIAction* a, GUIUpdateToken& t )
755 {
756  KigGUIAction* rem = 0;
757  for ( std::vector<KigGUIAction*>::iterator i = aActions.begin(); i != aActions.end(); ++i )
758  {
759  if ( (*i)->guiAction() == a )
760  {
761  rem = *i;
762  aActions.erase( i );
763  break;
764  }
765  };
766  assert( rem );
767  aMNewSegment.removeAll( rem );
768  aMNewConic.removeAll( rem );
769  aMNewPoint.removeAll( rem );
770  aMNewCircle.removeAll( rem );
771  aMNewLine.removeAll( rem );
772  aMNewOther.removeAll( rem );
773  aMNewAll.removeAll( rem );
774  t.push_back( rem );
775 }
776 
777 void KigPart::actionAdded( GUIAction* a, GUIUpdateToken& )
778 {
779  KigGUIAction* ret = new KigGUIAction( a, *this );
780  aActions.push_back( ret );
781  ret->plug( this );
782 }
783 
784 void KigPart::endGUIActionUpdate( GUIUpdateToken& t )
785 {
786  unplugActionLists();
787  plugActionLists();
788  delete_all( t.begin(), t.end() );
789  t.clear();
790 }
791 
792 KigPart::GUIUpdateToken KigPart::startGUIActionUpdate()
793 {
794  return GUIUpdateToken();
795 }
796 
797 void KigPart::setupMacroTypes()
798 {
799  static bool alreadysetup = false;
800  if ( ! alreadysetup )
801  {
802  alreadysetup = true;
803 
804  // the user's saved macro types:
805  const QStringList dataFiles =
806  KGlobal::dirs()->findAllResources("appdata", "kig-types/*.kigt",
807  KStandardDirs::Recursive);
808  std::vector<Macro*> macros;
809  for ( QStringList::const_iterator file = dataFiles.begin();
810  file != dataFiles.end(); ++file )
811  {
812  std::vector<Macro*> nmacros;
813  bool ok = MacroList::instance()->load( *file, nmacros, *this );
814  if ( ! ok ) continue;
815  copy( nmacros.begin(), nmacros.end(), back_inserter( macros ) );
816  }
817  MacroList::instance()->add( macros );
818  };
819  // hack: we need to plug the action lists _after_ the gui is
820  // built.. i can't find a better solution than this...
821  QTimer::singleShot( 0, this, SLOT( plugActionLists() ) );
822 }
823 
824 void KigPart::setupBuiltinMacros()
825 {
826  static bool alreadysetup = false;
827  if ( ! alreadysetup )
828  {
829  alreadysetup = true;
830  // builtin macro types ( we try to make the user think these are
831  // normal types )..
832  const QStringList builtinfiles =
833  KGlobal::dirs()->findAllResources( "appdata", "builtin-macros/*.kigt", KStandardDirs::Recursive);
834  for ( QStringList::const_iterator file = builtinfiles.begin();
835  file != builtinfiles.end(); ++file )
836  {
837  std::vector<Macro*> macros;
838  bool ok = MacroList::instance()->load( *file, macros, *this );
839  if ( ! ok ) continue;
840  for ( uint i = 0; i < macros.size(); ++i )
841  {
842  ObjectConstructorList* ctors = ObjectConstructorList::instance();
843  GUIActionList* actions = GUIActionList::instance();
844  Macro* macro = macros[i];
845  macro->ctor->setBuiltin( true );
846  ctors->add( macro->ctor );
847  actions->add( macro->action );
848  macro->ctor = 0;
849  macro->action = 0;
850  delete macro;
851  };
852  };
853  };
854 }
855 
856 void KigPart::addWidget( KigWidget* v )
857 {
858  mwidgets.push_back( v );
859 }
860 
861 void KigPart::delWidget( KigWidget* v )
862 {
863  mwidgets.erase( std::remove( mwidgets.begin(), mwidgets.end(), v ), mwidgets.end() );
864 }
865 
866 void KigPart::filePrintPreview()
867 {
868  QPrinter printer;
869  KPrintPreview printPreview( &printer );
870  doPrint( printer, document().grid(), document().axes() );
871  printPreview.exec();
872 }
873 
874 void KigPart::filePrint()
875 {
876  QPrinter printer;
877  KigPrintDialogPage* kp = new KigPrintDialogPage();
878  QPrintDialog *printDialog = KdePrint::createPrintDialog( &printer, QList<QWidget*>() << kp, m_widget );
879  printDialog->setWindowTitle( i18n("Print Geometry") );
880  printer.setFullPage( true );
881  //Unsupported in Qt
882  //printer.setPageSelection( QPrinter::ApplicationSide );
883  kp->setPrintShowGrid( document().grid() );
884  kp->setPrintShowAxes( document().axes() );
885  if (printDialog->exec())
886  {
887  doPrint( printer, kp->printShowGrid(), kp->printShowAxes() );
888  }
889  delete printDialog;
890 }
891 
892 void KigPart::doPrint( QPrinter& printer, bool printGrid, bool printAxes )
893 {
894  Rect rect = document().suggestedRect();
895  QRect qrect( 0, 0, printer.width(), printer.height() );
896  if ( rect.width() * qrect.height() > rect.height() * qrect.width() )
897  {
898  // qrect is too high..
899  int nh = static_cast<int>( qrect.width() * rect.height() / rect.width() );
900  int rest = qrect.height() - nh;
901  qrect.setTop( qrect.top() - rest / 2 );
902  qrect.setTop( rest / 2 );
903  }
904  else
905  {
906  // qrect is too wide..
907  int nw = static_cast<int>( qrect.height() * rect.width() / rect.height() );
908  int rest = qrect.width() - nw;
909  qrect.setLeft( rest / 2 );
910  qrect.setRight( qrect.right() - rest / 2 );
911  };
912  ScreenInfo si( rect, qrect );
913  KigPainter painter( si, &printer, document() );
914  painter.setWholeWinOverlay();
915  painter.drawGrid( document().coordinateSystem(), printGrid, printAxes );
916  painter.drawObjects( document().objects(), false );
917 }
918 
919 void KigPart::slotSelectAll()
920 {
921  mMode->selectAll();
922 }
923 
924 void KigPart::slotDeselectAll()
925 {
926  mMode->deselectAll();
927 }
928 
929 void KigPart::slotInvertSelection()
930 {
931  mMode->invertSelection();
932 }
933 
934 void KigPart::hideObjects( const std::vector<ObjectHolder*>& inos )
935 {
936  std::vector<ObjectHolder*> os;
937  for (std::vector<ObjectHolder*>::const_iterator i = inos.begin(); i != inos.end(); ++i )
938  {
939  if ( (*i)->shown() )
940  os.push_back( *i );
941  };
942  KigCommand* kc = 0;
943  if ( os.size() == 0 ) return;
944  else if ( os.size() == 1 )
945  kc = new KigCommand( *this, os[0]->imp()->type()->hideAStatement() );
946  else kc = new KigCommand( *this, i18np( "Hide %1 Object", "Hide %1 Objects", os.size() ) );
947  for ( std::vector<ObjectHolder*>::iterator i = os.begin();
948  i != os.end(); ++i )
949  kc->addTask( new ChangeObjectDrawerTask( *i, ( *i )->drawer()->getCopyShown( false ) ) );
950  mhistory->push( kc );
951 }
952 
953 void KigPart::showObjects( const std::vector<ObjectHolder*>& inos )
954 {
955  std::vector<ObjectHolder*> os;
956  for (std::vector<ObjectHolder*>::const_iterator i = inos.begin(); i != inos.end(); ++i )
957  {
958  if ( !(*i)->shown() )
959  os.push_back( *i );
960  };
961  KigCommand* kc = 0;
962  if ( os.size() == 0 ) return;
963  else if ( os.size() == 1 )
964  kc = new KigCommand( *this, os[0]->imp()->type()->showAStatement() );
965  else kc = new KigCommand( *this, i18np( "Show %1 Object", "Show %1 Objects", os.size() ) );
966  for ( std::vector<ObjectHolder*>::iterator i = os.begin();
967  i != os.end(); ++i )
968  kc->addTask( new ChangeObjectDrawerTask( *i, ( *i )->drawer()->getCopyShown( true ) ) );
969  mhistory->push( kc );
970 }
971 
972 void KigPart::redrawScreen( KigWidget* w )
973 {
974  mode()->redrawScreen( w );
975 }
976 
977 void KigPart::redrawScreen()
978 {
979  for ( std::vector<KigWidget*>::iterator i = mwidgets.begin();
980  i != mwidgets.end(); ++i )
981  {
982  mode()->redrawScreen( *i );
983  }
984 }
985 
986 const KigDocument& KigPart::document() const
987 {
988  return *mdocument;
989 }
990 
991 KigDocument& KigPart::document()
992 {
993  return *mdocument;
994 }
995 
996 extern "C" KDE_EXPORT int convertToNative( const KUrl& url, const QByteArray& outfile )
997 {
998  kDebug() << "converting " << url.prettyUrl() << " to " << outfile;
999 
1000  if ( ! url.isLocalFile() )
1001  {
1002  // TODO
1003  kError() << "--convert-to-native only supports local files for now." << endl;
1004  return -1;
1005  }
1006 
1007  QString file = url.toLocalFile();
1008 
1009  QFileInfo fileinfo( file );
1010  if ( ! fileinfo.exists() )
1011  {
1012  kError() << "The file \"" << file << "\" does not exist" << endl;
1013  return -1;
1014  };
1015 
1016  KMimeType::Ptr mimeType = KMimeType::findByPath ( file );
1017  kDebug() << "mimetype: " << mimeType->name();
1018  KigFilter* filter = KigFilters::instance()->find( mimeType->name() );
1019  if ( !filter )
1020  {
1021  kError() << "The file \"" << file << "\" is of a filetype not currently supported by Kig." << endl;
1022  return -1;
1023  };
1024 
1025  KigDocument* doc = filter->load (file);
1026  if ( !doc )
1027  {
1028  kError() << "Parse error in file \"" << file << "\"." << endl;
1029  return -1;
1030  }
1031 
1032  std::vector<ObjectCalcer*> tmp = calcPath( getAllParents( getAllCalcers( doc->objects() ) ) );
1033  for ( std::vector<ObjectCalcer*>::iterator i = tmp.begin(); i != tmp.end(); ++i )
1034  ( *i )->calc( *doc );
1035  for ( std::vector<ObjectCalcer*>::iterator i = tmp.begin(); i != tmp.end(); ++i )
1036  ( *i )->calc( *doc );
1037 
1038  QString out = ( outfile == "-" ) ? QString() : outfile;
1039  bool success = KigFilters::instance()->save( *doc, out );
1040  if ( !success )
1041  {
1042  kError() << "something went wrong while saving" << endl;
1043  return -1;
1044  }
1045 
1046  delete doc;
1047 
1048  return 0;
1049 }
1050 
1051 void KigPart::toggleGrid()
1052 {
1053  bool toshow = !mdocument->grid();
1054  aToggleGrid->setChecked( toshow );
1055  mdocument->setGrid( toshow );
1056 
1057  redrawScreen();
1058 }
1059 
1060 void KigPart::toggleAxes()
1061 {
1062  bool toshow = !mdocument->axes();
1063  aToggleAxes->setChecked( toshow );
1064  mdocument->setAxes( toshow );
1065 
1066  redrawScreen();
1067 }
1068 
1069 void KigPart::toggleNightVision()
1070 {
1071  bool nv = !mdocument->getNightVision();
1072  aToggleNightVision->setChecked( nv );
1073  mdocument->setNightVision( nv );
1074 
1075  redrawScreen();
1076 }
1077 
1078 void KigPart::coordSystemChanged( int id )
1079 {
1080  aCoordSystem->setCurrentItem( id );
1081 }
1082 
1083 void KigPart::saveTypes()
1084 {
1085  QString typesDir = KGlobal::dirs()->saveLocation( "appdata", "kig-types" );
1086  if ( !typesDir.endsWith( '/' ) )
1087  typesDir += '/';
1088  QString typesFileWithPath = typesDir + typesFile;
1089 
1090  // removing existent types file
1091  if ( QFile::exists( typesFileWithPath ) )
1092  QFile::remove( typesFileWithPath );
1093 
1094  MacroList* macrolist = MacroList::instance();
1095  macrolist->save( macrolist->macros(), typesFileWithPath );
1096 }
1097 
1098 void KigPart::loadTypes()
1099 {
1100  QString typesDir = KGlobal::dirs()->saveLocation( "appdata", "kig-types" );
1101  if ( !typesDir.endsWith( '/' ) )
1102  typesDir += '/';
1103  QString typesFileWithPath = typesDir + typesFile;
1104 
1105  if ( QFile::exists( typesFileWithPath ) )
1106  {
1107  std::vector<Macro*> macros;
1108  MacroList::instance()->load( typesFileWithPath, macros, *this );
1109  MacroList::instance()->add( macros );
1110  }
1111 }
1112 
1113 void KigPart::deleteTypes()
1114 {
1115  unplugActionLists();
1116  typedef MacroList::vectype vec;
1117  MacroList* macrolist = MacroList::instance();
1118  const vec& macros = macrolist->macros();
1119  for ( vec::const_reverse_iterator i = macros.rbegin(); i != macros.rend(); ++i )
1120  {
1121  macrolist->remove( *i );
1122  }
1123  plugActionLists();
1124 }
QSpacerItem
KigFilter
This is the base class for an input filter.
Definition: filter.h:67
KigPart::newMacro
void newMacro()
Definition: kig_part.cpp:598
GUIActionList
List of GUIActions for the parts to show.
Definition: lists.h:38
QWidget
CoordinateSystemFactory::build
static CoordinateSystem * build(int which)
Definition: coordinate_system.cpp:535
KigPart::internalSaveAs
bool internalSaveAs()
Definition: kig_part.cpp:707
KigView::realWidget
KigWidget * realWidget() const
Definition: kig_view.cpp:455
CoordinateSystem
a CoordinateSystem is what the user sees: it is kept by KigPart to show the user a grid...
Definition: coordinate_system.h:60
kig_view.h
KigPart::setupMacroTypes
void setupMacroTypes()
Definition: kig_part.cpp:797
KigPart::mode
KigMode * mode() const
Definition: kig_part.h:143
KigFilters::find
KigFilter * find(const QString &mime)
Definition: filter.cc:34
QEventLoop
KigPart::m_widget
KigView * m_widget
Definition: kig_part.h:278
KigPart::delWidget
void delWidget(KigWidget *)
Definition: kig_part.cpp:861
KigPainter::setWholeWinOverlay
void setWholeWinOverlay()
this is called by some drawing functions that modify the 'entire' screen, i.e.
Definition: kigpainter.cpp:494
KigMode::deleteObjects
virtual void deleteObjects()
Definition: mode.cc:99
KigPart::aNewMacro
KAction * aNewMacro
Definition: kig_part.h:242
KigPart::saveFile
virtual bool saveFile()
save our internal document to m_file
Definition: kig_part.cpp:451
KigCommand
a KigCommand represents almost every action performed in Kig.
Definition: kig_commands.h:44
KigPart::queryClose
virtual bool queryClose()
KigPart cannot be safely destroyed if it's in a nested event loop (construct mode).
Definition: kig_part.cpp:476
Rect::width
double width() const
Definition: rect.cc:204
KigDocument::delObject
void delObject(ObjectHolder *o)
Remove the object o from the document.
Definition: kig_document.cc:151
KigPart::openFile
virtual bool openFile()
load our internal document from m_file
Definition: kig_part.cpp:390
KigPart::fileSaveAs
void fileSaveAs()
Definition: kig_part.cpp:697
QByteArray
KigPart::aMNewSegment
QList< QAction * > aMNewSegment
Definition: kig_part.h:227
QPrinter
QFile::remove
bool remove()
KigPart::slotInvertSelection
void slotInvertSelection()
Definition: kig_part.cpp:929
KigCoordinatePrecisionDialog::getUserSpecifiedCoordinatePrecision
int getUserSpecifiedCoordinatePrecision() const
Definition: kigcoordinateprecisiondialog.cpp:50
MacroList::macros
const vectype & macros() const
get access to the list of macro's.
Definition: lists.cc:231
KigCommand::removeCommand
static KigCommand * removeCommand(KigPart &doc, const std::vector< ObjectHolder * > &os)
make sure that when you delete something, you are also deleting its parents.
Definition: kig_commands.cpp:93
KigPart::aBrowseHistory
KAction * aBrowseHistory
Definition: kig_part.h:245
KigDocument::grid
bool grid() const
Definition: kig_document.cc:186
KigDocument::objectsSet
const std::set< ObjectHolder * > & objectsSet() const
Definition: kig_document.cc:51
KigCommand::addTask
void addTask(KigCommandTask *)
Definition: kig_commands.cpp:74
QAction::setIcon
void setIcon(const QIcon &icon)
Rect
This file is part of Kig, a KDE program for Interactive Geometry...
Definition: rect.h:34
KigPart::document
const KigDocument & document() const
Definition: kig_part.cpp:986
GUIActionList::regDoc
void regDoc(KigPart *d)
register this document, so that it receives notifications for added and removed actions.
Definition: lists.cc:58
SetCoordinateSystemAction
Definition: kig_part.h:49
KigPart::filePrint
void filePrint()
Definition: kig_part.cpp:874
ObjectConstructorList
The list of object constructors for use in various places, e.g.
Definition: lists.h:69
KigPart::aShowHidden
KAction * aShowHidden
Definition: kig_part.h:243
KigPart::repeatLastConstruction
void repeatLastConstruction()
Definition: kig_part.cpp:584
KigPart::enableConstructActions
void enableConstructActions(bool enabled)
Definition: kig_part.cpp:663
KigPart::aMNewLine
QList< QAction * > aMNewLine
Definition: kig_part.h:230
getAllCalcers
std::vector< ObjectCalcer * > getAllCalcers(const std::vector< ObjectHolder * > &os)
get the calcers that the holders represent and their namecalcers
Definition: common.cc:21
KigMode::redrawScreen
virtual void redrawScreen(KigWidget *w)
Redraw the document on KigWidget w .
Definition: mode.cc:119
KigPart::history
QUndoStack * history()
Definition: kig_part.cpp:630
KigPart::aRepeatLastConstruction
KAction * aRepeatLastConstruction
Definition: kig_part.h:237
KigPart::aDeleteObjects
KAction * aDeleteObjects
Definition: kig_part.h:241
KigPart::setHistoryClean
void setHistoryClean(bool)
Definition: kig_part.cpp:613
KigPart::emitStatusBarText
void emitStatusBarText(const QString &text)
Definition: kig_part.cpp:692
KigPart::GUIUpdateToken
std::vector< KigGUIAction * > GUIUpdateToken
the "token" keeps some objects that should be deleted, we only delete them after we replug the action...
Definition: kig_part.h:263
KigPart::hideObjects
void hideObjects(const std::vector< ObjectHolder * > &os)
Definition: kig_part.cpp:934
KigMode::showHidden
virtual void showHidden()
Definition: mode.cc:103
KigMode::browseHistory
virtual void browseHistory()
Definition: mode.cc:115
KigDocument::getNightVision
bool getNightVision() const
Definition: kig_document.cc:211
QRect::height
int height() const
KigPart::toggleGrid
void toggleGrid()
Definition: kig_part.cpp:1051
KigExportManager::instance
static KigExportManager * instance()
Definition: exporter.cc:166
KigMode::eventLoop
QEventLoop * eventLoop() const
Definition: mode.cc:145
KigDocument::addObjects
void addObjects(const std::vector< ObjectHolder * > &os)
Add the objects os to the document.
Definition: kig_document.cc:143
KigMode::enableActions
virtual void enableActions()
actions: we enable the actions we want when our mode is made active.
Definition: mode.cc:27
QFile::exists
bool exists() const
kig_part.h
KigPart::browseHistory
void browseHistory()
Definition: kig_part.cpp:608
Macro::action
GUIAction * action
Definition: lists.h:94
GUIActionList::unregDoc
void unregDoc(KigPart *d)
Definition: lists.cc:63
KigGUIAction::plug
void plug(KigPart *doc)
Definition: guiaction.cc:162
KigPart::finishObjectGroup
void finishObjectGroup()
Draws the current group of objects and add them as a whole to the Undo history.
Definition: kig_part.cpp:571
QList::const_iterator
KigPart::toggleAxes
void toggleAxes()
Definition: kig_part.cpp:1060
KigPart::loadTypes
void loadTypes()
Definition: kig_part.cpp:1098
ObjectConstructorList::add
void add(ObjectConstructor *a)
Definition: lists.cc:155
KigMode::invertSelection
virtual void invertSelection()
Definition: mode.cc:136
Macro::ctor
MacroConstructor * ctor
Definition: lists.h:95
CoordinateSystemFactory::names
static QStringList names()
Definition: coordinate_system.cpp:527
QAction::setToolTip
void setToolTip(const QString &tip)
ScreenInfo
ScreenInfo is a simple utility class that maps a region of the document onto a region of the screen...
Definition: screeninfo.h:31
KigPart::deleteTypes
void deleteTypes()
Definition: kig_part.cpp:1113
KigPart::mwidgets
std::vector< KigWidget * > mwidgets
Definition: kig_part.h:276
KigMode
this is an ABC of a class containing the current "Mode" of the Kig document...
Definition: mode.h:37
KigPart::~KigPart
virtual ~KigPart()
Destructor.
Definition: kig_part.cpp:370
KigPart::mhistory
KUndoStack * mhistory
the command history
Definition: kig_part.h:215
KigPart::aSetCoordinatePrecision
KAction * aSetCoordinatePrecision
Definition: kig_part.h:246
KigFilter::load
virtual KigDocument * load(const QString &fromfile)=0
load file fromfile and build a KigDocument from it.
QPaintDevice::width
int width() const
KigGUIAction
Definition: guiaction.h:34
KSelectAction
KigFilters::instance
static KigFilters * instance()
Definition: filter.cc:52
KigPart::unplugActionLists
void unplugActionLists()
Definition: kig_part.cpp:670
QRect
KigDocument::setGrid
void setGrid(bool showgrid)
set to show/hide the grid.
Definition: kig_document.cc:181
QBoxLayout::addWidget
void addWidget(QWidget *widget, int stretch, QFlags< Qt::AlignmentFlag > alignment)
delete_all
void delete_all(T begin, T end)
Definition: objects/common.h:53
KigPart::aConfigureTypes
KAction * aConfigureTypes
Definition: kig_part.h:244
getAllParents
std::vector< ObjectCalcer * > getAllParents(const std::vector< ObjectCalcer * > &objs)
This function returns all objects above the given in the dependency graph.
Definition: calcpaths.cc:229
KigView
This class is a wrapper for KigWidget.
Definition: kig_view.h:229
MacroList::add
void add(Macro *m)
Add a Macro m .
Definition: lists.cc:213
calcPath
std::vector< ObjectCalcer * > calcPath(const std::vector< ObjectCalcer * > &os)
This function sorts os such that they're in the right order for calc()-ing.
Definition: calcpaths.cc:48
KigMode::cancelConstruction
virtual void cancelConstruction()
Definition: mode.cc:95
KigFilters::save
bool save(const KigDocument &data, const QString &outfile)
saving is always done with the native filter.
Definition: filter.cc:104
ChangeObjectDrawerTask
Definition: kig_commands.h:223
KigMode::editTypes
virtual void editTypes()
Definition: mode.cc:111
QPrintDialog
QEventLoop::exec
int exec(QFlags< QEventLoop::ProcessEventsFlag > flags)
KigPart::slotDeselectAll
void slotDeselectAll()
Definition: kig_part.cpp:924
KigPart::actionAdded
void actionAdded(GUIAction *a, GUIUpdateToken &t)
Definition: kig_part.cpp:777
convertToNative
KDE_EXPORT int convertToNative(const KUrl &url, const QByteArray &outfile)
Definition: kig_part.cpp:996
KigPart::misGroupingObjects
bool misGroupingObjects
Indicates whether objects added to the documents are being grouped or not.
Definition: kig_part.h:287
KigPart::redrawScreen
void redrawScreen()
Definition: kig_part.cpp:977
QObject
KigPainter
KigPainter is an extended QPainter.
Definition: kigpainter.h:51
KigPart::startGUIActionUpdate
GUIUpdateToken startGUIActionUpdate()
Definition: kig_part.cpp:792
QCheckBox
KigExportManager::addMenuAction
void addMenuAction(const KigPart *doc, KigWidget *w, KActionCollection *coll)
Definition: exporter.cc:155
KigPart::setCoordinatePrecision
void setCoordinatePrecision()
Definition: kig_part.cpp:618
ObjectHolder
An ObjectHolder represents an object as it is known to the document.
Definition: object_holder.h:40
QEventLoop::exit
void exit(int returnCode)
setupBuiltinStuff
void setupBuiltinStuff()
Definition: builtin_stuff.cc:48
QBoxLayout::addItem
virtual void addItem(QLayoutItem *item)
QObject::setObjectName
void setObjectName(const QString &name)
QString::isEmpty
bool isEmpty() const
KigPart::addWidget
void addWidget(KigWidget *)
Definition: kig_part.cpp:856
QList::removeAll
int removeAll(const T &value)
KigPart::showObjects
void showObjects(const std::vector< ObjectHolder * > &os)
Definition: kig_part.cpp:953
aboutdata.h
KigPart::aInvertSelection
KAction * aInvertSelection
Definition: kig_part.h:240
KigPart::mdocument
KigDocument * mdocument
Definition: kig_part.h:280
typesFile
static const QString typesFile
Definition: kig_part.cpp:82
QVBoxLayout
SetCoordinateSystemAction::SetCoordinateSystemAction
SetCoordinateSystemAction(KigPart &d, KActionCollection *parent)
QString::endsWith
bool endsWith(const QString &s, Qt::CaseSensitivity cs) const
KigPart::runMode
void runMode(KigMode *)
Definition: kig_part.cpp:732
KigPart::setupActions
void setupActions()
Definition: kig_part.cpp:212
KigPart::recenterScreen
void recenterScreen()
emitted when we want to suggest a new size for the view ( basically after loading a file...
KigWidget
This class is the real widget showing the document.
Definition: kig_view.h:50
QString
QList
KigPart::startObjectGroup
void startObjectGroup()
Call this method to start an object group which will be deleted as a whole if the construction is can...
Definition: kig_part.cpp:555
ConstructibleAction::descriptiveName
QString descriptiveName() const
Definition: guiaction.cc:72
ObjectConstructorList::instance
static ObjectConstructorList * instance()
Definition: lists.cc:129
KigPart::doneMode
void doneMode(KigMode *)
Definition: kig_part.cpp:746
KigCommand::changeCoordSystemCommand
static KigCommand * changeCoordSystemCommand(KigPart &doc, CoordinateSystem *s)
This creates directly a command to change the coordinate system to s .
Definition: kig_commands.cpp:118
KigPart::slotSelectAll
void slotSelectAll()
Definition: kig_part.cpp:919
KigDocument::objects
const std::vector< ObjectHolder * > objects() const
Get a hold of the objects of this KigDocument.
Definition: kig_document.cc:46
QStringList
QAction::setWhatsThis
void setWhatsThis(const QString &what)
KigPainter::drawGrid
void drawGrid(const CoordinateSystem &c, bool showGrid=true, bool showAxes=true)
Definition: kigpainter.cpp:507
KigPart::setupTypes
void setupTypes()
Definition: kig_part.cpp:341
KigPart::saveTypes
void saveTypes()
Definition: kig_part.cpp:1083
QFileInfo
KigPart::aActions
std::vector< KigGUIAction * > aActions
Definition: kig_part.h:250
QList::end
iterator end()
kig_document.h
KigPart::aCoordSystem
KSelectAction * aCoordSystem
Definition: kig_part.h:209
KigPart::aToggleGrid
KToggleAction * aToggleGrid
Definition: kig_part.h:247
QFileInfo::exists
bool exists() const
kig_commands.h
QPrinter::setFullPage
void setFullPage(bool fp)
KigPart::_addObject
void _addObject(ObjectHolder *inObject)
Definition: kig_part.cpp:511
KigPart::addObject
void addObject(ObjectHolder *inObject)
Definition: kig_part.cpp:489
KigPart::_delObject
void _delObject(ObjectHolder *inObject)
Definition: kig_part.cpp:531
MacroList::vectype
std::vector< Macro * > vectype
Definition: lists.h:113
ConstructibleAction::act
void act(KigPart &)
Definition: guiaction.cc:77
ConstructibleAction
Definition: guiaction.h:68
kigAboutData
KAboutData kigAboutData(const char *name, const char *iname)
Definition: aboutdata.h:26
KigPart::fileSave
void fileSave()
Definition: kig_part.cpp:702
KigDocument::setAxes
void setAxes(bool showaxes)
set to show/hide the grid.
Definition: kig_document.cc:191
KigDocument::setCoordinatePrecision
void setCoordinatePrecision(int precision)
Definition: kig_document.cc:201
KigPart::coordSystemChanged
void coordSystemChanged(int)
Definition: kig_part.cpp:1078
KigPart::aMNewCircle
QList< QAction * > aMNewCircle
Definition: kig_part.h:229
KigPart::_addObjects
void _addObjects(const std::vector< ObjectHolder * > &o)
Definition: kig_part.cpp:544
KigPart::setMode
void setMode(KigMode *)
Definition: kig_part.cpp:537
KigPart::toggleNightVision
void toggleNightVision()
Definition: kig_part.cpp:1069
KigCommand::addCommand
static KigCommand * addCommand(KigPart &doc, const std::vector< ObjectHolder * > &os)
To avoid confusion, this doesn't add a command to anything, this creates an AddCommand ;) ...
Definition: kig_commands.cpp:106
MacroList
This class keeps a list of all macro's, and allows them to be easily accessed, added etc...
Definition: lists.h:110
KigPart::editTypes
void editTypes()
Definition: kig_part.cpp:603
QPrintDialog::exec
virtual int exec()
Rect::height
double height() const
Definition: rect.cc:209
QKeySequence
KigPart::KigPart
KigPart(QWidget *parentWidget, QObject *parent=0, const QVariantList &=QVariantList())
Default constructor.
Definition: kig_part.cpp:173
MacroList::save
bool save(Macro *m, const QString &f)
Save macro m to file f .
Definition: lists.cc:240
KigMode::newMacro
virtual void newMacro()
Definition: mode.cc:107
KigPart::rememberConstruction
void rememberConstruction(ConstructibleAction *)
Definition: kig_part.cpp:356
QWidget::setWindowTitle
void setWindowTitle(const QString &)
Macro
this is just a simple data struct.
Definition: lists.h:91
QAction
KAction
MacroList::load
bool load(const QString &f, vectype &ret, const KigPart &)
load macro's from file f .
Definition: lists.cc:298
KigDocument
KigDocument is the class holding the real data in a Kig document.
Definition: kig_document.h:36
KigPart::mRememberConstruction
ConstructibleAction * mRememberConstruction
Definition: kig_part.h:210
GUIActionList::instance
static GUIActionList * instance()
Definition: lists.cc:42
QUndoStack
KigPart::actionRemoved
void actionRemoved(GUIAction *a, GUIUpdateToken &t)
Definition: kig_part.cpp:754
KigPart::endGUIActionUpdate
void endGUIActionUpdate(GUIUpdateToken &t)
Definition: kig_part.cpp:784
KigDocument::addObject
void addObject(ObjectHolder *oObject)
Add the objects o to the document.
Definition: kig_document.cc:138
K_EXPORT_PLUGIN
K_EXPORT_PLUGIN(KigPartFactory(kigAboutData("kig", I18N_NOOP("KigPart")))) SetCoordinateSystemAction
Definition: kig_part.cpp:86
KigDocument::setNightVision
void setNightVision(bool nv)
set to enable/disable night-vision (visibility of hidden objects)
Definition: kig_document.cc:196
KigPart::aToggleNightVision
KToggleAction * aToggleNightVision
Definition: kig_part.h:249
KigPart
This is a "Part".
Definition: kig_part.h:68
KigMode::selectAll
virtual void selectAll()
Definition: mode.cc:128
MacroList::remove
void remove(Macro *m)
Remove macro m .
Definition: lists.cc:220
KigMode::deselectAll
virtual void deselectAll()
Definition: mode.cc:132
GUIActionList::add
void add(GUIAction *a)
Definition: lists.cc:80
KigPart::aMNewPoint
QList< QAction * > aMNewPoint
Definition: kig_part.h:228
KigPart::addObjects
void addObjects(const std::vector< ObjectHolder * > &os)
Definition: kig_part.cpp:500
QPaintDevice::height
int height() const
KigDocument::axes
bool axes() const
Definition: kig_document.cc:206
GUIAction
Definition: guiaction.h:51
KigPart::aDeselectAll
KAction * aDeselectAll
Definition: kig_part.h:239
KigDocument::delObjects
void delObjects(const std::vector< ObjectHolder * > &os)
Remove the objects os from the document.
Definition: kig_document.cc:156
MacroConstructor::setBuiltin
void setBuiltin(bool builtin)
Definition: object_constructor.cc:526
KigPart::cancelConstruction
void cancelConstruction()
Definition: kig_part.cpp:579
KigDocument::coordinateSystem
const CoordinateSystem & coordinateSystem() const
Definition: kig_document.cc:40
KigPart::aCancelConstruction
KAction * aCancelConstruction
Definition: kig_part.h:236
KigPart::delObject
void delObject(ObjectHolder *inObject)
Definition: kig_part.cpp:517
KigPart::deleteObjects
void deleteObjects()
Definition: kig_part.cpp:550
GUIActionList::actions
const avectype & actions() const
Definition: lists.h:50
CoordinateSystem::id
virtual int id() const =0
KigPart::aToggleAxes
KToggleAction * aToggleAxes
Definition: kig_part.h:248
getAllChildren
std::set< ObjectCalcer * > getAllChildren(ObjectCalcer *obj)
This is an overloaded member function, provided for convenience. It differs from the above function o...
Definition: calcpaths.cc:281
KigPart::mMode
KigMode * mMode
Definition: kig_part.h:208
KigPart::cancelObjectGroup
void cancelObjectGroup()
Deletes the current group of objects from the document without adding them to the Undo history...
Definition: kig_part.cpp:564
KigPainter::drawObjects
void drawObjects(const std::vector< ObjectHolder * > &os, bool sel)
Definition: kigpainter.cpp:518
KigPart::aMNewConic
QList< QAction * > aMNewConic
Definition: kig_part.h:233
KigPart::delObjects
void delObjects(const std::vector< ObjectHolder * > &os)
Definition: kig_part.cpp:635
NormalMode
Definition: normal.h:26
QList::begin
iterator begin()
KigPart::filePrintPreview
void filePrintPreview()
Definition: kig_part.cpp:866
uint
unsigned int uint
Definition: object_imp.h:87
KigPart::aSelectAll
KAction * aSelectAll
Definition: kig_part.h:238
KigPart::setupBuiltinMacros
void setupBuiltinMacros()
Definition: kig_part.cpp:824
KigPart::plugActionLists
void plugActionLists()
Definition: kig_part.cpp:681
KigDocument::suggestedRect
Rect suggestedRect() const
Return a rect containing most of the objects, which would be a fine suggestion to map to the widget...
Definition: kig_document.cc:106
MacroList::instance
static MacroList * instance()
MacroList is a singleton.
Definition: lists.cc:195
QUndoStack::push
void push(QUndoCommand *cmd)
KigPart::showHidden
void showHidden()
Definition: kig_part.cpp:593
KigPart::aMNewOther
QList< QAction * > aMNewOther
Definition: kig_part.h:231
KigMode::setEventLoop
void setEventLoop(QEventLoop *e)
Definition: mode.cc:140
KigPart::_delObjects
void _delObjects(const std::vector< ObjectHolder * > &o)
Definition: kig_part.cpp:525
KigPart::aMNewAll
QList< QAction * > aMNewAll
Definition: kig_part.h:232
KigPart::mcurrentObjectGroup
std::vector< ObjectHolder * > mcurrentObjectGroup
Stores the current group of object being drawn if an object group has been started.
Definition: kig_part.h:294
KigPart::doPrint
void doPrint(QPrinter &printer, bool printGrid, bool printAxes)
Definition: kig_part.cpp:892
QTimer::singleShot
singleShot
KigCoordinatePrecisionDialog
This file is part of Kig, a KDE program for Interactive Geometry...
Definition: kigcoordinateprecisiondialog.h:28
This file is part of the KDE documentation.
Documentation copyright © 1996-2020 The KDE developers.
Generated on Mon Jun 22 2020 13:12:05 by doxygen 1.8.7 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.

kig

Skip menu "kig"
  • Main Page
  • Namespace List
  • Namespace Members
  • Alphabetical List
  • Class List
  • Class Hierarchy
  • Class Members
  • File List
  • File Members

kdeedu API Reference

Skip menu "kdeedu API Reference"
  • Analitza
  •     lib
  • kalgebra
  • kalzium
  •   libscience
  • kanagram
  • kig
  •   lib
  • klettres
  • marble
  • parley
  • rocs
  •   App
  •   RocsCore
  •   VisualEditor
  •   stepcore

Search



Report problems with this website to our bug tracking system.
Contact the specific authors with questions and comments about the page contents.

KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal