yetangitu/FBReaderJ
1
0
Fork 0
mirror of https://github.com/geometer/FBReaderJ.git synced 2025-10-04 18:29:23 +02:00
Code Issues Releases Wiki Activity

style entry writing to the model cache

Browse source
This commit is contained in:
Nikolay Pultsin 2012-05-07 15:14:10 +01:00
parent 2422f080a8
commit 74cb4cf7be
11 changed files with 234 additions and 180 deletions
Download patch file Download diff file Expand all files Collapse all files

18
jni/NativeFormats/fbreader/src/formats/css/StyleSheetTable.cpp
View file

@ -70,7 +70,7 @@ static void parseLength(const std::string &toParse, short &size, ZLTextStyleEntr
}
}
void StyleSheetTable::setLength(ZLTextStyleEntry &entry, ZLTextStyleEntry::Length name, const AttributeMap &map, const std::string &attributeName) {
void StyleSheetTable::setLength(ZLTextStyleEntry &entry, ZLTextStyleEntry::Feature fetureId, const AttributeMap &map, const std::string &attributeName) {
StyleSheetTable::AttributeMap::const_iterator it = map.find(attributeName);
if (it == map.end()) {
return;
@ -80,7 +80,7 @@ void StyleSheetTable::setLength(ZLTextStyleEntry &entry, ZLTextStyleEntry::Lengt
short size;
ZLTextStyleEntry::SizeUnit unit;
parseLength(values[0], size, unit);
entry.setLength(name, size, unit);
entry.setLength(fetureId, size, unit);
}
}
@ -190,19 +190,19 @@ shared_ptr<ZLTextStyleEntry> StyleSheetTable::createControl(const AttributeMap &
const std::vector<std::string> &fontSize = values(styles, "font-size");
if (!fontSize.empty()) {
if (fontSize[0] == "xx-small") {
entry->setFontSizeMag(-3);
entry->setFontSizeMagnification(-3);
} else if (fontSize[0] == "x-small") {
entry->setFontSizeMag(-2);
entry->setFontSizeMagnification(-2);
} else if (fontSize[0] == "small") {
entry->setFontSizeMag(-1);
entry->setFontSizeMagnification(-1);
} else if (fontSize[0] == "medium") {
entry->setFontSizeMag(0);
entry->setFontSizeMagnification(0);
} else if (fontSize[0] == "large") {
entry->setFontSizeMag(1);
entry->setFontSizeMagnification(1);
} else if (fontSize[0] == "x-large") {
entry->setFontSizeMag(2);
entry->setFontSizeMagnification(2);
} else if (fontSize[0] == "xx-large") {
entry->setFontSizeMag(3);
entry->setFontSizeMagnification(3);
}
}

2
jni/NativeFormats/fbreader/src/formats/css/StyleSheetTable.h
View file

@ -38,7 +38,7 @@ public:
private:
void addMap(const std::string &tag, const std::string &aClass, const AttributeMap &map);
static void setLength(ZLTextStyleEntry &entry, ZLTextStyleEntry::Length name, const AttributeMap &map, const std::string &attributeName);
static void setLength(ZLTextStyleEntry &entry, ZLTextStyleEntry::Feature featureId, const AttributeMap &map, const std::string &attributeName);
static const std::vector<std::string> &values(const AttributeMap &map, const std::string &name);
public:

4
jni/NativeFormats/fbreader/src/formats/xhtml/XHTMLReader.cpp
View file

@ -585,7 +585,7 @@ void XHTMLReader::beginParagraph() {
myModelReader.addControl(**it);
doBlockSpaceBefore =
doBlockSpaceBefore ||
(*it)->isLengthSupported(ZLTextStyleEntry::LENGTH_SPACE_BEFORE);
(*it)->isFeatureSupported(ZLTextStyleEntry::LENGTH_SPACE_BEFORE);
}
if (doBlockSpaceBefore) {
@ -604,7 +604,7 @@ void XHTMLReader::endParagraph() {
for (std::vector<shared_ptr<ZLTextStyleEntry> >::const_iterator it = myStyleEntryStack.begin(); it != myStyleEntryStack.end() - myStylesToRemove; ++it) {
doBlockSpaceAfter =
doBlockSpaceAfter ||
(*it)->isLengthSupported(ZLTextStyleEntry::LENGTH_SPACE_AFTER);
(*it)->isFeatureSupported(ZLTextStyleEntry::LENGTH_SPACE_AFTER);
}
if (doBlockSpaceAfter) {
ZLTextStyleEntry blockingEntry;

29
jni/NativeFormats/zlibrary/core/src/util/ZLBoolean3.h Normal file
View file

@ -0,0 +1,29 @@
/*
* Copyright (C) 2004-2010 Geometer Plus <contact@geometerplus.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301, USA.
*/
#ifndef __ZLBOOLEAN3_H__
#define __ZLBOOLEAN3_H__
enum ZLBoolean3 {
B3_FALSE = 0,
B3_TRUE = 1,
B3_UNDEFINED = 2
};
#endif /* __ZLBOOLEAN3_H__ */

105
jni/NativeFormats/zlibrary/text/src/model/ZLTextModel.cpp
View file

@ -25,9 +25,12 @@
//#include <ZLSearchUtil.h>
//#include <ZLLanguageUtil.h>
#include <ZLUnicodeUtil.h>
//#include <ZLStringUtil.h>
//#include <ZLLogger.h>
#include "ZLTextModel.h"
#include "ZLTextParagraph.h"
#include "ZLTextStyleEntry.h"
ZLTextModel::ZLTextModel(const std::string &id, const std::string &language, const size_t rowSize,
const std::string &directoryName, const std::string &fileExtension) :
@ -265,65 +268,73 @@ void ZLTextModel::addControl(ZLTextKind textKind, bool isStart) {
++myParagraphLengths.back();
}
//static int EntryCount = 0;
//static int EntryLen = 0;
void ZLTextModel::addControl(const ZLTextStyleEntry &entry) {
/*
size_t len = 10 + 2 * (ZLTextStyleEntry::NUMBER_OF_LENGTHS +
(ZLTextStyleEntry::NUMBER_OF_LENGTHS + 1) / 2);
ZLUnicodeUtil::Ucs2String fontFamily;
size_t fontFamilyLen = 0;
if (entry.fontFamilySupported()) {
ZLUnicodeUtil::utf8ToUcs2(fontFamily, entry.fontFamily());
fontFamilyLen = fontFamily.size() * 2;
len += 2 + fontFamilyLen;
// +++ calculating entry size
size_t len = 4; // entry type + feature mask
for (int i = 0; i < ZLTextStyleEntry::NUMBER_OF_LENGTHS; ++i) {
if (entry.isFeatureSupported((ZLTextStyleEntry::Feature)i)) {
len += 4; // each supported length
}
}
if (entry.isFeatureSupported(ZLTextStyleEntry::ALIGNMENT_TYPE) ||
entry.isFeatureSupported(ZLTextStyleEntry::FONT_SIZE_MAGNIFICATION)) {
len += 2;
}
ZLUnicodeUtil::Ucs2String fontFamily;
if (entry.isFeatureSupported(ZLTextStyleEntry::FONT_FAMILY)) {
ZLUnicodeUtil::utf8ToUcs2(fontFamily, entry.fontFamily());
len += 2 + fontFamily.size() * 2;
}
if (entry.isFeatureSupported(ZLTextStyleEntry::FONT_STYLE_MODIFIER)) {
len += 2;
}
// --- calculating entry size
/*
EntryCount += 1;
EntryLen += len;
std::string debug = "style entry counter: ";
ZLStringUtil::appendNumber(debug, EntryCount);
debug += "/";
ZLStringUtil::appendNumber(debug, EntryLen);
ZLLogger::Instance().println(ZLLogger::DEFAULT_CLASS, debug);
*/
// +++ writing entry
myLastEntryStart = myAllocator->allocate(len);
char *address = myLastEntryStart;
*address++ = ZLTextParagraphEntry::STYLE_ENTRY;
*address++ = 0;
address = ZLCachedMemoryAllocator::writeUInt16(address, entry.myFeatureMask);
ZLCachedMemoryAllocator::writeUInt32(address, entry.myMask);
address += 4;
for (int i = 0; i < ZLTextStyleEntry::NUMBER_OF_LENGTHS; ++i) {
if (entry.isFeatureSupported((ZLTextStyleEntry::Feature)i)) {
const ZLTextStyleEntry::LengthType &len = entry.myLengths[i];
address = ZLCachedMemoryAllocator::writeUInt16(address, len.Size);
*address++ = len.Unit;
*address++ = 0;
}
}
if (entry.isFeatureSupported(ZLTextStyleEntry::ALIGNMENT_TYPE) ||
entry.isFeatureSupported(ZLTextStyleEntry::FONT_SIZE_MAGNIFICATION)) {
*address++ = entry.myAlignmentType;
*address++ = entry.myFontSizeMagnification;
}
if (entry.isFeatureSupported(ZLTextStyleEntry::FONT_FAMILY)) {
address = ZLCachedMemoryAllocator::writeString(address, fontFamily);
}
if (entry.isFeatureSupported(ZLTextStyleEntry::FONT_STYLE_MODIFIER)) {
*address++ = entry.mySupportedFontModifier;
*address++ = entry.myFontModifier;
}
// --- writing entry
// Pack myLengths array in following manner:
//
// 1) for each two elements there is a word with those Units (two Units
// in two bytes) followed by two words with those Sizes;
//
// 2) if myLengths.size() is odd (that means the last element has no paired one)
// one more word is appended with only one Unit (in the first byte) followed by
// a word containing corresponding Size.
//
for (int i = 0; i < ZLTextStyleEntry::NUMBER_OF_LENGTHS - 1; i += 2) {
const ZLTextStyleEntry::LengthType &l0 = entry.myLengths[i];
const ZLTextStyleEntry::LengthType &l1 = entry.myLengths[i + 1];
*address++ = l0.Unit;
*address++ = l1.Unit;
ZLCachedMemoryAllocator::writeUInt16(address, l0.Size);
address += 2;
ZLCachedMemoryAllocator::writeUInt16(address, l1.Size);
address += 2;
}
if (ZLTextStyleEntry::NUMBER_OF_LENGTHS % 2 == 1) {
const ZLTextStyleEntry::LengthType &l0 = entry.myLengths[ZLTextStyleEntry::NUMBER_OF_LENGTHS - 1];
*address++ = l0.Unit;
*address++ = 0;
ZLCachedMemoryAllocator::writeUInt16(address, l0.Size);
address += 2;
}
*address++ = entry.mySupportedFontModifier;
*address++ = entry.myFontModifier;
*address++ = entry.myAlignmentType;
*address++ = entry.myFontSizeMag;
if (entry.fontFamilySupported()) {
ZLCachedMemoryAllocator::writeUInt16(address, fontFamily.size());
memcpy(address + 2, &fontFamily.front(), fontFamilyLen);
}
myParagraphs.back()->addEntry(myLastEntryStart);
++myParagraphLengths.back();
*/
}
void ZLTextModel::addHyperlinkControl(ZLTextKind textKind, ZLHyperlinkType hyperlinkType, const std::string &label) {

32
jni/NativeFormats/zlibrary/text/src/model/ZLTextParagraph.cpp
View file

@ -30,32 +30,33 @@
const shared_ptr<ZLTextParagraphEntry> ResetBidiEntry::Instance = new ResetBidiEntry();
short ZLTextStyleEntry::length(Length name, const Metrics &metrics) const {
switch (myLengths[name].Unit) {
short ZLTextStyleEntry::length(Feature featureId, const Metrics &metrics) const {
switch (myLengths[featureId].Unit) {
default:
case SIZE_UNIT_PIXEL:
return myLengths[name].Size;
return myLengths[featureId].Size;
case SIZE_UNIT_EM_100:
return (myLengths[name].Size * metrics.FontSize + 50) / 100;
return (myLengths[featureId].Size * metrics.FontSize + 50) / 100;
case SIZE_UNIT_EX_100:
return (myLengths[name].Size * metrics.FontXHeight + 50) / 100;
return (myLengths[featureId].Size * metrics.FontXHeight + 50) / 100;
case SIZE_UNIT_PERCENT:
switch (name) {
switch (featureId) {
default:
case LENGTH_LEFT_INDENT:
case LENGTH_RIGHT_INDENT:
case LENGTH_FIRST_LINE_INDENT_DELTA:
return (myLengths[name].Size * metrics.FullWidth + 50) / 100;
return (myLengths[featureId].Size * metrics.FullWidth + 50) / 100;
case LENGTH_SPACE_BEFORE:
case LENGTH_SPACE_AFTER:
return (myLengths[name].Size * metrics.FullHeight + 50) / 100;
return (myLengths[featureId].Size * metrics.FullHeight + 50) / 100;
}
}
}
/*
ZLTextStyleEntry::ZLTextStyleEntry(char *address) {
myMask = ZLCachedMemoryAllocator::readUInt32(address);
address += 4;
myFeatureMask = ZLCachedMemoryAllocator::readUInt16(address);
address += 2;
const int lengthMinusOne = ZLTextStyleEntry::NUMBER_OF_LENGTHS - 1;
for (int i = 0; i < lengthMinusOne; i += 2) {
@ -78,14 +79,15 @@ ZLTextStyleEntry::ZLTextStyleEntry(char *address) {
mySupportedFontModifier = *address++;
myFontModifier = *address++;
myAlignmentType = (ZLTextAlignmentType)*address++;
myFontSizeMag = *address++;
if (isFontFamilySupported()) {
myFontSizeMagnification = *address++;
if (isFeatureSupported(FONT_FAMILY)) {
const size_t len = ZLCachedMemoryAllocator::readUInt16(address);
ZLUnicodeUtil::Ucs2Char *ucs2data = (ZLUnicodeUtil::Ucs2Char *)(address + 2);
ZLUnicodeUtil::Ucs2String ucs2str(ucs2data, ucs2data + len);
ZLUnicodeUtil::ucs2ToUtf8(myFontFamily, ucs2str);
}
}
*/
ZLTextControlEntryPool ZLTextControlEntryPool::Pool;
@ -100,6 +102,7 @@ shared_ptr<ZLTextParagraphEntry> ZLTextControlEntryPool::controlEntry(ZLTextKind
return entry;
}
/*
ZLTextHyperlinkControlEntry::ZLTextHyperlinkControlEntry(const char *address) : ZLTextControlEntry((ZLTextKind)*address, true), myHyperlinkType((ZLHyperlinkType)*(address + 1)) {
const size_t len = ZLCachedMemoryAllocator::readUInt16(address + 2);
ZLUnicodeUtil::Ucs2Char *ucs2data = (ZLUnicodeUtil::Ucs2Char *)(address + 4);
@ -122,7 +125,6 @@ ImageEntry::ImageEntry(const char *address) {
ZLUnicodeUtil::ucs2ToUtf8(myId, ucs2str);
}
const shared_ptr<ZLTextParagraphEntry> ZLTextParagraph::Iterator::entry() const {
if (myEntry.isNull()) {
switch (*myPointer) {
@ -182,7 +184,7 @@ void ZLTextParagraph::Iterator::next() {
case ZLTextParagraphEntry::STYLE_ENTRY:
{
unsigned int mask = ZLCachedMemoryAllocator::readUInt32(myPointer + 2);
bool withFontFamily = (mask & ZLTextStyleEntry::SUPPORTS_FONT_FAMILY) == ZLTextStyleEntry::SUPPORTS_FONT_FAMILY;
bool withFontFamily = (mask & (1 << ZLTextStyleEntry::FONT_FAMILY)) != 0;
myPointer += 10 + 2 * (ZLTextStyleEntry::NUMBER_OF_LENGTHS +
(ZLTextStyleEntry::NUMBER_OF_LENGTHS + 1) / 2);
@ -234,7 +236,7 @@ size_t ZLTextParagraph::characterNumber() const {
}
return len;
}
*/
ZLTextTreeParagraph::ZLTextTreeParagraph(ZLTextTreeParagraph *parent) : myIsOpen(false), myParent(parent) {
if (parent != 0) {

20
jni/NativeFormats/zlibrary/text/src/model/ZLTextParagraph.h
View file

@ -103,7 +103,7 @@ private:
class ZLTextHyperlinkControlEntry : public ZLTextControlEntry {
public:
ZLTextHyperlinkControlEntry(const char *address);
//ZLTextHyperlinkControlEntry(const char *address);
~ZLTextHyperlinkControlEntry();
const std::string &label() const;
ZLHyperlinkType hyperlinkType() const;
@ -117,7 +117,7 @@ private:
class ZLTextEntry : public ZLTextParagraphEntry {
public:
ZLTextEntry(const char *address);
//ZLTextEntry(const char *address);
~ZLTextEntry();
size_t dataLength() const;
@ -130,7 +130,7 @@ private:
class ImageEntry : public ZLTextParagraphEntry {
public:
ImageEntry(const char *address);
//ImageEntry(const char *address);
~ImageEntry();
const std::string &id() const;
short vOffset() const;
@ -152,6 +152,7 @@ private:
class ZLTextParagraph {
public:
/*
class Iterator {
public:
@ -169,6 +170,7 @@ public:
size_t myEndIndex;
mutable shared_ptr<ZLTextParagraphEntry> myEntry;
};
*/
enum Kind {
TEXT_PARAGRAPH,
@ -189,8 +191,8 @@ public:
size_t entryNumber() const;
size_t textDataLength() const;
size_t characterNumber() const;
//size_t textDataLength() const;
//size_t characterNumber() const;
private:
void addEntry(char *address);
@ -283,10 +285,10 @@ inline ZLTextParagraph::Kind ZLTextParagraph::kind() const { return TEXT_PARAGRA
inline size_t ZLTextParagraph::entryNumber() const { return myEntryNumber; }
inline void ZLTextParagraph::addEntry(char *address) { if (myEntryNumber == 0) myFirstEntryAddress = address; ++myEntryNumber; }
inline ZLTextParagraph::Iterator::Iterator(const ZLTextParagraph &paragraph) : myPointer(paragraph.myFirstEntryAddress), myIndex(0), myEndIndex(paragraph.entryNumber()) {}
inline ZLTextParagraph::Iterator::~Iterator() {}
inline bool ZLTextParagraph::Iterator::isEnd() const { return myIndex == myEndIndex; }
inline ZLTextParagraphEntry::Kind ZLTextParagraph::Iterator::entryKind() const { return (ZLTextParagraphEntry::Kind)*myPointer; }
//inline ZLTextParagraph::Iterator::Iterator(const ZLTextParagraph &paragraph) : myPointer(paragraph.myFirstEntryAddress), myIndex(0), myEndIndex(paragraph.entryNumber()) {}
//inline ZLTextParagraph::Iterator::~Iterator() {}
//inline bool ZLTextParagraph::Iterator::isEnd() const { return myIndex == myEndIndex; }
//inline ZLTextParagraphEntry::Kind ZLTextParagraph::Iterator::entryKind() const { return (ZLTextParagraphEntry::Kind)*myPointer; }
inline ZLTextSpecialParagraph::ZLTextSpecialParagraph(Kind kind) : myKind(kind) {}
inline ZLTextSpecialParagraph::~ZLTextSpecialParagraph() {}

102
jni/NativeFormats/zlibrary/text/src/model/ZLTextStyleEntry.h
View file

@ -24,6 +24,7 @@
#include <ZLTextParagraph.h>
#include <ZLTextAlignmentType.h>
#include <ZLBoolean3.h>
class ZLTextStyleEntry : public ZLTextParagraphEntry {
@ -45,7 +46,6 @@ public:
};
enum FontModifier {
FONT_MODIFIER_DEFAULT = 0,
FONT_MODIFIER_BOLD = 1 << 0,
FONT_MODIFIER_ITALIC = 1 << 1,
FONT_MODIFIER_UNDERLINED = 1 << 2,
@ -53,19 +53,19 @@ public:
FONT_MODIFIER_SMALLCAPS = 1 << 4,
};
enum Length {
enum Feature {
LENGTH_LEFT_INDENT = 0,
LENGTH_RIGHT_INDENT = 1,
LENGTH_FIRST_LINE_INDENT_DELTA = 2,
LENGTH_SPACE_BEFORE = 3,
LENGTH_SPACE_AFTER = 4,
NUMBER_OF_LENGTHS = 5,
ALIGNMENT_TYPE = NUMBER_OF_LENGTHS,
FONT_SIZE_MAGNIFICATION = NUMBER_OF_LENGTHS + 1,
FONT_FAMILY = NUMBER_OF_LENGTHS + 2,
FONT_STYLE_MODIFIER = NUMBER_OF_LENGTHS + 3,
};
static const unsigned int SUPPORTS_ALIGNMENT_TYPE = 1U << NUMBER_OF_LENGTHS;
static const unsigned int SUPPORTS_FONT_SIZE_MAG = 1U << (NUMBER_OF_LENGTHS + 1);
static const unsigned int SUPPORTS_FONT_FAMILY = 1U << (NUMBER_OF_LENGTHS + 2);
private:
struct LengthType {
SizeUnit Unit;
@ -74,80 +74,88 @@ private:
public:
ZLTextStyleEntry();
ZLTextStyleEntry(char *address);
//ZLTextStyleEntry(char *address);
~ZLTextStyleEntry();
bool isEmpty() const;
bool isFeatureSupported(Feature featureId) const;
bool isLengthSupported(Length name) const;
short length(Length name, const Metrics &metrics) const;
void setLength(Length name, short length, SizeUnit unit);
short length(Feature featureId, const Metrics &metrics) const;
void setLength(Feature featureId, short length, SizeUnit unit);
bool isAlignmentTypeSupported() const;
ZLTextAlignmentType alignmentType() const;
void setAlignmentType(ZLTextAlignmentType alignmentType);
unsigned char supportedFontModifier() const;
unsigned char fontModifier() const;
void setFontModifier(FontModifier style, bool set);
ZLBoolean3 fontModifier(FontModifier modifier) const;
void setFontModifier(FontModifier modifier, bool on);
bool isFontSizeMagSupported() const;
signed char fontSizeMag() const;
void setFontSizeMag(signed char fontSizeMag);
signed char fontSizeMagnification() const;
void setFontSizeMagnification(signed char fontSizeMagnification);
bool isFontFamilySupported() const;
const std::string &fontFamily() const;
void setFontFamily(const std::string &fontFamily);
private:
unsigned int myMask;
unsigned short myFeatureMask;
LengthType myLengths[NUMBER_OF_LENGTHS];
ZLTextAlignmentType myAlignmentType;
unsigned char mySupportedFontModifier;
unsigned char myFontModifier;
signed char myFontSizeMag;
signed char myFontSizeMagnification;
std::string myFontFamily;
friend class ZLTextModel;
friend class ZLTextModel;
};
inline ZLTextStyleEntry::ZLTextStyleEntry() : myMask(0), myAlignmentType(ALIGN_UNDEFINED), mySupportedFontModifier(0), myFontModifier(0), myFontSizeMag(0) {}
inline ZLTextStyleEntry::ZLTextStyleEntry() : myFeatureMask(0), myAlignmentType(ALIGN_UNDEFINED), mySupportedFontModifier(0), myFontModifier(0), myFontSizeMagnification(0) {}
inline ZLTextStyleEntry::~ZLTextStyleEntry() {}
inline ZLTextStyleEntry::Metrics::Metrics(int fontSize, int fontXHeight, int fullWidth, int fullHeight) : FontSize(fontSize), FontXHeight(fontXHeight), FullWidth(fullWidth), FullHeight(fullHeight) {}
inline bool ZLTextStyleEntry::isEmpty() const { return myMask == 0; }
inline bool ZLTextStyleEntry::isLengthSupported(Length name) const { return (myMask & (1U << name)) != 0; }
inline void ZLTextStyleEntry::setLength(Length name, short length, SizeUnit unit) {
myLengths[name].Size = length;
myLengths[name].Unit = unit;
myMask |= 1U << name;
inline bool ZLTextStyleEntry::isEmpty() const { return myFeatureMask == 0; }
inline bool ZLTextStyleEntry::isFeatureSupported(Feature featureId) const {
return (myFeatureMask & (1 << featureId)) != 0;
}
inline void ZLTextStyleEntry::setLength(Feature featureId, short length, SizeUnit unit) {
myFeatureMask |= 1 << featureId;
myLengths[featureId].Size = length;
myLengths[featureId].Unit = unit;
}
inline bool ZLTextStyleEntry::isAlignmentTypeSupported() const { return (myMask & SUPPORTS_ALIGNMENT_TYPE) == SUPPORTS_ALIGNMENT_TYPE; }
inline ZLTextAlignmentType ZLTextStyleEntry::alignmentType() const { return myAlignmentType; }
inline void ZLTextStyleEntry::setAlignmentType(ZLTextAlignmentType alignmentType) { myAlignmentType = alignmentType; myMask |= SUPPORTS_ALIGNMENT_TYPE; }
inline unsigned char ZLTextStyleEntry::supportedFontModifier() const { return mySupportedFontModifier; }
inline unsigned char ZLTextStyleEntry::fontModifier() const { return myFontModifier; }
inline void ZLTextStyleEntry::setFontModifier(FontModifier style, bool set) {
if (set) {
myFontModifier |= style;
} else {
myFontModifier &= ~style;
}
mySupportedFontModifier |= style;
inline void ZLTextStyleEntry::setAlignmentType(ZLTextAlignmentType alignmentType) {
myFeatureMask |= 1 << ALIGNMENT_TYPE;
myAlignmentType = alignmentType;
}
inline bool ZLTextStyleEntry::isFontSizeMagSupported() const { return (myMask & SUPPORTS_FONT_SIZE_MAG) == SUPPORTS_FONT_SIZE_MAG; }
inline signed char ZLTextStyleEntry::fontSizeMag() const { return myFontSizeMag; }
inline void ZLTextStyleEntry::setFontSizeMag(signed char fontSizeMag) { myFontSizeMag = fontSizeMag; myMask |= SUPPORTS_FONT_SIZE_MAG; }
inline ZLBoolean3 ZLTextStyleEntry::fontModifier(FontModifier modifier) const {
if ((mySupportedFontModifier & modifier) == 0) {
return B3_UNDEFINED;
}
return (myFontModifier & modifier) == 0 ? B3_FALSE : B3_TRUE;
}
inline void ZLTextStyleEntry::setFontModifier(FontModifier modifier, bool on) {
myFeatureMask |= FONT_STYLE_MODIFIER;
mySupportedFontModifier |= modifier;
if (on) {
myFontModifier |= modifier;
} else {
myFontModifier &= ~modifier;
}
}
inline signed char ZLTextStyleEntry::fontSizeMagnification() const { return myFontSizeMagnification; }
inline void ZLTextStyleEntry::setFontSizeMagnification(signed char fontSizeMagnification) {
myFeatureMask |= FONT_SIZE_MAGNIFICATION;
myFontSizeMagnification = fontSizeMagnification;
}
inline bool ZLTextStyleEntry::isFontFamilySupported() const { return (myMask & SUPPORTS_FONT_FAMILY) == SUPPORTS_FONT_FAMILY; }
inline const std::string &ZLTextStyleEntry::fontFamily() const { return myFontFamily; }
inline void ZLTextStyleEntry::setFontFamily(const std::string &fontFamily) { myFontFamily = fontFamily; myMask |= SUPPORTS_FONT_FAMILY; }
inline void ZLTextStyleEntry::setFontFamily(const std::string &fontFamily) {
myFeatureMask |= FONT_FAMILY;
myFontFamily = fontFamily;
}
#endif /* __ZLTEXTSTYLEENTRY_H__ */

32
src/org/geometerplus/zlibrary/text/model/ZLTextPlainModel.java
View file

@ -24,7 +24,7 @@ import java.util.*;
import org.geometerplus.zlibrary.core.image.ZLImage;
import org.geometerplus.zlibrary.core.util.*;
public class ZLTextPlainModel implements ZLTextModel {
public class ZLTextPlainModel implements ZLTextModel, ZLTextStyleEntry.Feature {
private final String myId;
private final String myLanguage;
@ -184,20 +184,30 @@ public class ZLTextPlainModel implements ZLTextModel {
break;
case ZLTextParagraph.Entry.STYLE:
{
final int mask = (int)data[dataOffset++];
final ZLTextStyleEntry entry = new ZLTextStyleEntry();
if ((mask & ZLTextStyleEntry.SUPPORTS_LEFT_INDENT) ==
ZLTextStyleEntry.SUPPORTS_LEFT_INDENT) {
entry.setLeftIndent((short)data[dataOffset++]);
final short mask = (short)data[dataOffset++];
for (int i = 0; i < NUMBER_OF_LENGTHS; ++i) {
if (ZLTextStyleEntry.isFeatureSupported(mask, i)) {
// TODO: read length
dataOffset += 2;
}
}
if ((mask & ZLTextStyleEntry.SUPPORTS_RIGHT_INDENT) ==
ZLTextStyleEntry.SUPPORTS_RIGHT_INDENT) {
entry.setRightIndent((short)data[dataOffset++]);
if (ZLTextStyleEntry.isFeatureSupported(mask, ALIGNMENT_TYPE) ||
ZLTextStyleEntry.isFeatureSupported(mask, FONT_SIZE_MAGNIFICATION)) {
// TODO: read alignment type and/or font size magnification
dataOffset += 1;
}
if ((mask & ZLTextStyleEntry.SUPPORTS_ALIGNMENT_TYPE) ==
ZLTextStyleEntry.SUPPORTS_ALIGNMENT_TYPE) {
entry.setAlignmentType((byte)data[dataOffset++]);
if (ZLTextStyleEntry.isFeatureSupported(mask, FONT_FAMILY)) {
final short familyLength = (short)data[dataOffset++];
// TODO: read font family
dataOffset += familyLength;
}
if (ZLTextStyleEntry.isFeatureSupported(mask, FONT_STYLE_MODIFIER)) {
// TODO: read font modifiers
dataOffset += 1;
}
myStyleEntry = entry;
}
case ZLTextParagraph.Entry.RESET_BIDI:

67
src/org/geometerplus/zlibrary/text/model/ZLTextStyleEntry.java
View file

@ -20,58 +20,47 @@
package org.geometerplus.zlibrary.text.model;
public final class ZLTextStyleEntry {
final static short SUPPORTS_LEFT_INDENT = 1 << 0;
final static short SUPPORTS_RIGHT_INDENT = 1 << 1;
final static short SUPPORTS_ALIGNMENT_TYPE = 1 << 2;
private short myMask;
private short myLeftIndent;
private short myRightIndent;
private byte myAlignmentType;
interface Feature {
int LENGTH_LEFT_INDENT = 0;
int LENGTH_RIGHT_INDENT = 1;
int LENGTH_FIRST_LINE_INDENT_DELTA = 2;
int LENGTH_SPACE_BEFORE = 3;
int LENGTH_SPACE_AFTER = 4;
int NUMBER_OF_LENGTHS = 5;
int ALIGNMENT_TYPE = NUMBER_OF_LENGTHS;
int FONT_SIZE_MAGNIFICATION = NUMBER_OF_LENGTHS + 1;
int FONT_FAMILY = NUMBER_OF_LENGTHS + 2;
int FONT_STYLE_MODIFIER = NUMBER_OF_LENGTHS + 3;
}
private short myFeatureMask;
static boolean isFeatureSupported(short mask, int featureId) {
return (mask & (1 << featureId)) != 0;
}
public boolean isFeatureSupported(int featureId) {
return isFeatureSupported(myFeatureMask, featureId);
}
//private short myLeftIndent;
//private short myRightIndent;
//private byte myAlignmentType;
public ZLTextStyleEntry() {
}
short getMask() {
return myMask;
}
public boolean isLeftIndentSupported() {
return (myMask & SUPPORTS_LEFT_INDENT) == SUPPORTS_LEFT_INDENT;
}
/*
public short getLeftIndent() {
return myLeftIndent;
}
public void setLeftIndent(short leftIndent) {
myMask |= SUPPORTS_LEFT_INDENT;
myLeftIndent = leftIndent;
}
public boolean isRightIndentSupported() {
return (myMask & SUPPORTS_RIGHT_INDENT) == SUPPORTS_RIGHT_INDENT;
}
public short getRightIndent() {
return myRightIndent;
}
public void setRightIndent(short rightIndent) {
myMask |= SUPPORTS_RIGHT_INDENT;
myRightIndent = rightIndent;
}
public boolean isAlignmentTypeSupported() {
return (myMask & SUPPORTS_ALIGNMENT_TYPE) == SUPPORTS_ALIGNMENT_TYPE;
}
public byte getAlignmentType() {
return myAlignmentType;
}
public void setAlignmentType(byte alignmentType) {
myMask |= SUPPORTS_ALIGNMENT_TYPE;
myAlignmentType = alignmentType;
}
*/
}

3
src/org/geometerplus/zlibrary/text/model/ZLTextWritablePlainModel.java
View file

@ -132,6 +132,8 @@ public final class ZLTextWritablePlainModel extends ZLTextPlainModel implements
}
public void addStyleEntry(ZLTextStyleEntry entry) {
// TODO: implement
/*
int len = 2;
for (int mask = entry.getMask(); mask != 0; mask >>= 1) {
len += mask & 1;
@ -149,6 +151,7 @@ public final class ZLTextWritablePlainModel extends ZLTextPlainModel implements
if (entry.isAlignmentTypeSupported()) {
block[myBlockOffset++] = (char)entry.getAlignmentType();
}
*/
}
public void addFixedHSpace(short length) {