kig/misc/guiaction.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 "guiaction.h"
  19 #include "guiaction.moc"
  20
  21 #include "coordinate_system.h"
  22 #include "coordinate.h"
  23 #include "object_constructor.h"
  24
  25 #include "../kig/kig_part.h"
  26 #include "../kig/kig_document.h"
  27 #include "../modes/construct_mode.h"
  28 #include "../modes/label.h"
  29 #include "../objects/object_holder.h"
  30 #include "../objects/object_factory.h"
  31 #include "../objects/bogus_imp.h"
  32
  33 #include <kiconloader.h>
  34 #include <klocale.h>
  35
  36 #include <qregexp.h>
  37
  38 int GUIAction::shortcut() const
  39 {
  40   return 0;
  41 }
  42
  43 GUIAction::~GUIAction()
  44 {
  45 }
  46
  47 ConstructibleAction::~ConstructibleAction()
  48 {
  49 }
  50
  51 ConstructibleAction::ConstructibleAction(
  52   ObjectConstructor* ctor,
  53   const QCString& actionname,
  54   int shortcut )
  55   : GUIAction(), mctor( ctor ), mactionname( actionname ), mshortcut( shortcut )
  56 {
  57 }
  58
  59 QString ConstructibleAction::description() const
  60 {
  61   return mctor->description();
  62 }
  63
  64 QCString ConstructibleAction::iconFileName() const
  65 {
  66   return mctor->iconFileName();
  67 }
  68
  69 QString ConstructibleAction::descriptiveName() const
  70 {
  71   return mctor->descriptiveName();
  72 }
  73
  74 void ConstructibleAction::act( KigPart& d )
  75 {
  76   BaseConstructMode* m = mctor->constructMode( d );
  77   d.runMode( m );
  78   delete m;
  79 }
  80
  81 KigGUIAction::KigGUIAction( GUIAction* act,
  82                             KigPart& doc,
  83                             QObject* parent )
  84   : KAction( act->descriptiveName(),
  85              doc.instance()->iconLoader()->loadIcon(
  86                act->iconFileName(), KIcon::User ),
  87              act->shortcut(),
  88              0, 0,              // no slot connection
  89              parent, act->actionName() ),
  90   mact( act ),
  91   mdoc( doc )
  92 {
  93   setWhatsThis( act->description() );
  94   QString tooltip = act->descriptiveName();
  95   tooltip.replace( QRegExp( "&&" ), "&" );
  96   setToolTip( tooltip );
  97 }
  98
  99 void KigGUIAction::slotActivated()
 100 {
 101   mact->act( mdoc );
 102 }
 103
 104 const char* ConstructibleAction::actionName() const
 105 {
 106   return mactionname;
 107 }
 108
 109 ConstructPointAction::~ConstructPointAction()
 110 {
 111 }
 112
 113 QString ConstructPointAction::description() const
 114 {
 115   return i18n(
 116     "A normal point, i.e. one that is either independent or attached "
 117     "to a line, circle, segment."
 118     );
 119 }
 120
 121 QCString ConstructPointAction::iconFileName() const
 122 {
 123   return "point";
 124 }
 125
 126 QString ConstructPointAction::descriptiveName() const
 127 {
 128   return i18n("Point");
 129 }
 130
 131 const char* ConstructPointAction::actionName() const
 132 {
 133   return mactionname;
 134 }
 135
 136 int ConstructPointAction::shortcut() const
 137 {
 138   return Qt::Key_P;
 139 }
 140
 141 void ConstructPointAction::act( KigPart& d )
 142 {
 143   PointConstructMode m( d );
 144   d.runMode( &m );
 145 }
 146
 147 ConstructPointAction::ConstructPointAction( const char* actionname )
 148   : mactionname( actionname )
 149 {
 150 }
 151
 152 GUIAction* KigGUIAction::guiAction()
 153 {
 154   return mact;
 155 }
 156
 157 void KigGUIAction::plug( KigPart* doc )
 158 {
 159   mact->plug( doc, this );
 160 }
 161
 162 void ConstructibleAction::plug( KigPart* doc, KigGUIAction* kact )
 163 {
 164   mctor->plug( doc, kact );
 165 }
 166
 167 QString ConstructTextLabelAction::description() const
 168 {
 169   return i18n( "Construct a text label." );
 170 }
 171
 172 QCString ConstructTextLabelAction::iconFileName() const
 173 {
 174   return "text";
 175 }
 176
 177 QString ConstructTextLabelAction::descriptiveName() const
 178 {
 179   return i18n( "Text Label" );
 180 }
 181
 182 const char* ConstructTextLabelAction::actionName() const
 183 {
 184   return mactionname;
 185 }
 186
 187 void ConstructTextLabelAction::act( KigPart& d )
 188 {
 189   TextLabelConstructionMode m( d );
 190   d.runMode( &m );
 191 }
 192
 193 ConstructTextLabelAction::ConstructTextLabelAction( const char* actionname )
 194   : mactionname( actionname )
 195 {
 196 }
 197
 198 QString AddFixedPointAction::description() const
 199 {
 200   return i18n( "Construct a Point by its Coordinates" );
 201 }
 202
 203 QCString AddFixedPointAction::iconFileName() const
 204 {
 205   return "pointxy";
 206 }
 207
 208 QString AddFixedPointAction::descriptiveName() const
 209 {
 210   return i18n( "Point by Coordinates" );
 211 }
 212
 213 const char* AddFixedPointAction::actionName() const
 214 {
 215   return mactionname;
 216 }
 217
 218 void AddFixedPointAction::act( KigPart& doc )
 219 {
 220   bool ok;
 221   Coordinate c = doc.document().coordinateSystem().getCoordFromUser(
 222     i18n( "Fixed Point" ),
 223     i18n( "Enter the coordinates for the new point." ) +
 224     QString::fromLatin1("\n") +
 225     doc.document().coordinateSystem().coordinateFormatNotice(),
 226     doc.document(), doc.widget(), &ok );
 227   if ( ! ok ) return;
 228   ObjectHolder* p = ObjectFactory::instance()->fixedPoint( c );
 229   p->calc( doc.document() );
 230   doc.addObject( p );
 231 }
 232
 233 AddFixedPointAction::AddFixedPointAction( const char* actionname )
 234   : mactionname( actionname )
 235 {
 236 }
 237
 238 AddFixedPointAction::~AddFixedPointAction()
 239 {
 240 }
 241
 242 void GUIAction::plug( KigPart*, KigGUIAction* )
 243 {
 244 }
 245
 246 int ConstructibleAction::shortcut() const
 247 {
 248   return mshortcut;
 249 }
 250
 251 int ConstructTextLabelAction::shortcut() const
 252 {
 253   return Qt::Key_B;
 254 }
 255
 256 int AddFixedPointAction::shortcut() const
 257 {
 258   return Qt::Key_F;
 259 }
 260
 261 #if 0
 262 TestAction::TestAction( const char* actionname )
 263   : mactionname( actionname )
 264 {
 265 }
 266
 267 TestAction::~TestAction()
 268 {
 269 }
 270
 271 QString TestAction::description() const
 272 {
 273   return QString::fromLatin1( "Test stuff !!!" );
 274 }
 275
 276 QCString TestAction::iconFileName() const
 277 {
 278   return "new";
 279 }
 280
 281 QString TestAction::descriptiveName() const
 282 {
 283   return QString::fromLatin1( "Test stuff !!!" );
 284 }
 285
 286 const char* TestAction::actionName() const
 287 {
 288   return mactionname;
 289 }
 290
 291 void TestAction::act( KigPart& doc )
 292 {
 293   const char* script =
 294     "def calc( a ):\n\treturn Point( a.coordinate() + Coordinate( 2, 0 ) )\n";
 295   Object* constantpoint = ObjectFactory::instance()->fixedPoint( Coordinate( -1, -1 ) );
 296   constantpoint->calc( doc );
 297
 298   Object* codeobject = new DataObject( new StringImp( QString::fromLatin1( script ) ) );
 299   Object* compiledcode = new RealObject( PythonCompileType::instance(), Objects( codeobject ) );
 300   compiledcode->calc( doc );
 301
 302   Objects args( compiledcode );
 303   args.push_back( constantpoint );
 304   Object* scriptobject = new RealObject( PythonExecuteType::instance(), args );
 305   scriptobject->calc( doc );
 306
 307   doc.addObject( constantpoint );
 308   doc.addObject( scriptobject );
 309 }
 310
 311 #endif // if 0 ( TestAction )
 312
 313 #ifdef KIG_ENABLE_PYTHON_SCRIPTING
 314 #include "../scripting/python_type.h"
 315 #include "../scripting/script_mode.h"
 316
 317 NewScriptAction::NewScriptAction( const char* descname, const char* description,
 318                                   const char* actionname, const ScriptType::Type type,
 319                                   const char* icon )
 320   : GUIAction(), mactionname( actionname ), mdescname( descname ),
 321     mdescription( description ), micon( icon ), mtype( type )
 322 {
 323   if ( QString( micon ).isEmpty() )
 324   {
 325     micon = ScriptType::icon( type );
 326   }
 327 }
 328
 329 NewScriptAction::~NewScriptAction()
 330 {
 331 }
 332
 333 QString NewScriptAction::description() const
 334 {
 335   return i18n( mdescription );
 336 }
 337
 338 QCString NewScriptAction::iconFileName() const
 339 {
 340   return micon;
 341 }
 342
 343 QString NewScriptAction::descriptiveName() const
 344 {
 345   return i18n( mdescname );
 346 }
 347
 348 const char* NewScriptAction::actionName() const
 349 {
 350   return mactionname;
 351 }
 352
 353 void NewScriptAction::act( KigPart& doc )
 354 {
 355   ScriptMode m( doc );
 356   m.setScriptType( mtype );
 357   doc.runMode( &m );
 358 }
 359
 360 int NewScriptAction::shortcut() const
 361 {
 362   return 0;
 363 }
 364
 365 #endif // if KIG_ENABLE_PYTHON_SCRIPTING ( NewScriptAction )