1 /* |
|
2 * Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: Defines basic types. |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 |
|
20 #ifndef OSNTYPES_H |
|
21 #define OSNTYPES_H |
|
22 |
|
23 namespace osncore |
|
24 { |
|
25 |
|
26 /** |
|
27 * Defines a signed 8 bit integer. |
|
28 */ |
|
29 typedef signed char int8; |
|
30 |
|
31 /** |
|
32 * Defines an unsigned 8 bit integer. |
|
33 */ |
|
34 typedef unsigned char uint8; |
|
35 |
|
36 /** |
|
37 * Defines a signed 16 bit integer. |
|
38 */ |
|
39 typedef signed short int int16; |
|
40 |
|
41 /** |
|
42 * Defines an unsigned 16 bit integer. |
|
43 */ |
|
44 typedef unsigned short int uint16; |
|
45 |
|
46 /** |
|
47 * Defines an signed 32 bit integer. |
|
48 */ |
|
49 typedef signed long int int32; |
|
50 |
|
51 /** |
|
52 * Defines an unsigned 32 bit integer. |
|
53 */ |
|
54 typedef unsigned long int uint32; |
|
55 |
|
56 /** |
|
57 * Defines a signed 64 bit integer. |
|
58 */ |
|
59 typedef signed long long int64; |
|
60 |
|
61 /** |
|
62 * Defines an unsigned 64 bit integer. |
|
63 */ |
|
64 typedef unsigned long long uint64; |
|
65 |
|
66 /** |
|
67 * Defines a 32 bit floating point number. |
|
68 */ |
|
69 typedef float float32; |
|
70 |
|
71 /** |
|
72 * Defines a 64 bit floating point number. |
|
73 */ |
|
74 typedef double float64; |
|
75 |
|
76 /** |
|
77 * Defines an 8 bit character (usually ASCII). |
|
78 */ |
|
79 typedef char char8; |
|
80 |
|
81 /** |
|
82 * Defines an system dependent unsigned int |
|
83 * (in 32 bit system it is 4 bytes and in 16 bit system it is 2 bytes). |
|
84 */ |
|
85 typedef unsigned int uint; |
|
86 |
|
87 /** |
|
88 * Defines an 8 bit unsigned char |
|
89 */ |
|
90 typedef unsigned char uchar; |
|
91 |
|
92 |
|
93 |
|
94 /** |
|
95 * Defines a 16 bit character (usually unicode). |
|
96 */ |
|
97 #if defined(__VC32__) |
|
98 typedef uint16 char16; //here a uint16 is needed because the vc |
|
99 //version of L"..." returns an unsigned short |
|
100 #elif defined(__CW32__) |
|
101 typedef uint16 char16; //the same like for __VC32__ |
|
102 #elif defined(__GCC32__) |
|
103 typedef __wchar_t char16; //when using gcc the wchar_t type must be |
|
104 //used or else L in front of ASCI strings |
|
105 //(e.g. L"xyz") can't be used to assign a |
|
106 //unicode string to a char16[] |
|
107 #elif defined(__ARMCC_VERSION) // RVCT ARM COMPILER |
|
108 typedef wchar_t char16; |
|
109 #elif defined(__GCCE__) |
|
110 typedef wchar_t char16; |
|
111 #elif defined(__GNUC__) |
|
112 typedef uint16 char16; |
|
113 #endif |
|
114 |
|
115 /** |
|
116 * Defines a 32 bit boolean. |
|
117 */ |
|
118 typedef int32 bool32; |
|
119 |
|
120 /** |
|
121 * Defines the return code data type. |
|
122 */ |
|
123 typedef int32 ReturnCode; |
|
124 |
|
125 |
|
126 class CPoint; |
|
127 |
|
128 /** |
|
129 * @class CSize osntypes.h "osn/osntypes.h" |
|
130 * Defines a two dimensional size data type. |
|
131 * |
|
132 * @since S60 5.0 |
|
133 * @status Draft |
|
134 * @interfaces CSize |
|
135 */ |
|
136 class CSize |
|
137 { |
|
138 public: |
|
139 /** |
|
140 * Default constructor, initializing the mX and mY members to zero. |
|
141 */ |
|
142 inline CSize(); |
|
143 |
|
144 /** |
|
145 * Parameterized constructor. |
|
146 * |
|
147 * @param aX The first dimension of the size ( usually the width ). |
|
148 * @param aY The second dimension of the size ( usually the height ). |
|
149 */ |
|
150 inline CSize( int32 aX, int32 aY ); |
|
151 |
|
152 /** |
|
153 * Copy constructor. |
|
154 * |
|
155 * @param aSize The size object to be copied. |
|
156 */ |
|
157 inline CSize( const CSize& aSize ); |
|
158 |
|
159 /** |
|
160 * Gets a CPoint whose coordinates are the width and height of this |
|
161 * CSize. |
|
162 * |
|
163 * @return The coordinates of this CSize converted to a point. |
|
164 */ |
|
165 inline CPoint AsPoint(); |
|
166 |
|
167 /** |
|
168 * Compares this CSize with the specified CSize for equality. |
|
169 * |
|
170 * For two CSizes to be equal, both their width and height values |
|
171 * must be equal. |
|
172 * |
|
173 * @param aSize The CSize to be compared with this CSize. |
|
174 * |
|
175 * @return TRUE, if the sizes are equal, FALSE otherwise. |
|
176 */ |
|
177 inline bool32 operator==( const CSize& aSize ) const; |
|
178 |
|
179 /** |
|
180 * Compares this CSize with the specified CSize for inequality. |
|
181 * |
|
182 * For two CSize to be unequal, either their width or height values |
|
183 * must be different. |
|
184 * |
|
185 * @param aSize The CSize to be compared with this CSize. |
|
186 * |
|
187 * @return TRUE, if the sizes are different, FALSE |
|
188 * otherwise. |
|
189 */ |
|
190 inline bool32 operator!=( const CSize& aSize ) const; |
|
191 |
|
192 /** |
|
193 * CSize addition assignment operator. |
|
194 * |
|
195 * The operator adds the specified CSize to this CSize, and |
|
196 * assigns the result back to this CSize. |
|
197 * |
|
198 * @param aSize The CSize to be added. |
|
199 * |
|
200 * @return A reference to this point object. |
|
201 */ |
|
202 inline CSize& operator+=( const CSize& aSize ); |
|
203 |
|
204 /** |
|
205 * CSize subtraction assignment operator. |
|
206 * |
|
207 * The operator substracts the specified CSize from this CSize, |
|
208 * and assigns the result back to this CSize. |
|
209 * |
|
210 * @param aSize The CSize to be substracted. |
|
211 * |
|
212 * @return A reference to this point object. |
|
213 */ |
|
214 inline CSize& operator-=( const CSize& aSize ); |
|
215 |
|
216 int32 mX; ///< The first dimension. |
|
217 int32 mY; ///< The second dimension. |
|
218 }; |
|
219 |
|
220 /** |
|
221 * CSize addition operator. |
|
222 * |
|
223 * Calculates the sum of two CSize objects |
|
224 * |
|
225 * @param aLeftHandSide The left addend. |
|
226 * @param aRightHandSide The right addend. |
|
227 * |
|
228 * @return The sum. |
|
229 * |
|
230 */ |
|
231 inline const CSize operator+( const CSize& aLeftHandSide, |
|
232 const CSize& aRightHandSide ); |
|
233 |
|
234 /** |
|
235 * CSize substraction operator. |
|
236 * |
|
237 * Calculates the difference of two CSize objects |
|
238 * |
|
239 * @param aLeftHandSide The minuend. |
|
240 * @param aRightHandSide The subtrahend. |
|
241 * |
|
242 * @return The difference. |
|
243 * |
|
244 */ |
|
245 inline const CSize operator-( const CSize& aLeftHandSide, |
|
246 const CSize& aRightHandSide ); |
|
247 |
|
248 |
|
249 /** |
|
250 * @class CPoint osntypes.h "osn/osntypes.h" |
|
251 * Defines a two dimensional point data type. |
|
252 * |
|
253 * @since S60 5.0 |
|
254 * @status Draft |
|
255 * @interfaces CPoint |
|
256 */ |
|
257 class CPoint |
|
258 { |
|
259 public: |
|
260 /** |
|
261 * Default constructor, initializing the mX and mY members to zero. |
|
262 */ |
|
263 inline CPoint( ); |
|
264 |
|
265 /** |
|
266 * Parameterized constructor. |
|
267 * |
|
268 * @param aX The first coordinate of the point. |
|
269 * @param aY The second coordinate of the point. |
|
270 */ |
|
271 inline CPoint( int32 aX, int32 aY ); |
|
272 |
|
273 /** |
|
274 * Copy constructor. |
|
275 * |
|
276 * @param aPoint The point object to be copied. |
|
277 */ |
|
278 inline CPoint( const CPoint& aPoint ); |
|
279 |
|
280 /** |
|
281 * Gets a CSize whose width and height are the coordinates of this |
|
282 * CPoint. |
|
283 * |
|
284 * @return The width and height of this CPoint converted to a size. |
|
285 */ |
|
286 inline CSize AsSize(); |
|
287 |
|
288 /** |
|
289 * Compares two points for equality. |
|
290 * |
|
291 * For two points to be equal, both their x and y coordinate values |
|
292 * must be equal. |
|
293 * |
|
294 * @param aPoint The point to be compared with this point. |
|
295 * |
|
296 * @return TRUE, if the points are equal, FALSE otherwise. |
|
297 */ |
|
298 inline bool32 operator==( const CPoint& aPoint ) const; |
|
299 |
|
300 /** |
|
301 * Compares two points for inequality. |
|
302 * |
|
303 * For two points to be unequal, either their x or their y |
|
304 * coordinate values must be different. |
|
305 * |
|
306 * @param aPoint The point to be compared with this point. |
|
307 * |
|
308 * @return TRUE, if the points are different, FALSE |
|
309 * otherwise. |
|
310 */ |
|
311 inline bool32 operator!=( const CPoint& aPoint ) const; |
|
312 |
|
313 /** |
|
314 * CPoint addition assignment operator. |
|
315 * |
|
316 * The operator adds the specified CPoint to this CPoint, and |
|
317 * assigns the result back to this CPoint. |
|
318 * |
|
319 * @param aPoint The CPoint to be added. |
|
320 * |
|
321 * @return A reference to this point object. |
|
322 */ |
|
323 inline CPoint& operator+=( const CPoint& aPoint ); |
|
324 |
|
325 /** |
|
326 * CPoint subtraction assignment operator. |
|
327 * |
|
328 * The operator substracts the specified CPoint from this CPoint, |
|
329 * and assigns the result back to this CPoint. |
|
330 * |
|
331 * @param aPoint The CPoint to be substracted. |
|
332 * |
|
333 * @return A reference to this point object. |
|
334 */ |
|
335 inline CPoint& operator-=( const CPoint& aPoint ); |
|
336 |
|
337 int32 mX; ///< The x-coordinate position of the point. |
|
338 int32 mY; ///< The y-coordinate position of the point. |
|
339 }; |
|
340 |
|
341 /** |
|
342 * CPoint addition operator. |
|
343 * |
|
344 * Calculates the sum of two CPoint objects |
|
345 * |
|
346 * @param aLeftHandSide The left addend. |
|
347 * @param aRightHandSide The right addend. |
|
348 * |
|
349 * @return The sum. |
|
350 * |
|
351 */ |
|
352 inline const CPoint operator+( const CPoint& aLeftHandSide, |
|
353 const CPoint& aRightHandSide ); |
|
354 |
|
355 /** |
|
356 * CPoint substraction operator. |
|
357 * |
|
358 * Calculates the difference of two CPoint objects |
|
359 * |
|
360 * @param aLeftHandSide The minuend. |
|
361 * @param aRightHandSide The subtrahend. |
|
362 * |
|
363 * @return The difference. |
|
364 * |
|
365 */ |
|
366 inline const CPoint operator-( const CPoint& aLeftHandSide, |
|
367 const CPoint& aRightHandSide ); |
|
368 |
|
369 /** |
|
370 * @class CRect osntypes.h "osn/osntypes.h" |
|
371 * Defines a two dimensional rectangle data type. |
|
372 * |
|
373 * @since S60 5.0 |
|
374 * @status Draft |
|
375 * @interfaces CRect |
|
376 */ |
|
377 class CRect |
|
378 { |
|
379 public: |
|
380 /** |
|
381 * Default constructor, initializing the coordinates of the top left |
|
382 * corner and the size to ( 0,0 ). |
|
383 */ |
|
384 inline CRect(); |
|
385 |
|
386 /** |
|
387 * Parameterized constructor. |
|
388 * |
|
389 * @param aX The first coordinate of the rectangle's top left point. |
|
390 * @param aY The second coordinate of the rectangle's top left |
|
391 * point. |
|
392 * @param aWidth The width of the rectangle. |
|
393 * @param aHeight The height of the rectangle. |
|
394 */ |
|
395 inline CRect( int32 aX, int32 aY, int32 aWidth, int32 aHeight ); |
|
396 |
|
397 /** |
|
398 * Parameterized constructor. |
|
399 * |
|
400 * Constructs the rectangle with a point ( top left corner ) and a |
|
401 * size. |
|
402 * |
|
403 * @param aTopLeft The top left point of the rectangle. |
|
404 * @param aSize The size of the rectangle. |
|
405 */ |
|
406 inline CRect( const CPoint& aTopLeft, const CSize& aSize ); |
|
407 |
|
408 /** |
|
409 * Parameterized constructor. |
|
410 * |
|
411 * Constructs the rectangle with a size. The top left corner is set |
|
412 * to (0,0). |
|
413 * |
|
414 * @param aSize The size of the rectangle. |
|
415 */ |
|
416 inline CRect( const CSize& aSize ); |
|
417 |
|
418 /** |
|
419 * Copy constructor. |
|
420 * |
|
421 * @param aRect The rectangle object to be copied. |
|
422 */ |
|
423 inline CRect( const CRect& aRect ); |
|
424 |
|
425 /** |
|
426 * Determines whether the area covered by the rectangle is zero. |
|
427 * |
|
428 * @return TRUE, if the rectangle is empty, FALSE |
|
429 * otherwise. |
|
430 */ |
|
431 inline bool32 IsEmpty() const; |
|
432 |
|
433 /** |
|
434 * Tests whether this rectangle overlaps with the specified |
|
435 * rectangle. |
|
436 * |
|
437 * Two rectangles overlap if any point is located within both |
|
438 * rectangles. There is no intersection if two adjacent sides touch |
|
439 * without overlapping, or if either rectangle is empty. |
|
440 * |
|
441 * @param aRect The rectangle to compare with this rectangle for an |
|
442 * intersection. |
|
443 * |
|
444 * @return TRUE, if the two rectangles overlap, FALSE |
|
445 * otherwise. |
|
446 */ |
|
447 inline bool32 Intersects( CRect aRect ) const; |
|
448 |
|
449 /** |
|
450 * Tests whether this normalized rectangle overlaps with the |
|
451 * specified normalized rectangle. |
|
452 * |
|
453 * Two rectangles overlap if any point is located within both |
|
454 * rectangles. There is no intersection if two adjacent sides touch |
|
455 * without overlapping, or if either rectangle is empty. |
|
456 * If one of the rectangles isn't normalized, then the function also |
|
457 * returns FALSE, |
|
458 * |
|
459 * Because of performance reasons this function should favored over |
|
460 * the Intersects function, when it is certain that both rectangles |
|
461 * are normalized. |
|
462 * |
|
463 * @param aRect The rectangle to compare with this rectangle for an |
|
464 * intersection. |
|
465 * |
|
466 * @return TRUE, if the two rectangles are normalized and |
|
467 * overlap, FALSE otherwise. |
|
468 */ |
|
469 inline bool32 FastIntersects( const CRect& aRect ) const; |
|
470 |
|
471 /** |
|
472 * Gets the normalized area of intersection between this rectangle |
|
473 * and the specified rectangle, and assigns it to this rectangle. |
|
474 * |
|
475 * If the two rectangles do not intersect, then, on return, this |
|
476 * rectangle is set to be empty. |
|
477 * |
|
478 * @param aRect The rectangle to be used with this rectangle to get |
|
479 * the area of intersection. |
|
480 */ |
|
481 inline void Intersection( CRect aRect ); |
|
482 |
|
483 /** |
|
484 * Gets the normalized area of intersection between this normalized |
|
485 * rectangle and the specified normalized rectangle, and assigns it |
|
486 * to this rectangle. |
|
487 * |
|
488 * If the two rectangles do not intersect or are not normalized, |
|
489 * then, on return, this rectangle is set to be empty. |
|
490 * |
|
491 * Because of performance reasons this function should be favored |
|
492 * over the Intersection() function, when it is certain that both |
|
493 * rectangles are normalized. |
|
494 * |
|
495 * @param aRect The rectangle to be used with this rectangle to get |
|
496 * the area of intersection. |
|
497 */ |
|
498 inline void FastIntersection( const CRect& aRect ); |
|
499 |
|
500 /** |
|
501 * Ensures that the rectangle's width and height have positive |
|
502 * values. |
|
503 * |
|
504 * For example, if the rectangle's co-ordinates are such that the |
|
505 * top is below the bottom, or the right hand side is to the left of |
|
506 * the left hand side, normalisation swaps the co-ordinates of the |
|
507 * top and bottom or of the left and right. |
|
508 */ |
|
509 inline void Normalize(); |
|
510 |
|
511 /** |
|
512 * Tests whether the rectangle is normalized. |
|
513 * |
|
514 * A rectangle is normalized, when its width and height are both |
|
515 * greater than or equal to zero. |
|
516 */ |
|
517 inline bool32 IsNormalized() const; |
|
518 |
|
519 /** |
|
520 * Compares two rectangles for equality. |
|
521 * |
|
522 * For two rectangles to be equal, the coordinates of their top left |
|
523 * corners and their sizes must be equal. |
|
524 * |
|
525 * @param aRect The rectangle to compare with this rectangle. |
|
526 * |
|
527 * @return TRUE, if the rectangles are equal, FALSE |
|
528 * otherwise. |
|
529 */ |
|
530 inline bool32 operator==( const CRect& aRect ) const; |
|
531 |
|
532 /** |
|
533 * Compares two rectangles for inequality. |
|
534 * |
|
535 * Two rectangles are unequal if the coordinates of their top left |
|
536 * corners or their sizes differ. |
|
537 * |
|
538 * @param aRect The rectangle to compare with this rectangle. |
|
539 * |
|
540 * @return TRUE, if the rectangles are different, FALSE |
|
541 * otherwise. |
|
542 */ |
|
543 inline bool32 operator!=( const CRect& aRect ) const; |
|
544 |
|
545 /** |
|
546 * CPoint addition assignment operator. |
|
547 * |
|
548 * The operator moves this CRect's offset by the given point's |
|
549 * coordinates. |
|
550 * |
|
551 * @param aPoint The CPoint to be added. |
|
552 * |
|
553 * @return A reference to this rectangle object. |
|
554 */ |
|
555 inline CRect& operator+=( const CPoint& aPoint ); |
|
556 |
|
557 /** |
|
558 * CPoint subtraction assignment operator. |
|
559 * |
|
560 * The operator moves this CRect's offset by the given point's |
|
561 * coordinates. |
|
562 * |
|
563 * @param aPoint The CPoint to be substracted. |
|
564 * |
|
565 * @return A reference to this rectangle object. |
|
566 */ |
|
567 inline CRect& operator-=( const CPoint& aPoint ); |
|
568 |
|
569 /** |
|
570 * CSize addition assignment operator. |
|
571 * |
|
572 * The operator increases this CRect's size by the given size. |
|
573 * |
|
574 * @param aSize The CSize to be added. |
|
575 * |
|
576 * @return A reference to this rectangle object. |
|
577 */ |
|
578 inline CRect& operator+=( const CSize& aSize ); |
|
579 |
|
580 /** |
|
581 * CSize subtraction assignment operator. |
|
582 * |
|
583 * The operator decreases this CRect's size by the given size. |
|
584 * |
|
585 * @param aSize The CSize to be substracted. |
|
586 * |
|
587 * @return A reference to this rectangle object. |
|
588 */ |
|
589 inline CRect& operator-=( const CSize& aSize ); |
|
590 |
|
591 int32 mX; ///< The position of the left-hand side of the |
|
592 ///< rectangle. |
|
593 int32 mY; ///< The position of the top side of the rectangle. |
|
594 int32 mWidth; ///< The width of the rectangle. |
|
595 int32 mHeight; ///< The height of the rectangle. |
|
596 }; |
|
597 |
|
598 /** |
|
599 * CRect + CPoint addition operator. |
|
600 * |
|
601 * The operator copies the CRect and moves the copy's offset by the given |
|
602 * point's coordinates. |
|
603 * |
|
604 * @param aRect The CRect addend. |
|
605 * @param aPoint The CPoint to be added. |
|
606 * |
|
607 * @return The moved CRect. |
|
608 * |
|
609 */ |
|
610 inline const CRect operator+( const CRect& aRect, |
|
611 const CPoint& aPoint ); |
|
612 |
|
613 /** |
|
614 * CRect - CPoint subtraction operator. |
|
615 * |
|
616 * The operator copies the CRect and moves the copy's offset by the |
|
617 * given point's coordinates. |
|
618 * |
|
619 * @param aRect The CRect addend. |
|
620 * @param aPoint The CPoint to be substracted. |
|
621 * |
|
622 * @return The moved CRect. |
|
623 * |
|
624 */ |
|
625 inline const CRect operator-( const CRect& aRect, |
|
626 const CPoint& aPoint ); |
|
627 |
|
628 /** |
|
629 * CRect + CSize addition operator. |
|
630 * |
|
631 * The operator copies the CRect and resizes the copy by the given size. |
|
632 * |
|
633 * @param aRect The CRect addend. |
|
634 * @param aSize The CSize to be added. |
|
635 * |
|
636 * @return The resized CRect. |
|
637 * |
|
638 * @ingroup Runtime |
|
639 */ |
|
640 inline const CRect operator+( const CRect& aRect, |
|
641 const CSize& aSize ); |
|
642 |
|
643 /** |
|
644 * CRect - CSize subtraction operator. |
|
645 * |
|
646 * The operator copies the CRect and resizes the copy by the given size. |
|
647 * |
|
648 * @param aRect The CRect minuend. |
|
649 * @param aSize The CSize to be substracted. |
|
650 * |
|
651 * @return The resized CRect. |
|
652 * |
|
653 * @ingroup Runtime |
|
654 */ |
|
655 inline const CRect operator-( const CRect& aRect, |
|
656 const CSize& aSize ); |
|
657 |
|
658 /** |
|
659 * Defines maximum value for a int8 variable |
|
660 */ |
|
661 const int8 MAX_INT8 = 0x7f; |
|
662 |
|
663 /** |
|
664 * Defines minimum value for a int8 variable |
|
665 */ |
|
666 const int8 MIN_INT8 = 0x80; |
|
667 |
|
668 /** |
|
669 * Defines maximum value for a uint8 variable |
|
670 */ |
|
671 const uint8 MAX_UINT8 = 0xffu; |
|
672 |
|
673 /** |
|
674 * Defines maximum value for a int16 variable |
|
675 */ |
|
676 const int16 MAX_INT16 = 0x7fff; |
|
677 |
|
678 /** |
|
679 * Defines minimum value for a int16 variable |
|
680 */ |
|
681 const int16 MIN_INT16 = 0x8000; |
|
682 |
|
683 /** |
|
684 * Defines maximum value for a uint16 variable |
|
685 */ |
|
686 const uint16 MAX_UINT16 = 0xffffu; |
|
687 |
|
688 /** |
|
689 * Defines maximum value for a int32 variable |
|
690 */ |
|
691 const int32 MAX_INT32 = 0x7fffffff; |
|
692 |
|
693 /** |
|
694 * Defines minimum value for a int32 variable |
|
695 */ |
|
696 const int32 MIN_INT32 = 0x80000000; |
|
697 |
|
698 /** |
|
699 * Defines maximum value for a uint32 variable |
|
700 */ |
|
701 const uint32 MAX_UINT32 = 0xffffffffu; |
|
702 |
|
703 |
|
704 /** |
|
705 * Maximum path/filename length including a NULL terminator. A char16* |
|
706 * array of this size is guaranteed to accomodate all filenames returned |
|
707 * by the system. |
|
708 */ |
|
709 const uint32 MAX_PATH_LENGTH = 257; |
|
710 |
|
711 /// Filename path delimiter. |
|
712 const char16 PATH_DELIMITER = '\\'; |
|
713 |
|
714 /// Filename drive delimiter. |
|
715 const char16 DRIVE_DELIMITER = ':'; |
|
716 |
|
717 /// Filename extension delimiter. |
|
718 const char16 EXTENSION_DELIMITER = '.'; |
|
719 |
|
720 |
|
721 #include <osn/osntypes.inl> |
|
722 } |
|
723 #endif |
|