mirror
/
openmw-tes3mp
mirror of https://github.com/TES3MP/openmw-tes3mp.git
1
0
Fork 1
Code Issues Releases Wiki Activity

Merge remote-tracking branch 'miroslavr/master'

Browse Source
deque
Marc Zinnschlag 10 years ago
parent 147bffa7dd 22c71cec18
commit 56858c98b1
6 changed files with 490 additions and 410 deletions
Show Stats Download Patch File Download Diff File

61
apps/openmw/mwgui/bookwindow.cpp
Unescape Escape View File

@ -70,11 +70,6 @@ namespace MWGui
void BookWindow::clearPages() void BookWindow::clearPages()
{ {
for (std::vector<MyGUI::Widget*>::iterator it=mPages.begin();
it!=mPages.end(); ++it)
{
MyGUI::Gui::getInstance().destroyWidget(*it);
}
mPages.clear(); mPages.clear();
} }
@ -89,25 +84,9 @@ namespace MWGui
MWWorld::LiveCellRef<ESM::Book> *ref = mBook.get<ESM::Book>(); MWWorld::LiveCellRef<ESM::Book> *ref = mBook.get<ESM::Book>();
BookTextParser parser; Formatting::BookFormatter formatter;
std::vector<std::string> results = parser.split(ref->mBase->mText, mLeftPage->getSize().width, mLeftPage->getSize().height); mPages = formatter.markupToWidget(mLeftPage, ref->mBase->mText);
formatter.markupToWidget(mRightPage, ref->mBase->mText);
int i=0;
for (std::vector<std::string>::iterator it=results.begin();
it!=results.end(); ++it)
{
MyGUI::Widget* parent;
if (i%2 == 0)
parent = mLeftPage;
else
parent = mRightPage;
MyGUI::Widget* pageWidget = parent->createWidgetReal<MyGUI::Widget>("", MyGUI::FloatCoord(0.0,0.0,1.0,1.0), MyGUI::Align::Default, "BookPage" + boost::lexical_cast<std::string>(i));
pageWidget->setNeedMouseFocus(false);
parser.parsePage(*it, pageWidget, mLeftPage->getSize().width);
mPages.push_back(pageWidget);
++i;
}
updatePages(); updatePages();
@ -164,19 +143,6 @@ namespace MWGui
mLeftPageNumber->setCaption( boost::lexical_cast<std::string>(mCurrentPage*2 + 1) ); mLeftPageNumber->setCaption( boost::lexical_cast<std::string>(mCurrentPage*2 + 1) );
mRightPageNumber->setCaption( boost::lexical_cast<std::string>(mCurrentPage*2 + 2) ); mRightPageNumber->setCaption( boost::lexical_cast<std::string>(mCurrentPage*2 + 2) );
unsigned int i=0;
for (std::vector<MyGUI::Widget*>::iterator it = mPages.begin();
it != mPages.end(); ++it)
{
if (mCurrentPage*2 == i || mCurrentPage*2+1 == i)
(*it)->setVisible(true);
else
{
(*it)->setVisible(false);
}
++i;
}
//If it is the last page, hide the button "Next Page" //If it is the last page, hide the button "Next Page"
if ( (mCurrentPage+1)*2 == mPages.size() if ( (mCurrentPage+1)*2 == mPages.size()
|| (mCurrentPage+1)*2 == mPages.size() + 1) || (mCurrentPage+1)*2 == mPages.size() + 1)
@ -191,6 +157,27 @@ namespace MWGui
} else { } else {
mPrevPageButton->setVisible(true); mPrevPageButton->setVisible(true);
} }
if (mPages.empty())
return;
MyGUI::Widget * paper;
paper = mLeftPage->getChildAt(0);
paper->setCoord(paper->getPosition().left, -mPages[mCurrentPage*2].first,
paper->getWidth(), mPages[mCurrentPage*2].second);
paper = mRightPage->getChildAt(0);
if ((mCurrentPage+1)*2 <= mPages.size())
{
paper->setCoord(paper->getPosition().left, -mPages[mCurrentPage*2+1].first,
paper->getWidth(), mPages[mCurrentPage*2+1].second);
paper->setVisible(true);
}
else
{
paper->setVisible(false);
}
} }
void BookWindow::adjustButton (Gui::ImageButton* button) void BookWindow::adjustButton (Gui::ImageButton* button)

6
apps/openmw/mwgui/bookwindow.hpp
Unescape Escape View File

@ -34,17 +34,21 @@ namespace MWGui
void adjustButton(Gui::ImageButton* button); void adjustButton(Gui::ImageButton* button);
private: private:
typedef std::pair<int, int> Page;
typedef std::vector<Page> Pages;
Gui::ImageButton* mCloseButton; Gui::ImageButton* mCloseButton;
Gui::ImageButton* mTakeButton; Gui::ImageButton* mTakeButton;
Gui::ImageButton* mNextPageButton; Gui::ImageButton* mNextPageButton;
Gui::ImageButton* mPrevPageButton; Gui::ImageButton* mPrevPageButton;
MyGUI::TextBox* mLeftPageNumber; MyGUI::TextBox* mLeftPageNumber;
MyGUI::TextBox* mRightPageNumber; MyGUI::TextBox* mRightPageNumber;
MyGUI::Widget* mLeftPage; MyGUI::Widget* mLeftPage;
MyGUI::Widget* mRightPage; MyGUI::Widget* mRightPage;
unsigned int mCurrentPage; // 0 is first page unsigned int mCurrentPage; // 0 is first page
std::vector<MyGUI::Widget*> mPages; Pages mPages;
MWWorld::Ptr mBook; MWWorld::Ptr mBook;

634
apps/openmw/mwgui/formatting.cpp
Unescape Escape View File

@ -2,401 +2,405 @@
#include <components/interpreter/defines.hpp> #include <components/interpreter/defines.hpp>
#include <components/misc/resourcehelpers.hpp> #include <components/misc/resourcehelpers.hpp>
#include <components/misc/stringops.hpp>
#include "../mwscript/interpretercontext.hpp" #include "../mwscript/interpretercontext.hpp"
#include <boost/algorithm/string/replace.hpp> #include <boost/algorithm/string/replace.hpp>
#include <boost/algorithm/string/predicate.hpp> #include <boost/algorithm/string/predicate.hpp>
#include <boost/algorithm/string/trim.hpp>
#include <boost/lexical_cast.hpp> #include <boost/lexical_cast.hpp>
#include <boost/range/adaptor/filtered.hpp>
#include <boost/range/algorithm/copy.hpp>
#include <OgreUTFString.h>
#include <OgreUTFString.h>
#include <OgreResourceGroupManager.h> #include <OgreResourceGroupManager.h>
namespace #include <MyGUI_EditText.h>
{
int convertFromHex(std::string hex)
{
int value = 0;
int a = 0;
int b = hex.length() - 1;
for (; b >= 0; a++, b--)
{
if (hex[b] >= '0' && hex[b] <= '9')
{
value += (hex[b] - '0') * (1 << (a * 4));
}
else
{
switch (hex[b])
{
case 'A':
case 'a':
value += 10 * (1 << (a * 4));
break;
case 'B':
case 'b':
value += 11 * (1 << (a * 4));
break;
case 'C':
case 'c':
value += 12 * (1 << (a * 4));
break;
case 'D':
case 'd':
value += 13 * (1 << (a * 4));
break;
case 'E':
case 'e':
value += 14 * (1 << (a * 4));
break;
case 'F':
case 'f':
value += 15 * (1 << (a * 4));
break;
default:
throw std::runtime_error("invalid character in hex number");
break;
}
}
}
return value;
}
Ogre::UTFString::unicode_char unicodeCharFromChar(char ch)
{
std::string s;
s += ch;
Ogre::UTFString string(s);
return string.getChar(0);
}
bool is_not_empty(const std::string& s) {
std::string temp = s;
boost::algorithm::trim(temp);
return !temp.empty();
}
}
namespace MWGui namespace MWGui
{ {
namespace Formatting
std::vector<std::string> BookTextParser::split(std::string utf8Text, const int width, const int height)
{ {
using Ogre::UTFString; /* BookTextParser */
std::vector<std::string> result; BookTextParser::BookTextParser(const std::string & text)
: mIndex(0), mText(text), mIgnoreNewlineTags(true), mIgnoreLineEndings(true)
MWScript::InterpreterContext interpreterContext(NULL, MWWorld::Ptr()); // empty arguments, because there is no locals or actor {
utf8Text = Interpreter::fixDefinesBook(utf8Text, interpreterContext); MWScript::InterpreterContext interpreterContext(NULL, MWWorld::Ptr()); // empty arguments, because there is no locals or actor
mText = Interpreter::fixDefinesBook(mText, interpreterContext);
boost::algorithm::replace_all(utf8Text, "\n", ""); boost::algorithm::replace_all(mText, "\r", "");
boost::algorithm::replace_all(utf8Text, "\r", "");
boost::algorithm::replace_all(utf8Text, "<BR>", "\n");
boost::algorithm::replace_all(utf8Text, "<P>", "\n\n");
UTFString text(utf8Text); registerTag("br", Event_BrTag);
const int spacing = 48; registerTag("p", Event_PTag);
registerTag("img", Event_ImgTag);
registerTag("div", Event_DivTag);
registerTag("font", Event_FontTag);
}
const UTFString::unicode_char LEFT_ANGLE = unicodeCharFromChar('<'); void BookTextParser::registerTag(const std::string & tag, BookTextParser::Events type)
const UTFString::unicode_char NEWLINE = unicodeCharFromChar('\n'); {
const UTFString::unicode_char SPACE = unicodeCharFromChar(' '); mTagTypes[tag] = type;
}
while (!text.empty()) std::string BookTextParser::getReadyText()
{ {
// read in characters until we have exceeded the size, or run out of text return mReadyText;
int currentWidth = 0; }
int currentHeight = 0;
size_t currentWordStart = 0; BookTextParser::Events BookTextParser::next()
size_t index = 0; {
while (mIndex < mText.size())
{
std::string texToTrim = text.asUTF8();
boost::algorithm::trim( texToTrim );
text = UTFString(texToTrim);
}
while (currentHeight <= height - spacing && index < text.size())
{ {
const UTFString::unicode_char ch = text.getChar(index); char ch = mText[mIndex];
if (ch == LEFT_ANGLE) if (ch == '<')
{ {
const size_t tagStart = index + 1; const size_t tagStart = mIndex + 1;
const size_t tagEnd = text.find('>', tagStart); const size_t tagEnd = mText.find('>', tagStart);
if (tagEnd == UTFString::npos) if (tagEnd == std::string::npos)
throw std::runtime_error("BookTextParser Error: Tag is not terminated"); throw std::runtime_error("BookTextParser Error: Tag is not terminated");
const std::string tag = text.substr(tagStart, tagEnd - tagStart).asUTF8(); parseTag(mText.substr(tagStart, tagEnd - tagStart));
mIndex = tagEnd;
if (boost::algorithm::starts_with(tag, "IMG")) if (mTagTypes.find(mTag) != mTagTypes.end())
{ {
const int h = mHeight; Events type = mTagTypes.at(mTag);
parseImage(tag, false);
currentHeight += (mHeight - h); if (type == Event_BrTag || type == Event_PTag)
currentWidth = 0; {
} if (!mIgnoreNewlineTags)
else if (boost::algorithm::starts_with(tag, "FONT")) {
{ if (type == Event_BrTag)
parseFont(tag); mBuffer.push_back('\n');
if (currentWidth != 0) { else
currentHeight += currentFontHeight(); {
mBuffer.append("\n\n");
}
}
mIgnoreLineEndings = true;
} }
currentWidth = 0; else
} flushBuffer();
else if (boost::algorithm::starts_with(tag, "DIV"))
{ if (type == Event_ImgTag)
parseDiv(tag); {
if (currentWidth != 0) { mIgnoreLineEndings = false;
currentHeight += currentFontHeight(); mIgnoreNewlineTags = false;
currentWidth = 0;
} }
++mIndex;
return type;
} }
index = tagEnd;
} }
else if (ch == NEWLINE) else
{ {
currentHeight += currentFontHeight(); if (!mIgnoreLineEndings || ch != '\n')
currentWidth = 0; {
currentWordStart = index; mBuffer.push_back(ch);
mIgnoreLineEndings = false;
mIgnoreNewlineTags = false;
}
} }
else if (ch == SPACE)
++mIndex;
}
flushBuffer();
return Event_EOF;
}
void BookTextParser::flushBuffer()
{
mReadyText = mBuffer;
mBuffer.clear();
}
const BookTextParser::Attributes & BookTextParser::getAttributes() const
{
return mAttributes;
}
void BookTextParser::parseTag(std::string tag)
{
size_t tagNameEndPos = tag.find(' ');
mTag = tag.substr(0, tagNameEndPos);
Misc::StringUtils::toLower(mTag);
mAttributes.clear();
if (tagNameEndPos == std::string::npos)
return;
tag.erase(0, tagNameEndPos+1);
while (!tag.empty())
{
size_t sepPos = tag.find('=');
if (sepPos == std::string::npos)
return;
std::string key = tag.substr(0, sepPos);
Misc::StringUtils::toLower(key);
tag.erase(0, sepPos+1);
std::string value;
if (tag.empty())
return;
if (tag[0] == '"')
{ {
currentWidth += 3; // keep this in sync with the font's SpaceWidth property size_t quoteEndPos = tag.find('"', 1);
currentWordStart = index; if (quoteEndPos == std::string::npos)
throw std::runtime_error("BookTextParser Error: Missing end quote in tag");
value = tag.substr(1, quoteEndPos-1);
tag.erase(0, quoteEndPos+2);
} }
else else
{ {
currentWidth += widthForCharGlyph(ch); size_t valEndPos = tag.find(' ');
if (valEndPos == std::string::npos)
{
value = tag;
tag.erase();
}
else
{
value = tag.substr(0, valEndPos);
tag.erase(0, valEndPos+1);
}
} }
if (currentWidth > width) mAttributes[key] = value;
{
currentHeight += currentFontHeight();
currentWidth = 0;
// add size of the current word
UTFString word = text.substr(currentWordStart, index - currentWordStart);
for (UTFString::const_iterator it = word.begin(), end = word.end(); it != end; ++it)
currentWidth += widthForCharGlyph(it.getCharacter());
}
index += UTFString::_utf16_char_length(ch);
} }
const size_t pageEnd = (currentHeight > height - spacing && currentWordStart != 0)
? currentWordStart : index;
result.push_back(text.substr(0, pageEnd).asUTF8());
text.erase(0, pageEnd);
} }
std::vector<std::string> nonEmptyPages;
boost::copy(result | boost::adaptors::filtered(is_not_empty), std::back_inserter(nonEmptyPages));
return nonEmptyPages;
}
float BookTextParser::widthForCharGlyph(unsigned unicodeChar) const /* BookFormatter */
{ Paginator::Pages BookFormatter::markupToWidget(MyGUI::Widget * parent, const std::string & markup, const int pageWidth, const int pageHeight)
std::string fontName(mTextStyle.mFont == "Default" ? MyGUI::FontManager::getInstance().getDefaultFont() : mTextStyle.mFont); {
return MyGUI::FontManager::getInstance().getByName(fontName) Paginator pag(pageWidth, pageHeight);
->getGlyphInfo(unicodeChar)->width;
}
float BookTextParser::currentFontHeight() const while (parent->getChildCount())
{ {
std::string fontName(mTextStyle.mFont == "Default" ? MyGUI::FontManager::getInstance().getDefaultFont() : mTextStyle.mFont); MyGUI::Gui::getInstance().destroyWidget(parent->getChildAt(0));
return MyGUI::FontManager::getInstance().getByName(fontName)->getDefaultHeight(); }
}
MyGUI::IntSize BookTextParser::parsePage(std::string text, MyGUI::Widget* parent, const int width) MyGUI::Widget * paper = parent->createWidget<MyGUI::Widget>("Widget", MyGUI::IntCoord(0, 0, pag.getPageWidth(), pag.getPageHeight()), MyGUI::Align::Left | MyGUI::Align::Top);
{ paper->setNeedMouseFocus(false);
MWScript::InterpreterContext interpreterContext(NULL, MWWorld::Ptr()); // empty arguments, because there is no locals or actor
text = Interpreter::fixDefinesBook(text, interpreterContext);
mParent = parent; BookTextParser parser(markup);
mWidth = width; BookTextParser::Events event;
mHeight = 0; for (;;)
{
event = parser.next();
if (event == BookTextParser::Event_BrTag || event == BookTextParser::Event_PTag)
continue;
assert(mParent); std::string plainText = parser.getReadyText();
while (mParent->getChildCount()) if (!plainText.empty())
{ {
MyGUI::Gui::getInstance().destroyWidget(mParent->getChildAt(0)); // if there's a newline at the end of the box caption, remove it
} if (plainText[plainText.size()-1] == '\n')
plainText.erase(plainText.end()-1);
#if (MYGUI_VERSION < MYGUI_DEFINE_VERSION(3, 2, 2))
// splitting won't be fully functional until 3.2.2 (see TextElement::pageSplit())
// hack: prevent newlines at the end of the book possibly creating unnecessary pages
if (event == BookTextParser::Event_EOF)
{
while (plainText.size() && plainText[plainText.size()-1] == '\n')
plainText.erase(plainText.end()-1);
}
#endif
// remove trailing " TextElement elem(paper, pag, mTextStyle, plainText);
if (text[text.size()-1] == '\"') elem.paginate();
text.erase(text.size()-1); }
parseSubText(text); if (event == BookTextParser::Event_EOF)
return MyGUI::IntSize(mWidth, mHeight); break;
}
MyGUI::IntSize BookTextParser::parseScroll(std::string text, MyGUI::Widget* parent, const int width)
{
MWScript::InterpreterContext interpreterContext(NULL, MWWorld::Ptr()); // empty arguments, because there is no locals or actor
text = Interpreter::fixDefinesBook(text, interpreterContext);
mParent = parent; switch (event)
mWidth = width; {
mHeight = 0; case BookTextParser::Event_ImgTag:
{
const BookTextParser::Attributes & attr = parser.getAttributes();
assert(mParent); if (attr.find("src") == attr.end() || attr.find("width") == attr.end() || attr.find("height") == attr.end())
while (mParent->getChildCount()) continue;
{
MyGUI::Gui::getInstance().destroyWidget(mParent->getChildAt(0));
}
boost::algorithm::replace_all(text, "<BR>", "\n"); std::string src = attr.at("src");
boost::algorithm::replace_all(text, "<P>", "\n\n"); int width = boost::lexical_cast<int>(attr.at("width"));
boost::algorithm::trim_left(text); int height = boost::lexical_cast<int>(attr.at("height"));
// remove trailing " ImageElement elem(paper, pag, src, width, height);
if (text[text.size()-1] == '\"') elem.paginate();
text.erase(text.size()-1); break;
}
case BookTextParser::Event_FontTag:
handleFont(parser.getAttributes());
break;
case BookTextParser::Event_DivTag:
handleDiv(parser.getAttributes());
break;
default:
break;
}
}
parseSubText(text); // insert last page
return MyGUI::IntSize(mWidth, mHeight); if (pag.getStartTop() != pag.getCurrentTop())
} pag << Paginator::Page(pag.getStartTop(), pag.getStartTop() + pag.getPageHeight());
void BookTextParser::parseImage(std::string tag, bool createWidget) paper->setSize(paper->getWidth(), pag.getCurrentTop());
{
int src_start = tag.find("SRC=")+5;
int width_start = tag.find("WIDTH=")+7; return pag.getPages();
int width = boost::lexical_cast<int>(tag.substr(width_start, tag.find('"', width_start)-width_start)); }
int height_start = tag.find("HEIGHT=")+8; Paginator::Pages BookFormatter::markupToWidget(MyGUI::Widget * parent, const std::string & markup)
int height = boost::lexical_cast<int>(tag.substr(height_start, tag.find('"', height_start)-height_start)); {
return markupToWidget(parent, markup, parent->getWidth(), parent->getHeight());
}
if (createWidget) void BookFormatter::handleDiv(const BookTextParser::Attributes & attr)
{ {
MyGUI::ImageBox* box = mParent->createWidget<MyGUI::ImageBox> ("ImageBox", if (attr.find("align") == attr.end())
MyGUI::IntCoord(0, mHeight, width, height), MyGUI::Align::Left | MyGUI::Align::Top, return;
mParent->getName() + boost::lexical_cast<std::string>(mParent->getChildCount()));
std::string image = Misc::ResourceHelpers::correctBookartPath(tag.substr(src_start, tag.find('"', src_start)-src_start), width, height); std::string align = attr.at("align");
box->setImageTexture(image);
box->setProperty("NeedMouse", "false"); if (Misc::StringUtils::ciEqual(align, "center"))
mTextStyle.mTextAlign = MyGUI::Align::HCenter;
else if (Misc::StringUtils::ciEqual(align, "left"))
mTextStyle.mTextAlign = MyGUI::Align::Left;
} }
mWidth = std::max(mWidth, width); void BookFormatter::handleFont(const BookTextParser::Attributes & attr)
mHeight += height; {
} if (attr.find("color") != attr.end())
{
int color;
std::stringstream ss;
ss << attr.at("color");
ss >> std::hex >> color;
mTextStyle.mColour = MyGUI::Colour(
(color>>16 & 0xFF) / 255.f,
(color>>8 & 0xFF) / 255.f,
(color & 0xFF) / 255.f);
}
if (attr.find("face") != attr.end())
{
std::string face = attr.at("face");
void BookTextParser::parseDiv(std::string tag) if (face != "Magic Cards")
{ mTextStyle.mFont = face;
if (tag.find("ALIGN=") == std::string::npos) }
return; if (attr.find("size") != attr.end())
{
int align_start = tag.find("ALIGN=")+7; /// \todo
std::string align = tag.substr(align_start, tag.find('"', align_start)-align_start); }
if (align == "CENTER") }
mTextStyle.mTextAlign = MyGUI::Align::HCenter;
else if (align == "LEFT")
mTextStyle.mTextAlign = MyGUI::Align::Left;
}
void BookTextParser::parseFont(std::string tag) /* GraphicElement */
{ GraphicElement::GraphicElement(MyGUI::Widget * parent, Paginator & pag)
if (tag.find("COLOR=") != std::string::npos) : mParent(parent), mPaginator(pag)
{ {
int color_start = tag.find("COLOR=")+7; }
std::string color = tag.substr(color_start, tag.find('"', color_start)-color_start);
mTextStyle.mColour = MyGUI::Colour( void GraphicElement::paginate()
convertFromHex(color.substr(0, 2))/255.0, {
convertFromHex(color.substr(2, 2))/255.0, int newTop = mPaginator.getCurrentTop() + getHeight();
convertFromHex(color.substr(4, 2))/255.0); while (newTop-mPaginator.getStartTop() > mPaginator.getPageHeight())
{
int newStartTop = pageSplit();
mPaginator << Paginator::Page(mPaginator.getStartTop(), newStartTop);
mPaginator.setStartTop(newStartTop);
}
mPaginator.setCurrentTop(newTop);
} }
if (tag.find("FACE=") != std::string::npos)
int GraphicElement::pageSplit()
{ {
int face_start = tag.find("FACE=")+6; return mPaginator.getStartTop() + mPaginator.getPageHeight();
std::string face = tag.substr(face_start, tag.find('"', face_start)-face_start); }
if (face != "Magic Cards") /* TextElement */
mTextStyle.mFont = face; TextElement::TextElement(MyGUI::Widget * parent, Paginator & pag,
const TextStyle & style, const std::string & text)
: GraphicElement(parent, pag),
mStyle(style)
{
MyGUI::EditBox* box = parent->createWidget<MyGUI::EditBox>("NormalText",
MyGUI::IntCoord(0, pag.getCurrentTop(), pag.getPageWidth(), 0), MyGUI::Align::Left | MyGUI::Align::Top,
parent->getName() + boost::lexical_cast<std::string>(parent->getChildCount()));
box->setProperty("Static", "true");
box->setProperty("MultiLine", "true");
box->setProperty("WordWrap", "true");
box->setProperty("NeedMouse", "false");
box->setMaxTextLength(text.size());
box->setTextAlign(mStyle.mTextAlign);
box->setTextColour(mStyle.mColour);
box->setFontName(mStyle.mFont);
box->setCaption(MyGUI::TextIterator::toTagsString(text));
box->setSize(box->getSize().width, box->getTextSize().height);
mEditBox = box;
} }
if (tag.find("SIZE=") != std::string::npos)
int TextElement::currentFontHeight() const
{ {
/// \todo std::string fontName(mStyle.mFont == "Default" ? MyGUI::FontManager::getInstance().getDefaultFont() : mStyle.mFont);
return MyGUI::FontManager::getInstance().getByName(fontName)->getDefaultHeight();
} }
}
void BookTextParser::parseSubText(std::string text) int TextElement::getHeight()
{
if (text[0] == '<')
{ {
const size_t tagStart = 1; return mEditBox->getTextSize().height;
const size_t tagEnd = text.find('>', tagStart);
if (tagEnd == std::string::npos)
throw std::runtime_error("BookTextParser Error: Tag is not terminated");
const std::string tag = text.substr(tagStart, tagEnd - tagStart);
if (boost::algorithm::starts_with(tag, "IMG"))
parseImage(tag);
if (boost::algorithm::starts_with(tag, "FONT"))
parseFont(tag);
if (boost::algorithm::starts_with(tag, "DIV"))
parseDiv(tag);
text.erase(0, tagEnd + 1);
} }
size_t tagStart = std::string::npos; int TextElement::pageSplit()
std::string realText; // real text, without tags
for (size_t i = 0; i<text.size(); ++i)
{ {
char c = text[i]; // split lines
if (c == '<') const int lineHeight = currentFontHeight();
unsigned int lastLine = (mPaginator.getStartTop() + mPaginator.getPageHeight() - mPaginator.getCurrentTop()) / lineHeight;
int ret = mPaginator.getCurrentTop() + lastLine * lineHeight;
// first empty lines that would go to the next page should be ignored
// unfortunately, getLineInfo method won't be available until 3.2.2
#if (MYGUI_VERSION >= MYGUI_DEFINE_VERSION(3, 2, 2))
const MyGUI::VectorLineInfo & lines = mEditBox->getSubWidgetText()->castType<MyGUI::EditText>()->getLineInfo();
for (unsigned int i = lastLine; i < lines.size(); ++i)
{ {
if ((i + 1 < text.size()) && text[i+1] == '/') // ignore closing tags if (lines[i].width == 0)
{ ret += lineHeight;
while (c != '>')
{
if (i >= text.size())
throw std::runtime_error("BookTextParser Error: Tag is not terminated");
++i;
c = text[i];
}
continue;
}
else else
{
tagStart = i;
break; break;
}
} }
else #endif
realText += c; return ret;
} }
MyGUI::EditBox* box = mParent->createWidget<MyGUI::EditBox>("NormalText", /* ImageElement */
MyGUI::IntCoord(0, mHeight, mWidth, 24), MyGUI::Align::Left | MyGUI::Align::Top, ImageElement::ImageElement(MyGUI::Widget * parent, Paginator & pag,
mParent->getName() + boost::lexical_cast<std::string>(mParent->getChildCount())); const std::string & src, int width, int height)
box->setProperty("Static", "true"); : GraphicElement(parent, pag),
box->setProperty("MultiLine", "true"); mImageHeight(height)
box->setProperty("WordWrap", "true");
box->setProperty("NeedMouse", "false");
box->setMaxTextLength(realText.size());
box->setTextAlign(mTextStyle.mTextAlign);
box->setTextColour(mTextStyle.mColour);
box->setFontName(mTextStyle.mFont);
box->setCaption(MyGUI::TextIterator::toTagsString(realText));
box->setSize(box->getSize().width, box->getTextSize().height);
mHeight += box->getTextSize().height;
if (tagStart != std::string::npos)
{ {
parseSubText(text.substr(tagStart, text.size())); mImageBox = parent->createWidget<MyGUI::ImageBox> ("ImageBox",
MyGUI::IntCoord(0, pag.getCurrentTop(), width, mImageHeight), MyGUI::Align::Left | MyGUI::Align::Top,
parent->getName() + boost::lexical_cast<std::string>(parent->getChildCount()));
std::string image = Misc::ResourceHelpers::correctBookartPath(src, width, mImageHeight);
mImageBox->setImageTexture(image);
mImageBox->setProperty("NeedMouse", "false");
} }
}
int ImageElement::getHeight()
{
return mImageHeight;
}
int ImageElement::pageSplit()
{
// if the image is larger than the page, fall back to the default pageSplit implementation
if (mImageHeight > mPaginator.getPageHeight())
return GraphicElement::pageSplit();
return mPaginator.getCurrentTop();
}
}
} }

190
apps/openmw/mwgui/formatting.hpp
Unescape Escape View File

@ -2,66 +2,150 @@
#define MWGUI_FORMATTING_H #define MWGUI_FORMATTING_H
#include <MyGUI.h> #include <MyGUI.h>
#include <map>
namespace MWGui namespace MWGui
{ {
struct TextStyle namespace Formatting
{ {
TextStyle() : struct TextStyle
mColour(0,0,0)
, mFont("Default")
, mTextSize(16)
, mTextAlign(MyGUI::Align::Left | MyGUI::Align::Top)
{ {
} TextStyle() :
mColour(0,0,0)
, mFont("Default")
, mTextSize(16)
, mTextAlign(MyGUI::Align::Left | MyGUI::Align::Top)
{
}
MyGUI::Colour mColour; MyGUI::Colour mColour;
std::string mFont; std::string mFont;
int mTextSize; int mTextSize;
MyGUI::Align mTextAlign; MyGUI::Align mTextAlign;
}; };
/// \brief utilities for parsing book/scroll text as mygui widgets class BookTextParser
class BookTextParser {
{ public:
public: typedef std::map<std::string, std::string> Attributes;
/** enum Events
* Parse markup as MyGUI widgets {
* @param markup to parse Event_None = -2,
* @param parent for the created widgets Event_EOF = -1,
* @param maximum width Event_BrTag,
* @return size of the created widgets Event_PTag,
*/ Event_ImgTag,
MyGUI::IntSize parsePage(std::string text, MyGUI::Widget* parent, const int width); Event_DivTag,
Event_FontTag
/** };
* Parse markup as MyGUI widgets
* @param markup to parse BookTextParser(const std::string & text);
* @param parent for the created widgets void registerTag(const std::string & tag, Events type);
* @param maximum width std::string getReadyText();
* @return size of the created widgets
*/ Events next();
MyGUI::IntSize parseScroll(std::string text, MyGUI::Widget* parent, const int width); void flushBuffer();
const Attributes & getAttributes() const;
/** void parseTag(std::string tag);
* Split the specified text into pieces that fit in the area specified by width and height parameters
*/ private:
std::vector<std::string> split(std::string text, const int width, const int height); size_t mIndex;
std::string mText;
protected: std::string mReadyText;
float widthForCharGlyph(unsigned unicodeChar) const;
float currentFontHeight() const; bool mIgnoreNewlineTags;
void parseSubText(std::string text); bool mIgnoreLineEndings;
Attributes mAttributes;
void parseImage(std::string tag, bool createWidget=true); std::string mTag;
void parseDiv(std::string tag); std::map<std::string, Events> mTagTypes;
void parseFont(std::string tag); std::string mBuffer;
private: };
MyGUI::Widget* mParent;
int mWidth; // maximum width class Paginator
int mHeight; // current height {
TextStyle mTextStyle; public:
}; typedef std::pair<int, int> Page;
typedef std::vector<Page> Pages;
Paginator(int pageWidth, int pageHeight)
: mStartTop(0), mCurrentTop(0),
mPageWidth(pageWidth), mPageHeight(pageHeight)
{
}
int getStartTop() const { return mStartTop; }
int getCurrentTop() const { return mCurrentTop; }
int getPageWidth() const { return mPageWidth; }
int getPageHeight() const { return mPageHeight; }
Pages getPages() const { return mPages; }
void setStartTop(int top) { mStartTop = top; }
void setCurrentTop(int top) { mCurrentTop = top; }
Paginator & operator<<(const Page & page)
{
mPages.push_back(page);
return *this;
}
private:
int mStartTop, mCurrentTop;
int mPageWidth, mPageHeight;
Pages mPages;
};
/// \brief utilities for parsing book/scroll text as mygui widgets
class BookFormatter
{
public:
Paginator::Pages markupToWidget(MyGUI::Widget * parent, const std::string & markup, const int pageWidth, const int pageHeight);
Paginator::Pages markupToWidget(MyGUI::Widget * parent, const std::string & markup);
protected:
void handleImg(const BookTextParser::Attributes & attr);
void handleDiv(const BookTextParser::Attributes & attr);
void handleFont(const BookTextParser::Attributes & attr);
private:
TextStyle mTextStyle;
};
class GraphicElement
{
public:
GraphicElement(MyGUI::Widget * parent, Paginator & pag);
virtual int getHeight() = 0;
virtual void paginate();
virtual int pageSplit();
protected:
MyGUI::Widget * mParent;
Paginator & mPaginator;
};
class TextElement : public GraphicElement
{
public:
TextElement(MyGUI::Widget * parent, Paginator & pag, const TextStyle & style, const std::string & text);
virtual int getHeight();
virtual int pageSplit();
private:
int currentFontHeight() const;
TextStyle mStyle;
MyGUI::EditBox * mEditBox;
};
class ImageElement : public GraphicElement
{
public:
ImageElement(MyGUI::Widget * parent, Paginator & pag, const std::string & src, int width, int height);
virtual int getHeight();
virtual int pageSplit();
private:
int mImageHeight;
MyGUI::ImageBox * mImageBox;
};
}
} }
#endif #endif

5
apps/openmw/mwgui/scrollwindow.cpp
Unescape Escape View File

@ -54,8 +54,9 @@ namespace MWGui
MWWorld::LiveCellRef<ESM::Book> *ref = mScroll.get<ESM::Book>(); MWWorld::LiveCellRef<ESM::Book> *ref = mScroll.get<ESM::Book>();
BookTextParser parser; Formatting::BookFormatter formatter;
MyGUI::IntSize size = parser.parseScroll(ref->mBase->mText, mTextView, 390); formatter.markupToWidget(mTextView, ref->mBase->mText, 390, mTextView->getHeight());
MyGUI::IntSize size = mTextView->getChildAt(0)->getSize();
// Canvas size must be expressed with VScroll disabled, otherwise MyGUI would expand the scroll area when the scrollbar is hidden // Canvas size must be expressed with VScroll disabled, otherwise MyGUI would expand the scroll area when the scrollbar is hidden
mTextView->setVisibleVScroll(false); mTextView->setVisibleVScroll(false);

4
files/mygui/openmw_book.layout
Unescape Escape View File

@ -41,8 +41,8 @@
<Property key="TextColour" value="0 0 0"/> <Property key="TextColour" value="0 0 0"/>
</Widget> </Widget>
<Widget type="Widget" skin="" position="30 22 240 300" name="LeftPage"/> <Widget type="Widget" skin="" position="30 15 240 328" name="LeftPage"/>
<Widget type="Widget" skin="" position="300 22 240 300" name="RightPage"/> <Widget type="Widget" skin="" position="300 15 240 328" name="RightPage"/>
</Widget> </Widget>
</Widget> </Widget>
</Widget> </Widget>

Write Preview
Loading…
Cancel
Save