kig/kig/kig_commands.cpp

   1 /**
   2  This file is part of Kig, a KDE program for Interactive Geometry...
   3  Copyright (C) 2002  Dominique Devriese <devriese@kde.org>
   4
   5  This program is free software; you can redistribute it and/or modify
   6  it under the terms of the GNU General Public License as published by
   7  the Free Software Foundation; either version 2 of the License, or
   8  (at your option) any later version.
   9
  10  This program is distributed in the hope that it will be useful,
  11  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  GNU General Public License for more details.
  14
  15  You should have received a copy of the GNU General Public License
  16  along with this program; if not, write to the Free Software
  17  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
  18  USA
  19 **/
  20
  21 #include "kig_commands.h"
  22 #include "kig_commands.moc"
  23
  24 #include "kig_part.h"
  25 #include "kig_document.h"
  26 #include "kig_view.h"
  27
  28 #include "../modes/mode.h"
  29 #include "../objects/object_imp.h"
  30 #include "../objects/object_drawer.h"
  31 #include "../misc/calcpaths.h"
  32 #include "../misc/coordinate_system.h"
  33
  34 #include <vector>
  35
  36 using std::vector;
  37 using std::max;
  38 using std::min;
  39
  40 class KigCommand::Private
  41 {
  42 public:
  43   Private( KigPart& d ) : doc( d ) {};
  44   KigPart& doc;
  45   vector<KigCommandTask*> tasks;
  46 };
  47
  48 KigCommand::KigCommand( KigPart& doc, const QString& name )
  49   : KNamedCommand(name), d( new Private( doc ) )
  50 {
  51 }
  52
  53 KigCommand::~KigCommand()
  54 {
  55   for ( uint i = 0; i < d->tasks.size(); ++i )
  56     delete d->tasks[i];
  57   delete d;
  58 }
  59
  60 void KigCommand::execute()
  61 {
  62   for ( uint i = 0; i < d->tasks.size(); ++i )
  63     d->tasks[i]->execute( d->doc );
  64   d->doc.redrawScreen();
  65 }
  66
  67 void KigCommand::unexecute()
  68 {
  69   for ( uint i = 0; i < d->tasks.size(); ++i )
  70     d->tasks[i]->unexecute( d->doc );
  71   d->doc.redrawScreen();
  72 }
  73
  74 void KigCommand::addTask( KigCommandTask* t )
  75 {
  76   d->tasks.push_back( t );
  77 }
  78
  79 KigCommand* KigCommand::removeCommand( KigPart& doc, ObjectHolder* o )
  80 {
  81   std::vector<ObjectHolder*> os;
  82   os.push_back( o );
  83   return removeCommand( doc, os );
  84 }
  85
  86 KigCommand* KigCommand::addCommand( KigPart& doc, ObjectHolder* o )
  87 {
  88   std::vector<ObjectHolder*> os;
  89   os.push_back( o );
  90   return addCommand( doc, os );
  91 }
  92
  93 KigCommand* KigCommand::removeCommand( KigPart& doc, const std::vector<ObjectHolder*>& os )
  94 {
  95   assert( os.size() > 0 );
  96   QString text;
  97   if ( os.size() == 1 )
  98     text = os.back()->imp()->type()->removeAStatement();
  99   else
 100     text = i18n( "Remove %1 Objects" ).arg( os.size() );
 101   KigCommand* ret = new KigCommand( doc, text );
 102   ret->addTask( new RemoveObjectsTask( os ) );
 103   return ret;
 104 }
 105
 106 KigCommand* KigCommand::addCommand( KigPart& doc, const std::vector<ObjectHolder*>& os )
 107 {
 108   QString text;
 109   if ( os.size() == 1 )
 110     text = os.back()->imp()->type()->addAStatement();
 111   else
 112     text = i18n( "Add %1 Objects" ).arg( os.size() );
 113   KigCommand* ret = new KigCommand( doc, text );
 114   ret->addTask( new AddObjectsTask( os ) );
 115   return ret;
 116 }
 117
 118 KigCommand* KigCommand::changeCoordSystemCommand( KigPart& doc, CoordinateSystem* s )
 119 {
 120   QString text = CoordinateSystemFactory::setCoordinateSystemStatement( s->id() );
 121   KigCommand* ret = new KigCommand( doc, text );
 122   ret->addTask( new ChangeCoordSystemTask( s ) );
 123   return ret;
 124 }
 125
 126 KigCommandTask::KigCommandTask()
 127 {
 128 }
 129
 130 KigCommandTask::~KigCommandTask()
 131 {
 132 }
 133
 134 AddObjectsTask::AddObjectsTask( const std::vector<ObjectHolder*>& os)
 135   : KigCommandTask(), undone( true ), mobjs( os )
 136 {
 137 }
 138
 139 void AddObjectsTask::execute( KigPart& doc )
 140 {
 141   doc._addObjects( mobjs );
 142   undone = false;
 143 }
 144
 145 void AddObjectsTask::unexecute( KigPart& doc )
 146 {
 147   doc._delObjects( mobjs );
 148   undone = true;
 149 }
 150
 151 AddObjectsTask::~AddObjectsTask()
 152 {
 153   if ( undone )
 154     for ( std::vector<ObjectHolder*>::iterator i = mobjs.begin();
 155           i != mobjs.end(); ++i )
 156       delete *i;
 157 }
 158
 159 RemoveObjectsTask::RemoveObjectsTask( const std::vector<ObjectHolder*>& os )
 160   : AddObjectsTask( os )
 161 {
 162   undone = false;
 163 }
 164
 165 void RemoveObjectsTask::execute( KigPart& doc )
 166 {
 167   AddObjectsTask::unexecute( doc );
 168 }
 169
 170 void RemoveObjectsTask::unexecute( KigPart& doc )
 171 {
 172   AddObjectsTask::execute( doc );
 173 }
 174
 175 ChangeObjectConstCalcerTask::ChangeObjectConstCalcerTask( ObjectConstCalcer* calcer, ObjectImp* newimp )
 176   : KigCommandTask(), mcalcer( calcer ), mnewimp( newimp )
 177 {
 178 }
 179
 180 void ChangeObjectConstCalcerTask::execute( KigPart& doc )
 181 {
 182   mnewimp = mcalcer->switchImp( mnewimp );
 183
 184   std::set<ObjectCalcer*> allchildren = getAllChildren( mcalcer.get() );
 185   std::vector<ObjectCalcer*> allchildrenvect( allchildren.begin(), allchildren.end() );
 186   allchildrenvect = calcPath( allchildrenvect );
 187   for ( std::vector<ObjectCalcer*>::iterator i = allchildrenvect.begin();
 188         i != allchildrenvect.end(); ++i )
 189     ( *i )->calc( doc.document() );
 190 }
 191
 192 void ChangeObjectConstCalcerTask::unexecute( KigPart& doc )
 193 {
 194   execute( doc );
 195 }
 196
 197 struct MoveDataStruct
 198 {
 199   ObjectConstCalcer* o;
 200   ObjectImp* oldimp;
 201   MoveDataStruct( ObjectConstCalcer* io, ObjectImp* oi )
 202     : o( io ), oldimp( oi ) { }
 203 };
 204
 205 class MonitorDataObjects::Private
 206 {
 207 public:
 208   vector<MoveDataStruct> movedata;
 209 };
 210
 211 MonitorDataObjects::MonitorDataObjects( const std::vector<ObjectCalcer*>& objs )
 212   : d( new Private )
 213 {
 214   monitor( objs );
 215 }
 216
 217 void MonitorDataObjects::monitor( const std::vector<ObjectCalcer*>& objs )
 218 {
 219   for ( std::vector<ObjectCalcer*>::const_iterator i = objs.begin(); i != objs.end(); ++i )
 220     if ( dynamic_cast<ObjectConstCalcer*>( *i ) )
 221     {
 222       MoveDataStruct n( static_cast<ObjectConstCalcer*>( *i ), (*i)->imp()->copy() );
 223       d->movedata.push_back( n );
 224     };
 225 }
 226
 227 void MonitorDataObjects::finish( KigCommand* comm )
 228 {
 229   for ( uint i = 0; i < d->movedata.size(); ++i )
 230   {
 231     ObjectConstCalcer* o = d->movedata[i].o;
 232     if ( ! d->movedata[i].oldimp->equals( *o->imp() ) )
 233     {
 234       ObjectImp* newimp = o->switchImp( d->movedata[i].oldimp );
 235       comm->addTask( new ChangeObjectConstCalcerTask( o, newimp ) );
 236     }
 237     else
 238       delete d->movedata[i].oldimp;
 239   };
 240   d->movedata.clear();
 241 }
 242
 243 MonitorDataObjects::~MonitorDataObjects()
 244 {
 245   assert( d->movedata.empty() );
 246   delete d;
 247 }
 248
 249 ChangeCoordSystemTask::ChangeCoordSystemTask( CoordinateSystem* s )
 250   : KigCommandTask(), mcs( s )
 251 {
 252 }
 253
 254 void ChangeCoordSystemTask::execute( KigPart& doc )
 255 {
 256   mcs = doc.document().switchCoordinateSystem( mcs );
 257   std::vector<ObjectCalcer*> calcpath = calcPath( getAllCalcers( doc.document().objects() ) );
 258   for ( std::vector<ObjectCalcer*>::iterator i = calcpath.begin(); i != calcpath.end(); ++i )
 259     ( *i )->calc( doc.document() );
 260   doc.coordSystemChanged( doc.document().coordinateSystem().id() );
 261 }
 262
 263 void ChangeCoordSystemTask::unexecute( KigPart& doc )
 264 {
 265   execute( doc );
 266 }
 267
 268 ChangeCoordSystemTask::~ChangeCoordSystemTask()
 269 {
 270   delete mcs;
 271 }
 272
 273 class ChangeParentsAndTypeTask::Private
 274 {
 275 public:
 276   ObjectTypeCalcer* o;
 277   std::vector<ObjectCalcer::shared_ptr> newparents;
 278   const ObjectType* newtype;
 279 };
 280
 281 ChangeParentsAndTypeTask::~ChangeParentsAndTypeTask()
 282 {
 283   delete d;
 284 }
 285
 286 ChangeParentsAndTypeTask::ChangeParentsAndTypeTask(
 287   ObjectTypeCalcer* o, const std::vector<ObjectCalcer*>& newparents,
 288   const ObjectType* newtype )
 289   : KigCommandTask(), d( new Private )
 290 {
 291   d->o = o;
 292   std::copy( newparents.begin(), newparents.end(),
 293              std::back_inserter( d->newparents ) );
 294   d->newtype = newtype;
 295 }
 296
 297 void ChangeParentsAndTypeTask::execute( KigPart& doc )
 298 {
 299   const ObjectType* oldtype = d->o->type();
 300   d->o->setType( d->newtype );
 301   d->newtype = oldtype;
 302
 303   std::vector<ObjectCalcer*> oldparentso = d->o->parents();
 304   std::vector<ObjectCalcer::shared_ptr> oldparents(
 305     oldparentso.begin(), oldparentso.end() );
 306   std::vector<ObjectCalcer*> newparents;
 307   for ( std::vector<ObjectCalcer::shared_ptr>::iterator i = d->newparents.begin();
 308         i != d->newparents.end(); ++i )
 309     newparents.push_back( i->get() );
 310   d->o->setParents( newparents );
 311   d->newparents = oldparents;
 312
 313   for ( std::vector<ObjectCalcer*>::iterator i = newparents.begin(); i != newparents.end(); ++i )
 314     ( *i )->calc( doc.document() );
 315   d->o->calc( doc.document() );
 316   std::set<ObjectCalcer*> allchildren = getAllChildren( d->o );
 317   std::vector<ObjectCalcer*> allchildrenvect( allchildren.begin(), allchildren.end() );
 318   allchildrenvect = calcPath( allchildrenvect );
 319   for ( std::vector<ObjectCalcer*>::iterator i = allchildrenvect.begin();
 320         i != allchildrenvect.end(); ++i )
 321     ( *i )->calc( doc.document() );
 322 }
 323
 324 void ChangeParentsAndTypeTask::unexecute( KigPart& doc )
 325 {
 326   execute( doc );
 327 }
 328
 329 class KigViewShownRectChangeTask::Private
 330 {
 331 public:
 332   Private( KigWidget& view, const Rect& r ) : v( view ), rect( r )  { };
 333   KigWidget& v;
 334   Rect rect;
 335 };
 336
 337 KigViewShownRectChangeTask::KigViewShownRectChangeTask(
 338   KigWidget& v, const Rect& newrect )
 339   : KigCommandTask()
 340 {
 341   d = new Private( v, newrect );
 342 }
 343
 344 KigViewShownRectChangeTask::~KigViewShownRectChangeTask()
 345 {
 346   delete d;
 347 }
 348
 349 void KigViewShownRectChangeTask::execute( KigPart& doc )
 350 {
 351   Rect oldrect = d->v.showingRect();
 352   d->v.setShowingRect( d->rect );
 353   doc.mode()->redrawScreen( &d->v );
 354   d->v.updateScrollBars();
 355   d->rect = oldrect;
 356 }
 357
 358 void KigViewShownRectChangeTask::unexecute( KigPart& doc )
 359 {
 360   execute( doc );
 361 }
 362
 363 ChangeObjectDrawerTask::~ChangeObjectDrawerTask()
 364 {
 365   delete mnewdrawer;
 366 }
 367
 368 ChangeObjectDrawerTask::ChangeObjectDrawerTask(
 369   ObjectHolder* holder, ObjectDrawer* newdrawer )
 370   : KigCommandTask(), mholder( holder ), mnewdrawer( newdrawer )
 371 {
 372 }
 373
 374 void ChangeObjectDrawerTask::execute( KigPart& )
 375 {
 376   mnewdrawer = mholder->switchDrawer( mnewdrawer );
 377 }
 378
 379 void ChangeObjectDrawerTask::unexecute( KigPart& doc )
 380 {
 381   execute( doc );
 382 }
 383
 384 MonitorDataObjects::MonitorDataObjects( ObjectCalcer* c )
 385   : d( new Private )
 386 {
 387   if ( dynamic_cast<ObjectConstCalcer*>( c ) )
 388   {
 389     MoveDataStruct n( static_cast<ObjectConstCalcer*>( c ), c->imp()->copy() );
 390     d->movedata.push_back( n );
 391   };
 392 }
 393
 394 ChangeObjectConstCalcerTask::~ChangeObjectConstCalcerTask()
 395 {
 396   delete mnewimp;
 397 }
 398