1/*
2 * Copyright (C) 2010 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#ifndef ANDROID_HWUI_TEXT_DROP_SHADOW_CACHE_H
18#define ANDROID_HWUI_TEXT_DROP_SHADOW_CACHE_H
19
20#include <GLES2/gl2.h>
21
22#include <SkPaint.h>
23
24#include <utils/LruCache.h>
25#include <utils/String16.h>
26
27#include "FontRenderer.h"
28#include "Texture.h"
29
30namespace android {
31namespace uirenderer {
32
33class Caches;
34
35struct ShadowText {
36    ShadowText(): len(0), radius(0.0f), textSize(0.0f), typeface(NULL),
37            flags(0), italicStyle(0.0f), scaleX(0), text(NULL), positions(NULL) {
38    }
39
40    // len is the number of bytes in text
41    ShadowText(const SkPaint* paint, float radius, uint32_t len, const char* srcText,
42            const float* positions):
43            len(len), radius(radius), positions(positions) {
44        // TODO: Propagate this through the API, we should not cast here
45        text = (const char16_t*) srcText;
46
47        textSize = paint->getTextSize();
48        typeface = paint->getTypeface();
49
50        flags = 0;
51        if (paint->isFakeBoldText()) {
52            flags |= Font::kFakeBold;
53        }
54
55        italicStyle = paint->getTextSkewX();
56        scaleX = paint->getTextScaleX();
57    }
58
59    ~ShadowText() {
60    }
61
62    hash_t hash() const;
63
64    static int compare(const ShadowText& lhs, const ShadowText& rhs);
65
66    bool operator==(const ShadowText& other) const {
67        return compare(*this, other) == 0;
68    }
69
70    bool operator!=(const ShadowText& other) const {
71        return compare(*this, other) != 0;
72    }
73
74    void copyTextLocally() {
75        uint32_t charCount = len / sizeof(char16_t);
76        str.setTo((const char16_t*) text, charCount);
77        text = str.string();
78        if (positions != NULL) {
79            positionsCopy.clear();
80            positionsCopy.appendArray(positions, charCount * 2);
81            positions = positionsCopy.array();
82        }
83    }
84
85    uint32_t len;
86    float radius;
87    float textSize;
88    SkTypeface* typeface;
89    uint32_t flags;
90    float italicStyle;
91    float scaleX;
92    const char16_t* text;
93    const float* positions;
94
95    // Not directly used to compute the cache key
96    String16 str;
97    Vector<float> positionsCopy;
98
99}; // struct ShadowText
100
101// Caching support
102
103inline int strictly_order_type(const ShadowText& lhs, const ShadowText& rhs) {
104    return ShadowText::compare(lhs, rhs) < 0;
105}
106
107inline int compare_type(const ShadowText& lhs, const ShadowText& rhs) {
108    return ShadowText::compare(lhs, rhs);
109}
110
111inline hash_t hash_type(const ShadowText& entry) {
112    return entry.hash();
113}
114
115/**
116 * Alpha texture used to represent a shadow.
117 */
118struct ShadowTexture: public Texture {
119    ShadowTexture(Caches& caches): Texture(caches) {
120    }
121
122    float left;
123    float top;
124}; // struct ShadowTexture
125
126class TextDropShadowCache: public OnEntryRemoved<ShadowText, ShadowTexture*> {
127public:
128    TextDropShadowCache();
129    TextDropShadowCache(uint32_t maxByteSize);
130    ~TextDropShadowCache();
131
132    /**
133     * Used as a callback when an entry is removed from the cache.
134     * Do not invoke directly.
135     */
136    void operator()(ShadowText& text, ShadowTexture*& texture);
137
138    ShadowTexture* get(const SkPaint* paint, const char* text, uint32_t len,
139            int numGlyphs, float radius, const float* positions);
140
141    /**
142     * Clears the cache. This causes all textures to be deleted.
143     */
144    void clear();
145
146    void setFontRenderer(FontRenderer& fontRenderer) {
147        mRenderer = &fontRenderer;
148    }
149
150    /**
151     * Sets the maximum size of the cache in bytes.
152     */
153    void setMaxSize(uint32_t maxSize);
154    /**
155     * Returns the maximum size of the cache in bytes.
156     */
157    uint32_t getMaxSize();
158    /**
159     * Returns the current size of the cache in bytes.
160     */
161    uint32_t getSize();
162
163private:
164    void init();
165
166    LruCache<ShadowText, ShadowTexture*> mCache;
167
168    uint32_t mSize;
169    uint32_t mMaxSize;
170    FontRenderer* mRenderer;
171    bool mDebugEnabled;
172}; // class TextDropShadowCache
173
174}; // namespace uirenderer
175}; // namespace android
176
177#endif // ANDROID_HWUI_TEXT_DROP_SHADOW_CACHE_H
178