libgraphicsmagick++1-dev 1.3.30+hg15796-1~deb9u2 / usr / include / GraphicsMagick / Magick++ / Geometry.h

This file is indexed.

/usr/include/GraphicsMagick/Magick++/Geometry.h is in libgraphicsmagick++1-dev 1.3.30+hg15796-1~deb9u2.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below. 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
// This may look like C code, but it is really -*- C++ -*-
//
// Copyright Bob Friesenhahn, 1999 - 2014
//
// Geometry Definition
//
// Representation of an ImageMagick geometry specification
// X11 geometry specification plus hints

#if !defined (Magick_Geometry_header)
#define Magick_Geometry_header

#include "Magick++/Include.h"
#include <string>

namespace Magick
{

  class MagickDLLDecl Geometry;

  // Compare two Geometry objects regardless of LHS/RHS
  int MagickDLLDecl operator == ( const Magick::Geometry& left_, const Magick::Geometry& right_ );
  int MagickDLLDecl operator != ( const Magick::Geometry& left_, const Magick::Geometry& right_ );
  int MagickDLLDecl operator >  ( const Magick::Geometry& left_, const Magick::Geometry& right_ );
  int MagickDLLDecl operator <  ( const Magick::Geometry& left_, const Magick::Geometry& right_ );
  int MagickDLLDecl operator >= ( const Magick::Geometry& left_, const Magick::Geometry& right_ );
  int MagickDLLDecl operator <= ( const Magick::Geometry& left_, const Magick::Geometry& right_ );

  class MagickDLLDecl Geometry
  {
  public:

    Geometry ( unsigned int width_,
               unsigned int height_,
               unsigned int xOff_ = 0,
               unsigned int yOff_ = 0,
               bool xNegative_ = false,
               bool yNegative_ = false );
    Geometry ( const std::string &geometry_ );
    Geometry ( const char * geometry_ );
    Geometry ( const Geometry &geometry_ );
    Geometry ( );
    ~Geometry ( void );

    // Width
    void          width ( unsigned int width_ );
    unsigned int  width ( void ) const;

    // Height
    void          height ( unsigned int height_ );
    unsigned int  height ( void ) const;

    // X offset from origin
    void          xOff ( unsigned int xOff_ );
    unsigned int  xOff ( void ) const;

    // Y offset from origin
    void          yOff ( unsigned int yOff_ );
    unsigned int  yOff ( void ) const;

    // Sign of X offset negative? (X origin at right)
    void          xNegative ( bool xNegative_ );
    bool          xNegative ( void ) const;

    // Sign of Y offset negative? (Y origin at bottom)
    void          yNegative ( bool yNegative_ );
    bool          yNegative ( void ) const;

    // Width and height are expressed as percentages
    void          percent ( bool percent_ );
    bool          percent ( void ) const;

    // Resize without preserving aspect ratio (!)
    void          aspect ( bool aspect_ );
    bool          aspect ( void ) const;

    // Resize if image is greater than size (>)
    void          greater ( bool greater_ );
    bool          greater ( void ) const;

    // Resize if image is less than size (<)
    void          less ( bool less_ );
    bool          less ( void ) const;

    // Resize image to fit total pixel area specified by dimensions (@).
    void          limitPixels ( bool limitPixels_ );
    bool          limitPixels ( void ) const;

    // Dimensions are treated as minimum rather than maximum values (^)
    void          fillArea ( bool fillArea_ );
    bool          fillArea ( void ) const;

    // Does object contain valid geometry?
    void          isValid ( bool isValid_ );
    bool          isValid ( void ) const;

    // Set via geometry string
    const Geometry& operator = ( const std::string &geometry_ );
    const Geometry& operator = ( const char * geometry_ );

    // Assignment operator
    Geometry& operator= ( const Geometry& Geometry_ );

    // Return geometry string
    operator std::string() const;

    //
    // Public methods below this point are for Magick++ use only.
    //

    // Construct from RectangleInfo
    Geometry ( const MagickLib::RectangleInfo &rectangle_ );

    // Return an ImageMagick RectangleInfo struct
    operator MagickLib::RectangleInfo() const;

  private:
    unsigned int  _width;
    unsigned int  _height;
    unsigned int  _xOff;
    unsigned int  _yOff;
    union
    {
      struct
      {
        // Bit-field for compact boolean storage
        bool          _xNegative : 1;
        bool          _yNegative : 1;
        bool          _isValid : 1;
        bool          _percent : 1;    // Interpret width & height as percentages (%)
        bool          _aspect : 1;     // Force exact size (!)
        bool          _greater : 1;    // Re-size only if larger than geometry (>)
        bool          _less : 1;       // Re-size only if smaller than geometry (<)
        bool          _limitPixels : 1;// Resize image to fit total pixel area (@).
        bool          _fillArea : 1;   // Dimensions are treated as
                                       // minimum rather than maximum
                                       // values (^)
      } _b;
      struct
      {
        // Padding for future use.
        unsigned int pad[2];
      } _padding;
    } _flags; // union
  }; // class Geometry;
} // namespace Magick

//
// Inlines
//


#endif // Magick_Geometry_header

APT Browse - Built by Thomas Orozco.