← Back to branch summary

~ubuntu-branches/ubuntu/precise/ipe/precise

« back to all changes in this revision

Viewing changes to src/include/ipebase.h

  • Committer: Bazaar Package Importer
  • Author(s): Steve M. Robbins
  • Date: 2005-02-24 22:09:16 UTC
  • mfrom: (2.1.1 hoary)
  • Revision ID: james.westby@ubuntu.com-20050224220916-9vxiiqjz066r5489
Tags: 6.0pre23-2
http://bugs.debian.org/296771
debian/control: Ipe should depend on exact version of libipe.
Closes: #296771.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/include/ipebase.h
41
41
 
42
42
// --------------------------------------------------------------------
43
43
 
 
44
typedef unsigned char uchar;
 
45
 
44
46
#ifdef WIN32
 
47
typedef unsigned short ushort;
45
48
typedef unsigned int uint;
46
49
typedef unsigned long int ulong;
47
50
#if defined(IPE_MAKEDLL)        /* create a DLL library */
56
59
// --------------------------------------------------------------------
57
60
 
58
61
//! Ipelib version.
59
 
const int IPELIB_VERSION = 60016;
 
62
const int IPELIB_VERSION = 60023;
60
63
 
61
64
extern IPE_EXPORT int IpelibVersion();
62
65
 
85
88
 
86
89
// --------------------------------------------------------------------
87
90
 
 
91
class IpeStream;
 
92
 
88
93
class IPE_EXPORT IpeString {
89
94
public:
90
95
  IpeString();
118
123
  bool operator==(const IpeString &rhs) const;
119
124
  bool operator<(const IpeString &rhs) const;
120
125
  IpeString operator+(const IpeString &rhs) const;
 
126
  int unicode(int &index) const;
121
127
  const char *CString() const;
122
128
private:
123
129
  void Detach(int n);
133
139
 
134
140
// --------------------------------------------------------------------
135
141
 
136
 
class IPE_EXPORT IpeStream {
137
 
public:
138
 
  //! Virtual destructor, so you can delete using a pointer to IpeStream
139
 
  virtual ~IpeStream();
140
 
  //! Output character.
141
 
  virtual void PutChar(char ch) = 0;
142
 
  //! Output string.
143
 
  virtual void PutString(IpeString s) = 0;
144
 
  //! Output C string.
145
 
  virtual void PutCString(const char *s) = 0;
146
 
  //! Output raw character data.
147
 
  virtual void PutRaw(const char *data, int size) = 0;
148
 
  //! Output character.
149
 
  inline IpeStream &operator<<(char ch) { PutChar(ch); return *this; }
150
 
  //! Output string.
151
 
  inline IpeStream &operator<<(const IpeString &s) {
152
 
    PutString(s); return *this; }
153
 
  //! Output C string.
154
 
  inline IpeStream &operator<<(const char *s) { PutCString(s); return *this; }
155
 
  IpeStream &operator<<(int i);
156
 
  IpeStream &operator<<(double d);
157
 
  void PutHexByte(char b);
158
 
  void PutXmlString(IpeString s);
159
 
};
160
 
 
161
 
class IPE_EXPORT IpeStringStream : public IpeStream {
162
 
public:
163
 
  IpeStringStream(IpeString &string);
164
 
  virtual void PutChar(char ch);
165
 
  virtual void PutString(IpeString s);
166
 
  virtual void PutCString(const char *s);
167
 
  virtual void PutRaw(const char *data, int size);
168
 
private:
169
 
  IpeString &iString;
170
 
};
171
 
 
172
 
class IPE_EXPORT IpeFileStream : public IpeStream {
173
 
public:
174
 
  IpeFileStream(std::FILE *file);
175
 
  virtual void PutChar(char ch);
176
 
  virtual void PutString(IpeString s);
177
 
  virtual void PutCString(const char *s);
178
 
  virtual void PutRaw(const char *data, int size);
179
 
private:
180
 
  std::FILE *iFile;
181
 
};
 
142
class IPE_EXPORT IpeFixed {
 
143
public:
 
144
  explicit IpeFixed(int val) : iValue(val * 1000) { /* nothing */ }
 
145
  explicit IpeFixed() { /* nothing */ }
 
146
  inline static IpeFixed FromInternal(int val);
 
147
  inline int ToInt() const { return iValue / 1000; }
 
148
  inline double ToDouble() const { return iValue / 1000.0; }
 
149
  inline int Internal() const { return iValue; }
 
150
  IpeFixed Mult(int a, int b) const;
 
151
private:
 
152
  int iValue;
 
153
 
 
154
  friend IpeStream &operator<<(IpeStream &stream, const IpeFixed &f);
 
155
};
 
156
 
 
157
// --------------------------------------------------------------------
182
158
 
183
159
class IPE_EXPORT IpeLex {
184
160
public:
188
164
  IpeString NextToken();
189
165
  int GetInt();
190
166
  int GetHexByte();
191
 
  int GetHexNumber();
 
167
  IpeFixed GetFixed();
 
168
  unsigned long int GetHexNumber();
192
169
  double GetDouble();
193
170
  //! Extract next character (not skipping anything).
194
171
  inline char GetChar() {
219
196
  int iMark;
220
197
};
221
198
 
 
199
// --------------------------------------------------------------------
 
200
 
222
201
class IPE_EXPORT IpeBuffer {
223
202
public:
224
203
  IpeBuffer();
249
228
};
250
229
 
251
230
// --------------------------------------------------------------------
 
231
 
 
232
class IPE_EXPORT IpeStream {
 
233
public:
 
234
  //! Virtual destructor, so you can delete using a pointer to IpeStream
 
235
  virtual ~IpeStream();
 
236
  //! Output character.
 
237
  virtual void PutChar(char ch) = 0;
 
238
  //! Close the stream.  No more writing allowed!
 
239
  virtual void Close();
 
240
  //! Output string.
 
241
  virtual void PutString(IpeString s);
 
242
  //! Output C string.
 
243
  virtual void PutCString(const char *s);
 
244
  //! Output raw character data.
 
245
  virtual void PutRaw(const char *data, int size);
 
246
  //! Output character.
 
247
  inline IpeStream &operator<<(char ch) { PutChar(ch); return *this; }
 
248
  //! Output string.
 
249
  inline IpeStream &operator<<(const IpeString &s) {
 
250
    PutString(s); return *this; }
 
251
  //! Output C string.
 
252
  inline IpeStream &operator<<(const char *s) { PutCString(s); return *this; }
 
253
  IpeStream &operator<<(int i);
 
254
  IpeStream &operator<<(double d);
 
255
  void PutHexByte(char b);
 
256
  void PutXmlString(IpeString s);
 
257
};
 
258
 
 
259
/*! \class IpeTellStream
 
260
  \ingroup base
 
261
  \brief Adds position feedback to IpeStream.
 
262
*/
 
263
 
 
264
class IPE_EXPORT IpeTellStream : public IpeStream {
 
265
public:
 
266
  virtual int Tell() const = 0;
 
267
};
 
268
 
 
269
class IPE_EXPORT IpeStringStream : public IpeTellStream {
 
270
public:
 
271
  IpeStringStream(IpeString &string);
 
272
  virtual void PutChar(char ch);
 
273
  virtual void PutString(IpeString s);
 
274
  virtual void PutCString(const char *s);
 
275
  virtual void PutRaw(const char *data, int size);
 
276
  virtual int Tell() const;
 
277
private:
 
278
  IpeString &iString;
 
279
};
 
280
 
 
281
class IPE_EXPORT IpeFileStream : public IpeTellStream {
 
282
public:
 
283
  IpeFileStream(std::FILE *file);
 
284
  virtual void PutChar(char ch);
 
285
  virtual void PutString(IpeString s);
 
286
  virtual void PutCString(const char *s);
 
287
  virtual void PutRaw(const char *data, int size);
 
288
  virtual int Tell() const;
 
289
private:
 
290
  std::FILE *iFile;
 
291
};
 
292
 
 
293
// --------------------------------------------------------------------
 
294
 
 
295
class IPE_EXPORT IpeDataSource {
 
296
public:
 
297
  virtual ~IpeDataSource() = 0;
 
298
  //! Get one more character, or EOF.
 
299
  virtual int GetChar() = 0;
 
300
};
 
301
 
 
302
class IPE_EXPORT IpeFileSource : public IpeDataSource {
 
303
public:
 
304
  IpeFileSource(std::FILE *file);
 
305
  virtual int GetChar();
 
306
private:
 
307
  std::FILE *iFile;
 
308
};
 
309
 
 
310
class IPE_EXPORT IpeBufferSource : public IpeDataSource {
 
311
public:
 
312
  IpeBufferSource(const IpeBuffer &buffer);
 
313
  virtual int GetChar();
 
314
private:
 
315
  const IpeBuffer &iBuffer;
 
316
  int iPos;
 
317
};
 
318
 
 
319
inline IpeFixed IpeFixed::FromInternal(int val)
 
320
{
 
321
  IpeFixed f;
 
322
  f.iValue = val;
 
323
  return f;
 
324
}
 
325
 
 
326
inline IpeStream &operator<<(IpeStream &stream, const IpeFixed &f)
 
327
{
 
328
  stream << (f.iValue / 1000);
 
329
  if (f.iValue % 1000) {
 
330
    stream << "." << ((f.iValue / 100) % 10);
 
331
    if (f.iValue % 100) {
 
332
      stream << ((f.iValue / 10) % 10);
 
333
      if (f.iValue % 10)
 
334
        stream << (f.iValue % 10);
 
335
    }
 
336
  }
 
337
  return stream;
 
338
}
 
339
 
 
340
// --------------------------------------------------------------------
252
341
#endif