Merged changes in the trunk up to revision 28600.
[blender.git] / source / blender / freestyle / intern / stroke / Predicates0D.h
1 //
2 //  Filename         : Predicates0D.h
3 //  Author(s)        : Stephane Grabli, Emmanuel Turquin
4 //  Purpose          : Class gathering stroke creation algorithms
5 //  Date of creation : 01/07/2003
6 //
7 ///////////////////////////////////////////////////////////////////////////////
8
9
10 //
11 //  Copyright (C) : Please refer to the COPYRIGHT file distributed 
12 //   with this source distribution. 
13 //
14 //  This program is free software; you can redistribute it and/or
15 //  modify it under the terms of the GNU General Public License
16 //  as published by the Free Software Foundation; either version 2
17 //  of the License, or (at your option) any later version.
18 //
19 //  This program is distributed in the hope that it will be useful,
20 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
21 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22 //  GNU General Public License for more details.
23 //
24 //  You should have received a copy of the GNU General Public License
25 //  along with this program; if not, write to the Free Software
26 //  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
27 //
28 ///////////////////////////////////////////////////////////////////////////////
29
30 #ifndef  PREDICATES0D_H
31 # define PREDICATES0D_H
32
33 # include "../view_map/Functions0D.h"
34
35 # include  "../python/Director.h"
36
37 //
38 // UnaryPredicate0D (base class for predicates in 0D)
39 //
40 ///////////////////////////////////////////////////////////
41 /*! Base class for Unary Predicates that work
42  *  on Interface0DIterator.
43  *  A UnaryPredicate0D is a functor that evaluates
44  *  a condition on a Interface0DIterator and returns
45  *  true or false depending on whether this condition is
46  *  satisfied or not.
47  *  The UnaryPredicate0D is used by calling its () operator.
48  *  Any inherited class must overload the () operator.
49  */
50 class UnaryPredicate0D
51 {
52 public:
53         
54         bool result;
55         PyObject *py_up0D;
56         
57   /*! Default constructor. */
58         UnaryPredicate0D() { py_up0D = 0; }
59   /*! Destructor. */
60   virtual ~UnaryPredicate0D() {}
61   /*! Returns the string of the name
62    *  of the UnaryPredicate0D.
63    */
64   virtual string getName() const {
65     return "UnaryPredicate0D";
66   }
67   /*! The () operator. Must be overload
68    *  by inherited classes.
69    *  \param it
70    *    The Interface0DIterator pointing onto the
71    *    Interface0D at which we wish to evaluate
72    *    the predicate.
73    *  \return true if the condition is satisfied,
74    *    false otherwise.
75    */
76   virtual int operator()(Interface0DIterator& it) {
77         return Director_BPy_UnaryPredicate0D___call__(this, it);
78   }
79
80 };
81
82
83 //
84 // BinaryPredicate0D (base class for predicates in 0D)
85 //
86 ///////////////////////////////////////////////////////////
87 /*! Base class for Binary Predicates working on Interface0D.
88  *  A BinaryPredicate0D is typically an ordering relation
89  *  between two Interface0D.
90  *  It evaluates a relation between 2 Interface0D and
91  *  returns true or false.
92  *  It is used by calling the () operator.
93  */
94 class BinaryPredicate0D
95 {
96 public:
97         
98                 bool result;
99                 PyObject *py_bp0D;
100         
101   /*! Default constructor. */
102                 BinaryPredicate0D() { py_bp0D = 0; }
103   /*! Destructor. */
104   virtual ~BinaryPredicate0D() {}
105   /*! Returns the string of the name of the
106    * binary predicate.
107    */
108   virtual string getName() const {
109     return "BinaryPredicate0D";
110   }
111
112   /*! The () operator. Must be overload by inherited classes.
113    *  It evaluates a relation between 2 Interface0D.
114    *  \param inter1
115    *    The first Interface0D.
116    *  \param inter2
117    *    The second Interface0D.
118    *  \return true or false.
119    */
120   virtual int operator()(Interface0D& inter1, Interface0D& inter2) {
121         return Director_BPy_BinaryPredicate0D___call__(this, inter1, inter2);
122   }
123
124 };
125
126
127 //
128 // Predicates definitions
129 //
130 ///////////////////////////////////////////////////////////
131
132 namespace Predicates0D {
133
134   // TrueUP0D
135   /*! Returns true any time */
136   class TrueUP0D : public UnaryPredicate0D
137   {
138   public:
139     /*! Default constructor. */
140     TrueUP0D() {}
141     /*! Returns the string "TrueUP0D"*/
142     string getName() const {
143       return "TrueUP0D";
144     }
145     /*! The () operator. */
146     int operator()(Interface0DIterator&) {
147           result = true;
148           return 0;
149     }
150   };
151
152   // FalseUP0D
153   /*! Returns false any time */
154   class FalseUP0D : public UnaryPredicate0D
155   {
156   public:
157     /*! Default constructor. */
158     FalseUP0D() {}
159     /*! Returns the string "FalseUP0D"*/
160     string getName() const {
161       return "FalseUP0D";
162     }
163     /*! The () operator. */
164     int operator()(Interface0DIterator&) {
165           result = false;
166       return 0;
167     }
168   };
169
170 } // end of namespace Predicates0D
171
172 #endif // PREDICATES0D_H