DEV/flutter_flutter
1
0
Fork 0
mirror of https://github.com/flutter/flutter.git synced 2026-02-20 02:29:02 +08:00
Code Issues Packages Projects Releases Wiki Activity

Remove sample directory

Browse Source 
Since there are no known users of Minikin outside Android yet, these
files are simply a maintenance burden with no actual benefit.
Removing the samples until there are potential external users.

Test: Not needed
Change-Id: If7f1fb775cae427fbe31b86c202d1380c701bf28
This commit is contained in:
Roozbeh Pournader 2017-03-06 14:05:23 -08:00
parent 2f1aebfcc6
commit 22d4e7e3f3
5 changed files with 0 additions and 427 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

69
engine/src/flutter/sample/Android.mk
View File

@ -1,69 +0,0 @@
# Copyright (C) 2013 The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
LOCAL_PATH:= $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE_TAGS := tests
LOCAL_C_INCLUDES += \
external/harfbuzz_ng/src \
external/freetype/include \
frameworks/minikin/include
LOCAL_SRC_FILES:= example.cpp
LOCAL_SHARED_LIBRARIES += \
libutils \
liblog \
libcutils \
libharfbuzz_ng \
libicuuc \
libft2 \
libpng \
libz \
libminikin
LOCAL_MODULE:= minikin_example
include $(BUILD_EXECUTABLE)
include $(CLEAR_VARS)
LOCAL_MODULE_TAG := tests
LOCAL_C_INCLUDES += \
external/harfbuzz_ng/src \
external/freetype/include \
frameworks/minikin/include \
external/skia/src/core
LOCAL_SRC_FILES:= example_skia.cpp \
MinikinSkia.cpp
LOCAL_SHARED_LIBRARIES += \
libutils \
liblog \
libcutils \
libharfbuzz_ng \
libicuuc \
libskia \
libminikin \
libft2
LOCAL_MODULE:= minikin_skia_example
include $(BUILD_EXECUTABLE)

68
engine/src/flutter/sample/MinikinSkia.cpp
View File

@ -1,68 +0,0 @@
#include <SkTypeface.h>
#include <SkPaint.h>
#include <minikin/MinikinFont.h>
#include "MinikinSkia.h"
namespace minikin {
MinikinFontSkia::MinikinFontSkia(sk_sp<SkTypeface> typeface) :
MinikinFont(typeface->uniqueID()),
mTypeface(std::move(typeface)) {
}
static void MinikinFontSkia_SetSkiaPaint(sk_sp<SkTypeface> typeface, SkPaint* skPaint, const MinikinPaint& paint) {
skPaint->setTypeface(std::move(typeface));
skPaint->setTextEncoding(SkPaint::kGlyphID_TextEncoding);
// TODO: set more paint parameters from Minikin
skPaint->setTextSize(paint.size);
}
float MinikinFontSkia::GetHorizontalAdvance(uint32_t glyph_id,
const MinikinPaint &paint) const {
SkPaint skPaint;
uint16_t glyph16 = glyph_id;
SkScalar skWidth;
MinikinFontSkia_SetSkiaPaint(mTypeface, &skPaint, paint);
skPaint.getTextWidths(&glyph16, sizeof(glyph16), &skWidth, NULL);
#ifdef VERBOSE
ALOGD("width for typeface %d glyph %d = %f", mTypeface->uniqueID(), glyph_id
#endif
return skWidth;
}
void MinikinFontSkia::GetBounds(MinikinRect* bounds, uint32_t glyph_id,
const MinikinPaint& paint) const {
SkPaint skPaint;
uint16_t glyph16 = glyph_id;
SkRect skBounds;
MinikinFontSkia_SetSkiaPaint(mTypeface, &skPaint, paint);
skPaint.getTextWidths(&glyph16, sizeof(glyph16), NULL, &skBounds);
bounds->mLeft = skBounds.fLeft;
bounds->mTop = skBounds.fTop;
bounds->mRight = skBounds.fRight;
bounds->mBottom = skBounds.fBottom;
}
const void* MinikinFontSkia::GetTable(uint32_t tag, size_t* size,
MinikinDestroyFunc* destroy) const {
// we don't have a buffer to the font data, copy to own buffer
const size_t tableSize = mTypeface->getTableSize(tag);
*size = tableSize;
if (tableSize == 0) {
return nullptr;
}
void* buf = malloc(tableSize);
if (buf == nullptr) {
return nullptr;
}
mTypeface->getTableData(tag, 0, tableSize, buf);
*destroy = free;
return buf;
}
SkTypeface *MinikinFontSkia::GetSkTypeface() const {
return mTypeface.get();
}
} // namespace minikin

40
engine/src/flutter/sample/MinikinSkia.h
View File

@ -1,40 +0,0 @@
/*
* Copyright (C) 2016 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
namespace minikin {
class MinikinFontSkia : public MinikinFont {
public:
explicit MinikinFontSkia(sk_sp<SkTypeface> typeface);
float GetHorizontalAdvance(uint32_t glyph_id,
const MinikinPaint &paint) const;
void GetBounds(MinikinRect* bounds, uint32_t glyph_id,
const MinikinPaint& paint) const;
const std::vector<minikin::FontVariation>& GetAxes() const {
return mAxes;
}
const void* GetTable(uint32_t tag, size_t* size, MinikinDestroyFunc* destroy) const;
SkTypeface *GetSkTypeface() const;
private:
sk_sp<SkTypeface> mTypeface;
std::vector<minikin::FontVariation> mAxes;
};
} // namespace minikin

100
engine/src/flutter/sample/example.cpp
View File

@ -1,100 +0,0 @@
/*
* Copyright (C) 2013 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
// This is a test program that uses Minikin to layout and draw some text.
// At the moment, it just draws a string into /data/local/tmp/foo.pgm.
#include <stdio.h>
#include <vector>
#include <fstream>
#include <unicode/unistr.h>
#include <unicode/utf16.h>
#include <minikin/MinikinFontFreeType.h>
#include <minikin/Layout.h>
using std::vector;
using namespace minikin;
FT_Library library; // TODO: this should not be a global
FontCollection *makeFontCollection() {
vector<std::shared_ptr<FontFamily>>typefaces;
const char *fns[] = {
"/system/fonts/Roboto-Regular.ttf",
"/system/fonts/Roboto-Italic.ttf",
"/system/fonts/Roboto-BoldItalic.ttf",
"/system/fonts/Roboto-Light.ttf",
"/system/fonts/Roboto-Thin.ttf",
"/system/fonts/Roboto-Bold.ttf",
"/system/fonts/Roboto-ThinItalic.ttf",
"/system/fonts/Roboto-LightItalic.ttf"
};
FT_Face face;
FT_Error error;
std::vector<Font> fonts;
for (size_t i = 0; i < sizeof(fns)/sizeof(fns[0]); i++) {
const char *fn = fns[i];
printf("adding %s\n", fn);
error = FT_New_Face(library, fn, 0, &face);
if (error != 0) {
printf("error loading %s, %d\n", fn, error);
}
std::shared_ptr<MinikinFont> font(new MinikinFontFreeType(face));
fonts.push_back(Font(font, FontStyle()));
}
std::shared_ptr<FontFamily> family(new FontFamily(std::move(fonts)));
typefaces.push_back(family);
#if 1
const char *fn = "/system/fonts/DroidSansDevanagari-Regular.ttf";
error = FT_New_Face(library, fn, 0, &face);
std::shared_ptr<MinikinFont> font(new MinikinFontFreeType(face));
family.reset(new FontFamily(std::vector<Font>({ Font(font, FontStyle()) })));
typefaces.push_back(family);
#endif
return new FontCollection(typefaces);
}
int runMinikinTest() {
FT_Error error = FT_Init_FreeType(&library);
if (error) {
return -1;
}
std::shared_ptr<FontCollection> collection(makeFontCollection());
Layout layout(collection);
const char *text = "fine world \xe0\xa4\xa8\xe0\xa4\xae\xe0\xa4\xb8\xe0\xa5\x8d\xe0\xa4\xa4\xe0\xa5\x87";
int bidiFlags = 0;
FontStyle fontStyle;
MinikinPaint paint;
paint.size = 32;
icu::UnicodeString icuText = icu::UnicodeString::fromUTF8(text);
layout.doLayout(icuText.getBuffer(), 0, icuText.length(), icuText.length(), bidiFlags, fontStyle, paint);
layout.dump();
Bitmap bitmap(250, 50);
layout.draw(&bitmap, 10, 40, 32);
std::ofstream o;
o.open("/data/local/tmp/foo.pgm", std::ios::out | std::ios::binary);
bitmap.writePnm(o);
return 0;
}
int main() {
return runMinikinTest();
}

150
engine/src/flutter/sample/example_skia.cpp
View File

@ -1,150 +0,0 @@
/*
* Copyright (C) 2013 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
// This is a test program that uses Minikin to layout and draw some text.
// At the moment, it just draws a string into /data/local/tmp/foo.pgm.
#include <stdio.h>
#include <vector>
#include <fstream>
#include <unicode/unistr.h>
#include <unicode/utf16.h>
#include <minikin/MinikinFontFreeType.h>
#include <minikin/Layout.h>
#include <SkCanvas.h>
#include <SkGraphics.h>
#include <SkImageEncoder.h>
#include <SkTypeface.h>
#include <SkPaint.h>
#include "MinikinSkia.h"
using std::vector;
namespace minikin {
FT_Library library; // TODO: this should not be a global
FontCollection *makeFontCollection() {
vector<std::shared_ptr<FontFamily>> typefaces;
const char *fns[] = {
"/system/fonts/Roboto-Regular.ttf",
"/system/fonts/Roboto-Italic.ttf",
"/system/fonts/Roboto-BoldItalic.ttf",
"/system/fonts/Roboto-Light.ttf",
"/system/fonts/Roboto-Thin.ttf",
"/system/fonts/Roboto-Bold.ttf",
"/system/fonts/Roboto-ThinItalic.ttf",
"/system/fonts/Roboto-LightItalic.ttf"
};
std::vector<Font> fonts;
for (size_t i = 0; i < sizeof(fns)/sizeof(fns[0]); i++) {
const char *fn = fns[i];
sk_sp<SkTypeface> skFace = SkTypeface::MakeFromFile(fn);
std::shared_ptr<MinikinFont> font(new MinikinFontSkia(std::move(skFace)));
fonts.push_back(Font(font, FontStyle()));
}
std::shared_ptr<FontFamily> family(new FontFamily(std::move(fonts)));
typefaces.push_back(family);
#if 1
const char *fn = "/system/fonts/DroidSansDevanagari-Regular.ttf";
sk_sp<SkTypeface> skFace = SkTypeface::MakeFromFile(fn);
std::shared_ptr<MinikinFont> font(new MinikinFontSkia(std::move(skFace)));
family.reset(new FontFamily(std::vector<Font>({ Font(font, FontStyle()) })));
typefaces.push_back(family);
#endif
return new FontCollection(typefaces);
}
// Maybe move to MinikinSkia (esp. instead of opening GetSkTypeface publicly)?
void drawToSkia(SkCanvas *canvas, SkPaint *paint, Layout *layout, float x, float y) {
size_t nGlyphs = layout->nGlyphs();
uint16_t *glyphs = new uint16_t[nGlyphs];
SkPoint *pos = new SkPoint[nGlyphs];
SkTypeface *lastFace = NULL;
SkTypeface *skFace = NULL;
size_t start = 0;
paint->setTextEncoding(SkPaint::kGlyphID_TextEncoding);
for (size_t i = 0; i < nGlyphs; i++) {
const MinikinFontSkia *mfs = static_cast<const MinikinFontSkia *>(layout->getFont(i));
skFace = mfs->GetSkTypeface();
glyphs[i] = layout->getGlyphId(i);
pos[i].fX = x + layout->getX(i);
pos[i].fY = y + layout->getY(i);
if (i > 0 && skFace != lastFace) {
paint->setTypeface(sk_ref_sp(lastFace));
canvas->drawPosText(glyphs + start, (i - start) << 1, pos + start, *paint);
start = i;
}
lastFace = skFace;
}
paint->setTypeface(sk_ref_sp(skFace));
canvas->drawPosText(glyphs + start, (nGlyphs - start) << 1, pos + start, *paint);
delete[] glyphs;
delete[] pos;
}
int runMinikinTest() {
FT_Error error = FT_Init_FreeType(&library);
if (error) {
return -1;
}
std::shared_ptr<FontCollection> collection(makeFontCollection());
Layout layout(collection);
const char *text = "fine world \xe0\xa4\xa8\xe0\xa4\xae\xe0\xa4\xb8\xe0\xa5\x8d\xe0\xa4\xa4\xe0\xa5\x87";
int bidiFlags = 0;
FontStyle fontStyle(7);
MinikinPaint minikinPaint;
minikinPaint.size = 32;
icu::UnicodeString icuText = icu::UnicodeString::fromUTF8(text);
layout.doLayout(icuText.getBuffer(), 0, icuText.length(), icuText.length(), bidiFlags, fontStyle, minikinPaint);
layout.dump();
SkAutoGraphics ag;
int width = 800;
int height = 600;
SkBitmap bitmap;
bitmap.allocN32Pixels(width, height);
SkCanvas canvas(bitmap);
SkPaint paint;
paint.setARGB(255, 0, 0, 128);
paint.setStyle(SkPaint::kStroke_Style);
paint.setStrokeWidth(2);
paint.setTextSize(100);
paint.setAntiAlias(true);
canvas.drawLine(10, 300, 10 + layout.getAdvance(), 300, paint);
paint.setStyle(SkPaint::kFill_Style);
drawToSkia(&canvas, &paint, &layout, 10, 300);
SkFILEWStream file("/data/local/tmp/foo.png");
SkEncodeImage(&file, bitmap, SkEncodedImageFormat::kPNG, 100);
return 0;
}
} // namespace minikin
int main(int argc, const char** argv) {
return minikin::runMinikinTest();
}