• Skip to content
  • Skip to link menu
KDE API Reference
  • KDE API Reference
  • kdeedu API Reference
  • KDE Home
  • Contact Us
 

kig

  • sources
  • kde-4.14
  • kdeedu
  • kig
  • modes
macro.cc
Go to the documentation of this file.
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., 51 Franklin Street, Fifth Floor, Boston, MA
16 // 02110-1301, USA.
17 
18 #include "macro.h"
19 
20 #include "macrowizard.h"
21 #include "dragrectmode.h"
22 #include "../kig/kig_part.h"
23 #include "../kig/kig_view.h"
24 #include "../misc/kigpainter.h"
25 #include "../misc/object_constructor.h"
26 #include "../misc/lists.h"
27 #include "../misc/guiaction.h"
28 #include "../objects/object_imp.h"
29 
30 #include <klineedit.h>
31 #include <kmessagebox.h>
32 #include <kcursor.h>
33 #include <klocale.h>
34 
35 #include <functional>
36 #include <algorithm>
37 #include <iterator>
38 
39 using namespace std;
40 
41 DefineMacroMode::DefineMacroMode( KigPart& d )
42  : BaseMode( d )
43 {
44  mwizard = new MacroWizard( d.widget(), this );
45  mwizard->show();
46 }
47 
48 DefineMacroMode::~DefineMacroMode()
49 {
50  delete mwizard;
51 }
52 
53 void DefineMacroMode::abandonMacro()
54 {
55  mdoc.doneMode( this );
56 }
57 
58 void DefineMacroMode::enableActions()
59 {
60  KigMode::enableActions();
61  // we don't enable any actions...
62 }
63 
64 void DefineMacroMode::givenPageEntered()
65 {
66  std::vector<ObjectHolder*> given( mgiven.begin(), mgiven.end() );
67  static_cast<KigView*>( mdoc.widget() )->realWidget()->redrawScreen( given );
68 }
69 
70 void DefineMacroMode::finalPageEntered()
71 {
72  std::vector<ObjectHolder*> final( mfinal.begin(), mfinal.end() );
73  static_cast<KigView*>( mdoc.widget() )->realWidget()->redrawScreen( final );
74 }
75 
76 bool DefineMacroMode::validateObjects()
77 {
78  bool res = true;
79  ObjectCalcer* (ObjectHolder::*memfun)() = &ObjectHolder::calcer;
80  std::vector<ObjectCalcer*> given;
81  std::transform( mgiven.begin(), mgiven.end(),
82  std::back_inserter( given ),
83  std::mem_fun( memfun ) );
84  std::vector<ObjectCalcer*> final;
85  std::transform( mfinal.begin(), mfinal.end(),
86  std::back_inserter( final ),
87  std::mem_fun( memfun ) );
88  ObjectHierarchy hier( given, final );
89  if ( hier.resultDoesNotDependOnGiven() )
90  {
91  KMessageBox::sorry( mwizard,
92  i18n( "One of the result objects you selected "
93  "cannot be calculated from the given objects. "
94  "Kig cannot calculate this macro because of this. "
95  "Please press Back, and construct the objects "
96  "in the correct order..." ) );
97  res = false;
98  }
99  else if( !hier.allGivenObjectsUsed() )
100  {
101  KMessageBox::sorry( mwizard,
102  i18n( "One of the given objects is not used in the "
103  "calculation of the resultant objects. This "
104  "probably means you are expecting Kig to do "
105  "something impossible. Please check the "
106  "macro and try again." ) );
107  res = false;
108  }
109 
110  static_cast<KigView*>( mdoc.widget() )->realWidget()->redrawScreen( std::vector<ObjectHolder*>() );
111 
112  return res;
113 }
114 
115 void DefineMacroMode::finishPressed()
116 {
117  ObjectCalcer* (ObjectHolder::*memfun)() = &ObjectHolder::calcer;
118  std::vector<ObjectCalcer*> given;
119  std::transform( mgiven.begin(), mgiven.end(),
120  std::back_inserter( given ),
121  std::mem_fun( memfun ) );
122  std::vector<ObjectCalcer*> final;
123  std::transform( mfinal.begin(), mfinal.end(),
124  std::back_inserter( final ),
125  std::mem_fun( memfun ) );
126  ObjectHierarchy hier( given, final );
127  MacroConstructor* ctor =
128  new MacroConstructor( hier,
129  mwizard->field( "name" ).toString(),
130  mwizard->field( "description" ).toString(),
131  mwizard->field( "icon" ).toByteArray() );
132  ConstructibleAction* act = new ConstructibleAction( ctor, 0 );
133  MacroList::instance()->add( new Macro( act, ctor ) );
134 
135  abandonMacro();
136 }
137 
138 void DefineMacroMode::cancelPressed()
139 {
140  abandonMacro();
141 }
142 
143 void DefineMacroMode::dragRect( const QPoint& p, KigWidget& w )
144 {
145  if ( mwizard->currentId() == MacroWizard::MacroInfoPageId ) return;
146  std::vector<ObjectHolder*>* objs = mwizard->currentId() == MacroWizard::GivenArgsPageId ? &mgiven : &mfinal;
147  DragRectMode dm( p, mdoc, w );
148  mdoc.runMode( &dm );
149  KigPainter pter( w.screenInfo(), &w.stillPix, mdoc.document() );
150  if ( ! dm.cancelled() )
151  {
152  std::vector<ObjectHolder*> ret = dm.ret();
153  if ( dm.needClear() )
154  {
155  pter.drawObjects( objs->begin(), objs->end(), false );
156  objs->clear();
157  }
158 
159  std::copy( ret.begin(), ret.end(), std::back_inserter( *objs ) );
160  pter.drawObjects( objs->begin(), objs->end(), true );
161  };
162  w.updateCurPix( pter.overlay() );
163  w.updateWidget();
164 
165  if ( mwizard->currentId() == MacroWizard::GivenArgsPageId )
166  mwizard->givenArgsChanged();
167  else
168  mwizard->finalArgsChanged();
169 }
170 
171 void DefineMacroMode::leftClickedObject( ObjectHolder* o, const QPoint&,
172  KigWidget& w, bool )
173 {
174  if ( mwizard->currentId() == MacroWizard::MacroInfoPageId ) return;
175  std::vector<ObjectHolder*>* objs = mwizard->currentId() == MacroWizard::GivenArgsPageId ? &mgiven : &mfinal;
176  std::vector<ObjectHolder*>::iterator iter = std::find( objs->begin(), objs->end(), o );
177  bool isselected = ( iter != objs->end() );
178  if ( isselected ) objs->erase( iter );
179  else objs->push_back( o );
180 
181  KigPainter p( w.screenInfo(), &w.stillPix, mdoc.document() );
182  p.drawObject( o, !isselected );
183  w.updateCurPix( p.overlay() );
184  w.updateWidget();
185 
186  if ( mwizard->currentId() == MacroWizard::GivenArgsPageId )
187  mwizard->givenArgsChanged();
188  else
189  mwizard->finalArgsChanged();
190 }
191 
192 void DefineMacroMode::mouseMoved( const std::vector<ObjectHolder*>& os, const QPoint& pt, KigWidget& w, bool )
193 {
194  w.updateCurPix();
195 
196  if ( os.empty() )
197  {
198  w.setCursor( Qt::ArrowCursor );
199  mdoc.emitStatusBarText( 0 );
200  w.updateWidget();
201  }
202  else
203  {
204  // the cursor is over an object, show object type next to cursor
205  // and set statusbar text
206 
207  w.setCursor( Qt::PointingHandCursor );
208  QString selectstat = os.front()->selectStatement();
209 
210  // statusbar text
211  mdoc.emitStatusBarText( selectstat );
212  KigPainter p( w.screenInfo(), &w.curPix, mdoc.document() );
213 
214  // set the text next to the arrow cursor
215  QPoint point = pt;
216  point.setX(point.x()+15);
217 
218  p.drawTextStd( point, selectstat );
219  w.updateWidget( p.overlay() );
220  }
221 }
222 
223 void DefineMacroMode::rightClicked( const std::vector<ObjectHolder*>&, const QPoint&, KigWidget& )
224 {
225 }
226 
227 void DefineMacroMode::midClicked( const QPoint&, KigWidget& )
228 {
229 }
230 
231 bool DefineMacroMode::hasGivenArgs() const
232 {
233  return !mgiven.empty();
234 }
235 
236 bool DefineMacroMode::hasFinalArgs() const
237 {
238  return !mfinal.empty();
239 }
DefineMacroMode::cancelPressed
void cancelPressed()
Definition: macro.cc:138
QWizard::field
QVariant field(const QString &name) const
DefineMacroMode::rightClicked
void rightClicked(const std::vector< ObjectHolder * > &oco, const QPoint &p, KigWidget &w)
Definition: macro.cc:223
DefineMacroMode::mgiven
std::vector< ObjectHolder * > mgiven
Definition: macro.h:65
QVariant::toByteArray
QByteArray toByteArray() const
DefineMacroMode::~DefineMacroMode
~DefineMacroMode()
Definition: macro.cc:48
ObjectHierarchy
Definition: object_hierarchy.h:30
QWidget::setCursor
void setCursor(const QCursor &)
DefineMacroMode::abandonMacro
void abandonMacro()
quit this mode...
Definition: macro.cc:53
QWizard::currentId
currentId
DragRectMode::needClear
bool needClear() const
this returns false if the control or shift button were pressed when the mouse button was released...
Definition: dragrectmode.cc:82
DefineMacroMode::hasFinalArgs
bool hasFinalArgs() const
Definition: macro.cc:236
KigPart::document
const KigDocument & document() const
Definition: kig_part.cpp:986
DragRectMode::cancelled
bool cancelled() const
whether the user cancelled the rect mode.
Definition: dragrectmode.cc:170
MacroWizard::givenArgsChanged
void givenArgsChanged()
Definition: macrowizard.cc:226
KigPart::emitStatusBarText
void emitStatusBarText(const QString &text)
Definition: kig_part.cpp:692
QPoint
KigMode::enableActions
virtual void enableActions()
actions: we enable the actions we want when our mode is made active.
Definition: mode.cc:27
dragrectmode.h
BaseMode
The BaseMode is a particular mode that allows an easy mapping of the mouse actions to real...
Definition: base_mode.h:33
DefineMacroMode::dragRect
void dragRect(const QPoint &p, KigWidget &w)
Definition: macro.cc:143
KigMode::mdoc
KigPart & mdoc
Definition: mode.h:94
DragRectMode::ret
std::vector< ObjectHolder * > ret() const
this returns the selected objects.
Definition: dragrectmode.cc:77
MacroWizard::MacroInfoPageId
static const int MacroInfoPageId
Definition: macrowizard.h:36
KigWidget::screenInfo
const ScreenInfo & screenInfo() const
the part of the document we're currently showing i.e.
Definition: kig_view.cpp:272
KigView
This class is a wrapper for KigWidget.
Definition: kig_view.h:229
MacroList::add
void add(Macro *m)
Add a Macro m .
Definition: lists.cc:213
MacroConstructor
MacroConstructor is a class that represents Kig macro's: these are constructed by the user...
Definition: object_constructor.h:336
DefineMacroMode::hasGivenArgs
bool hasGivenArgs() const
Definition: macro.cc:231
KigPainter
KigPainter is an extended QPainter.
Definition: kigpainter.h:51
MacroWizard::finalArgsChanged
void finalArgsChanged()
Definition: macrowizard.cc:231
ObjectHolder
An ObjectHolder represents an object as it is known to the document.
Definition: object_holder.h:40
ObjectCalcer
An ObjectCalcer is an object that represents an algorithm for calculating an ObjectImp from other Obj...
Definition: object_calcer.h:66
DefineMacroMode::leftClickedObject
void leftClickedObject(ObjectHolder *o, const QPoint &p, KigWidget &w, bool ctrlOrShiftDown)
Definition: macro.cc:171
KigPart::runMode
void runMode(KigMode *)
Definition: kig_part.cpp:732
DefineMacroMode::DefineMacroMode
DefineMacroMode(KigPart &)
Definition: macro.cc:41
DefineMacroMode::mwizard
MacroWizard * mwizard
Definition: macro.h:62
DefineMacroMode::enableActions
void enableActions()
actions: we enable the actions we want when our mode is made active.
Definition: macro.cc:58
KigWidget
This class is the real widget showing the document.
Definition: kig_view.h:50
QString
DefineMacroMode::finalPageEntered
void finalPageEntered()
Definition: macro.cc:70
KigPart::doneMode
void doneMode(KigMode *)
Definition: kig_part.cpp:746
macrowizard.h
KigWidget::updateCurPix
void updateCurPix(const std::vector< QRect > &=std::vector< QRect >())
update curPix (bitBlt stillPix onto curPix..)
Definition: kig_view.cpp:187
ObjectHolder::calcer
const ObjectCalcer * calcer() const
Definition: object_holder.cc:53
KigPainter::drawObject
void drawObject(const ObjectHolder *o, bool sel)
draw an object ( by calling its draw function.
Definition: kigpainter.cpp:513
ConstructibleAction
Definition: guiaction.h:68
DefineMacroMode::givenPageEntered
void givenPageEntered()
Definition: macro.cc:64
DefineMacroMode::validateObjects
bool validateObjects()
Definition: macro.cc:76
KigWidget::curPix
QPixmap curPix
temporary, gets bitBlt'd (copied) onto the widget (to avoid flickering)
Definition: kig_view.h:84
DefineMacroMode::mfinal
std::vector< ObjectHolder * > mfinal
Definition: macro.h:66
MacroWizard
Definition: macrowizard.h:27
DefineMacroMode::mouseMoved
void mouseMoved(const std::vector< ObjectHolder * > &os, const QPoint &p, KigWidget &w, bool shiftpressed)
Definition: macro.cc:192
DefineMacroMode::finishPressed
void finishPressed()
Definition: macro.cc:115
Macro
this is just a simple data struct.
Definition: lists.h:91
KigWidget::updateWidget
void updateWidget(const std::vector< QRect > &=std::vector< QRect >())
this means bitBlting curPix on the actual widget...
Definition: kig_view.cpp:115
QPoint::setX
void setX(int x)
MacroWizard::GivenArgsPageId
static const int GivenArgsPageId
Definition: macrowizard.h:34
QWidget::show
void show()
KigPart
This is a "Part".
Definition: kig_part.h:68
macro.h
DefineMacroMode::midClicked
void midClicked(const QPoint &p, KigWidget &w)
Definition: macro.cc:227
QVariant::toString
QString toString() const
KigWidget::stillPix
QPixmap stillPix
what do the still objects look like wondering if this is appropriate, maybe it should be part of Movi...
Definition: kig_view.h:79
MacroList::instance
static MacroList * instance()
MacroList is a singleton.
Definition: lists.cc:195
DragRectMode
DragRectMode is a mode that provides a rect for selecting the objects inside it.
Definition: dragrectmode.h:40
This file is part of the KDE documentation.
Documentation copyright © 1996-2020 The KDE developers.
Generated on Mon Jun 22 2020 13:12:05 by doxygen 1.8.7 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.

kig

Skip menu "kig"
  • Main Page
  • Namespace List
  • Namespace Members
  • Alphabetical List
  • Class List
  • Class Hierarchy
  • Class Members
  • File List
  • File Members

kdeedu API Reference

Skip menu "kdeedu API Reference"
  • Analitza
  •     lib
  • kalgebra
  • kalzium
  •   libscience
  • kanagram
  • kig
  •   lib
  • klettres
  • marble
  • parley
  • rocs
  •   App
  •   RocsCore
  •   VisualEditor
  •   stepcore

Search



Report problems with this website to our bug tracking system.
Contact the specific authors with questions and comments about the page contents.

KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal