api_text.c revision 5d64a06a6322b6e6f88233e79c6431e96eda7de6 
1/**************************************************************************
2 *
3 * Copyright 2009 VMware, Inc.  All Rights Reserved.
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the
7 * "Software"), to deal in the Software without restriction, including
8 * without limitation the rights to use, copy, modify, merge, publish,
9 * distribute, sub license, and/or sell copies of the Software, and to
10 * permit persons to whom the Software is furnished to do so, subject to
11 * the following conditions:
12 *
13 * The above copyright notice and this permission notice (including the
14 * next paragraph) shall be included in all copies or substantial portions
15 * of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
19 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
20 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
21 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
22 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
23 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
24 *
25 **************************************************************************/
26
27#include "VG/openvg.h"
28
29#include "vg_context.h"
30#include "text.h"
31#include "api.h"
32
33#include "util/u_memory.h"
34
35#ifdef OPENVG_VERSION_1_1
36
37VGFont vegaCreateFont(VGint glyphCapacityHint)
38{
39   struct vg_context *ctx = vg_current_context();
40
41   if (glyphCapacityHint < 0) {
42      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
43      return VG_INVALID_HANDLE;
44   }
45
46   return (VGFont) font_create(glyphCapacityHint);
47}
48
49void vegaDestroyFont(VGFont f)
50{
51   struct vg_font *font = (struct vg_font *)f;
52   struct vg_context *ctx = vg_current_context();
53
54   if (f == VG_INVALID_HANDLE) {
55      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
56      return;
57   }
58   if (!vg_object_is_valid((void *) font, VG_OBJECT_FONT)) {
59      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
60      return;
61   }
62
63   font_destroy(font);
64}
65
66void vegaSetGlyphToPath(VGFont font,
67                        VGuint glyphIndex,
68                        VGPath path,
69                        VGboolean isHinted,
70                        const VGfloat glyphOrigin[2],
71                        const VGfloat escapement[2])
72{
73   struct vg_context *ctx = vg_current_context();
74   struct path *pathObj;
75   struct vg_font *f;
76
77   if (font == VG_INVALID_HANDLE ||
78       !vg_context_is_object_valid(ctx, VG_OBJECT_FONT, (void *)font)) {
79      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
80      return;
81   }
82   if (!glyphOrigin || !escapement ||
83       !is_aligned(glyphOrigin) || !is_aligned(escapement)) {
84      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
85      return;
86   }
87   if (path != VG_INVALID_HANDLE &&
88       !vg_context_is_object_valid(ctx, VG_OBJECT_PATH, (void *)path)) {
89      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
90      return;
91   }
92
93   pathObj = (struct path*) path;
94   f = (struct vg_font*) font;
95
96   font_set_glyph_to_path(f, glyphIndex, pathObj,
97         isHinted, glyphOrigin, escapement);
98}
99
100void vegaSetGlyphToImage(VGFont font,
101                         VGuint glyphIndex,
102                         VGImage image,
103                         const VGfloat glyphOrigin[2],
104                         const VGfloat escapement[2])
105{
106   struct vg_context *ctx = vg_current_context();
107   struct vg_image *img_obj;
108   struct vg_font *f;
109
110   if (font == VG_INVALID_HANDLE ||
111       !vg_context_is_object_valid(ctx, VG_OBJECT_FONT, (void *)font)) {
112      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
113      return;
114   }
115   if (!glyphOrigin || !escapement ||
116       !is_aligned(glyphOrigin) || !is_aligned(escapement)) {
117      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
118      return;
119   }
120   if (image != VG_INVALID_HANDLE &&
121       !vg_context_is_object_valid(ctx, VG_OBJECT_IMAGE, (void *)image)) {
122      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
123      return;
124   }
125
126   img_obj = (struct vg_image*)image;
127   f = (struct vg_font*)font;
128
129   font_set_glyph_to_image(f, glyphIndex, img_obj, glyphOrigin, escapement);
130}
131
132void vegaClearGlyph(VGFont font,
133                    VGuint glyphIndex)
134{
135   struct vg_context *ctx = vg_current_context();
136   struct vg_font *f;
137
138   if (font == VG_INVALID_HANDLE) {
139      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
140      return;
141   }
142
143   f = (struct vg_font*) font;
144
145   font_clear_glyph(f, glyphIndex);
146}
147
148void vegaDrawGlyph(VGFont font,
149                   VGuint glyphIndex,
150                   VGbitfield paintModes,
151                   VGboolean allowAutoHinting)
152{
153   struct vg_context *ctx = vg_current_context();
154   struct vg_font *f;
155
156   if (font == VG_INVALID_HANDLE) {
157      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
158      return;
159   }
160   if (paintModes & (~(VG_STROKE_PATH|VG_FILL_PATH))) {
161      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
162      return;
163   }
164   f = (struct vg_font*)font;
165
166   font_draw_glyph(f, glyphIndex, paintModes, allowAutoHinting);
167}
168
169void vegaDrawGlyphs(VGFont font,
170                    VGint glyphCount,
171                    const VGuint *glyphIndices,
172                    const VGfloat *adjustments_x,
173                    const VGfloat *adjustments_y,
174                    VGbitfield paintModes,
175                    VGboolean allowAutoHinting)
176{
177   struct vg_context *ctx = vg_current_context();
178   struct vg_font *f;
179
180   if (font == VG_INVALID_HANDLE) {
181      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
182      return;
183   }
184   if (glyphCount <= 0) {
185      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
186      return;
187   }
188   if (!glyphIndices || !is_aligned(glyphIndices)) {
189      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
190      return;
191   }
192   if ((adjustments_x && !is_aligned(adjustments_x)) ||
193       (adjustments_y && !is_aligned(adjustments_y))) {
194      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
195      return;
196   }
197   if (paintModes & (~(VG_STROKE_PATH|VG_FILL_PATH))) {
198      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
199      return;
200   }
201
202   f = (struct vg_font*)font;
203
204   font_draw_glyphs(f, glyphCount, glyphIndices,
205         adjustments_x, adjustments_y, paintModes, allowAutoHinting);
206}
207
208#endif /* OPENVG_VERSION_1_1 */
209