diff --git a/modes/macro.cc b/modes/macro.cc
index 341736dd..ad735848 100644
--- a/modes/macro.cc
+++ b/modes/macro.cc
@@ -1,237 +1,237 @@
 // Copyright (C)  2002  Dominique Devriese <devriese@kde.org>
 
 // This program is free software; you can redistribute it and/or
 // modify it under the terms of the GNU General Public License
 // as published by the Free Software Foundation; either version 2
 // of the License, or (at your option) any later version.
 
 // This program is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 // GNU General Public License for more details.
 
 // You should have received a copy of the GNU General Public License
 // along with this program; if not, write to the Free Software
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 // 02110-1301, USA.
 
 #include "macro.h"
 
 #include "macrowizard.h"
 #include "dragrectmode.h"
 #include "../kig/kig_part.h"
 #include "../kig/kig_view.h"
 #include "../misc/kigpainter.h"
 #include "../misc/object_constructor.h"
 #include "../misc/lists.h"
 #include "../misc/guiaction.h"
 #include "../objects/object_imp.h"
 
 #include <klineedit.h>
 #include <kmessagebox.h>
 #include <kcursor.h>
 
 #include <functional>
 #include <algorithm>
 #include <iterator>
 
 using namespace std;
 
 DefineMacroMode::DefineMacroMode( KigPart& d )
   : BaseMode( d )
 {
   mwizard = new MacroWizard( d.widget(), this );
   mwizard->show();
 }
 
 DefineMacroMode::~DefineMacroMode()
 {
   delete mwizard;
 }
 
 void DefineMacroMode::abandonMacro()
 {
   mdoc.doneMode( this );
 }
 
 void DefineMacroMode::enableActions()
 {
   KigMode::enableActions();
   // we don't enable any actions...
 }
 
 void DefineMacroMode::givenPageEntered()
 {
   std::vector<ObjectHolder*> given( mgiven.begin(), mgiven.end() );
   static_cast<KigView*>( mdoc.widget() )->realWidget()->redrawScreen( given );
 }
 
 void DefineMacroMode::finalPageEntered()
 {
   std::vector<ObjectHolder*> final( mfinal.begin(), mfinal.end() );
   static_cast<KigView*>( mdoc.widget() )->realWidget()->redrawScreen( final );
 }
 
 bool DefineMacroMode::validateObjects()
 {
   ObjectCalcer* (ObjectHolder::*memfun)() = &ObjectHolder::calcer;
   std::vector<ObjectCalcer*> given;
   std::transform( mgiven.begin(), mgiven.end(),
                   std::back_inserter( given ),
                   std::mem_fun( memfun ) );
   std::vector<ObjectCalcer*> final;
   std::transform( mfinal.begin(), mfinal.end(),
                   std::back_inserter( final ),
                   std::mem_fun( memfun ) );
   ObjectHierarchy hier( given, final );
-  if ( !hier.resultDependsOnGiven() )
+  if ( !mgiven.empty() && !hier.resultDependsOnGiven() )
   {
     KMessageBox::sorry( mwizard,
                         i18n( "One of the result objects you selected "
                               "cannot be calculated from the given objects. "
                               "Kig cannot calculate this macro because of this. "
                               "Please press Back, and construct the objects "
                               "in the correct order..." ) );
     return false;
   }
   else if( !hier.allGivenObjectsUsed() )
   {
     KMessageBox::sorry( mwizard,
                         i18n( "One of the given objects is not used in the "
                               "calculation of the resultant objects.  This "
                               "probably means you are expecting Kig to do "
                               "something impossible.  Please check the "
                               "macro and try again." ) );
     return false;
   }
 
   static_cast<KigView*>( mdoc.widget() )->realWidget()->redrawScreen( std::vector<ObjectHolder*>() );
 
   return true;
 }
 
 void DefineMacroMode::finishPressed()
 {
   ObjectCalcer* (ObjectHolder::*memfun)() = &ObjectHolder::calcer;
   std::vector<ObjectCalcer*> given;
   std::transform( mgiven.begin(), mgiven.end(),
                   std::back_inserter( given ),
                   std::mem_fun( memfun ) );
   std::vector<ObjectCalcer*> final;
   std::transform( mfinal.begin(), mfinal.end(),
                   std::back_inserter( final ),
                   std::mem_fun( memfun ) );
   ObjectHierarchy hier( given, final );
   MacroConstructor* ctor =
     new MacroConstructor( hier,
                           mwizard->field( "name" ).toString(),
                           mwizard->field( "description" ).toString(),
                           mwizard->field( "icon" ).toByteArray() );
   ConstructibleAction* act = new ConstructibleAction( ctor, 0 );
   MacroList::instance()->add( new Macro( act, ctor ) );
 
   abandonMacro();
 }
 
 void DefineMacroMode::cancelPressed()
 {
   abandonMacro();
 }
 
 void DefineMacroMode::dragRect( const QPoint& p, KigWidget& w )
 {
   if ( mwizard->currentId() == MacroWizard::MacroInfoPageId ) return;
   std::vector<ObjectHolder*>* objs = mwizard->currentId() == MacroWizard::GivenArgsPageId ? &mgiven : &mfinal;
   DragRectMode dm( p, mdoc, w );
   mdoc.runMode( &dm );
   KigPainter pter( w.screenInfo(), &w.stillPix, mdoc.document() );
   if ( ! dm.cancelled() )
   {
     std::vector<ObjectHolder*> ret = dm.ret();
     if ( dm.needClear() )
     {
       pter.drawObjects( objs->begin(), objs->end(), false );
       objs->clear();
     }
 
     std::copy( ret.begin(), ret.end(), std::back_inserter( *objs ) );
     pter.drawObjects( objs->begin(), objs->end(), true );
   };
   w.updateCurPix( pter.overlay() );
   w.updateWidget();
 
   if ( mwizard->currentId() == MacroWizard::GivenArgsPageId )
     mwizard->givenArgsChanged();
   else
     mwizard->finalArgsChanged();
 }
 
 void DefineMacroMode::leftClickedObject( ObjectHolder* o, const QPoint&,
                                          KigWidget& w, bool )
 {
   if ( mwizard->currentId() == MacroWizard::MacroInfoPageId ) return;
   std::vector<ObjectHolder*>* objs = mwizard->currentId() == MacroWizard::GivenArgsPageId ? &mgiven : &mfinal;
   std::vector<ObjectHolder*>::iterator iter = std::find( objs->begin(), objs->end(), o );
   bool isselected = ( iter != objs->end() );
   if ( isselected ) objs->erase( iter );
   else objs->push_back( o );
 
   KigPainter p( w.screenInfo(), &w.stillPix, mdoc.document() );
   p.drawObject( o, !isselected );
   w.updateCurPix( p.overlay() );
   w.updateWidget();
 
   if ( mwizard->currentId() == MacroWizard::GivenArgsPageId )
     mwizard->givenArgsChanged();
   else
     mwizard->finalArgsChanged();
 }
 
 void DefineMacroMode::mouseMoved( const std::vector<ObjectHolder*>& os, const QPoint& pt, KigWidget& w, bool )
 {
   w.updateCurPix();
 
   if ( os.empty() )
   {
     w.setCursor( Qt::ArrowCursor );
     mdoc.emitStatusBarText( 0 );
     w.updateWidget();
   }
   else
   {
     // the cursor is over an object, show object type next to cursor
     // and set statusbar text
 
     w.setCursor( Qt::PointingHandCursor );
     QString selectstat = os.front()->selectStatement();
 
     // statusbar text
     mdoc.emitStatusBarText( selectstat );
     KigPainter p( w.screenInfo(), &w.curPix, mdoc.document() );
 
     // set the text next to the arrow cursor
     QPoint point = pt;
     point.setX(point.x()+15);
 
     p.drawTextStd( point, selectstat );
     w.updateWidget( p.overlay() );
   }
 }
 
 void DefineMacroMode::rightClicked( const std::vector<ObjectHolder*>&, const QPoint&, KigWidget& )
 {
 }
 
 void DefineMacroMode::midClicked( const QPoint&, KigWidget& )
 {
 }
 
 bool DefineMacroMode::hasGivenArgs() const
 {
   return !mgiven.empty();
 }
 
 bool DefineMacroMode::hasFinalArgs() const
 {
   return !mfinal.empty();
 }
diff --git a/modes/macrowizard.cc b/modes/macrowizard.cc
index 8f657291..7fdf3fe0 100644
--- a/modes/macrowizard.cc
+++ b/modes/macrowizard.cc
@@ -1,233 +1,233 @@
 // Copyright (C)  2002  Dominique Devriese <devriese@kde.org>
 
 // This program is free software; you can redistribute it and/or
 // modify it under the terms of the GNU General Public License
 // as published by the Free Software Foundation; either version 2
 // of the License, or (at your option) any later version.
 
 // This program is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 // GNU General Public License for more details.
 
 // You should have received a copy of the GNU General Public License
 // along with this program; if not, write to the Free Software
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 // 02110-1301, USA.
 
 #include "macrowizard.h"
 
 
 #include "macro.h"
 
 #include <qlabel.h>
 #include <qlayout.h>
 
 #include <QDebug>
 #include <QDialog>
 #include <QLineEdit>
 
 #include <KHelpClient>
 #include <KIconButton>
 #include <KLocalizedString>
 
 class GivenArgsPage
   : public QWizardPage
 {
 public:
   GivenArgsPage( QWidget* parent, DefineMacroMode* mode );
 
   bool isComplete() const Q_DECL_OVERRIDE;
 
   void setChanged();
 
 private:
   DefineMacroMode* mmode;
 };
 
 GivenArgsPage::GivenArgsPage( QWidget* parent, DefineMacroMode* mode )
   : QWizardPage( parent ), mmode( mode )
 {
   setTitle( i18n( "Given Objects" ) );
   setSizePolicy( QSizePolicy::Expanding, QSizePolicy::Expanding );
 
   QVBoxLayout* lay = new QVBoxLayout( this );
   lay->setMargin( 0 );
   QLabel* label = new QLabel( this );
   lay->addWidget( label );
   label->setText( i18n( "Select the \"given\" objects for your new macro and press \"Next\"." ) );
   label->setAlignment( Qt::AlignCenter );
 }
 
 bool GivenArgsPage::isComplete() const
 {
-  return mmode->hasGivenArgs();
+  return true;
 }
 
 void GivenArgsPage::setChanged()
 {
   emit completeChanged();
 }
 
 
 class FinalArgsPage
   : public QWizardPage
 {
 public:
   FinalArgsPage( QWidget* parent, DefineMacroMode* mode );
 
   bool isComplete() const Q_DECL_OVERRIDE;
   bool validatePage() Q_DECL_OVERRIDE;
 
   void setChanged();
 
 private:
   DefineMacroMode* mmode;
 };
 
 FinalArgsPage::FinalArgsPage( QWidget* parent, DefineMacroMode* mode )
   : QWizardPage( parent ), mmode( mode )
 {
   setTitle( i18n( "Final Object" ) );
   setSizePolicy( QSizePolicy::Expanding, QSizePolicy::Expanding );
 
   QVBoxLayout* lay = new QVBoxLayout( this );
   lay->setMargin( 0 );
   QLabel* label = new QLabel( this );
   lay->addWidget( label );
   label->setText( i18n( "Select the final object(s) for your new macro." ) );
   label->setAlignment( Qt::AlignCenter );
 }
 
 bool FinalArgsPage::isComplete() const
 {
   return mmode->hasFinalArgs();
 }
 
 bool FinalArgsPage::validatePage()
 {
   return mmode->validateObjects();
 }
 
 void FinalArgsPage::setChanged()
 {
   emit completeChanged();
 }
 
 
 class MacroInfoPage
   : public QWizardPage
 {
 public:
   MacroInfoPage( QWidget* parent );
 };
 
 MacroInfoPage::MacroInfoPage( QWidget* parent )
   : QWizardPage( parent )
 {
   setTitle( i18n( "Name" ) );
   setSubTitle( i18n( "Enter a name and description for your new type." ) );
   setSizePolicy( QSizePolicy::Expanding, QSizePolicy::Expanding );
   setFinalPage( true );
 
   //TODO Make this a ui file
   QGridLayout* lay = new QGridLayout( this );
   lay->setMargin( 0 );
   QLabel* label = new QLabel( this );
   lay->addWidget( label, 0, 0 );
   label->setText( i18n( "&Name:" ) );
   label->setAlignment( Qt::AlignRight );
   QLineEdit* editname = new QLineEdit( this );
   lay->addWidget( editname, 0, 1 );
   label->setBuddy( editname );
   label = new QLabel( this );
   lay->addWidget( label, 1, 0 );
   label->setText( i18n( "&Description:" ) );
   label->setAlignment( Qt::AlignRight );
   QLineEdit* editdesc = new QLineEdit( this );
   lay->addWidget( editdesc, 1, 1 );
   label->setBuddy( editdesc );
   label = new QLabel( this );
   label->setText( i18n( "&Icon:" ) );
   label->setAlignment( Qt::AlignRight );
   lay->addWidget( label, 2, 0 );
   QHBoxLayout* iconlay = new QHBoxLayout();
   lay->addLayout( iconlay, 2, 1 );
   KIconButton* iconbutton = new KIconButton( this );
   iconlay->addWidget( iconbutton );
   label->setBuddy( iconbutton );
   iconbutton->setIcon( "system-run" );
   iconlay->addItem( new QSpacerItem( 5, 5, QSizePolicy::Expanding, QSizePolicy::Fixed ) );
 
   registerField( "name*", editname );
   registerField( "description", editdesc );
   registerField( "icon", iconbutton, "icon", SIGNAL( iconChanged( const QString& ) ) );
 }
 
 
 MacroWizard::MacroWizard( QWidget* parent, DefineMacroMode* m )
   : QWizard( parent ), mmode( m )
 {
   setModal( false );
   setObjectName( QLatin1String( "Define Macro Wizard" ) );
   setWindowTitle( i18n( "Define New Macro" ) );
   setOption( HaveHelpButton );
 
   mgivenArgsPage = new GivenArgsPage( this, mmode );
   setPage( GivenArgsPageId, mgivenArgsPage );
   mfinalArgsPage = new FinalArgsPage( this, mmode );
   setPage( FinalArgsPageId, mfinalArgsPage );
   setPage( MacroInfoPageId, new MacroInfoPage( this ) );
 
   connect( this, SIGNAL( helpRequested() ), this,
            SLOT( slotHelpClicked() ) );
   connect( this, SIGNAL( currentIdChanged( int ) ), this, SLOT( currentIdChanged( int ) ) );
 }
 
 MacroWizard::~MacroWizard()
 {
 }
 
 void MacroWizard::reject()
 {
   QWizard::reject();
   mmode->cancelPressed();
 }
 
 void MacroWizard::accept()
 {
   QWizard::accept();
   mmode->finishPressed();
 }
 
 void MacroWizard::slotHelpClicked()
 {
   KHelpClient::invokeHelp( "defining-macros", "kig" );
 }
 
 void MacroWizard::currentIdChanged( int id )
 {
   switch ( id )
   {
     case GivenArgsPageId:
       mmode->givenPageEntered();
       break;
     case FinalArgsPageId:
       mmode->finalPageEntered();
       break;
     case -1: // no id - skip it
       break;
     default:
       ;
   }
 }
 
 void MacroWizard::givenArgsChanged()
 {
   mgivenArgsPage->setChanged();
 }
 
 void MacroWizard::finalArgsChanged()
 {
   mfinalArgsPage->setChanged();
 }
diff --git a/modes/popup/objectconstructoractionsprovider.cc b/modes/popup/objectconstructoractionsprovider.cc
index 9e7baec3..50c3ba0b 100644
--- a/modes/popup/objectconstructoractionsprovider.cc
+++ b/modes/popup/objectconstructoractionsprovider.cc
@@ -1,97 +1,98 @@
 /**
     This file is part of Kig, a KDE program for Interactive Geometry...
     Copyright (C) 2012  David E. Narvaez <david.narvaez@computer.org>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License along
     with this program; if not, write to the Free Software Foundation, Inc.,
     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
 #include "objectconstructoractionsprovider.h"
 
 #include "../../kig/kig_part.h"
 #include "../../kig/kig_view.h"
 #include "../../misc/argsparser.h"
 #include "../../misc/lists.h"
 #include "../../misc/object_constructor.h"
 #include "../../modes/construct_mode.h"
 #include "../../modes/normal.h"
 
 #include <KIconEngine>
 
 void ObjectConstructorActionsProvider::fillUpMenu( NormalModePopupObjects& popup, int menu, int& nextfree )
 {
   const KigDocument& d = popup.part().document();
   const KigWidget& v = popup.widget();
   typedef ObjectConstructorList::vectype vectype;
   vectype vec = ObjectConstructorList::instance()->constructors();
 
   for ( vectype::iterator i = vec.begin(); i != vec.end(); ++i )
   {
     bool add = false;
     if ( popup.objects().empty() )
     {
-      add = menu == NormalModePopupObjects::StartMenu && ! (*i)->isTransform() && ! (*i)->isTest();
+      add = ( menu == NormalModePopupObjects::StartMenu && ! ( *i )->isTransform() && ! ( *i )->isTest() )
+            || ( menu == NormalModePopupObjects::ConstructMenu && ( *i )->wantArgs( {}, d, v ) == ArgsParser::Complete );
     }
     else
     {
       int ret = (*i)->wantArgs( getCalcers( popup.objects() ), d, v );
       if ( ret == ArgsParser::Invalid ) continue;
       if ( (*i)->isTransform() && popup.objects().size() == 1 ) add = menu == NormalModePopupObjects::TransformMenu;
       else if ( (*i)->isTest() ) add = menu == NormalModePopupObjects::TestMenu;
       else if ( ( *i )->isIntersection() ) add = menu == NormalModePopupObjects::ToplevelMenu;
       else if ( ret == ArgsParser::Complete ) add = menu == NormalModePopupObjects::ConstructMenu;
       else add = menu == NormalModePopupObjects::StartMenu;
     };
     if ( add )
     {
       QByteArray iconfile = (*i)->iconFileName();
       if ( !iconfile.isEmpty() && !iconfile.isNull() )
       {
         popup.addInternalAction( menu, QIcon( new KIconEngine( iconfile, popup.part().iconLoader() ) ), (*i)->descriptiveName(), nextfree++ );
       }
       else
         popup.addInternalAction( menu, (*i)->descriptiveName(), nextfree++ );
       mctors[menu].push_back( *i );
     }
   };
 }
 
 bool ObjectConstructorActionsProvider::executeAction(
   int menu, int& id, const std::vector<ObjectHolder*>& os,
   NormalModePopupObjects&,
   KigPart& doc, KigWidget& w, NormalMode& m )
 {
   if ( (uint) id >= mctors[menu].size() )
   {
     id -= mctors[menu].size();
     return false;
   }
 
   ObjectConstructor* ctor = mctors[menu][id];
   std::vector<ObjectCalcer*> osc = getCalcers( os );
-  if ( ! os.empty() && ctor->wantArgs( osc, doc.document(), w ) == ArgsParser::Complete )
+  if ( ctor->wantArgs( osc, doc.document(), w ) == ArgsParser::Complete )
   {
     ctor->handleArgs( osc, doc, w );
     m.clearSelection();
   }
   else
   {
     BaseConstructMode* mode = ctor->constructMode( doc );
     mode->selectObjects( os, w );
     doc.runMode( mode );
     delete mode;
   };
   return true;
 }