kig/misc/object_constructor.cc

   1 // Copyright (C)  2002  Dominique Devriese <devriese@kde.org>
   2
   3 // This program is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU General Public License
   5 // as published by the Free Software Foundation; either version 2
   6 // of the License, or (at your option) any later version.
   7
   8 // This program is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11 // GNU General Public License for more details.
  12
  13 // You should have received a copy of the GNU General Public License
  14 // along with this program; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  16 // 02111-1307, USA.
  17
  18 #include "object_constructor.h"
  19
  20 #include "argsparser.h"
  21 #include "kigpainter.h"
  22 #include "guiaction.h"
  23
  24 #include "../kig/kig_part.h"
  25 #include "../kig/kig_view.h"
  26
  27 #include "../objects/object_holder.h"
  28 #include "../objects/object_drawer.h"
  29 #include "../objects/object_type.h"
  30 #include "../objects/other_type.h"
  31 #include "../objects/object_imp.h"
  32 #include "../objects/bogus_imp.h"
  33 #include "../objects/line_imp.h"
  34 #include "../objects/circle_imp.h"
  35 #include "../objects/point_imp.h"
  36
  37 #include "../modes/construct_mode.h"
  38
  39 #include <qpen.h>
  40
  41 #include <klocale.h>
  42
  43 #include <algorithm>
  44 #include <functional>
  45
  46 const QString StandardConstructorBase::descriptiveName() const
  47 {
  48   return i18n( mdescname );
  49 }
  50
  51 const QString StandardConstructorBase::description() const
  52 {
  53   return i18n( mdesc );
  54 }
  55
  56 const QCString StandardConstructorBase::iconFileName( const bool ) const
  57 {
  58   return miconfile;
  59 }
  60
  61 const bool StandardConstructorBase::isAlreadySelectedOK( const std::vector<ObjectCalcer*>&, const int& ) const
  62 {
  63   return false;
  64 }
  65
  66 StandardConstructorBase::StandardConstructorBase(
  67   const char* descname, const char* desc,
  68   const char* iconfile, const ArgsParser& parser )
  69   : mdescname( descname ),
  70     mdesc( desc ),
  71     miconfile( iconfile ),
  72     margsparser( parser )
  73 {
  74 }
  75
  76 const int StandardConstructorBase::wantArgs( const std::vector<ObjectCalcer*>& os,
  77                                              const KigDocument&,
  78                                              const KigWidget& ) const
  79 {
  80   return margsparser.check( os );
  81 }
  82
  83 void StandardConstructorBase::handleArgs(
  84   const std::vector<ObjectCalcer*>& os, KigPart& d,
  85   KigWidget& v ) const
  86 {
  87   std::vector<ObjectHolder*> bos = build( os, d.document(), v );
  88   for ( std::vector<ObjectHolder*>::iterator i = bos.begin();
  89         i != bos.end(); ++i )
  90   {
  91     (*i)->calc( d.document() );
  92   }
  93
  94   d.addObjects( bos );
  95 }
  96
  97 void StandardConstructorBase::handlePrelim(
  98   KigPainter& p, const std::vector<ObjectCalcer*>& os,
  99   const KigDocument& d, const KigWidget&
 100   ) const
 101 {
 102   assert ( margsparser.check( os ) != ArgsParser::Invalid );
 103   std::vector<ObjectCalcer*> args = margsparser.parse( os );
 104   p.setBrushStyle( Qt::NoBrush );
 105   p.setBrushColor( Qt::red );
 106   p.setPen( QPen ( Qt::red,  1) );
 107   p.setWidth( -1 ); // -1 means the default width for the object being
 108                     // drawn..
 109
 110   ObjectDrawer drawer( Qt::red );
 111   drawprelim( drawer, p, args, d );
 112 }
 113
 114 SimpleObjectTypeConstructor::SimpleObjectTypeConstructor(
 115   const ArgsParserObjectType* t, const char* descname,
 116   const char* desc, const char* iconfile )
 117   : StandardConstructorBase( descname, desc, iconfile,
 118                              t->argsParser() ),
 119     mtype( t )
 120 {
 121 }
 122
 123 SimpleObjectTypeConstructor::~SimpleObjectTypeConstructor()
 124 {
 125 }
 126
 127 void SimpleObjectTypeConstructor::drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& parents,
 128                                               const KigDocument& doc ) const
 129 {
 130   Args args;
 131   using namespace std;
 132   transform( parents.begin(), parents.end(),
 133              back_inserter( args ), mem_fun( &ObjectCalcer::imp ) );
 134   ObjectImp* data = mtype->calc( args, doc );
 135   drawer.draw( *data, p, true );
 136   delete data;
 137 }
 138
 139 std::vector<ObjectHolder*> SimpleObjectTypeConstructor::build(
 140   const std::vector<ObjectCalcer*>& os, KigDocument&, KigWidget& ) const
 141 {
 142   ObjectTypeCalcer* calcer = new ObjectTypeCalcer( mtype, os );
 143   ObjectHolder* h = new ObjectHolder( calcer );
 144   std::vector<ObjectHolder*> ret;
 145   ret.push_back( h );
 146   return ret;
 147 }
 148
 149 StandardConstructorBase::~StandardConstructorBase()
 150 {
 151 }
 152
 153 MultiObjectTypeConstructor::MultiObjectTypeConstructor(
 154   const ArgsParserObjectType* t, const char* descname,
 155   const char* desc, const char* iconfile,
 156   const std::vector<int>& params )
 157   : StandardConstructorBase( descname, desc, iconfile, mparser ),
 158     mtype( t ), mparams( params ),
 159     mparser( t->argsParser().without( IntImp::stype() ) )
 160 {
 161 }
 162
 163 MultiObjectTypeConstructor::MultiObjectTypeConstructor(
 164   const ArgsParserObjectType* t, const char* descname,
 165   const char* desc, const char* iconfile,
 166   int a, int b, int c, int d )
 167   : StandardConstructorBase( descname, desc, iconfile, mparser ),
 168     mtype( t ), mparams(),
 169     mparser( t->argsParser().without( IntImp::stype() ) )
 170 {
 171   mparams.push_back( a );
 172   mparams.push_back( b );
 173   if ( c != -999 ) mparams.push_back( c );
 174   if ( d != -999 ) mparams.push_back( d );
 175 }
 176
 177 MultiObjectTypeConstructor::~MultiObjectTypeConstructor()
 178 {
 179 }
 180
 181 void MultiObjectTypeConstructor::drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& parents,
 182                                              const KigDocument& doc ) const
 183 {
 184   Args args;
 185   using namespace std;
 186   transform( parents.begin(), parents.end(),
 187              back_inserter( args ), mem_fun( &ObjectCalcer::imp ) );
 188
 189   for ( vector<int>::const_iterator i = mparams.begin(); i != mparams.end(); ++i )
 190   {
 191     IntImp param( *i );
 192     args.push_back( &param );
 193     ObjectImp* data = mtype->calc( args, doc );
 194     drawer.draw( *data, p, true );
 195     delete data;
 196     args.pop_back();
 197   };
 198 }
 199
 200 std::vector<ObjectHolder*> MultiObjectTypeConstructor::build(
 201   const std::vector<ObjectCalcer*>& os, KigDocument&, KigWidget& ) const
 202 {
 203   std::vector<ObjectHolder*> ret;
 204   for ( std::vector<int>::const_iterator i = mparams.begin();
 205         i != mparams.end(); ++i )
 206   {
 207     ObjectConstCalcer* d = new ObjectConstCalcer( new IntImp( *i ) );
 208
 209     std::vector<ObjectCalcer*> args( os );
 210     args.push_back( d );
 211
 212     ret.push_back( new ObjectHolder( new ObjectTypeCalcer( mtype, args ) ) );
 213   };
 214   return ret;
 215 }
 216
 217 MergeObjectConstructor::~MergeObjectConstructor()
 218 {
 219   for ( vectype::iterator i = mctors.begin(); i != mctors.end(); ++i )
 220     delete *i;
 221 }
 222
 223 MergeObjectConstructor::MergeObjectConstructor(
 224   const char* descname, const char* desc, const char* iconfilename )
 225   : ObjectConstructor(), mdescname( descname ), mdesc( desc ),
 226     miconfilename( iconfilename ), mctors()
 227 {
 228 }
 229
 230 ObjectConstructor::~ObjectConstructor()
 231 {
 232 }
 233
 234 void MergeObjectConstructor::merge( ObjectConstructor* e )
 235 {
 236   mctors.push_back( e );
 237 }
 238
 239 const QString MergeObjectConstructor::descriptiveName() const
 240 {
 241   return i18n( mdescname );
 242 }
 243
 244 const QString MergeObjectConstructor::description() const
 245 {
 246   return i18n( mdesc );
 247 }
 248
 249 const QCString MergeObjectConstructor::iconFileName( const bool ) const
 250 {
 251   return miconfilename;
 252 }
 253
 254 const bool MergeObjectConstructor::isAlreadySelectedOK( const std::vector<ObjectCalcer*>&, const int& ) const
 255 {
 256   return false;
 257 }
 258
 259 const int MergeObjectConstructor::wantArgs(
 260   const std::vector<ObjectCalcer*>& os, const KigDocument& d, const KigWidget& v ) const
 261 {
 262   for ( vectype::const_iterator i = mctors.begin(); i != mctors.end(); ++i )
 263   {
 264     int w = (*i)->wantArgs( os, d, v );
 265     if ( w != ArgsParser::Invalid ) return w;
 266   };
 267   return ArgsParser::Invalid;
 268 }
 269
 270 void MergeObjectConstructor::handleArgs(
 271   const std::vector<ObjectCalcer*>& os, KigPart& d, KigWidget& v ) const
 272 {
 273   for ( vectype::const_iterator i = mctors.begin(); i != mctors.end(); ++i )
 274   {
 275     int w = (*i)->wantArgs( os, d.document(), v );
 276     if ( w == ArgsParser::Complete )
 277     {
 278       (*i)->handleArgs( os, d, v );
 279       return;
 280     };
 281   };
 282   assert( false );
 283 }
 284
 285 void MergeObjectConstructor::handlePrelim(
 286   KigPainter& p, const std::vector<ObjectCalcer*>& sel,
 287   const KigDocument& d, const KigWidget& v ) const
 288 {
 289   for ( vectype::const_iterator i = mctors.begin(); i != mctors.end(); ++i )
 290   {
 291     int w = (*i)->wantArgs( sel, d, v );
 292     if ( w != ArgsParser::Invalid )
 293     {
 294       (*i)->handlePrelim( p, sel, d, v );
 295       return;
 296     };
 297   };
 298 }
 299
 300 QString StandardConstructorBase::useText( const ObjectCalcer& o, const std::vector<ObjectCalcer*>& sel,
 301                                           const KigDocument&, const KigWidget& ) const
 302 {
 303   using namespace std;
 304   Args args;
 305   transform( sel.begin(), sel.end(), back_inserter( args ), mem_fun( &ObjectCalcer::imp ) );
 306
 307   std::string ret = margsparser.usetext( o.imp(), args );
 308   if ( ret.empty() ) return QString::null;
 309   return i18n( ret.c_str() );
 310 }
 311
 312 QString StandardConstructorBase::selectStatement(
 313   const std::vector<ObjectCalcer*>& sel, const KigDocument&,
 314   const KigWidget& ) const
 315 {
 316   using namespace std;
 317   Args args;
 318   transform( sel.begin(), sel.end(), back_inserter( args ), mem_fun( &ObjectCalcer::imp ) );
 319
 320   std::string ret = margsparser.selectStatement( args );
 321   if ( ret.empty() ) return QString::null;
 322   return i18n( ret.c_str() );
 323 }
 324
 325 QString MergeObjectConstructor::useText( const ObjectCalcer& o, const std::vector<ObjectCalcer*>& sel,
 326                                          const KigDocument& d, const KigWidget& v ) const
 327 {
 328   for ( vectype::const_iterator i = mctors.begin(); i != mctors.end(); ++i )
 329   {
 330     std::vector<ObjectCalcer*> args( sel );
 331     int w = (*i)->wantArgs( args, d, v );
 332     if ( w != ArgsParser::Invalid ) return (*i)->useText( o, sel, d, v );
 333   };
 334   return QString::null;
 335 }
 336
 337 QString MergeObjectConstructor::selectStatement(
 338   const std::vector<ObjectCalcer*>& sel, const KigDocument& d,
 339   const KigWidget& w ) const
 340 {
 341   for ( vectype::const_iterator i = mctors.begin(); i != mctors.end(); ++i )
 342   {
 343     std::vector<ObjectCalcer*> args( sel );
 344     int wa = (*i)->wantArgs( args, d, w );
 345     if ( wa != ArgsParser::Invalid ) return (*i)->selectStatement( sel, d, w );
 346   };
 347   return QString::null;
 348 }
 349
 350 MacroConstructor::MacroConstructor( const ObjectHierarchy& hier, const QString& name,
 351                                     const QString& desc, const QCString& iconfile )
 352   : ObjectConstructor(), mhier( hier ), mname( name ), mdesc( desc ),
 353     mbuiltin( false ), miconfile( iconfile ),
 354     mparser( mhier.argParser() )
 355 {
 356 }
 357
 358 MacroConstructor::MacroConstructor(
 359   const std::vector<ObjectCalcer*>& input, const std::vector<ObjectCalcer*>& output,
 360   const QString& name, const QString& description,
 361   const QCString& iconfile )
 362   : ObjectConstructor(), mhier( input, output ),
 363     mname( name ), mdesc( description ), mbuiltin( false ),
 364     miconfile( iconfile ),
 365     mparser( mhier.argParser() )
 366 {
 367 }
 368
 369 MacroConstructor::~MacroConstructor()
 370 {
 371 }
 372
 373 const QString MacroConstructor::descriptiveName() const
 374 {
 375   return mname;
 376 }
 377
 378 const QString MacroConstructor::description() const
 379 {
 380   return mdesc;
 381 }
 382
 383 const QCString MacroConstructor::iconFileName( const bool canBeNull ) const
 384 {
 385   return ( miconfile.isNull() && !canBeNull ) ? QCString( "gear" ) : miconfile;
 386 }
 387
 388 const bool MacroConstructor::isAlreadySelectedOK( const std::vector<ObjectCalcer*>&, const int& ) const
 389 {
 390   return false;
 391 }
 392
 393 const int MacroConstructor::wantArgs( const std::vector<ObjectCalcer*>& os, const KigDocument&,
 394                                       const KigWidget& ) const
 395 {
 396   return mparser.check( os );
 397 }
 398
 399 void MacroConstructor::handleArgs( const std::vector<ObjectCalcer*>& os, KigPart& d,
 400                                    KigWidget& ) const
 401 {
 402   std::vector<ObjectCalcer*> args = mparser.parse( os );
 403   std::vector<ObjectCalcer*> bos = mhier.buildObjects( args, d.document() );
 404   std::vector<ObjectHolder*> hos;
 405   for ( std::vector<ObjectCalcer*>::iterator i = bos.begin();
 406         i != bos.end(); ++i )
 407   {
 408     hos.push_back( new ObjectHolder( *i ) );
 409     hos.back()->calc( d.document() );
 410   }
 411
 412   d.addObjects( hos );
 413 }
 414
 415 QString MacroConstructor::selectStatement(
 416   const std::vector<ObjectCalcer*>& sel, const KigDocument&,
 417   const KigWidget& ) const
 418 {
 419   using namespace std;
 420   Args args;
 421   transform( sel.begin(), sel.end(), back_inserter( args ),
 422              mem_fun( &ObjectCalcer::imp ) );
 423   std::string ret = mparser.selectStatement( args );
 424   if ( ret.empty() ) return QString::null;
 425   else return i18n( ret.c_str() );
 426 }
 427
 428 QString MacroConstructor::useText( const ObjectCalcer& o, const std::vector<ObjectCalcer*>& sel,
 429                                    const KigDocument&, const KigWidget&
 430   ) const
 431 {
 432   using namespace std;
 433   Args args;
 434   transform( sel.begin(), sel.end(), back_inserter( args ),
 435              mem_fun( &ObjectCalcer::imp ) );
 436   std::string ret = mparser.usetext( o.imp(), args );
 437   if ( ret.empty() ) return QString::null;
 438   else return i18n( ret.c_str() );
 439 }
 440
 441 void MacroConstructor::handlePrelim( KigPainter& p, const std::vector<ObjectCalcer*>& sel,
 442                                      const KigDocument& doc, const KigWidget&
 443   ) const
 444 {
 445   if ( sel.size() != mhier.numberOfArgs() ) return;
 446
 447   using namespace std;
 448   Args args;
 449   transform( sel.begin(), sel.end(), back_inserter( args ),
 450              mem_fun( &ObjectCalcer::imp ) );
 451   args = mparser.parse( args );
 452   std::vector<ObjectImp*> ret = mhier.calc( args, doc );
 453   for ( uint i = 0; i < ret.size(); ++i )
 454   {
 455     ObjectDrawer d;
 456     d.draw( *ret[i], p, true );
 457     ret[i]->draw( p );
 458     delete ret[i];
 459   };
 460 }
 461
 462 void SimpleObjectTypeConstructor::plug( KigPart*, KigGUIAction* )
 463 {
 464 }
 465
 466 void MultiObjectTypeConstructor::plug( KigPart*, KigGUIAction* )
 467 {
 468 }
 469
 470 void MergeObjectConstructor::plug( KigPart*, KigGUIAction* )
 471 {
 472 }
 473
 474 void MacroConstructor::plug( KigPart* doc, KigGUIAction* kact )
 475 {
 476   if ( mbuiltin ) return;
 477   if ( mhier.numberOfResults() != 1 )
 478     doc->aMNewOther.append( kact );
 479   else
 480   {
 481     if ( mhier.idOfLastResult() == SegmentImp::stype() )
 482       doc->aMNewSegment.append( kact );
 483     else if ( mhier.idOfLastResult() == PointImp::stype() )
 484       doc->aMNewPoint.append( kact );
 485     else if ( mhier.idOfLastResult() == CircleImp::stype() )
 486       doc->aMNewCircle.append( kact );
 487     else if ( mhier.idOfLastResult()->inherits( AbstractLineImp::stype() ) )
 488       // line or ray
 489       doc->aMNewLine.append( kact );
 490     else if ( mhier.idOfLastResult() == ConicImp::stype() )
 491       doc->aMNewConic.append( kact );
 492     else doc->aMNewOther.append( kact );
 493   };
 494   doc->aMNewAll.append( kact );
 495 }
 496
 497 const ObjectHierarchy& MacroConstructor::hierarchy() const
 498 {
 499   return mhier;
 500 }
 501
 502 bool SimpleObjectTypeConstructor::isTransform() const
 503 {
 504   return mtype->isTransform();
 505 }
 506
 507 bool MultiObjectTypeConstructor::isTransform() const
 508 {
 509   return mtype->isTransform();
 510 }
 511
 512 bool MergeObjectConstructor::isTransform() const
 513 {
 514   bool ret = false;
 515   for ( vectype::const_iterator i = mctors.begin(); i != mctors.end(); ++i )
 516     ret |= (*i)->isTransform();
 517   return ret;
 518 }
 519
 520 bool MacroConstructor::isTransform() const
 521 {
 522   return false;
 523 }
 524
 525 void MacroConstructor::setBuiltin( bool builtin )
 526 {
 527   mbuiltin = builtin;
 528 }
 529
 530 bool ObjectConstructor::isIntersection() const
 531 {
 532   return false;
 533 }
 534
 535 PropertyObjectConstructor::PropertyObjectConstructor(
 536     const ObjectImpType* imprequirement, const char* usetext,
 537     const char* selectstat, const char* descname, const char* desc,
 538     const char* iconfile, const char* propertyinternalname )
 539   : StandardConstructorBase( descname, desc, iconfile, mparser ),
 540     mpropinternalname( propertyinternalname )
 541 {
 542   ArgsParser::spec argsspec[1];
 543   argsspec[0].type = imprequirement;
 544   argsspec[0].usetext = usetext;
 545   argsspec[0].selectstat = selectstat;
 546   mparser.initialize( argsspec, 1 );
 547 }
 548
 549 PropertyObjectConstructor::~PropertyObjectConstructor()
 550 {
 551 }
 552
 553 void PropertyObjectConstructor::drawprelim(
 554   const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& parents,
 555   const KigDocument& d ) const
 556 {
 557   int index = parents[0]->imp()->propertiesInternalNames().findIndex( mpropinternalname );
 558   assert ( index != -1 );
 559   ObjectImp* imp = parents[0]->imp()->property( index, d );
 560   drawer.draw( *imp, p, true );
 561   delete imp;
 562 }
 563
 564 std::vector<ObjectHolder*> PropertyObjectConstructor::build(
 565   const std::vector<ObjectCalcer*>& parents, KigDocument&,
 566   KigWidget& ) const
 567 {
 568   int index = parents[0]->imp()->propertiesInternalNames().findIndex( mpropinternalname );
 569   assert( index != -1 );
 570   std::vector<ObjectHolder*> ret;
 571   ret.push_back(
 572     new ObjectHolder(
 573       new ObjectPropertyCalcer( parents[0], index ) ) );
 574   return ret;
 575 }
 576
 577 void PropertyObjectConstructor::plug( KigPart*, KigGUIAction* )
 578 {
 579 }
 580
 581 bool PropertyObjectConstructor::isTransform() const
 582 {
 583   return false;
 584 }
 585
 586 bool ObjectConstructor::isTest() const
 587 {
 588   return false;
 589 }
 590
 591 BaseConstructMode* ObjectConstructor::constructMode( KigPart& doc )
 592 {
 593   return new ConstructMode( doc, this );
 594 }
 595
 596 void MacroConstructor::setName( const QString& name )
 597 {
 598   mname = name;
 599 }
 600
 601 void MacroConstructor::setDescription( const QString& desc )
 602 {
 603   mdesc = desc;
 604 }
 605
 606 void MacroConstructor::setIcon( QCString& icon )
 607 {
 608   miconfile = icon;
 609 }