blob: 6e40d3c95743bf01bbc5ee250a6e0d7396885f00 (
plain)
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
|
#ifndef __FTCharToGlyphIndexMap__
#define __FTCharToGlyphIndexMap__
#include <stdlib.h>
#include "FTGL.h"
/**
* Provides a non-STL alternative to the STL map<unsigned long, unsigned long>
* which maps character codes to glyph indices inside FTCharmap.
*
* Implementation:
* - NumberOfBuckets buckets are considered.
* - Each bucket has BucketSize entries.
* - When the glyph index for the character code C has to be stored, the
* bucket this character belongs to is found using 'C div BucketSize'.
* If this bucket has not been allocated yet, do it now.
* The entry in the bucked is found using 'C mod BucketSize'.
* If it is set to IndexNotFound, then the glyph entry has not been set.
* - Try to mimic the calls made to the STL map API.
*
* Caveats:
* - The glyph index is now a signed long instead of unsigned long, so
* the special value IndexNotFound (= -1) can be used to specify that the
* glyph index has not been stored yet.
*/
class FTGL_EXPORT FTCharToGlyphIndexMap
{
public:
typedef unsigned long CharacterCode;
typedef signed long GlyphIndex;
enum
{
NumberOfBuckets = 256,
BucketSize = 256,
IndexNotFound = -1
};
FTCharToGlyphIndexMap()
{
this->Indices = 0;
}
virtual ~FTCharToGlyphIndexMap()
{
if( this->Indices)
{
// Free all buckets
this->clear();
// Free main structure
delete [] this->Indices;
this->Indices = 0;
}
}
void clear()
{
if(this->Indices)
{
for( int i = 0; i < FTCharToGlyphIndexMap::NumberOfBuckets; i++)
{
if( this->Indices[i])
{
delete [] this->Indices[i];
this->Indices[i] = 0;
}
}
}
}
const GlyphIndex find( CharacterCode c)
{
if( !this->Indices)
{
return 0;
}
// Find position of char code in buckets
div_t pos = div( c, FTCharToGlyphIndexMap::BucketSize);
if( !this->Indices[pos.quot])
{
return 0;
}
const FTCharToGlyphIndexMap::GlyphIndex *ptr = &this->Indices[pos.quot][pos.rem];
if( *ptr == FTCharToGlyphIndexMap::IndexNotFound)
{
return 0;
}
return *ptr;
}
void insert( CharacterCode c, GlyphIndex g)
{
if( !this->Indices)
{
this->Indices = new GlyphIndex* [FTCharToGlyphIndexMap::NumberOfBuckets];
for( int i = 0; i < FTCharToGlyphIndexMap::NumberOfBuckets; i++)
{
this->Indices[i] = 0;
}
}
// Find position of char code in buckets
div_t pos = div(c, FTCharToGlyphIndexMap::BucketSize);
// Allocate bucket if does not exist yet
if( !this->Indices[pos.quot])
{
this->Indices[pos.quot] = new GlyphIndex [FTCharToGlyphIndexMap::BucketSize];
for( int i = 0; i < FTCharToGlyphIndexMap::BucketSize; i++)
{
this->Indices[pos.quot][i] = FTCharToGlyphIndexMap::IndexNotFound;
}
}
this->Indices[pos.quot][pos.rem] = g;
}
private:
GlyphIndex** Indices;
};
#endif // __FTCharToGlyphIndexMap__
|
