kig/objects/other_type.cc

   1 // Copyright (C)  2003  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 "other_type.h"
  19
  20 #include "bogus_imp.h"
  21 #include "point_imp.h"
  22 #include "locus_imp.h"
  23
  24 #include "../misc/common.h"
  25 #include "../misc/calcpaths.h"
  26 #include "../misc/goniometry.h"
  27 #include "../kig/kig_part.h"
  28 #include "../kig/kig_view.h"
  29 #include "../kig/kig_commands.h"
  30
  31 #include <functional>
  32 #include <algorithm>
  33 #include <cmath>
  34
  35 using std::find;
  36
  37 static const struct ArgsParser::spec argsspecLocus[] =
  38 {
  39   { HierarchyImp::stype(), "hierarchy", "SHOULD NOT BE SEEN", false },
  40   { CurveImp::stype(), "curve", "SHOULD NOT BE SEEN", false }
  41 };
  42
  43 KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( LocusType )
  44
  45 LocusType::LocusType()
  46   : ArgsParserObjectType( "Locus", argsspecLocus, 2 )
  47 {
  48 }
  49
  50 LocusType::~LocusType()
  51 {
  52 }
  53
  54 ObjectImp* LocusType::calc( const Args& args, const KigDocument& ) const
  55 {
  56   using namespace std;
  57
  58   assert( args.size() >= 2 );
  59   const Args firsttwo( args.begin(), args.begin() + 2 );
  60   Args fixedargs( args.begin() + 2, args.end() );
  61
  62   if ( ! margsparser.checkArgs( firsttwo ) ) return new InvalidImp;
  63   for ( Args::iterator i = fixedargs.begin(); i != fixedargs.end(); ++i )
  64     if ( ! (*i)->valid() )
  65       return new InvalidImp;
  66
  67   const ObjectHierarchy& hier =
  68     static_cast<const HierarchyImp*>( args[0] )->data();
  69   const CurveImp* curveimp = static_cast<const CurveImp*>( args[1] );
  70
  71   return new LocusImp( curveimp->copy(), hier.withFixedArgs( fixedargs ) );
  72 }
  73
  74 bool LocusType::inherits( int type ) const
  75 {
  76   return type == ID_LocusType ? true : Parent::inherits( type );
  77 }
  78
  79 const ObjectImpType* LocusType::resultId() const
  80 {
  81   return LocusImp::stype();
  82 }
  83
  84 KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( CopyObjectType )
  85
  86 CopyObjectType::CopyObjectType()
  87   : ObjectType( "Copy" )
  88 {
  89 }
  90
  91 CopyObjectType::~CopyObjectType()
  92 {
  93 }
  94
  95 CopyObjectType* CopyObjectType::instance()
  96 {
  97   static CopyObjectType t;
  98   return &t;
  99 }
 100
 101 bool CopyObjectType::inherits( int ) const
 102 {
 103   return false;
 104 }
 105
 106 ObjectImp* CopyObjectType::calc( const Args& parents, const KigDocument& ) const
 107 {
 108   assert( parents.size() == 1 );
 109   return parents[0]->copy();
 110 }
 111
 112 const ObjectImpType* CopyObjectType::impRequirement( const ObjectImp*, const Args& ) const
 113 {
 114   return ObjectImp::stype();
 115 }
 116
 117 const ObjectImpType* CopyObjectType::resultId() const
 118 {
 119   // we don't know what we return..
 120   return ObjectImp::stype();
 121 }
 122
 123 const ObjectImpType* LocusType::impRequirement( const ObjectImp* o, const Args& parents ) const
 124 {
 125   assert( parents.size() >= 2 );
 126   Args firsttwo( parents.begin(), parents.begin() + 2 );
 127   if ( o == parents[0] || o == parents[1] )
 128     return margsparser.impRequirement( o, firsttwo );
 129   else
 130   {
 131     const HierarchyImp* h = dynamic_cast<const HierarchyImp*>( parents[0] );
 132     if (  h )
 133     {
 134       PointImp* p = new PointImp( Coordinate() );
 135       Args hargs( parents.begin()+ 2, parents.end() );
 136       hargs.push_back( p );
 137       ArgsParser hparser = h->data().argParser();
 138       const ObjectImpType* ret = hparser.impRequirement( o, hargs );
 139       delete p;
 140       return ret;
 141     }
 142     else
 143       return ObjectImp::stype();
 144   };
 145 }
 146
 147 const LocusType* LocusType::instance()
 148 {
 149   static const LocusType t;
 150   return &t;
 151 }
 152
 153 std::vector<ObjectCalcer*> CopyObjectType::sortArgs( const std::vector<ObjectCalcer*>& os ) const
 154 {
 155   assert( os.size() == 1 );
 156   return os;
 157 }
 158
 159 std::vector<ObjectCalcer*> LocusType::sortArgs( const std::vector<ObjectCalcer*>& args ) const
 160 {
 161   assert( args.size() >= 2 );
 162   std::vector<ObjectCalcer*> firsttwo( args.begin(), args.begin() + 2 );
 163   firsttwo = margsparser.parse( firsttwo );
 164   std::copy( args.begin() + 2, args.end(), std::back_inserter( firsttwo ) );
 165   return firsttwo;
 166 }
 167
 168 Args LocusType::sortArgs( const Args& args ) const
 169 {
 170   assert( args.size() >= 2 );
 171   Args firsttwo( args.begin(), args.begin() + 2 );
 172   firsttwo = margsparser.parse( firsttwo );
 173   std::copy( args.begin() + 2, args.end(), std::back_inserter( firsttwo ) );
 174   return firsttwo;
 175 }
 176
 177 Args CopyObjectType::sortArgs( const Args& args ) const
 178 {
 179   assert( args.size() == 1 );
 180   return args;
 181 }
 182
 183 bool CopyObjectType::isDefinedOnOrThrough( const ObjectImp*, const Args& ) const
 184 {
 185   // TODO: vragen aan parent ?
 186   // TODO: translate the above TODO ?
 187   return false;
 188 }
 189