Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Sep 12, 2010, 12:47:30 AM (14 years ago)
Author:
rgrieder
Message:

Basic stuff up and running for the Qt sandbox.
No GUI support yet.

Location:
sandbox_qt/src/libraries/util
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • sandbox_qt/src/libraries/util/CMakeLists.txt

    r7284 r7421  
    1919
    2020SET_SOURCE_FILES(UTIL_SRC_FILES
    21   Clock.cc
    2221  Exception.cc
    23   ExprParser.cc
    2422  Math.cc
    25   MultiType.cc
    26   Scope.cc
    2723  StringUtils.cc
    2824COMPILATION_BEGIN StableCompilation.cc
    29   Clipboard.cc
    3025  Convert.cc
    31   CRC32.cc
    3226  OutputHandler.cc
    33   ScopedSingletonManager.cc
    34   SharedPtr.cc
    35   SignalHandler.cc
    3627  Sleep.cc
    37   SmallObjectAllocator.cc
    3828  SubString.cc
    3929COMPILATION_END
    4030)
    4131
    42 IF(GCC_NO_SYSTEM_HEADER_SUPPORT)
    43   # Get around displaying a few hundred lines of warning code
    44   SET_SOURCE_FILES_PROPERTIES(MultiType.cc PROPERTIES COMPILE_FLAGS "-w")
    45 ENDIF()
    46 IF(MSVC)
    47   # Simply using #pragma warning(disable:4244) doesn't really disable it
    48   # if the warning occurs in a template in another file
    49   # Hence promote it manually to a higher warning level (4)
    50   SET_SOURCE_FILES_PROPERTIES(MultiType.cc PROPERTIES COMPILE_FLAGS "-w44244")
    51 ENDIF()
    52 
    5332ORXONOX_ADD_LIBRARY(util
    5433  FIND_HEADER_FILES
    5534  LINK_LIBRARIES
    56     ${CEGUI_LIBRARY}
    57     ${OGRE_LIBRARY}
     35    ${QT_QTCORE_LIBRARY}
    5836  SOURCE_FILES
    5937    ${UTIL_SRC_FILES}

  • sandbox_qt/src/libraries/util/Exception.cc

    r7401 r7421  
    3535#include "Exception.h"
    3636
    37 #include <CEGUIExceptions.h>
    3837#include "Debug.h"
    3938
    … …  
    9998            return ex.what();
    10099        }
    101         catch (const CEGUI::Exception& ex)
    102         {
    103 #if CEGUI_VERSION_MAJOR == 0 && CEGUI_VERSION_MINOR < 6
    104             return GeneralException(ex.getMessage().c_str()).getDescription();
    105 #else
    106             return GeneralException(ex.getMessage().c_str(), ex.getLine(),
    107                 ex.getFileName().c_str(), ex.getName().c_str()).getDescription();
    108 #endif
    109         }
    110100        catch (...)
    111101        {

  • sandbox_qt/src/libraries/util/Math.cc

    r7401 r7421  
    3434#include "Math.h"
    3535
    36 #include <OgrePlane.h>
    37 
    38 #include "MathConvert.h"
    39 #include "SubString.h"
    40 // Do not remove this include, it avoids linker errors.
    41 #include "mbool.h"
    42 
    4336namespace orxonox
    4437{
    45 #if OGRE_VERSION < 0x010603
    46     /**
    47         @brief Function for writing a Radian to a stream.
    48     */
    49     std::ostream& operator<<(std::ostream& out, const orxonox::Radian& radian)
    50     {
    51         out << radian.valueRadians();
    52         return out;
    53     }
    54 
    55     /**
    56         @brief Function for writing a Degree to a stream.
    57     */
    58     std::ostream& operator<<(std::ostream& out, const orxonox::Degree& degree)
    59     {
    60         out << degree.valueDegrees();
    61         return out;
    62     }
    63 #endif
    64 
    65     /**
    66         @brief Function for reading a Radian from a stream.
    67     */
    68     std::istream& operator>>(std::istream& in, orxonox::Radian& radian)
    69     {
    70         float temp;
    71         in >> temp;
    72         radian = temp;
    73         return in;
    74     }
    75 
    76     /**
    77         @brief Function for reading a Degree from a stream.
    78     */
    79     std::istream& operator>>(std::istream& in, orxonox::Degree& degree)
    80     {
    81         float temp;
    82         in >> temp;
    83         degree = temp;
    84         return in;
    85     }
    86 
    87 
    88     /**
    89         @brief Gets the angle between my viewing direction and the direction to the position of the other object.
    90         @param myposition My position
    91         @param mydirection My viewing direction
    92         @param otherposition The position of the other object
    93         @return The angle in radian
    94 
    95         Examples:
    96          - If the other object is exactly in front of me, the function returns 0.
    97          - If the other object is exactly behind me, the function returns pi.
    98          - If the other object is exactly right/left to me (or above/below), the function returns pi/2.
    99     */
    100     float getAngle(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& otherposition)
    101     {
    102         orxonox::Vector3 distance = otherposition - myposition;
    103         float distancelength = distance.length();
    104         if (distancelength == 0)
    105             return 0;
    106         else
    107             return acos(clamp<float>(mydirection.dotProduct(distance) / distancelength, -1, 1));
    108     }
    109 
    110     /**
    111         @brief Gets the 2D viewing direction (up/down, left/right) to the position of the other object.
    112         @param myposition My position
    113         @param mydirection My viewing direction
    114         @param myorthonormal My orthonormalvector (pointing upwards through my head)
    115         @param otherposition The position of the other object
    116         @return The viewing direction
    117 
    118         Examples:
    119          - If the other object is exactly in front of me, the function returns <tt>Vector2(0, 0)</tt>.
    120          - If the other object is exactly at my left, the function returns <tt>Vector2(-1, 0)</tt>.
    121          - If the other object is exactly at my right, the function returns <tt>Vector2(1, 0)</tt>.
    122          - If the other object is only a bit at my right, the function still returns <tt>Vector2(1, 0)</tt>.
    123          - If the other object is exactly above me, the function returns <tt>Vector2(0, 1)</tt>.
    124     */
    125     orxonox::Vector2 get2DViewdirection(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition)
    126     {
    127         orxonox::Vector3 distance = otherposition - myposition;
    128 
    129         // project difference vector on our plane
    130         orxonox::Vector3 projection = Ogre::Plane(mydirection, myposition).projectVector(distance);
    131 
    132         float projectionlength = projection.length();
    133         if (projectionlength == 0)
    134         {
    135             if (myposition.dotProduct(otherposition) >= 0)
    136                 return orxonox::Vector2(0, 0);
    137             else
    138                 return orxonox::Vector2(0, 1);
    139         }
    140 
    141         float cos_value = clamp<float>(myorthonormal.dotProduct(projection) / projectionlength, -1, 1);
    142         float sin_value = sqrt( 1 - cos_value*cos_value );
    143 
    144         if ((mydirection.crossProduct(myorthonormal)).dotProduct(distance) > 0)
    145             return orxonox::Vector2( sin_value, cos_value );
    146         else
    147             return orxonox::Vector2( -sin_value, cos_value );
    148     }
    149 
    150     /**
    151         @brief Gets the 2D viewing direction (up/down, left/right) to the position of the other object, multiplied with the viewing distance to the object (0° = 0, 180° = 1).
    152         @param myposition My position
    153         @param mydirection My viewing direction
    154         @param myorthonormal My orthonormalvector (pointing upwards through my head)
    155         @param otherposition The position of the other object
    156         @return The viewing direction
    157 
    158         Examples:
    159          - If the other object is exactly in front of me, the function returns <tt>Vector2(0, 0)</tt>.
    160          - If the other object is exactly at my left, the function returns <tt>Vector2(-0.5, 0)</tt>.
    161          - If the other object is exactly at my right, the function returns <tt>Vector2(0.5, 0)</tt>.
    162          - If the other object is only a bit at my right, the function still returns <tt>Vector2(0.01, 0)</tt>.
    163          - If the other object is exactly above me, the function returns <tt>Vector2(0, 0.5)</tt>.
    164     */
    165     orxonox::Vector2 get2DViewcoordinates(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition)
    166     {
    167         orxonox::Vector3 distance = otherposition - myposition;
    168 
    169         // project difference vector on our plane
    170         orxonox::Vector3 projection = Ogre::Plane(mydirection, myposition).projectVector(distance);
    171 
    172         float projectionlength = projection.length();
    173         if (projectionlength == 0)
    174         {
    175             if (myposition.dotProduct(otherposition) >= 0)
    176                 return orxonox::Vector2(0, 0);
    177             else
    178                 return orxonox::Vector2(0, 1);
    179         }
    180         //float angle = acos(clamp<float>(myorthonormal.dotProduct(projection) / projectionlength, -1, 1));
    181 
    182         float cos_value = clamp<float>(myorthonormal.dotProduct(projection) / projectionlength, -1, 1);
    183         float sin_value = sqrt( 1 - cos_value*cos_value );
    184 
    185         float distancelength = distance.length();
    186         if (distancelength == 0) return orxonox::Vector2(0, 0);
    187         float radius = acos(clamp<float>(mydirection.dotProduct(distance) / distancelength, -1, 1)) / math::pi;
    188 
    189         if ((mydirection.crossProduct(myorthonormal)).dotProduct(distance) > 0)
    190             return orxonox::Vector2( sin_value * radius, cos_value * radius);
    191         else
    192             return orxonox::Vector2( -sin_value * radius, cos_value * radius);
    193     }
    194 
    195     /**
    196         @brief Returns the predicted position I have to aim at, if I want to hit a moving target with a moving projectile.
    197         @param myposition My position
    198         @param projectilespeed The speed of my projectile
    199         @param targetposition The position of my target
    200         @param targetvelocity The velocity of my target
    201         @return The predicted position
    202 
    203         The function predicts the position based on a linear velocity of the target. If the target changes speed or direction, the projectile will miss.
    204     */
    205     orxonox::Vector3 getPredictedPosition(const orxonox::Vector3& myposition, float projectilespeed, const orxonox::Vector3& targetposition, const orxonox::Vector3& targetvelocity)
    206     {
    207         float squaredProjectilespeed = projectilespeed * projectilespeed;
    208         orxonox::Vector3 distance = targetposition - myposition;
    209         float a = distance.squaredLength();
    210         float b = 2 * (distance.x + distance.y + distance.z) * (targetvelocity.x + targetvelocity.y + targetvelocity.z);
    211         float c = targetvelocity.squaredLength();
    212 
    213         float temp = 4*squaredProjectilespeed*c + a*a - 4*b*c;
    214         if (temp < 0)
    215             return orxonox::Vector3::ZERO;
    216 
    217         temp = sqrt(temp);
    218         float time = (temp + a) / (2 * (squaredProjectilespeed - b));
    219         return (targetposition + targetvelocity * time);
    220     }
    221 
    22238    /**
    22339        @brief Returns a unique number. This function will never return the same value twice.
    … …  
    22844        return aNumber++;
    22945    }
    230 
    231 
    232     //////////////////////////
    233     // Conversion functions //
    234     //////////////////////////
    235 
    236     // std::string to Vector2
    237     bool ConverterFallback<std::string, orxonox::Vector2>::convert(orxonox::Vector2* output, const std::string& input)
    238     {
    239         size_t opening_parenthesis, closing_parenthesis = input.find('}');
    240         if ((opening_parenthesis = input.find('{')) == std::string::npos)
    241             opening_parenthesis = 0;
    242         else
    243             opening_parenthesis++;
    244 
    245         SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis),
    246                          ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
    247         if (tokens.size() >= 2)
    248         {
    249             if (!convertValue(&(output->x), tokens[0]))
    250                 return false;
    251             if (!convertValue(&(output->y), tokens[1]))
    252                 return false;
    253 
    254             return true;
    255         }
    256         return false;
    257     }
    258 
    259     // std::string to Vector3
    260     bool ConverterFallback<std::string, orxonox::Vector3>::convert(orxonox::Vector3* output, const std::string& input)
    261     {
    262         size_t opening_parenthesis, closing_parenthesis = input.find('}');
    263         if ((opening_parenthesis = input.find('{')) == std::string::npos)
    264             opening_parenthesis = 0;
    265         else
    266             opening_parenthesis++;
    267 
    268         SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis),
    269                          ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
    270         if (tokens.size() >= 3)
    271         {
    272             if (!convertValue(&(output->x), tokens[0]))
    273                 return false;
    274             if (!convertValue(&(output->y), tokens[1]))
    275                 return false;
    276             if (!convertValue(&(output->z), tokens[2]))
    277                 return false;
    278 
    279             return true;
    280         }
    281         return false;
    282     }
    283 
    284     // std::string to Vector4
    285     bool ConverterFallback<std::string, orxonox::Vector4>::convert(orxonox::Vector4* output, const std::string& input)
    286     {
    287         size_t opening_parenthesis, closing_parenthesis = input.find('}');
    288         if ((opening_parenthesis = input.find('{')) == std::string::npos)
    289             opening_parenthesis = 0;
    290         else
    291             opening_parenthesis++;
    292 
    293         SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis),
    294                          ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
    295         if (tokens.size() >= 4)
    296         {
    297             if (!convertValue(&(output->x), tokens[0]))
    298                 return false;
    299             if (!convertValue(&(output->y), tokens[1]))
    300                 return false;
    301             if (!convertValue(&(output->z), tokens[2]))
    302                 return false;
    303             if (!convertValue(&(output->w), tokens[3]))
    304                 return false;
    305 
    306             return true;
    307         }
    308         return false;
    309     }
    310 
    311     // std::string to Quaternion
    312     bool ConverterFallback<std::string, orxonox::Quaternion>::convert(orxonox::Quaternion* output, const std::string& input)
    313     {
    314         size_t opening_parenthesis, closing_parenthesis = input.find('}');
    315         if ((opening_parenthesis = input.find('{')) == std::string::npos)
    316             opening_parenthesis = 0;
    317         else
    318             opening_parenthesis++;
    319 
    320         SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
    321         if (tokens.size() >= 4)
    322         {
    323             if (!convertValue(&(output->w), tokens[0]))
    324                 return false;
    325             if (!convertValue(&(output->x), tokens[1]))
    326                 return false;
    327             if (!convertValue(&(output->y), tokens[2]))
    328                 return false;
    329             if (!convertValue(&(output->z), tokens[3]))
    330                 return false;
    331 
    332             return true;
    333         }
    334         return false;
    335     }
    336 
    337     // std::string to ColourValue
    338     bool ConverterFallback<std::string, orxonox::ColourValue>::convert(orxonox::ColourValue* output, const std::string& input)
    339     {
    340         size_t opening_parenthesis, closing_parenthesis = input.find('}');
    341         if ((opening_parenthesis = input.find('{')) == std::string::npos)
    342             opening_parenthesis = 0;
    343         else
    344             opening_parenthesis++;
    345 
    346         SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
    347         if (tokens.size() >= 3)
    348         {
    349             if (!convertValue(&(output->r), tokens[0]))
    350                 return false;
    351             if (!convertValue(&(output->g), tokens[1]))
    352                 return false;
    353             if (!convertValue(&(output->b), tokens[2]))
    354                 return false;
    355             if (tokens.size() >= 4)
    356             {
    357                 if (!convertValue(&(output->a), tokens[3]))
    358                     return false;
    359             }
    360             else
    361                 output->a = 1.0;
    362 
    363             return true;
    364         }
    365         return false;
    366     }
    36746}

  • sandbox_qt/src/libraries/util/Math.h

    r7401 r7421  
    3535    @file
    3636    @ingroup Math
    37     @brief Declaration and implementation of several math-functions, typedefs of some Ogre::Math classes to the orxonox namespace.
     37    @brief Declaration and implementation of several math-functions.
    3838*/
    3939
    … …  
    4545#include <string>
    4646#include <cmath>
    47 
    48 #include <OgreMath.h>
    49 #include <OgreVector2.h>
    50 #include <OgreVector3.h>
    51 #include <OgreVector4.h>
    52 #include <OgreQuaternion.h>
    53 #include <OgreColourValue.h>
    5447
    5548// Certain headers might define unwanted macros...
    … …  
    8376    }
    8477
    85 #if OGRE_VERSION < 0x010603
    86     _UtilExport std::ostream& operator<<(std::ostream& out, const orxonox::Radian& radian);
    87     _UtilExport std::ostream& operator<<(std::ostream& out, const orxonox::Degree& degree);
    88 #endif
    89     _UtilExport std::istream& operator>>(std::istream& in, orxonox::Radian& radian);
    90     _UtilExport std::istream& operator>>(std::istream& in, orxonox::Degree& degree);
    91 
    92     _UtilExport float getAngle(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& otherposition);
    93     _UtilExport orxonox::Vector2 get2DViewdirection(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition);
    94     _UtilExport orxonox::Vector2 get2DViewcoordinates(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition);
    95     _UtilExport orxonox::Vector3 getPredictedPosition(const orxonox::Vector3& myposition, float projectilespeed, const orxonox::Vector3& targetposition, const orxonox::Vector3& targetvelocity);
    96 
    9778    /**
    9879        @brief Returns the sign of the given value.
    … …  
    177158            return ((x % max) + max);
    178159    }
    179 
    180     /**
    181         @brief Returns a "zero" value for the given type.
    182         @note This is the default template of the zeroise() function. The template is spezialized for each supported type.
    183 
    184         The exact return value of the function depends on the type. For @c int this is 0,
    185         for @c float it's 0.0f. For a @c std::string the function returns "" and for
    186         @c Vector3 you get <tt>Vector3(0, 0, 0)</tt>.
    187     */
    188     template <typename T>
    189     inline T zeroise()
    190     {
    191         // Default, raise a compiler error without including large boost header cascade.
    192         T temp();
    193         *********temp; // If you reach this code, you abused zeroise()!
    194         return temp;
    195     }
    196 
    197     template <> inline char                 zeroise<char>()                 { return 0; }
    198     template <> inline unsigned char        zeroise<unsigned char>()        { return 0; }
    199     template <> inline short                zeroise<short>()                { return 0; }
    200     template <> inline unsigned short       zeroise<unsigned short>()       { return 0; }
    201     template <> inline int                  zeroise<int>()                  { return 0; }
    202     template <> inline unsigned int         zeroise<unsigned int>()         { return 0; }
    203     template <> inline long                 zeroise<long>()                 { return 0; }
    204     template <> inline unsigned long        zeroise<unsigned long>()        { return 0; }
    205     template <> inline long long            zeroise<long long>()            { return 0; }
    206     template <> inline unsigned long long   zeroise<unsigned long long>()   { return 0; }
    207     template <> inline float                zeroise<float>()                { return 0; }
    208     template <> inline double               zeroise<double>()               { return 0; }
    209     template <> inline long double          zeroise<long double>()          { return 0; }
    210     template <> inline bool                 zeroise<bool>()                 { return 0; }
    211     template <> inline void*                zeroise<void*>()                { return 0; }
    212     template <> inline std::string          zeroise<std::string>()          { return std::string(); }
    213     template <> inline orxonox::Radian      zeroise<orxonox::Radian>()      { return orxonox::Radian(0.0f); }
    214     template <> inline orxonox::Degree      zeroise<orxonox::Degree>()      { return orxonox::Degree(0.0f); }
    215     template <> inline orxonox::Vector2     zeroise<orxonox::Vector2>()     { return orxonox::Vector2    (0, 0)      ; }
    216     template <> inline orxonox::Vector3     zeroise<orxonox::Vector3>()     { return orxonox::Vector3    (0, 0, 0)   ; }
    217     template <> inline orxonox::Vector4     zeroise<orxonox::Vector4>()     { return orxonox::Vector4    (0, 0, 0, 0); }
    218     template <> inline orxonox::ColourValue zeroise<orxonox::ColourValue>() { return orxonox::ColourValue(0, 0, 0, 0); }
    219     template <> inline orxonox::Quaternion  zeroise<orxonox::Quaternion>()  { return orxonox::Quaternion (0, 0, 0, 0); }
    220 
    221     /**
    222         @brief Provides zero value symbols that can be returned as reference
    223         @see zeroise()
    224     */
    225     template <typename T>
    226     struct NilValue
    227     {
    228         inline operator const T&() const
    229         {
    230             return value;
    231         }
    232         static T value;
    233     };
    234     template <typename T>
    235     T NilValue<T>::value = zeroise<T>();
    236160
    237161    /**
    … …  
    297221
    298222    _UtilExport unsigned long getUniqueNumber();
    299 
    300     /**
    301         @brief A Vector class containing two integers @a x and @a y.
    302     */
    303     class IntVector2
    304     {
    305     public:
    306         IntVector2() : x(0), y(0) { }
    307         IntVector2(int _x, int _y) : x(_x), y(_y) { }
    308         int x;
    309         int y;
    310     };
    311 
    312     /**
    313         @brief A Vector class containing three integers @a x, @a y, and @a z.
    314     */
    315     class IntVector3
    316     {
    317     public:
    318         IntVector3() : x(0), y(0), z(0) { }
    319         IntVector3(int _x, int _y, int _z) : x(_x), y(_y), z(_z) { }
    320         int x;
    321         int y;
    322         int z;
    323     };
    324223}
    325224

  • sandbox_qt/src/libraries/util/Singleton.h

    r7401 r7421  
    145145
    146146        //! Update method called by ClassSingletonManager (if used)
    147         void preUpdateSingleton(const Clock& time) { static_cast<T*>(T::singletonPtr_s)->preUpdate(time); }
     147        void preUpdateSingleton() { static_cast<T*>(T::singletonPtr_s)->preUpdate(); }
    148148        //! Empty update method for the static polymorphism
    149         void preUpdate(const Clock& time) { }
     149        void preUpdate() { }
    150150        //! Update method called by ClassSingletonManager (if used)
    151         void postUpdateSingleton(const Clock& time) { static_cast<T*>(T::singletonPtr_s)->postUpdate(time); }
     151        void postUpdateSingleton() { static_cast<T*>(T::singletonPtr_s)->postUpdate(); }
    152152        //! Empty update method for the static polymorphism
    153         void postUpdate(const Clock& time) { }
     153        void postUpdate() { }
    154154
    155155    protected:

  • sandbox_qt/src/libraries/util/StringUtils.cc

    r7401 r7421  
    3535
    3636#include <cctype>
    37 #include <boost/scoped_array.hpp>
     37#include <QVarLengthArray>
     38#include <QDir>
     39
    3840#include "Convert.h"
    3941#include "Math.h"
    … …  
    493495        size_t cols = str1.size() + 1;
    494496        size_t rows = str2.size() + 1;
    495         boost::scoped_array<int> matrix(new int[rows * cols]);
     497        QVarLengthArray<int> matrix(rows * cols);
    496498
    497499        for (size_t r = 0; r < rows; ++r)
    … …  
    516518        return matrix[(rows-1)*cols + cols-1];
    517519    }
     520
     521    QDir& operator/=(QDir& lhs, const QDir& rhs)
     522    {
     523        lhs.setPath(lhs.path() + QDir::separator() + rhs.path());
     524        return lhs;
     525    }
     526
     527    QDir& operator/=(QDir& lhs, const QString& rhs)
     528    {
     529        return operator/=(lhs, QDir(rhs));
     530    }
     531
     532    QDir operator/(const QDir& lhs, const QDir& rhs)
     533    {
     534        return (QDir(lhs) /= rhs);
     535    }
     536
     537    QDir operator/(const QDir& lhs, const QString& rhs)
     538    {
     539        return operator/(lhs, QDir(rhs));
     540    }
    518541}

  • sandbox_qt/src/libraries/util/UtilPrereqs.h

    r6417 r7421  
    5959
    6060//-----------------------------------------------------------------------
    61 // Enums
    62 //-----------------------------------------------------------------------
    63 
    64 namespace orxonox
    65 {
    66     namespace ScopeID
    67     {
    68         //!A list of available scopes for the Scope template.
    69         enum Value
    70         {
    71             Root,
    72             Graphics
    73         };
    74     }
    75 }
    76 
    77 //-----------------------------------------------------------------------
    7861// Forward declarations
    7962//-----------------------------------------------------------------------
    … …  
    8164namespace orxonox
    8265{
    83     class Clock;
    8466    class Exception;
    85     class ExprParser;
    86     class IntVector2;
    87     class IntVector3;
    88     class MultiType;
    8967    class OutputHandler;
    9068    class OutputListener;
    91     template <ScopeID::Value>
    92     class Scope;
    93     template <class, ScopeID::Value>
    94     class ScopedSingleton;
    95     class ScopeListener;
    96     class SignalHandler;
    9769    template <class T>
    9870    class Singleton;
    9971    class SubString;
    100 }
    101 
    102 namespace Ogre
    103 {
    104     class Radian;
    105     class Degree;
    106     class Vector2;
    107     class Vector3;
    108     class Vector4;
    109     class Matrix3;
    110     class Matrix4;
    111     class Quaternion;
    112     class ColourValue;
    113 }
    114 namespace orxonox
    115 {
    116     using Ogre::Radian;
    117     using Ogre::Degree;
    118     using Ogre::Vector2;
    119     using Ogre::Vector3;
    120     using Ogre::Vector4;
    121     using Ogre::Matrix3;
    122     using Ogre::Matrix4;
    123     using Ogre::Quaternion;
    124     using Ogre::ColourValue;
    12572}
    12673
    … …  
    13178}
    13279
     80class QDir;
     81class QString;
     82
    13383// Just so you don't have to include StringUtils.h everywhere just for this
    13484namespace orxonox
    … …  
    13787}
    13888
     89//-----------------------------------------------------------------------
     90// Functions (implementations in StringUtils.cc)
     91//-----------------------------------------------------------------------
     92
     93namespace orxonox
     94{
     95    _UtilExport QDir& operator/=(QDir& lhs, const QDir& rhs);
     96    _UtilExport QDir& operator/=(QDir& lhs, const QString& rhs);
     97    _UtilExport QDir operator/(const QDir& lhs, const QDir& rhs);
     98    _UtilExport QDir operator/(const QDir& lhs, const QString& rhs);
     99}
    139100
    140101#endif /* _UtilPrereqs_H__ */
Note: See TracChangeset for help on using the changeset viewer.